Pascal/Turbo Pascal - detección de error

   
Vista:

detección de error

Publicado por Diego (98 intervenciones) el 02/05/2014 03:39:36
Buenas noches estuve bastante tiempo tratando de ver en donde es que pierdo una lista dentro del programa.
Luego de salir del módulo eliminar al parecer pierde la lista; aunque no se porque.
A mi parecer el problema debe estar en el eliminar o mostrar_bloque;
Parece ser que es un poco largo el código lo dejo en dos partes de ser posible, además trabaja la carga desde un archivo de texto con el nombre personas.txt el cual tiene adentro las personas en el formato que admite, para ahorrrarles la carga acá les dejo una carga;
4424444#cddc#asa#7577@
6245566#vjkg de#deljl cj#44578@
8670965#ihyoth dj#blbllb#8977@
76767588#fldjlf#ccsjj lclc#3365@
755#vbgbg#sssd#6666@
2233#advdf a#cfvf re#75@
5856#vllb#popdd#6685@
7575#vkgbkj#dcd#475@
12#vfv#cd#7650@
90#aa#c#45@
1#vkf#d#884@
123456789#qwerty#asdfgh#88520@
1142#ki#lp#4888@
4#frf#aaa#777@
98#fr#c c#9530@
4353#vfgb bgb#ddf#14445@
556443#llhlh slf#ldl#44450@
90876#fg lkdfg#poii#47805@
---recuerden no dejar espacios al final.---

codigo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
program prueba;
Const
        LongBloque = 1024;
    Type
        info = record
            posicion: word; {posicion del bloque}
            tam_ocup : word; {tamaño ocupado por todos los registros}
            cant_pers : byte; {cantidad de personas en el bloque}
        end;
        lista = ^nodo;
            nodo = record
                elemen : info;
                dir_sig: lista;
            end;
        tBloque = Array[1..LongBloque] of char; {array para conener los caracteres del bloque}
        arch_pers_bloque = File; {tipo de archivo para empaquetar registros de longitud variable de personas en bloques}
        tPersona = Record {tipo de registro desempaquetado para personas}
            DNI: Longword; {0..4294967295}
            Apellido: String[20];
            Nombres: String[20];
            FechaNac: Longword {AAAAMMDD}
        end;
        ctrl_pers = Record {tipo de registro de control para archivo de personas (handle).
                            Se pasa como parámetro por referencia a cualquier subprograma
                             que acceda al archivo}
            archivo: arch_pers_bloque; {archivo de bloques de personas}
            bloque: tBloque; {bloque buffer para leer o escribir en el archivo de personas}
            indiceBloque: Word; {índice de posicionamiento en el bloque}
            libres: lista; {lista doble ordenada por tamaño disponible en el bloque}
            long_bloque: Word; {longitud del bloque buffer}
            persona: tPersona; {registro buffer para registros desempaquetados de personas}
            ok : boolean; {comprobación del exito de la operación}
        end;
procedure agregar_libre(var list: lista; pos : word; tam: word; cant : byte);
        var
            nue, ant, act : lista;
        begin
            new(nue);
            nue^.elemen.posicion := pos;
            nue^.elemen.tam_ocup := tam;
            nue^.elemen.cant_pers := cant;
            nue^.dir_sig := nil;
            if (list = nil) then
                begin
                    list := nue;
                end
            else
                begin
                    act :=  list;
                    ant := act; {para caso en que sea el primer elemento}
                    while (act <> nil) and (tam > act^.elemen.tam_ocup) do {ordenar de menor a mayor por tamaño}
                        begin
                            ant := act;
                            act := act^.dir_sig;
                        end;
 
                    if (act = nil) then {inserción al final}
                        begin
                            act^.dir_sig := nue;
                        end
                    else
                        begin
                            if (ant = act) then {primer elemento de la lista}
                                begin
                                  nue^.dir_sig := act;
                                  list := nue;
                                end
                             else  {sino es una inserción entre dos elementos}
                                begin
                                    ant^.dir_sig := nue;
                                    nue^.dir_sig := act;
                                end;
                        end;
                end;
        end;
