Skip to content

Instantly share code, notes, and snippets.

@vitaminac
Created January 8, 2018 22:16
Show Gist options
  • Save vitaminac/32be4aba966574ee44be725c76d4283a to your computer and use it in GitHub Desktop.
Save vitaminac/32be4aba966574ee44be725c76d4283a to your computer and use it in GitHub Desktop.
PROGRAM aparcamiento;
{**************************TIPO DE DATOS*********************************}
CONST
LONGMATRICULA = 7; {longitud matricula}
NUMCARMARCA = 15; {numero caracteres campo marca}
NUMCARCOLOR = 20; {numero caracteres campo color}
LONGTELEFONO = 9; {longitud telefono}
LONGDNI = 9; {longitud dni}
MAXVEHICULOS = 100; {numero maximo de vehiculos}
MAXCONDUCTORES = 100; {numero maximo de conductores}
TYPE
tMatricula = string[LONGMATRICULA];
tMarca = string[NUMCARMARCA];
tColor = string[NUMCARCOLOR];
tDni = string[LONGDNI];
tTelefono = string[LONGDNI];
{tipo vehiculo}
tVehiculo = RECORD
matricula : tMatricula;
marca : tMarca;
color : tColor;
dni : TDni;
END;
{tipo conductor}
tConductor = RECORD
nombreApellidos, email : string;
telefono : tTelefono;
dni : TDni;
END;
{tipo lista de vehiculos}
tIndiceVehiculos = 1..MAXVEHICULOS;
tListaVehiculos = ARRAY [tIndiceVehiculos] OF tVehiculo;
{Array parcialmente lleno para vehiculos autorizados y para vehiculos aparcados}
tVehiculosRegistrados = RECORD
vehiculos: tListaVehiculos;
tope : integer;
END;
{tipo lista de conductores}
tIndiceConductores = 1..MAXCONDUCTORES;
tListaConductores = ARRAY [tIndiceConductores] OF tConductor;
{Array parcialmente lleno para conductores autorizados}
tConductoresRegistrados = RECORD
conductores:tListaConductores;
tope : integer;
END;
{tipo archivo binario}
tArchivoVehiculos = FILE OF tVehiculo;
tArchivoConductores = FILE OF tConductor;
{***************************DECLARACION DE VARIABLE GLOBAL************************}
VAR
opcion:char;
vehiculosAutorizados:tVehiculosRegistrados;
vehiculosAparcados:tVehiculosRegistrados;
conductores:tConductoresRegistrados;
archivo_vehiculos_autorizado:tArchivoVehiculos;
archivo_vehiculos_aparcado:tArchivoVehiculos;
archivo_conductores:tArchivoConductores;
archivo_conductores_txt:text;
matricula_tmp:tMatricula;
vehiculo:tVehiculo;
conductor:tConductor;
dni_temp:tDni;
indice:integer;
{**************************************SUBPROGRAMA*****************************************************************}
{muestra la informacion de cada opcion}
PROCEDURE menu;
BEGIN
writeln('a - Alta vehiculo autorizado.');
writeln('b - Baja vehiculo.');
writeln('c - Listado vehiculos autorizados.');
writeln('d - Listado vehiculos aparcados.');
writeln('e - Listado de vehiculos de un conductor.');
writeln('f - Alta conductor.');
writeln('g - Baja conductor.');
writeln('h - Listado de conductores autorizados.');
writeln('i - Acceso vehiculo.');
writeln('j - Salida vehiculo.');
writeln('k - Guardar vehiculos autorizados.');
writeln('l - Guardar vehiculos que se encuentran en el parking.');
writeln('m - Guardar conductores.');
writeln('n - Guardar el nombre y apellidos de los conductores.');
writeln('o - Cargar vehiculos autorizados.');
writeln('p - Cargar vehiculos que se encuentran en el parking.');
writeln('q - Cargar conductores.');
writeln('t - termina');
END;
PROCEDURE leertelefono(VAR telefono:tTelefono);
VAR
telefono_n:LONGINT;
error:integer;
BEGIN
readln(telefono);
val(telefono,telefono_n,error);
WHILE (error<>0) OR (((telefono_n<900000000) OR (telefono_n>999999999)) AND ((telefono_n<600000000) OR (telefono_n>699999999))) DO BEGIN
writeln('no es formato valido');
readln(telefono);
val(telefono,telefono_n,error);
END;
END;
PROCEDURE leerdni(VAR dni:tDni);
VAR
dni_n:LONGINT;
error:integer;
BEGIN
readln(dni);
val(copy(dni,2,7),dni_n,error);
WHILE (error<>0) OR (((ord(dni[1])<65) OR (ord(dni[1])>90)) AND ((ord(dni[1])<97) OR (ord(dni[1])>122)) AND ((ord(dni[1])<48) OR (ord(dni[1])>57))) OR (((ord(dni[9])<65) OR (ord(dni[9])>90)) AND ((ord(dni[9])<97) OR (ord(dni[9])>122))) DO BEGIN
writeln('no es formato valido');
readln(dni);
val(copy(dni,2,7),dni_n,error);
END;
error:=dni_n MOD 2;
END;
PROCEDURE leermatricula(VAR matricula:tMatricula);
VAR
matricula_n:LONGINT;
error:integer;
BEGIN
readln(matricula);
val(copy(matricula,1,4),matricula_n,error);
WHILE (error<>0)
OR (((ord(matricula[5])<65) OR (ord(matricula[5])>90)) AND ((ord(matricula[5])<97) OR (ord(matricula[5])>122)))
OR (((ord(matricula[6])<65) OR (ord(matricula[6])>90)) AND ((ord(matricula[6])<97) OR (ord(matricula[6])>122)))
OR (((ord(matricula[7])<65) OR (ord(matricula[7])>90)) AND ((ord(matricula[7])<97) OR (ord(matricula[7])>122))) DO BEGIN
writeln('no es formato valido');
readln(matricula);
val(copy(matricula,1,4),matricula_n,error);
END;
error:=matricula_n MOD 2;
END;
{recibe una variable de tipo conductor, y se pregunta los datos de conductor
por patanlla, y devuelve variable cambiada}
PROCEDURE leerConductor(VAR conductor:tConductor);
BEGIN
WITH conductor DO BEGIN
writeln('Introduzca su DNI');
leerdni(dni);
writeln('Introduzca su nombre y apellidos');
readln(nombreApellidos);
writeln('Introduzca su email');
readln(email);
writeln('Introduzca su telefono');
leertelefono(telefono);
END;
END;
{recibe una variable de tipo vehiculo, y se pregunta los datos de vehiculo
por patanlla, y devuelve variable cambiada}
PROCEDURE leerVehiculo(VAR vehiculo:tVehiculo);
BEGIN
WITH vehiculo DO BEGIN
writeln('Introduzca la matricula');
leermatricula(matricula);
writeln('Introduzca su DNI');
leerdni(dni);
writeln('Introduzca la marca');
readln(marca);
writeln('Introduzca el color');
readln(color);
END;
END;
{recibe una variable de tipo tVehiculosRegistrados y muestra por patanlla
todos los vehiculos almacenados desde 1 hasta tope, se considera que los datos ya
estan ordenados y la ordenacion esta controlada por otros procedimientos}
PROCEDURE listadoVehiculos(vehiculosRegistrados:tVehiculosRegistrados);
VAR i:integer;
BEGIN
WITH vehiculosRegistrados DO BEGIN
IF tope>0 THEN BEGIN
FOR i:=1 TO tope DO
WITH vehiculos[i] DO
writeln('Matricula: ',matricula,' Marca: ',marca,' Color: ',color,' DNI: ',dni);
writeln();
END
ELSE
writeln('No existe vehiculo registrado');
END;
END;
{recibe una variable de tipo tConductoresRegistrados y muestra por patanlla
todos los conductores almacenados desde 1 hasta tope, se considera que los datos ya
estan ordenados y la ordenacion esta controlada por otros procedimientos}
PROCEDURE listadoConductoresautorizados(conductoresRegistrados:tConductoresRegistrados);
VAR i:integer;
BEGIN
WITH conductoresRegistrados DO BEGIN
IF tope>0 THEN BEGIN
FOR i:=1 TO tope DO
WITH conductores[i] DO
writeln('DNI: ',dni,' Nombre y apellidos: ',nombreApellidos,' Telefono: ',telefono,' Email: ',email);
writeln();
END
ELSE
writeln('No existe conductor registrado');
END;
END;
{recibe una variable de tipo tVehiculosRegistrados y una variable de archivo
binario de tipo tVehiculo, guarda todos los vehiculos almacenados desde 1 hasta tope
en ese archivo, los datos se considera que ya estan ordenados
y la ordenacion esta controlada por otros procedimientos}
PROCEDURE guardarVehiculos(vehiculosRegistrados:tVehiculosRegistrados;VAR archivo_vehiculos:tArchivoVehiculos);
VAR i:integer;
BEGIN
rewrite(archivo_vehiculos);
WITH vehiculosRegistrados DO
FOR i:=1 TO tope DO BEGIN
write(archivo_vehiculos,vehiculos[i])
END;
close(archivo_vehiculos);
END;
{recibe una variable de tipo tConductoresRegistrados y una variable de archivo
binario de tipo tConductor, guarda todos los conductores almacenados desde 1 hasta tope
en ese archivo, los datos se considera que ya estan ordenados
y la ordenacion esta controlada por otros procedimientos}
PROCEDURE guardarConductores(conductoresRegistrados:tConductoresRegistrados;VAR archivo_conductores:tArchivoConductores);
VAR i:integer;
BEGIN
rewrite(archivo_conductores);
WITH conductoresRegistrados DO
FOR i:=1 TO tope DO BEGIN
write(archivo_conductores,conductores[i])
END;
close(archivo_conductores);
END;
{recibe una variable de tipo tConductoresRegistrados y una variable de archivo de
texto, guarda todos los nombres de conductores almacenados desde 1 hasta tope
en ese archivo, los datos se considera que ya estan ordenados
y la ordenacion esta controlada por otros procedimientos}
PROCEDURE guardarConductores_txt(conductoresRegistrados:tConductoresRegistrados;VAR archivo_conductores_txt:text);
VAR
i:integer;
BEGIN
rewrite(archivo_conductores_txt);
WITH conductoresRegistrados DO
FOR i:=1 TO tope DO BEGIN
writeln(archivo_conductores_txt,conductores[i].nombreApellidos)
END;
close(archivo_conductores_txt);
END;
{recibe un dni y una variable de tipo tConductoresRegistrados, y devuelve la
posicion de primer conductor que coincide el dni con el dado, y si no haya
encontrado dicho conductor devuelve 0, se considera que no haya datos repetidos
y la no repeticion de datos esta controlada por otros procedimientos}
FUNCTION posicionConductor(dni:tDni;conductoresRegistrados:tConductoresRegistrados):integer;
VAR i:integer;
BEGIN
i:=1;
WITH conductoresRegistrados DO BEGIN
WHILE (i<=tope) AND (conductores[i].dni<dni) DO
i:=i+1;
IF (i<=tope) AND (conductores[i].dni=dni) THEN
posicionConductor:=i
ELSE
posicionConductor:=0
END;
END;
{recibe una matricula y una variable de tipo tVehiculosRegistrados, y devuelve la
posicion de primer vehiculo que coincide la matricula con la dada, y si no haya
encontrado dicho vehiculo devuelve 0, se considera que no haya datos repetidos
y la no repeticion de datos esta controlada por otros procedimientos}
FUNCTION posicionVehiculo(matricula:tMatricula;vehiculosRegistrados:tVehiculosRegistrados):integer;
VAR i:integer;
BEGIN
i:=1;
WITH vehiculosRegistrados DO BEGIN
WHILE (i<=tope) AND (vehiculos[i].matricula<matricula) DO
i:=i+1;
IF (i<=tope) AND (vehiculos[i].matricula=matricula) THEN
posicionVehiculo:=i
ELSE
posicionVehiculo:=0
END;
END;
{recibe una dni, un indice inicial y una variable de tipo tVehiculosRegistrados,
y devuelve la posicion de primer vehiculo que esta en el intervalo desde el indice
inicial hasta tope y que coincide el dni con el dado, y si no haya
encontrado dicho vehiculo devuelve 0. Si el indice inicial es menor que 1,
se considera como 1}
FUNCTION posicionVehiculo_por_dni(dni:tDni;indice_inicial:integer;vehiculosRegistrados:tVehiculosRegistrados):integer;
VAR i:integer;
BEGIN
i:=indice_inicial;
IF i<1 THEN
i:=1;
WITH vehiculosRegistrados DO BEGIN
WHILE (i<=tope) AND (vehiculos[i].dni<>dni) DO
i:=i+1;
IF (i<=tope) AND (vehiculos[i].dni=dni) THEN
posicionVehiculo_por_dni:=i
ELSE
posicionVehiculo_por_dni:=0
END;
END;
{recibe una variable de tipo tVehiculosRegistrados, y pregunta por pantalla el
numero de dni de conductor y muestra por patanlla todos los vehiculos asociado
con ese conductor, se considera que los datos ya estan ordenados
y la ordenacion esta controlada por otros procedimientos}
PROCEDURE listadoConductor(vehiculosAutorizados:tVehiculosRegistrados);
VAR
dni_temp:tDni;
i:integer;
BEGIN
writeln('Introduzca dni de conductor');
leerdni(dni_temp);
i:=1;
WHILE posicionVehiculo_por_dni(dni_temp,i,vehiculosAutorizados)>0 DO BEGIN
i:= posicionVehiculo_por_dni(dni_temp,i,vehiculosAutorizados)+1;
WITH vehiculosAutorizados.vehiculos[i-1] DO
writeln('Matricula: ',matricula,' Marca: ',marca,' Color: ',color,' DNI: ',dni);
END;
END;
{recibe un conductor y un conductoresRegistrados, y anade ese conductor de forma
ordenada a la lista de conductoresRegistrados, si el dni de ese conductor coincide
con algunos de la lista o que la lista esta llena, da un mensaje y deja de realizar la operacion,
se considera que los datos estan previamente ordenados y todos los conductores
de la lista fue anadido por esta subprograma}
PROCEDURE altaConductor(conductor:tConductor;VAR conductoresRegistrados:tConductoresRegistrados);
VAR
i:integer;
BEGIN
WITH conductoresRegistrados DO BEGIN
IF tope<MAXCONDUCTORES THEN BEGIN
IF posicionConductor(conductor.dni,conductoresRegistrados)=0 THEN BEGIN
i:=tope;
WHILE (i>=1) AND (conductores[i].dni > conductor.dni) DO BEGIN
conductores[i+1]:=conductores[i];
i:=i-1;
END;
conductores[i+1]:=conductor;
tope:=tope+1;
END
ELSE
writeln('Conductor registrado')
END
ELSE
writeln('Ya no hay plaza libre')
END;
END;
{recibe un vehiculo y un vehiculosRegistrados, y anade ese vehiculo de forma
ordenada a la lista de vehiculosRegistrados, si la matricula de ese vehiculo coincide
con algunos de la lista o que la lista esta llena, da un mensaje y deja de realizar la operacion,
se considera que los datos estan previamente ordenados y todos los vehiculos
de la lista fue anadido por esta subprograma}
PROCEDURE altaVehiculo(vehiculo:tVehiculo;VAR vehiculosRegistrados:tVehiculosRegistrados);
VAR
i:integer;
BEGIN
WITH vehiculosRegistrados DO BEGIN
IF tope<MAXVEHICULOS THEN BEGIN
IF posicionVehiculo(vehiculo.matricula,vehiculosRegistrados)=0 THEN BEGIN
i:=tope;
WHILE (i>=1) AND (vehiculos[i].matricula > vehiculo.matricula) DO BEGIN
vehiculos[i+1]:=vehiculos[i];
i:=i-1;
END;
vehiculos[i+1]:=vehiculo;
tope:=tope+1
END
ELSE
writeln('Vehiculo registrado');
END
ELSE
writeln('Ya no hay plaza libre')
END;
END;
{recibe una variable de tVehiculosRegistrados, y pregunta la ubicacion de
archivo, se elimina todo los datos de la lista y carga los vehiculos
desde el archivo de uno en uno y utiliza la subprograma altaVehiculo
para anadir de forma ordenada a la lista, y si haya datos repetidos en el archivo
omite el segundo y da un mensaje}
PROCEDURE cargarVehiculos(VAR vehiculosRegistrados:tVehiculosRegistrados);
VAR
archivo_vehiculos:tArchivoVehiculos;
nombreArchivo:String;
vehiculo:tVehiculo;
BEGIN
writeln('Introduzca la ubicacion de archivo');
readln(nombreArchivo);
assign(archivo_vehiculos,nombreArchivo);
{$i-}
Reset (archivo_vehiculos);
{$I+}
vehiculosRegistrados.tope:=0;
IF (IoResult=0) AND (nombreArchivo<>'') THEN BEGIN
WHILE (NOT EOF(archivo_vehiculos)) AND (vehiculosRegistrados.tope<=MAXVEHICULOS) DO BEGIN
read(archivo_vehiculos,vehiculo);
altaVehiculo(vehiculo,vehiculosRegistrados);
END;
close(archivo_vehiculos);
END
ELSE
writeln('Archivo no existe')
END;
{recibe una variable de tConductoresRegistrados, y pregunta la ubicacion de
archivo, se elimina todo los datos de la lista y carga los conductores
desde el archivo de uno en uno y utiliza la subprograma altaConductor
para anadir de forma ordenada a la lista, y si haya datos repetidos en el archivo
omite el segundo y da un mensaje}
PROCEDURE cargarConductores(VAR conductoresRegistrados:tConductoresRegistrados);
VAR
archivo_conductores:tArchivoConductores;
nombreArchivo:String;
conductor:tConductor;
BEGIN
writeln('Introduzca la ubicacion de archivo');
readln(nombreArchivo);
assign(archivo_conductores,nombreArchivo);
{$i-}
Reset (archivo_conductores);
{$I+}
conductoresRegistrados.tope:=0;
IF (IoResult=0) AND (nombreArchivo<>'') THEN BEGIN
WHILE (NOT EOF(archivo_conductores)) AND (conductoresRegistrados.tope<=MAXCONDUCTORES) DO BEGIN
read(archivo_conductores,conductor);
altaConductor(conductor,conductoresRegistrados);
END;
close(archivo_conductores);
END
ELSE
writeln('Archivo no existe')
END;
{recibe una matricula y la lista de VehiculosRegistrados, eliminaria el primer
vehiculo que coincide la matricula con la dada}
PROCEDURE bajaVehiculo(matricula:tMatricula;VAR vehiculosRegistrados:tVehiculosRegistrados);
VAR i,posicion:integer;
BEGIN
i:=1;
posicion:= posicionVehiculo(matricula,vehiculosRegistrados);
IF posicion>0 THEN
WITH vehiculosRegistrados DO BEGIN
writeln('Matricula: ',vehiculos[posicion].matricula,' Marca: ',vehiculos[posicion].marca,' Color: ',vehiculos[posicion].color,' DNI: ',vehiculos[posicion].dni,' Eliminando de la lista');
FOR i:=posicion TO tope-1 DO
vehiculos[i]:=vehiculos[i+1];
tope:=tope-1;
END
ELSE
writeln('no encuentra dicho vehiculo');
END;
{recibe un dni y la lista de ConductoresRegistrados, eliminaria el primer
conductor que coincide el dni con el dado}
PROCEDURE bajaConductor(dni:tDni;VAR conductoresRegistrados:tConductoresRegistrados);
VAR i:integer;
BEGIN
i:=1;
WITH conductoresRegistrados DO BEGIN
WHILE (i<=tope) AND (conductores[i].dni < dni) DO
i:=i+1;
IF (i<=tope) AND (conductores[i].dni = dni) THEN BEGIN
writeln('DNI: ',conductores[i].dni,' Nombre y apellidos: ',conductores[i].nombreApellidos,' Telefono: ',conductores[i].telefono,' Email: ',conductores[i].email,' Eliminando de la lista');
FOR i:=i TO tope-1 DO
conductores[i]:=conductores[i+1];
tope:=tope-1;
END
ELSE
writeln('no encuentra dicho conductor');
END
END;
{recibe lista de vehiculosAparcados, y pregunta la ubicacion de archivo de
vehiculosAutorizados, la ubicacion de conductoresAutorizado, el dni de conductor
y la matricula de vehiculo, se comprueba que si dicho conductor y vehiculo esta registrado
en el archivo, y preguntara si se permite acceder a dicho vehiculo al parking.
En el caso de que el parking esta lleno o que no encuentra dicho vehiculo/conductor
en el archivo da un mensaje y deja de realizar la operacion}
{Los datos de vehiculosAutorizados y conductoresAutorizado en el sistema no va
ser afectado, cuando carga el archivo}
PROCEDURE accesoVehiculo(VAR vehiculosAparcados:tVehiculosRegistrados);
VAR
vehiculos:tVehiculosRegistrados;
conductores:tConductoresRegistrados;
matricula:tMatricula;
dni:tDni;
opcion:char;
BEGIN
writeln('Introduzca su DNI');
leerdni(dni);
writeln('Introduzca la matricula de vehiculo');
leermatricula(matricula);
writeln('Cargando vehiculos Autorizados');
cargarVehiculos(vehiculos);
writeln('Cargando Conductores');
cargarConductores(conductores);
IF (posicionVehiculo(matricula,vehiculos)>0) AND (posicionConductor(dni,conductores)>0) THEN BEGIN
WITH vehiculos.vehiculos[posicionVehiculo(matricula,vehiculos)] DO
writeln('Matricula: ',matricula,' Marca: ',marca,' Color: ',color,' DNI: ',dni);
WITH conductores.conductores[posicionConductor(dni,conductores)] DO
writeln('DNI: ',dni,' Nombre y apellidos: ',nombreApellidos,' Telefono: ',telefono,' Email: ',email);
writeln('accede al parking? s/n');
REPEAT
readln(opcion);
IF (opcion='s') OR (opcion='S') THEN
altaVehiculo(vehiculos.vehiculos[posicionVehiculo(matricula,vehiculos)],vehiculosAparcados);
UNTIL (opcion = 'S') OR (opcion = 's') OR (opcion = 'N') OR (opcion = 'n');
END
ELSE
writeln('No esta registrado')
END;
{**************************************PROGRAMA PRINCIPAL*****************************************************************}
BEGIN
{inicializacion}
assign(archivo_vehiculos_autorizado,'.\autoriz.dat');
assign(archivo_vehiculos_aparcado,'.\aparcad.dat');
assign(archivo_conductores,'.\conduct.dat');
assign(archivo_conductores_txt,'.\nombre.txt');
vehiculosAutorizados.tope:=0;
vehiculosAparcados.tope:=0;
conductores.tope:=0;
REPEAT
menu();
readln(opcion);
CASE opcion OF
'a','A':BEGIN
leerVehiculo(vehiculo);
WHILE posicionConductor(vehiculo.dni,conductores)=0 DO BEGIN
writeln('Ese conductor con dni ',vehiculo.dni,' no esta en lista de autorizados');
writeln('procede a alta el conductor');
leerConductor(conductor);
altaConductor(conductor,conductores);
END;
altaVehiculo(vehiculo,vehiculosAutorizados);
END;
'b','B':BEGIN
writeln('Introduzca la matricula de vehiculo');
leermatricula(matricula_tmp);
IF posicionVehiculo(matricula_tmp,vehiculosAparcados)=0 THEN
bajaVehiculo(matricula_tmp,vehiculosAutorizados)
ELSE
writeln(matricula_tmp,' se encuentra en aparcamiento');
END;
'c','C':listadoVehiculos(vehiculosAutorizados);
'd','D':listadoVehiculos(vehiculosAparcados);
'e','E':listadoConductor(vehiculosAutorizados);
'f','F':BEGIN
leerConductor(conductor);
altaConductor(conductor,conductores);
END;
'g','G':BEGIN
writeln('Introduzca el dni');
leerdni(dni_temp);
IF posicionVehiculo_por_dni(dni_temp,1,vehiculosAparcados)=0 THEN BEGIN
indice:=1;
WHILE posicionVehiculo_por_dni(dni_temp,indice,vehiculosAutorizados)>0 DO BEGIN
indice:= posicionVehiculo_por_dni(dni_temp,indice,vehiculosAutorizados);
bajaVehiculo(vehiculosAutorizados.vehiculos[indice].matricula,vehiculosAutorizados);
END;
bajaConductor(dni_temp,conductores);
END
ELSE
writeln(vehiculosAparcados.vehiculos[posicionVehiculo_por_dni(dni_temp,1,vehiculosAparcados)].matricula,' se encuentra en aparcamiento');
END;
'h','H':listadoConductoresautorizados(conductores);
'i','I':BEGIN
writeln('Quiere guardar los archivos para actualizar los nuevos cambios realizado? s/N');
readln(opcion);
IF (opcion = 's') OR (opcion='S') THEN BEGIN
guardarVehiculos(vehiculosAutorizados,archivo_vehiculos_autorizado);
guardarVehiculos(vehiculosAparcados,archivo_vehiculos_aparcado);
guardarConductores(conductores,archivo_conductores);
END;
accesoVehiculo(vehiculosAparcados);
END;
'j','J':BEGIN
writeln('Introduzca la matricula de vehiculo');
leermatricula(matricula_tmp);
bajaVehiculo(matricula_tmp,vehiculosAparcados);
END;
'k','K':guardarVehiculos(vehiculosAutorizados,archivo_vehiculos_autorizado);
'l','L':guardarVehiculos(vehiculosAparcados,archivo_vehiculos_aparcado);
'm','M':guardarConductores(conductores,archivo_conductores);
'n','N':guardarConductores_txt(conductores,archivo_conductores_txt);
'o','O':cargarVehiculos(vehiculosAutorizados);
'p','P':cargarVehiculos(vehiculosAparcados);
'q','Q':cargarConductores(conductores);
't','T':
ELSE writeln('opcion incorrecta')
END;
UNTIL (opcion = 't') OR (opcion = 'T');
readln();
END.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment