Pascal/Turbo Pascal - alguien que quiera testear y corregorme

hola que tal, estuve probando y probando, asta que me salio es codigo que le envio aca abajo, pero no anda,,, y no se dond eesta el problema


eSTE ES MI PROGRAMITA, QUE pude hacer, con muchos problemas, puesto que no domino mucho programacion, jajajaja, pero aprendi bastante por el solo hecho de empesar hacer este..

El programita no anda al 100 porciento, hay unos detalles que me estan rompiendo la cabeza, y no logro ver cual es el error..

Bueno le comento brevemente cual es el tema.

La idea es que abra un archivo, y me extraiga todas las palabras que tengan la u con acento, y me lo guarde en oro archivo destino LISTO.TXT

Resumienod:
me busca el archivo a.txt del disco, lo abre, carga el primer renglon (255) caracteres, y de aca empiesa a extraerme todas las palabras con u (ú) que tienen acento, ago mencion que las palabras es el archivo a.txt pueden estar de la siguiente manera

**********************************************
* este-e$ ún.ejemplo del,texto a úextrer *
* a ver *
* $i anda, por/qúe no;qúiere andar*múy bi*en me=pare$e*
**********************************************

palabras que me va a etraer y almacenar en el archivo destino LISTO.TXT, LA CONDICION ES QUE CADA PALABRA TENGA LA LETRA U CON ACENTO, Y PUEDE CONTENER ESTOS CAREACTERES; PUNTO. GUIN BAJO _ GUIN MEDIO - SIMBOLO MOETARIO $

ún.ejemplo
úextrer
qúe
qúiere
múy

Los simbolos . - $ son los unicos simbolos aparte de las letras y los numeros que el programita me puede o deberia procesar, cuando me detecte otro simbolo en medio de una palabra, entonces lo deberia desechar esa palabra si no tiene la letra u con acento, péro no pude ahcerlo, por que son muchos simbolos, y en la linea

While (cad[i] <> ' ') and (cad[i] <> ',') and (cad[i] <> '*') and (cad[i] <> '/') and (i >= 1) do

o en la

While (letra <> 'ú') and (letra <> ' ') and not(eoln(archi)) do

no puedo poner todos los simbolos, por que me salta un error que no me acuerdo cual era, creo que decia que la linea era demasiado largo, y creo que esto lo podria solucionar asi:
** me extrae todas las palabras,una ves que me guarda en un archivo, lo que hago es otro programita que me lea este archivo y me elimine los simbolos que el programa anterior me guardo, osea deberia hacer dos pasadas, para ir viendo caracter por caracter esta dentro del grupó de caracteres que quiero.

COMO SE DARAN CUANTA NO SOY MUY BUENA PROGRAMADORA, PERO DESPACITO IREMOS DEPURANDO ESTE CODIGO

tambien andube viendo que en lugar de utilizar estas lineas

While (cad[i] <> ' ') and (cad[i] <> ',') and (cad[i] <> '*') and (cad[i] <> '/') and (i >= 1) do

o en la

While (letra <> 'ú') and (letra <> ' ') and not(eoln(archi)) do

puedo utilizar CONJUNTOS, y preguntar si cad(i) pertenece o no al conjunto, pero todavia no entendi muy bien eso

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Program principal;

uses Dos;

var
DirInfo : SearchRec; {For Windows,use TSearchRec }
a, z, zz, aa, cont1,y : integer;
NomFile, digito,q,cadena : string;
letra : char;

{ *************************************** }
{ ****** INICIO PROCEDURE crear carpeta****** }


{ }
{ ****** INICIO PROCEDURE EXTRA PALABRA****** }

Procedure Extraepalabra(Archivo: string);

Var
I, p, cont, longi, ll, avansaChar, c : integer;
Archi, dest: text;
Cad, palabra, cola, j, Nom_dest : string;
cadChar : char;


esta funcion lo que hace es poner en orden cada letra, por que, por que se va almacenando en orden inverso, osea la palbra esta al reves
por ejemplo kola:= arbalap, asi llega a esta funcion, y esta funcion
lo que hace es ponerla en orden correcto kola:= palabra

Function concater(yi, xp : integer; kola: string):string;
Var
N,l : integer;
Con : string;
Begin
Con := '';
N := xp - yi;
While (n >= 1) do begin
Con := con + kola[n];
N := n - 1;
End;
Concater := con;
End;

Begin

{ cont1: lo utilizo para enumerar los archivos creado }
{ cuando el archivo creado,supere las 80 palabras }
{ se creara el siguiente, file1.sdn, file2.sdn, file(n+1).sdn }

Str(cont1, digito); { convierte integer a string }
Nom_Dest := 'file' + digito;
Assign (Dest, Nom_dest + '.sdn');
ReWrite(Dest);

Assign(Archi, archivo); {archivo = nomfile}
Reset(archi);
Cont := 0;

While not (eof(archi)) do
Begin
ReadLn(Archi, cad);
P := pos('ú', cad);