procedure mostrar_bloque(var control: ctrl_pers; num : word);
    var
        i : word;
        aux : lista;
    begin
        with (control) do
            begin
                writeln('Modulo mostrar');
                readln();
                reset(archivo, Longbloque);
                writeln('reset');
                readln();
                seek(archivo, num);
                writeln('Posicionamiento');
                readln();
                blockread(archivo, bloque, 1);
                writeln('lectura');
                readln();
                aux := libres;
                if aux = nil then  begin writeln('Lista perdida antes del mostrar'); readln(); end;
                while (aux^.elemen.posicion <> num)do
                    begin
                    writeln('Posición de la lista: ', aux^.elemen.posicion );
                    aux := aux^.dir_sig;
                    end;
 
                if (aux^.elemen.cant_pers = 0) then
                    writeln('Bloque vacio')
                else
                    begin
                        writeln('Tamaño del bloque: ', aux^.elemen.tam_ocup);
                        readln();
                        for i := 1 to aux^.elemen.tam_ocup do
                            begin
                                write(bloque[i]);
                                if (bloque[i] = '@') then
                                  begin
                                    writeln();
                                    readln();
                                  end;
                            end;
                    end;
               close(archivo);
            end;
   end;
 
 
 
 
 
{a partir de un dato ctrl_pers y  una persona carga la persona al archivo; de haber una única persona
la escribe en el archivo, de haber más de una persona lo deja en el buffer y actualiza el indice del buffer
para la siguiente escritura en el buffer}
procedure cargar(var control: ctrl_pers; linea : string); {testeado: V; funciona: V}
        begin
            with (control) do
                begin
                    reset(archivo, Longbloque);
                    move(linea[0], bloque[indiceBloque], length(linea)+ 1);
                    indiceBloque := indiceBloque + length(linea)+ 1; {comienza luego del @}{creo que no uso indiceBloque}
                    long_bloque := length(linea) + 1;
                    blockwrite(archivo, bloque, 1);
                    agregar_libre(libres, filepos(archivo)- 1, long_bloque, 1);
                    close(archivo);
                end;
        end;
 
{dado un registro de control, busca una persona solo tomando la primera parte que corresponde al dni y la compara
con la primera parte de la persona enviada que corresponde al dni, de encontrarla devuelve un boolean para el exito
de la busqueda y un entero del tipo word para indicar en que bloque se encontró esta persona}
procedure buscar_pers(var control : ctrl_pers; linea : string; var encontrado : boolean; var lugar : word);
        var
          cadena : string; {persona del bloque}
          pos : longword;
          tam_reg : byte;
          indice : word;
          indice_vec : word;
          aux : lista;
          indice_cadena : byte;
        begin
            encontrado := false;
            with (control) do
                begin
                    reset(archivo, LongBloque);
 
                    while (not eof(archivo)) do
                        begin
                            blockread(archivo, bloque, 1);
                            aux := libres;
                            pos := filepos(archivo) -1;
                            while (aux^.elemen.posicion <> pos) do   {error corregido}
                              aux := aux^.dir_sig;
                            tam_reg := 0;
                            indice_vec := 1;
                            indice := 1;
                            while ((indice <= aux^.elemen.tam_ocup) and (encontrado <> true))do
                                begin
                                     if (bloque[indice] <> '@') then
                                        begin
                                            tam_reg := tam_reg + 1;
                                        end
                                     else
                                        begin
                                            move(bloque[indice_vec], cadena[0], tam_reg+1);
                                            indice_vec := indice_vec + tam_reg + 1;
                                            indice_cadena := 1;
                                            while (cadena[indice_cadena] = linea[indice_cadena]) and (cadena[indice_cadena] <> '#') do
                                                indice_cadena := indice_cadena + 1;
                                            if (cadena[indice_cadena] = linea [indice_cadena]) then
                                                begin
                                                    encontrado := true;
                                                    lugar := filepos(archivo) - 1;{indica en que bloque encontró a la persona}
                                                end;
                                            tam_reg := 0;
                                        end;
                                     indice := indice + 1;
                                end;
                        end;
                    close(archivo);
                end;
        end;
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder

detección de error

