aparcamiento.pas

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.