Duda pascal... Carga de archivo

Eso es manejo de ficheros ^^
Verás; te lo voy a explicar con detalles, para que, si no entiendes algo, sepas qué buscar o qué preguntarme de nuevo.
Necesitas 2 pasos para "abrir" un fichero.
En este caso tu ficheros se tratará como si fuera de Texto (TEXT)
Lo declaras en las varables como TEXT.
VAR fichero:TEXT;
También necesitarás el directorio del mismo:
CONST directorio='texto.TXT';
*Nota: la distinción de mayúsculas/minúsulas en los directorios dependerá de tu Sistema Operativo y el sistema de archivos que emplee. Con Windows no hay distinción (NTFS/FAT32/FAT16), pero hay de todo.
Y también necesitarás una variable doende guardar la línea de texto:
VAR cadena:STRING;
Para preparar al programa para trabajar ocn un ficoero, hay que asignarle memoria RAM. Esto se hace con:
ASSIGN(fichero,directorio);
Con esto, ya hemos reservado un buffer (algo así como un "comodín") en memoria (esto lo hace solo, no te preocupes).
Luego, indicamos que lo queremos abrir para LEER (con esto, permitimos que otros programas también lo puedan abrir para leer. Si es para escribir, el S.O. dará u error si lo intentamos abrir desde otro sitio, diciendo algo así como: "No se pudo abrir le fichero", porque puede que esté cambiando en la escritura ;) )
Pues eso; abrimos con:
RESET(fichero);
Y leemos una línea con:
READLN(fichero,cadena);
Es como el READLN del teclado, pero desde un fichero.
Nunca te has fijado en el (INPUT, ¿OUTPUT) qué te dicen que pongas en la cabecera del programa? Pues INPUT por defecto es el buffer del teclado, y OUTPUT por defecto es el buffer de la pantalla del MSDOS. Si el INPUT lo cambias por un fichero, debería leer directamente del fichero.
De esta forma, si en el READLN especificas otro ficheo distinto, leerá desde ahí.
Y por último, debemos indicar al Sistema Operativo que hemos acabado de toquetear el fichero, y esto se hace SIEMPRE con:
CLOSE(fichero);
Esto es lo básico. Ahora, para leer un fichero, tienes que asegurarte de no pasarte de listo y tratar de leer más líneas de las que tiene.
Para evitar esto, tenemos una functión booleana que te dice si estás ya en el final o no:
EOF(fichero);
(EndOfFile)
Entonces, tu programita resultante quedaría algo así:
PROCEDURE MostrarFichero(directorio:STRING);
 VAR fichero;TEXT;
        cadena:STRING;
 BEGIN
  ASSIGN(fichero,directorio);
  RESET(fichero);
  WHILE NOT (EOF(fichero)) DO
   BEGIN
    READLN(fichero,cadena);
    WRITELN(cadena);
   END;
  CLOSE(f¡chero);
 END;
Vale. Eso te lo escribiría. Pero... Y si el directorio, por lo que sea, no existe, ¿o está mal puedo? (Siele ocurrir si lo introduce el usuario).
Pues que te da un error de entrada/salida (I/O - Innput/Output) en forma de ExitCode, con su numerito, y se cierra (que estoy convencido de que es lo que te pasa). Esto también sucede con cualquier cosa referente a ficheros que no esté bien hecha (como leer más allá del fichero).
Para evitar esto, tenemos DIRECTIVAS de COMPILADOR. Esto avisa al compilador para que active/desactive algunas comprobaciones que haga nuestro lenguaje.
Las utilizaremos para que no compruebe si el fichero existe o no.
Y estas son: {$I-} y {$I+}
La I es de INPUT, y el + indica activar, - dseactivar.
Si ocurre algún error, se almacenará en forma de número en la variable global IORESULT (luego coges el nº, y lo buscas en la lista de errores que viene en la documentación, y ahí ves qué fue lo que suceció).
Entonces, hacemos así:
PROCEDURE MostrarFichero(directorio:STRING);
 VAR fichero;TEXT;
        cadena:STRING;
 BEGIN
  ASSIGN(fichero,directorio);
{$I-}
RESET(fichero);
{$I+}
IF IORESULT=0 THEN //el 0 indica que todo fue bien
 BEGIN
  WHILE NOT (EOF(fichero)) DO
   BEGIN
    READLN(fichero,cadena);
    WRITELN(cadena);
   END;
  CLOSE(f¡chero);
 END;
END;
Espero haber sido de ayuda, y haber respondido, al menos en parte, a tus preguntas. Creo que con esto má o menos puedo haberte aclarado algo ;)

Mira este es el programa que tengo para hacer la carga de archivo
program Untitled;
uses crt;
var
ruta:string;
archivo:text;
bandera:boolean;
begin
repeat
bandera:=true;
writeln ('introduzca la ruta del archivo');
readln (ruta);
assign (archivo,ruta);
{$i-}
reset (archivo);
if (ioresult <> 0) then
begin
bandera:=false;
writeln ('ruta no valida');
readln (ruta);
end;
{$i+}{F:\Mis archivos recibidos gun.txt}
until bandera=true;
readln;
end.
Por lo que leí de lo que me dijiste necesito cerrar el archivo que estoy abriendo... pero el punto es que noc en que parte exactamente tengo que colocarlo... haber si me puedes ayudar
Dentro del block de notas tengo esto... y esa ruta que me aparece hay es de donde lo tiene que leer
..._...|..____________________,,
....../ ..---___________---_____|]
...../_==o;;;;;;;;_______.:/
...), ---.(_(__) /
...// (..) ), ----'
...//___//
..//___//
.//___//
Agradecería tu respuesta

Creo que esto te ayudaría:
FUNCTION ExisteFichero(dir:STRING);
 VAR f:FILE;
 BEGIN
  ASSIGN(f,dir);
  {$I-}
  RESET(f);
  {$I+}
  ExisteFichero:=IORESULT=0;
 END;
Yo lo metería e un bucle:
(...)
WRITELN('Introduzca la ruta del fichero:');
REPEAT
  READLN(ruta);
UNTIL ExisteFichero(ruta);
(...) //Aquí lo que queras hacer con esa ruta, que Sí existe

Aja pero exactamente en que parte del problema tengo que colocar eso... porque toy perdido este es el tema más complicado que he visto hasta ahora en pascal y con las dos clasecitas que he tenido... realmente no me aclaran muchas dudas de que hacer en los ejercicios
Agradezco tu respuesta