Publicado por Diego (98 intervenciones) el 02/05/2014 03:57:53
codigo segunda parte:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
procedure insertar(var control: ctrl_pers; linea : string);
        var
            encontrado : boolean;
            tam_pers : byte;
            guardar : boolean;
            aux : lista;
            pos : word;
            bloque_nuevo : tBloque;
        begin
            buscar_pers(control, linea, encontrado, pos);
            if (not encontrado) then
                begin
                    control.ok := true;
                    tam_pers := length(linea)+1;
                    with (control) do
                      begin
                        guardar := false;
                        aux := libres;
                        while ((aux <> nil) and (guardar <> true)) do
                            begin
                                        if (aux^.elemen.cant_pers < 16) then {preguntar si el bloque no está completo}
                                            begin
                                                reset(archivo, LongBloque);
                                                seek(archivo, aux^.elemen.posicion);
                                                blockread(archivo, bloque, 1);
                                                move(linea[0], bloque[aux^.elemen.tam_ocup + 1], tam_pers);
                                                seek(archivo, filepos(archivo)-1);
                                                blockwrite(archivo, bloque, 1);{guardado en el archivo}
                                                guardar := true;
                                                writeln('bloque: ', filepos(archivo)-1);
                                                readln();
                                                aux^.elemen.cant_pers := aux^.elemen.cant_pers + 1; {actualización}
                                                aux^.elemen.tam_ocup := aux^.elemen.tam_ocup + tam_pers;{de libres}
                                                close(archivo);
                                            end;
                                        aux := aux^.dir_sig;
                            end;
                        if (guardar <> true) then {si no se guardó no hay espacio en ningun bloque}
                            begin
                                reset(archivo, LongBloque);
                                seek(archivo, filesize(archivo));
                                move(linea[0], bloque_nuevo[1], tam_pers);
                                blockwrite(archivo, bloque_nuevo, 1);
                                writeln('bloque: ', filepos(archivo)-1);
                                                readln();
                                agregar_libre(libres, filepos(archivo)- 1, tam_pers, 1);
                                close(archivo);
                            end;
 
                      end;
                end
            else
                control.ok := false;
        end;
procedure eliminar(var control : ctrl_pers; dni : longword);
    var
          cadena : string;
          pos : word;
          tam_reg : byte;
          indice : word;
          aux : lista;
          encontrado : boolean;
          linea : string;
          indice_vec : word;
          indice_cadena : byte;
          inicio, bytes : word;
        begin
            Str(dni, linea); {obtención del dni en una cadena}
            linea := linea + '#';{inserción del campo separador de información}
            buscar_pers(control, linea, encontrado, pos);
            if (encontrado = false) then
                begin
                    control.ok := false;
                end
            else
                begin
                    control.ok := true;
                    with (control) do
                        begin
                            encontrado := false;
                            reset(archivo, LongBloque);
                            seek(archivo, pos); {posicionamiento en el bloque en que se encontró el dni}
                            blockread(archivo, bloque, 1);
                            aux := libres;
                            while (aux^.elemen.posicion <> pos) do
                              aux := aux^.dir_sig;
                            writeln('Posicion en la que se encuentra la persona: ', aux^.elemen.posicion);
                            readln();      {hasta aca funciona}
                            tam_reg := 0;
                            indice_vec := 1;
                            indice := 1;
                            while ((indice <= aux^.elemen.tam_ocup) and (encontrado <> true))do
                                begin
                                     if (bloque[indice] <> '@') then
                                        begin
                                            tam_reg := tam_reg + 1;
                                        end
                                     else
                                        begin
                                            inicio := indice_vec;
                                            bytes := tam_reg + 1;
                                            move(bloque[indice_vec], cadena[0], tam_reg+1);
                                            indice_vec := indice_vec + tam_reg + 1;
                                            indice_cadena := 1;
                                            while (cadena[indice_cadena] = linea[indice_cadena]) and (cadena[indice_cadena] <> '#') do
                                                indice_cadena := indice_cadena + 1;
                                            if (cadena[indice_cadena] = linea [indice_cadena]) then
                                                begin
                                                    encontrado := true;
                                                end;
                                            tam_reg := 0;
                                        end;
                                     indice := indice + 1;
                                end;
                            if ((indice -1 = aux^.elemen.tam_ocup) and (encontrado)) then {preguntar si la persona a eliminar es la última}
                                                                    {de ser así solo reduce el tamaño del bloque}
                                begin
                                    aux^.elemen.tam_ocup := aux^.elemen.tam_ocup - bytes;
                                    aux^.elemen.cant_pers := aux^.elemen.cant_pers - 1;
                                end
                            else
                                if (encontrado) then begin
                                begin
                                    move(bloque[indice], bloque[inicio], LongBloque - bytes);  {problema solucionado}
                                    seek(archivo, filepos(archivo)-1);
                                    blockwrite(archivo, bloque, 1);
                                    aux^.elemen.tam_ocup := aux^.elemen.tam_ocup - bytes;
                                    writeln('Tamaño restante: ', aux^.elemen.tam_ocup );
                                    readln();
                                    aux^.elemen.cant_pers := aux^.elemen.cant_pers - 1;
                                end;
                                end;
                            close(archivo);
                        end;
                end;
        end;
 