{supongamos que el primer renglon del archivo a.txt tiene 300 carateres}
{en cad se almacenaran 255 caracteres, y si writeln(cad) me mostrara }
{los 255 caracteres, bueno si ahora le hago read(archi,letra)}
{siendo letra tipo CHAR, me deberia leer el caracter numero 256 del }
{renglon en el que estoy, pero eso no sucede, aca es el punto en donde }
{no funciona mi programejo }
{aca no importa esto,por que en esta parte solo tiene que procesar el string CAD }
{Y SI cad es mayor a 255 caracteres, mas abajo en el ***if I=255 then** }
{se deberia encargar de procesar los demas caracteres del renglon }
{PERO DETECTE QUE EN ESTA PARTE DE ACA ABASO YA NO LEE CARACTER POR CARACTER}

writeln(cad); {imprimelos primeros 255 caracteres }
read(archi,letra); {lee carater 256, o pienso que deberia hacer eso variable letra tipo char}
writeln(letra); {no me imrpime nada }

While p <> 0 do begin {si es distindo de cero significa que hay una u con acento }
I := p; {guardo el posicion de la u }
Cola := '';

While (cad[i] <> ' ') and (cad[i] <> ',') and (cad[i] <> '*') and (cad[i] <> '/') and (i >= 1) do
Begin
Cola := cola + cad[i];
I := i - 1;
End;

PALABRA := concater(I, p, cola); { llama function concater }

I := p + 1;
Longi := length(cad);

{ anvansamos de la ú(la letra u con acento) para adelante asta extraer la palabra}
While (cad[i] <> ' ') and (cad[i] <> ',') and (cad[i] <> '/') and (cad[i] <> '*') and (I <= longi) do
Begin
palabra := palabra + cad[i];
I := I + 1;
End;

If (cont < 80) then
Begin
WriteLn(Dest, palabra);
Cont := cont + 1;
cad[p] := ' '; {eliminamos la ú(u con acento) ,y}
p := pos('ú', cad); {buscamos la siguiente}
end

ELSE {si la cant supera 80 palabras se }
{cierra file actual se crea proximo }
{file numerado y c reinicia el ciclo}

Begin
Close(Dest);
Cont := 0; {contador de palabras grabados}
Cont1 := cont1 + 1; {numerador de files creados}
Str(cont1, digito);
Nom_Dest := 'listo_' + digito;
WriteLn(Nom_Dest);

Assign (Dest, Nom_dest + '.sdn');

Writeln('nombre file destino ', nom_dest);

Rewrite(dest);
Writeln(dest,palabra);
Cont := cont + 1;
cad[p] := ' ';
p := pos('ú', cad);
end;
end;
I:= length(cad);
read(archi, letra);

{ **** ACAAAA }

if I = 255 then begin

{ }
{ si llega asta aca, es por que en este renglon deL STRING CAD que se esta procesando }
{el renglon es superior a 255 caracteres, entonces empesaremos}
{ a leer caracter por caracter }

read(archi, letra); { LEEMOS EL CARACTER 256}
while not(eoln(archi)) do { final renglon }
begin

{ vamos avansando la palabra asta encontrar la ú o un espacio }
{ si encontramos un espacio significa que esa palabra no tiene}
{ una ú, si encuantra la ú salta de este bucle y entra en el IF THEN }
While (letra <> 'ú') and (letra <> ' ') and not(eoln(archi)) do
Begin
cadena := cadena + letra;
read(archi, letra);
end;

if letra = 'ú' then
begin
writeln('se encontro una ú, por eso salio del bucle WHILE');
While (letra <> ' ') and (letra <> ',') and (letra <> '*') and not(eoln(archi)) do
Begin
cadena := cadena + letra;
read(archi, letra);
End;

if pos('ú',cadena) <> 0 then
begin {si c cumple, entonces en cadena ay una ú}
cadena := cadena + letra; {y salio del bucle por k llego al final }
WriteLn(Dest, cadena);
end;
end;

if letra = ' ' then
writeln(' espacio ', letra);

read(archi, letra);
cadena := '';
End;
End;

End;

IF (cont >= 1) then {si es >= 1 then ay palabras, si no entonces en ese file no ay palabras}
begin
read(archi, letra);
cadena := '';
while not(eoln(archi)) do { final renglon }
begin
While (letra <> 'ú') and (letra <> ' ') and not(eoln(archi)) do
Begin
cadena := cadena + letra;
read(archi, letra);
end;

if letra = 'ú' then
begin
writeln('se encontro una ú, por eso salio del bucle WHILE');
While (letra <> ' ') and (letra <> ',') and (letra <> '"') and not(eoln(archi)) do
Begin
cadena := cadena + letra;
read(archi, letra);
End;

if pos('ú',cadena) <> 0 then {si se cumple, entonces en cadena ay un u con acento}
cadena := cadena + letra; {y salio del bucle por k llego al final }

WriteLn(Dest, cadena);
end;

cadena := '';

End;{ }
Cont1 := cont1 + 1;
Close(dest);
Close(archi);
end
else
begin
Close(dest);
Close(archi);
end;

End; { FIN PROCEDURE EXTRA palabra }

{ CUERPO PRINCIPAL PROGRAMEJO }

begin { For Windows, use faArchive }
FindFirst('*.txt', Archive, DirInfo); { Same as DIR *.PAS }
cont1 := 1; { contador de numero de files procesados }
while DosError = 0 do
begin
Writeln('Nombre del file = ', DirInfo.Name); { imprime el file }
NomFile := DirInfo.Name;
ExtraePalabra(NomFile); { llama procedure para extraer }
FindNext(DirInfo); { busca proximo file }
end;
end.