var
    control : ctrl_pers;
    linea : string;
    arch : text;
    i : byte;
    pos : word;
    encontrado : boolean;
    dni : longword;
    aux : lista;
begin
    with (control) do {trabajamos dentro del registro control}   {módulo crear}
                    begin
                        assign(archivo, 'prueba');
                        ok := true;
                        rewrite(archivo, LongBloque); {cada read/write el puntero del archivo se desplazará}
                                                              {de a 1024 byte, que es la longitud del bloque}
                        indiceBloque := 1; {posiciona el indice en el primer elemento del bloque}
                        libres := nil; {inicialización de las listas de libres}
                        close(archivo);
                    end;
    assign(arch, 'personas.txt');
    reset(arch);
    readln(arch, linea);
    cargar(control, linea);
    i := 1;
    while (not eof(arch)) do
        begin
            readln(arch, linea);
            insertar(control, linea);
            i := i + 1;
            write('persona numero: ', i);
            readln();
            if (control.ok) then
                begin
                    writeln('Se ha ingresado correctamente');
                    readln();
                end
            else
                begin
                    writeln('No se ha posido insertar ya está repetido');
                    readln();
                end;
        end;
    close(arch);
    writeln('bloque a mostrar: ');
    readln(dni);
    mostrar_bloque(control, dni);
    writeln('Ingrese un dni a eliminar: ');
    readln(dni);
    eliminar(control, dni);
    if (control.ok) then
        begin
            writeln('Se ha eliminado correctamente');
            readln();
        end
    else
        begin
            writeln('No se ha eliminado; no existe la persona');
            readln();
        end;
    {writeln('Ingrese la persona a buscar');
    readln(linea);
    buscar_pers(control, linea, encontrado, pos);
    if (encontrado) then
        begin
            writeln('Se encontra en la posición ', pos);
            readln();
        end
    else
        begin
            writeln(linea, ' no se encuentra en el archivo');
            readln();
        end;}
    readln();
    aux := control.libres;
    if (aux = nil) then
        begin
        writeln('Se ha perdido la lista');
        readln();
        end;
    while (aux <> nil ) do
        begin
            writeln('Posicion: ', aux^.elemen.posicion);
            writeln('Tamaño: ', aux^.elemen.tam_ocup);
            writeln('personas: ', aux^.elemen.cant_pers);
            aux := aux^.dir_sig;
        end;
    readln();
    write('INGRESE EL BLOQUE A MOSTRAR: ' );
    readln(dni)     ;
    mostrar_bloque(control, dni);
 
    writeln();
    readln();
    readln();
end. {76758493#cdv#cd cd#5546@}

Intenté subir un rar y un zip, pero no me dejo subir en ningun formato, intenté cambiarle la extensió a jpg, para que solo lo cambien la extensión a .rar, pero parece que no deja bajar la foto así que creo que no servirá.
Lo subo más que nada por el problema de indentación que hay al copiar y pegar en otro lado desde esta página.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

detección de error

Publicado por Diego (98 intervenciones) el 02/05/2014 04:17:44
Parece ser que si funciona, no se, pero si desean bajar el archivo fuente descarguen al imagen i luego cambien la extensión a rar, Yo lo realizé usando el jdowloader, que me detecto la imagen y la descargué, lo digo porque desde el explorador no pude hacer un guardar como.

No sé si sea un problema de la página o del día, ya que en otra ocación si pude subir .rar.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

detección de error

Publicado por Diego (98 intervenciones) el 02/05/2014 18:24:11
Ya pude ver donde es que se pierde la lista; la lista se pierde luego de realizar un move fuera del while en el modulo eliminar; aunque todavía sigo sin entender porque es que se pierde esa lista si no la utilizo.
Si alguien sabe porque es que se pierde esa lista luego de realizar el move, le agradeceria que me lo dijiese.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar