Pascal/Turbo Pascal - Consulta Analizador Léxico

   
Vista:

Consulta Analizador Léxico

Publicado por Jeremias jeremias_93@hotmail.com (3 intervenciones) el 20/07/2013 04:00:50
Necesitaria que me revisen el siguiente codigo, sobre un analizador lexico, y me digan donde esta el error, ya que no me hace lo que tiene que hacer, es decir compila y todo pero siempre nos devuelve vacio como compolex y no ejecuta las demas funciones. La unit declaraciones que usamos en el analizador se las agrego tambien al comienzo. El analizador sintactico lo tengo hecho aparte, pero funciona correctamente. Muchas gracias.

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
unit declaraciones;
 interface
 uses crt;
type
 
 archivo=file of char;
 
 simbolos=(comienzo,fin,id,mientras,si,entero,entonces,leer,mostrar,pa,pc,hacer,es,sino,coma,puntocoma,mas,menos,por,divi,pot,constante,may,men,ig,dist,mayig,menig,andd,orr,nott,punto,epsilon,vacio,peso,PROGRAMA,LISTASENT,SENT,N,P,LISTASAL,M,EXPARIT,J,W,Z,X,T2,EXPLOG,A,D,EXPREL,OPREL,Y);
 
 terminales=comienzo..peso;
 
 variables=PROGRAMA..Y;
 
 tdatol=simbolos;
 
 tpunterol=^tnodo;
 
 tnodo=record
        info:simbolos;
        sig:tpunterol;
       end;
 
 tlista=record
          cab:tpunterol;
          tam:cardinal;
         end;
 
 tas=array[variables,terminales] of tlista;
 
 tdatop=simbolos;
 tpunterop=^tnodop;
 tnodop= record
        info:tdatop;
        sig: tpunterop;
       end;
 
 tpila= record
        tope:tpunterop;
        tam:cardinal;
       end;
 
 tdatotabla=simbolos;
 
 tpunterotabla=^tnodotabla;
 
 tnodotabla=record
             lex:string;
             comp:tdatotabla;
             sig:tpunterotabla;
            end;
 
 ttabla= record
          cab:tpunterotabla;
          tam:cardinal;
         end;
 
 
var
 pila:tpila;
 
procedure crearlista (var l:tlista);
procedure insertarl(var l:tlista;x:tdatol);
function  tamaniolista(l:tlista):cardinal;
procedure crearp(var p:tpila);
procedure insertarp(var p:tpila; x:tdatop);
procedure eliminarp(var p:tpila;var x:tdatop);
procedure apilarproducciones(var p:tpila;producciones:tlista);
procedure ruta(var l:string; var r:string);
procedure creartabla(var l:ttabla);
procedure agregartabla(var l:ttabla; lexema:string; comp:terminales);
procedure busqentabla(var l:ttabla; lexema:string;var comp:terminales; var aux:byte);
 
implementation
procedure crearlista (var l:tlista);
begin
 l.cab:=nil;
 l.tam:=0;
end;
 
procedure insertarl(var l:tlista;x:tdatol);
var aux,ant,act:tpunterol;
 
begin
 inc(l.tam);
 new(aux);
 aux^.info:=x;
  if (l.cab=nil) or (x<l.cab^.info) then
   begin
    aux^.sig:=l.cab;
    l.cab:=aux;
   end
  else
   begin
    ant:=l.cab;
    act:=l.cab^.sig;
     while (act<>nil) and (act^.info <= x) do
      begin
       ant:=act;
       act:=act^.sig;
      end;
    aux^.sig:=act;
    ant^.sig:=aux;
   end;
end;
 
function  tamaniolista(l:tlista):cardinal;
 
begin
 tamaniolista:=l.tam;
end;
 
procedure crearp(var p:tpila);
 
begin
p.tope:=nil;
p.tam:=0;
end;
 
procedure insertarp(var p:tpila; x:tdatop);
var aux:tpunterop;
 
begin
new(aux);
aux^.info:=x;
aux^.sig:=p.tope;
p.tope:=aux;
inc(p.tam);
end;
 
procedure eliminarp(var p:tpila;var x:tdatop);
var aux:tpunterop;
 
begin
x:=p.tope^.info;
aux:=p.tope;
p.tope:=aux^.sig;
dispose(aux);
dec(p.tam);
end;
 
procedure apilarproducciones(var p:tpila;producciones:tlista);
type
 tvector=array[1..30] of simbolos;
var
     i,t:byte;
     vecaaux:tvector;
 
 procedure barridol(l:tlista;var vector:tvector);
  var act:tpunterol;
 
  begin
   act:=l.cab;
   i:=1;
   while (act <> nil) do
    begin
     vector[i]:=act^.info;
     act:=act^.sig;
     inc(i);
    end;
   end;
 
begin
 barridol(producciones,vecaaux);
 t:=tamaniolista(producciones);
  for i:=t downto 1 do
   if vecaaux[i]<>epsilon then
    insertarp(p,vecaaux[i]);
 
end;
 
procedure ruta(var l:string; var r:string);
Var aux1,aux2:string;
 begin
   aux1:='C:\Users\MATIAS\Desktop\Proyecto\';
   aux2:='.txt';
   gotoxy(33,4);
   readln(l);
   gotoxy(18,7);
   readln(r);
   r:=aux1+r+aux2;
 end;
 
procedure creartabla(var l:ttabla);
begin
 l.cab:=nil;
 l.tam:=0;
end;
 
procedure busqentabla(var l:ttabla; lexema:string;var comp:terminales; var aux:byte);
   var act:tpunterotabla;
  begin
   aux:=1;
   act:=l.cab;
    while (act <> nil) do
     begin
      if act^.lex=lexema then
       comp:=act^.comp
      else
       act:=act^.sig;
     end;
    if act=nil then
     aux:=0
  end;
 
procedure agregartabla(var l:ttabla; lexema:string;comp:terminales);
 var aux,ant,act:tpunterotabla;
 
begin
 inc(l.tam);
 new(aux);
 aux^.lex:=lexema;
 aux^.comp:=comp;
  if (l.cab=nil) or (lexema<l.cab^.lex) then
   begin
    aux^.sig:=l.cab;
    l.cab:=aux;
   end
  else
   begin
    ant:=l.cab;
    act:=l.cab^.sig;
     while (act<>nil) and (act^.lex <=lexema) do
      begin
       ant:=act;
       act:=act^.sig;
      end;
    aux^.sig:=act;
    ant^.sig:=aux;
   end;
end;
 
 
END.


---------------------------------------------------------------------------------------------------------------------------------------

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
234
235
236
237
238
unit analex;
 
interface
uses declaraciones;
 
procedure obtenersigcomplex(var fuente:archivo; var control:longint; var compolex:terminales; var lexema:string; ts:ttabla);
 
 
implementation
 
 
procedure esid(var fuente:archivo;var control:longint;var lexema:string;var compolex:terminales; var ts:ttabla;var a:byte);
Const
  q0=0;
Type
  Sigma=(Letra, Digito, Otro);
  Q=0..3;
  TipoDelta=Array[Q,Sigma] of Q;
Var
  EstadoActual: Q;
  Delta: TipoDelta;
  b:byte;
  caracter:char;
 
  function CarASimb(Car:char):sigma;
   Begin
       Case car of
        'a'..'z', 'A'..'Z':CarASimb:=Letra;
        '0'..'9':CarASimb:=Digito;
       else
       CarASimb:=Otro
       End;
   End;
 
Begin
 
  Delta[0,Letra]:=1;
  Delta[0,Digito]:=2;
  Delta[0,Otro]:=2;
  Delta[1,letra]:=1;
  Delta[1,digito]:=1;
  Delta[1,otro]:=3;
  Delta[2,letra]:=2;
  Delta[2,digito]:=2;
  Delta[2,otro]:=2;
  lexema:='';
  EstadoActual:=q0;
 
  while (EstadoActual<>2) and (EstadoActual<>3) and not eof(fuente) do
    begin
 
    read(fuente,caracter);
    EstadoActual:=Delta[EstadoActual, CarAsimb(Lexema[Control])];
    inc(control);
    seek(fuente,control);lexema:=lexema+caracter;inc(control);
    end;
 
    if estadoactual<>3 then
     a:=0
    else
     begin
      a:=1;
      delete(lexema,length(lexema),1);
      control:=filepos(fuente)-1;
      busqentabla(ts,lexema,compolex,b);
      if b=0 then
         begin
          compolex:=id;
          agregartabla(ts,lexema,compolex);
         end
    end;
 
End;
 
function esentero(var fuente:archivo;var control:longint;var lexema:string):byte;
 Const
  q0=0;
Type
  Sigma=(signo, Digito, Otro);
  Q=0..4;
  TipoDelta=Array[Q,Sigma] of Q;
Var
  EstadoActual: Q;
  Delta: TipoDelta;
  caracter:char;
 
  function CarASimb(Car:char):sigma;
   Begin
    Case car of
     '0'..'9':CarASimb:=Digito;
     '-': CarAsimb:=Signo
    else
     CarASimb:=Otro
    End;
   End;
Begin
  Delta[0,Digito]:=1;
  Delta[0,Signo]:=2;
  Delta[0,Otro]:=3;
  Delta[1,Digito]:=1;
  Delta[1,Signo]:=3;
  Delta[1,otro]:=4;
  Delta[2,Digito]:=1;
  Delta[2,otro]:=3;
  Delta[2,signo]:=3;
  Delta[3,digito]:=3;
  Delta[3,signo]:=3;
  Delta[3,otro]:=3;
  EstadoActual:=q0;
  lexema:='';
 
while (EstadoActual<>3) and (EstadoActual<>4)and not eof(fuente) do
   begin
    seek(fuente,control);
    read(fuente,caracter);
    lexema:=lexema+caracter;
    EstadoActual:=Delta[EstadoActual, CarAsimb(Lexema[Control])];
    inc(control);
   end;
   if EstadoActual=3 then
   esentero:=0
   else
    begin
    delete(lexema,length(lexema),1);
    esentero:=1;
    control:=filepos(fuente)-1;
    end;
End;
 
 
procedure obtenersigcomplex(var fuente:archivo; var control:longint; var compolex:terminales; var lexema:string; ts:ttabla);
 
var
caracter:char;
c:byte;
 
begin
  seek(fuente,control);
   if eof(fuente) then
         compolex:=peso
   else
	begin
     read(fuente,caracter);
     while (caracter in [#0..#32]) and not eof(fuente) do
      begin
       inc(control);
       read(fuente,caracter);
      end;
     if eof(fuente) then
      compolex:=peso
     else
      begin
      if caracter in ['=',',','.','(',')',';','>','<','+','-','*','/','^','&','~','|'] then
       case caracter of
        '=': begin
             compolex:=ig;
             inc(control);
             end;
        ';': begin
             compolex:=puntocoma;
             inc(control);
             end;
        ',': begin
             compolex:=coma;
             inc(control);
             end;
        '.': begin
             compolex:=punto;
             inc(control);
             end;
        '(': begin
             compolex:=pa;
             inc(control);
             end;
        ')': begin
             compolex:= pc;
             inc(control);
             end;
        '>': begin
             compolex:= may;
             inc(control);
             end;
        '<': begin
             compolex:= men;
             inc(control);
             end;
        '+': begin
             compolex:= mas;
             inc(control);
             end;
        '-': begin
             compolex:= menos;
             inc(control);
             end;
        '*': begin
             compolex:=por;
             inc(control);
             end;
        '/': begin
             compolex:=divi;
             inc(control);
             end;
        '^': begin
             compolex:=pot;
             inc(control);
             end;
        '&': begin
             compolex:=andd;
             inc(control);
             end;
        '~': begin
             compolex:=nott;
             inc(control);
             end;
        '|': begin
             compolex:=orr;
             inc(control);
             end;
       end
       else
        begin
         esid(fuente,control,lexema,compolex,ts,c);
         if c=1 then
           compolex:=compolex
         else
          begin
          control:=control-1;
           if esentero(fuente,control,lexema)=1 then
            begin
             lexema:=lexema;
            compolex:=constante;
            end;
          end;
      end;
  end;
 end;
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

Consulta Analizador Léxico

Publicado por ramon (2072 intervenciones) el 22/07/2013 21:22:29
Para poder darte una revisión correcta necesito el programa principal para examinar el funcionamiento de las dos unidades pu esto que estas no dan error de compilación.
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

Consulta Analizador Léxico

Publicado por Jeremias (3 intervenciones) el 22/07/2013 21:39:40
Este es el analilzador sintactico, con el que trabaja el lexico.. Mas abajo te mando el programa principal. Muchas gracias!

Analizador Sintactico

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
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
unit anasin;
 
 
interface
 
uses declaraciones,analex;
 
procedure analizadorsint(r:string; var s:boolean);
 
 
 
implementation
procedure creartablasim(var l:ttabla);
begin
creartabla(l);
agregartabla(l,'comienzo',comienzo);
agregartabla(l,'fin',fin);
agregartabla(l,'mientras',mientras);
agregartabla(l,'si',si);
agregartabla(l,'entero',entero);
agregartabla(l,'entonces',entonces);
agregartabla(l,'leer',leer);
agregartabla(l,'mostrar',mostrar);
agregartabla(l,'pa',pa);
agregartabla(l,'pc',pc);
agregartabla(l,'hacer',hacer);
agregartabla(l,'es',es);
agregartabla(l,'sino',sino);
agregartabla(l,'coma',coma);
agregartabla(l,'puntocoma',puntocoma);
agregartabla(l,'mas',mas);
agregartabla(l,'menos',menos);
agregartabla(l,'por',por);
agregartabla(l,'divi',divi);
agregartabla(l,'pot',pot);
agregartabla(l,'constante',constante);
agregartabla(l,'may',may);
agregartabla(l,'men',men);
agregartabla(l,'dist',dist);
agregartabla(l,'mayig',mayig);
agregartabla(l,'menig',menig);
agregartabla(l,'andd',andd);
agregartabla(l,'orr',orr);
agregartabla(l,'nott',nott);
agregartabla(l,'punto',punto);
agregartabla(l,'epsilon',epsilon);
agregartabla(l,'vacio',vacio);
agregartabla(l,'peso',peso);
end;
 
procedure creartas(var tabla:tas);
var
I,K:simbolos;
 
begin
for I:= comienzo to peso do
  begin
  for K:=PROGRAMA to Y do
     begin
     crearlista(tabla[I,K]);
     end;
  end;
 
New(Tabla[PROGRAMA,comienzo].cab);
 insertarl(Tabla[PROGRAMA,comienzo],comienzo);
 insertarl(Tabla[PROGRAMA,comienzo],LISTASENT);
 insertarl(Tabla[PROGRAMA,comienzo],fin);
 
New(Tabla[LISTASENT,id].cab);
 insertarl(Tabla[LISTASENT,id],SENT);
 insertarl(Tabla[LISTASENT,id],puntocoma);
 insertarl(Tabla[LISTASENT,id],N);
 
New(Tabla[LISTASENT,mientras].cab);
 insertarl(Tabla[LISTASENT,mientras],SENT);
 insertarl(Tabla[LISTASENT,mientras],puntocoma);
 insertarl(Tabla[LISTASENT,mientras],N);
 
New(Tabla[LISTASENT,si].cab);
 insertarl(Tabla[LISTASENT,si],SENT);
 insertarl(Tabla[LISTASENT,si],puntocoma);
 insertarl(Tabla[LISTASENT,si],N);
 
New(Tabla[LISTASENT,leer].cab);
 insertarl(Tabla[LISTASENT,leer],SENT);
 insertarl(Tabla[LISTASENT,leer],puntocoma);
 insertarl(Tabla[LISTASENT,leer],N);
 
New(Tabla[LISTASENT,mostrar].cab);
 insertarl(Tabla[LISTASENT,mostrar],SENT);
 insertarl(Tabla[LISTASENT,mostrar],puntocoma);
 insertarl(Tabla[LISTASENT,mostrar],N);
 
New(Tabla[SENT,id].cab);
 insertarl(Tabla[SENT,id],id);
 insertarl(Tabla[SENT,id],P);
 
New(Tabla[SENT,mientras].cab);
 insertarl(Tabla[SENT,mientras],mientras);
 insertarl(Tabla[SENT,mientras],EXPLOG);
 insertarl(Tabla[SENT,mientras],hacer);
 insertarl(Tabla[SENT,mientras],comienzo);
 insertarl(Tabla[SENT,mientras],LISTASENT);
 insertarl(Tabla[SENT,mientras],fin);
 
New(Tabla[SENT,si].cab);
 insertarl(Tabla[SENT,si],si);
 insertarl(Tabla[SENT,si],EXPLOG);
 insertarl(Tabla[SENT,si],entonces);
 insertarl(Tabla[SENT,si],comienzo);
 insertarl(Tabla[SENT,si],LISTASENT);
 insertarl(Tabla[SENT,si],fin);
 insertarl(Tabla[SENT,si],J);
 
New(Tabla[SENT,leer].cab);
 insertarl(Tabla[SENT,leer],leer);
 insertarl(Tabla[SENT,leer],pa);
 insertarl(Tabla[SENT,leer],id);
 insertarl(Tabla[SENT,leer],pc);
 
New(Tabla[SENT,mostrar].cab);
 insertarl(Tabla[SENT,mostrar],mostrar);
 insertarl(Tabla[SENT,mostrar],pa);
 insertarl(Tabla[SENT,mostrar],LISTASAL);
 insertarl(Tabla[SENT,mostrar],pc);
 
 
New(Tabla[N,fin].cab);
 insertarl(Tabla[N,fin],epsilon);
 
New(Tabla[N,id].cab);
 insertarl(Tabla[N,id],LISTASENT);
 
New(Tabla[N,mientras].cab);
 insertarl(Tabla[N,mientras],LISTASENT);
 
New(Tabla[N,si].cab);
 insertarl(Tabla[N,si],LISTASENT);
 
New(Tabla[N,leer].cab);
 insertarl(Tabla[N,leer],LISTASENT);
 
New(Tabla[N,mostrar].cab);
 insertarl(Tabla[N,mostrar],LISTASENT);
 
New(Tabla[P,es].cab);
 insertarl(Tabla[P,es],es);
 insertarl(Tabla[P,es],entero);
 
New(Tabla[P,ig].cab);
 insertarl(Tabla[P,ig],ig);
 insertarl(Tabla[P,ig],EXPARIT);
 
New(Tabla[LISTASAL,id].cab);
 insertarl(Tabla[LISTASAL,id],EXPARIT);
 insertarl(Tabla[LISTASAL,id],M);
 
New(Tabla[LISTASAL,constante].cab);
 insertarl(Tabla[LISTASAL,constante],EXPARIT);
 insertarl(Tabla[LISTASAL,constante],M);
 
New(Tabla[M,pc].cab);
 insertarl(Tabla[M,pc],epsilon);
 
New(Tabla[M,coma].cab);
 insertarl(Tabla[M,coma],coma);
 insertarl(Tabla[M,coma],EXPARIT);
 insertarl(Tabla[M,coma],M);
 
New(Tabla[EXPARIT,id].cab);
 insertarl(Tabla[EXPARIT,id],T2);
 insertarl(Tabla[EXPARIT,id],X);
 insertarl(Tabla[EXPARIT,id],Z);
 insertarl(Tabla[EXPARIT,id],W);
 
New(Tabla[EXPARIT,pa].cab);
 insertarl(Tabla[EXPARIT,pa],T2);
 insertarl(Tabla[EXPARIT,pa],X);
 insertarl(Tabla[EXPARIT,pa],Z);
 insertarl(Tabla[EXPARIT,pa],W);
 
New(Tabla[EXPARIT,constante].cab);
 insertarl(Tabla[EXPARIT,constante],T2);
 insertarl(Tabla[EXPARIT,constante],X);
 insertarl(Tabla[EXPARIT,constante],Z);
 insertarl(Tabla[EXPARIT,constante],W);
 
New(Tabla[J,puntocoma].cab);
 insertarl(Tabla[J,puntocoma],epsilon);
 
New(Tabla[J,sino].cab);
 insertarl(Tabla[J,sino],sino);
 insertarl(Tabla[J,sino],comienzo);
 insertarl(Tabla[J,sino],LISTASENT);
 insertarl(Tabla[J,sino],fin);
 
New(Tabla[W,pc].cab);
 insertarl(Tabla[W,pc],epsilon);
 
New(Tabla[W,hacer].cab);
 insertarl(Tabla[W,hacer],epsilon);
 
New(Tabla[W,coma].cab);
 insertarl(Tabla[W,coma],epsilon);
 
New(Tabla[W,puntocoma].cab);
 insertarl(Tabla[W,puntocoma],epsilon);
 
New(Tabla[W,mas].cab);
 insertarl(Tabla[W,mas],mas);
 insertarl(Tabla[W,mas],T2);
 insertarl(Tabla[W,mas],X);
 insertarl(Tabla[W,mas],Z);
 insertarl(Tabla[W,mas],W);
 
New(Tabla[W,menos].cab);
 insertarl(Tabla[W,menos],menos);
 insertarl(Tabla[W,menos],T2);
 insertarl(Tabla[W,menos],X);
 insertarl(Tabla[W,menos],Z);
 insertarl(Tabla[W,menos],W);
 
New(Tabla[W,mayig].cab);
 insertarl(Tabla[W,mayig],epsilon);
 
New(Tabla[W,may].cab);
 insertarl(Tabla[W,may],epsilon);
 
New(Tabla[W,menig].cab);
 insertarl(Tabla[W,menig],epsilon);
 
New(Tabla[W,men].cab);
 insertarl(Tabla[W,men],epsilon);
 
New(Tabla[W,ig].cab);
 insertarl(Tabla[W,ig],epsilon);
 
New(Tabla[W,dist].cab);
 insertarl(Tabla[W,dist],epsilon);
 
New(Tabla[W,andd].cab);
 insertarl(Tabla[W,andd],epsilon);
 
New(Tabla[W,orr].cab);
 insertarl(Tabla[W,orr],epsilon);
 
New(Tabla[W,entonces].cab);
 insertarl(Tabla[W,entonces],epsilon);
 
New(Tabla[Z,divi].cab);
 insertarl(Tabla[Z,divi],divi);
 insertarl(Tabla[Z,divi],T2);
 insertarl(Tabla[Z,divi],X);
 insertarl(Tabla[Z,divi],Z);
 
New(Tabla[Z,por].cab);
 insertarl(Tabla[Z,por],por);
 insertarl(Tabla[Z,por],T2);
 insertarl(Tabla[Z,por],X);
 insertarl(Tabla[Z,por],Z);
 
New(Tabla[Z,mas].cab);
 insertarl(Tabla[Z,mas],epsilon);
 
New(Tabla[Z,coma].cab);
 insertarl(Tabla[Z,coma],epsilon);
 
New(Tabla[Z,pc].cab);
 insertarl(Tabla[Z,pc],epsilon);
 
New(Tabla[Z,may].cab);
 insertarl(Tabla[Z,may],epsilon);
 
New(Tabla[Z,mayig].cab);
 insertarl(Tabla[Z,mayig],epsilon);
 
New(Tabla[Z,men].cab);
 insertarl(Tabla[Z,men],epsilon);
 
New(Tabla[Z,menig].cab);
 insertarl(Tabla[Z,menig],epsilon);
 
New(Tabla[Z,ig].cab);
 insertarl(Tabla[Z,ig],epsilon);
 
New(Tabla[Z,fin].cab);
 insertarl(Tabla[Z,fin],epsilon);
 
New(Tabla[Z,dist].cab);
 insertarl(Tabla[Z,dist],epsilon);
 
New(Tabla[Z,orr].cab);
 insertarl(Tabla[Z,orr],epsilon);
 
New(Tabla[Z,andd].cab);
 insertarl(Tabla[Z,andd],epsilon);
 
New(Tabla[Z,hacer].cab);
 insertarl(Tabla[Z,hacer],epsilon);
 
New(Tabla[Z,entonces].cab);
 insertarl(Tabla[Z,entonces],epsilon);
 
New(Tabla[Z,menos].cab);
 insertarl(Tabla[Z,menos],epsilon);
 
 
New(Tabla[X,pc].cab);
 insertarl(Tabla[X,pc],epsilon);
 
New(Tabla[X,hacer].cab);
 insertarl(Tabla[X,hacer],epsilon);
 
New(Tabla[X,coma].cab);
 insertarl(Tabla[X,coma],epsilon);
 
New(Tabla[X,divi].cab);
 insertarl(Tabla[X,divi],epsilon);
 
New(Tabla[X,mas].cab);
 insertarl(Tabla[X,mas],epsilon);
 
New(Tabla[X,menos].cab);
 insertarl(Tabla[X,menos],epsilon);
 
New(Tabla[X,por].cab);
 insertarl(Tabla[X,por],epsilon);
 
New(Tabla[X,pot].cab);
 insertarl(Tabla[X,pot],pot);
 insertarl(Tabla[X,pot],T2);
 insertarl(Tabla[X,pot],X);
 
New(Tabla[X,may].cab);
 insertarl(Tabla[X,may],epsilon);
 
New(Tabla[X,men].cab);
 insertarl(Tabla[X,men],epsilon);
 
New(Tabla[X,mayig].cab);
 insertarl(Tabla[X,mayig],epsilon);
 
New(Tabla[X,menig].cab);
 insertarl(Tabla[X,menig],epsilon);
 
New(Tabla[X,ig].cab);
 insertarl(Tabla[X,ig],epsilon);
 
New(Tabla[X,dist].cab);
 insertarl(Tabla[X,dist],epsilon);
 
New(Tabla[X,andd].cab);
 insertarl(Tabla[X,andd],epsilon);
 
New(Tabla[X,orr].cab);
 insertarl(Tabla[X,orr],epsilon);
 
New(Tabla[X,entonces].cab);
 insertarl(Tabla[X,entonces],epsilon);
 
New(Tabla[X,puntocoma].cab);
 insertarl(Tabla[X,puntocoma],epsilon);
 
 
New(Tabla[T2,id].cab);
 insertarl(Tabla[T2,id],id);
 
New(Tabla[T2,pc].cab);
 insertarl(Tabla[T2,pc],pa);
 insertarl(Tabla[T2,pc],EXPARIT);
 insertarl(Tabla[T2,pc],pc);
 
New(Tabla[T2,constante].cab);
 insertarl(Tabla[T2,constante],constante);
 
New(Tabla[EXPLOG,id].cab);
 insertarl(Tabla[EXPLOG,id],D);
 insertarl(Tabla[EXPLOG,id],Y);
 insertarl(Tabla[EXPLOG,id],A);
 
New(Tabla[EXPLOG,pc].cab);
 insertarl(Tabla[EXPLOG,pc],D);
 insertarl(Tabla[EXPLOG,pc],Y);
 insertarl(Tabla[EXPLOG,pc],A);
 
New(Tabla[EXPLOG,constante].cab);
 insertarl(Tabla[EXPLOG,constante],D);
 insertarl(Tabla[EXPLOG,constante],Y);
 insertarl(Tabla[EXPLOG,constante],A);
 
New(Tabla[EXPLOG,nott].cab);
 insertarl(Tabla[EXPLOG,nott],D);
 insertarl(Tabla[EXPLOG,nott],Y);
 insertarl(Tabla[EXPLOG,nott],A);
 
New(Tabla[A,pc].cab);
 insertarl(Tabla[A,pc],epsilon);
 
New(Tabla[A,hacer].cab);
 insertarl(Tabla[A,hacer],epsilon);
 
New(Tabla[A,entonces].cab);
 insertarl(Tabla[A,entonces],epsilon);
 
New(Tabla[A,orr].cab);
 insertarl(Tabla[A,orr],orr);
 insertarl(Tabla[A,orr],D);
 insertarl(Tabla[A,orr],Y);
 insertarl(Tabla[A,orr],A);
 
New(Tabla[D,id].cab);
 insertarl(Tabla[D,id],EXPREL);
 
New(Tabla[D,pc].cab);
 insertarl(Tabla[D,pc],pa);
 insertarl(Tabla[D,pc],EXPLOG);
 insertarl(Tabla[D,pc],pc);
 
New(Tabla[D,constante].cab);
 insertarl(Tabla[D,constante],EXPREL);
 
New(Tabla[D,nott].cab);
 insertarl(Tabla[D,nott],nott);
 insertarl(Tabla[D,nott],pa);
 insertarl(Tabla[D,nott],EXPLOG);
 insertarl(Tabla[D,nott],pc);
 
New(Tabla[EXPREL,id].cab);
 insertarl(Tabla[EXPREL,id],EXPARIT);
 insertarl(Tabla[EXPREL,id],OPREL);
 insertarl(Tabla[EXPREL,id],EXPARIT);
 
New(Tabla[EXPREL,pa].cab);
 insertarl(Tabla[EXPREL,pa],EXPARIT);
 insertarl(Tabla[EXPREL,pa],OPREL);
 insertarl(Tabla[EXPREL,pa],EXPARIT);
 
New(Tabla[EXPREL,constante].cab);
 insertarl(Tabla[EXPREL,constante],EXPARIT);
 insertarl(Tabla[EXPREL,constante],OPREL);
 insertarl(Tabla[EXPREL,constante],EXPARIT);
 
New(Tabla[OPREL,may].cab);
 insertarl(Tabla[OPREL,may],may);
 
New(Tabla[OPREL,men].cab);
 insertarl(Tabla[OPREL,men],men);
 
New(Tabla[OPREL,mayig].cab);
 insertarl(Tabla[OPREL,mayig],mayig);
 
New(Tabla[OPREL,menig].cab);
 insertarl(Tabla[OPREL,menig],menig);
 
New(Tabla[OPREL,dist].cab);
 insertarl(Tabla[OPREL,dist],dist);
 
New(Tabla[OPREL,ig].cab);
 insertarl(Tabla[OPREL,ig],ig);
 
New(Tabla[Y,pc].cab);
 insertarl(Tabla[Y,pc],epsilon);
 
New(Tabla[Y,hacer].cab);
 insertarl(Tabla[Y,hacer],epsilon);
 
New(Tabla[Y,orr].cab);
 insertarl(Tabla[Y,orr],epsilon);
 
New(Tabla[Y,entonces].cab);
 insertarl(Tabla[Y,entonces],epsilon);
 
New(Tabla[Y,andd].cab);
 insertarl(Tabla[Y,andd],andd);
 insertarl(Tabla[Y,andd],D);
 insertarl(Tabla[Y,andd],Y);
 
end;
 
procedure analizadorsint(r:string; var s:boolean);
type
 result=(procesando,exito,errorlex,errorsint);
 
 var
  tas:tas;
  pilasint:tpila;
  f:archivo;
  complex:terminales;
  control:longint;
  lexema:string;
  ts:ttabla;
  resultado:result;
 
begin
 creartablasim(ts);
 creartas(tas);
 crearp(pilasint);
 insertarp(pilasint,peso);
 insertarp(pilasint,PROGRAMA);
 control:=0;
 assign(f,r);
 reset(f);
 obtenersigcomplex(f,control,complex,lexema,ts);
 resultado:=procesando;
  while resultado=procesando do
   begin           //resultado: (procesando,exito,errorlexico,errorsintantico)
       eliminarp(pilasint,pilasint.tope^.info);
       if pilasint.tope^.info in [comienzo..peso] then
        begin
          if pilasint.tope^.info=complex then
           begin
            obtenersigcomplex(f,control,complex,lexema,ts);
            if complex=vacio then
               resultado:=errorlex
              else
               if complex=peso then
                resultado:=exito
           end
          else
             resultado:=errorlex;
        end;
       if pilasint.tope^.info in [PROGRAMA..Y] then
        begin
         if tas[pilasint.tope^.info,complex].cab=nil then
           resultado:=errorsint
          else
           apilarproducciones(pilasint,tas[pilasint.tope^.info,complex]);
         end;
       if pilasint.tope^.info=peso then
        resultado:=exito;
   end;
 
  if resultado=exito then
   s:=true
  else
   s:=false;
 
 end;
END.


----------------------------------------------------------------------------------------------------------------------

Programa principal

1
2
3
4
5
6
7
8
9
10
11
12
PROGRAM principal;
USES crt,pantallas,declaraciones,anasin;
var
  n,r:string;
 
BEGIN
   pantalla1;
   ruta(n,r);
   analizadorsint(r,s);
   pantalla2(n,r,s);
   readkey;
END.
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

Consulta Analizador Léxico

Publicado por ramon (2072 intervenciones) el 25/07/2013 23:11:38
Puedes pasar la unidad pantallas o decirme que hace
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

Consulta Analizador Léxico

Publicado por Jeremias (3 intervenciones) el 26/07/2013 02:06:15
Esta es la unit de pantalla Ramon, muchas gracias por tu intencion de ayudarme!

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
unit pantallas;
 
interface
 
Uses crt;
 
Var n,p:string;
    s:boolean;
 
Procedure pantalla1;
Procedure pantalla2(n:string; r:string; s:boolean);
Procedure ruta;
procedure Mensaje(U,U1:byte;msj:string);
procedure Color(T,F:byte);
 
implementation
 
procedure Color(T,F:byte);
 begin
     Textcolor(T);
     Textbackground(F);
 end;
 
procedure Mensaje(U,U1:byte;msj:string);
 begin
     gotoxy(U,U1);
     write(msj);
 end;
 
Procedure pantalla1;
 begin
     clrscr;
     color(blue,black);
     Mensaje(30,2,'Without Holidays');
     Mensaje(1,4,'Escriba el nombre del programa:');
     Mensaje(1,7,'Escriba la ruta:');
 end;
 
Procedure ruta;
 begin
     gotoxy(33,4);
     readln(n);
     gotoxy(18,7);
     readln(p);
 end;
 
Procedure pantalla2(n:string; r:string; s:boolean);
 begin
     clrscr;
     color(blue,black);
     Mensaje(30,2,'Without Holidays');
     Mensaje(1,4,'Programa: ');
     Mensaje(12,4,n);
     Mensaje(1,5,'ruta: ');
     Mensaje(7,5,r);
     if s=true then
         Mensaje(1,7,'Compilo Correctamente')
     else
         Mensaje(1,7,'Error al compilar');
 end;
 
END.
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

Consulta Analizador Léxico

Publicado por ramon (2072 intervenciones) el 26/07/2013 22:46:57
A ver si la reviso lo antes posible.
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

Consulta Analizador Léxico

Publicado por ramon (2072 intervenciones) el 27/07/2013 21:35:37
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
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
{Lo segundo}
 
{//////////////////////////////////////////////////////////////}
 
 
  procedure creartablasim(var l:ttabla);
  begin
      creartabla(l);
      agregartabla(l,'comienzo',comienzo);
      agregartabla(l,'fin',fin);
      agregartabla(l,'mientras',mientras);
      agregartabla(l,'si',si);
      agregartabla(l,'entero',entero);
      agregartabla(l,'entonces',entonces);
      agregartabla(l,'leer',leer);
      agregartabla(l,'mostrar',mostrar);
      agregartabla(l,'pa',pa);
      agregartabla(l,'pc',pc);
      agregartabla(l,'hacer',hacer);
      agregartabla(l,'es',es);
      agregartabla(l,'sino',sino);
      agregartabla(l,'coma',coma);
      agregartabla(l,'puntocoma',puntocoma);
      agregartabla(l,'mas',mas);
      agregartabla(l,'menos',menos);
      agregartabla(l,'por',por);
      agregartabla(l,'divi',divi);
      agregartabla(l,'pot',pot);
      agregartabla(l,'constante',constante);
      agregartabla(l,'may',may);
      agregartabla(l,'men',men);
      agregartabla(l,'dist',dist);
      agregartabla(l,'mayig',mayig);
      agregartabla(l,'menig',menig);
      agregartabla(l,'andd',andd);
      agregartabla(l,'orr',orr);
      agregartabla(l,'nott',nott);
      agregartabla(l,'punto',punto);
      agregartabla(l,'epsilon',epsilon);
      agregartabla(l,'vacio',vacio);
      agregartabla(l,'peso',peso);
  end;
 
  procedure creartas(var tabla:tas);
  var
    I, K : simbolos;
  begin
    for K := PROGRAMA to Y do
   begin
     for I:= comienzo to peso do
     begin
       crearlista(tabla[k,i]);
     end;
  end;
 
  New(Tabla[PROGRAMA,comienzo].cab);
    insertarl(Tabla[PROGRAMA,comienzo],comienzo);
    insertarl(Tabla[PROGRAMA,comienzo],LISTASENT);
    insertarl(Tabla[PROGRAMA,comienzo],fin);
 
  New(Tabla[LISTASENT,id].cab);
    insertarl(Tabla[LISTASENT,id],SENT);
    insertarl(Tabla[LISTASENT,id],puntocoma);
    insertarl(Tabla[LISTASENT,id],N);
 
  New(Tabla[LISTASENT,mientras].cab);
    insertarl(Tabla[LISTASENT,mientras],SENT);
    insertarl(Tabla[LISTASENT,mientras],puntocoma);
    insertarl(Tabla[LISTASENT,mientras],N);
 
  New(Tabla[LISTASENT,si].cab);
    insertarl(Tabla[LISTASENT,si],SENT);
    insertarl(Tabla[LISTASENT,si],puntocoma);
    insertarl(Tabla[LISTASENT,si],N);
 
  New(Tabla[LISTASENT,leer].cab);
    insertarl(Tabla[LISTASENT,leer],SENT);
    insertarl(Tabla[LISTASENT,leer],puntocoma);
    insertarl(Tabla[LISTASENT,leer],N);
 
  New(Tabla[LISTASENT,mostrar].cab);
    insertarl(Tabla[LISTASENT,mostrar],SENT);
    insertarl(Tabla[LISTASENT,mostrar],puntocoma);
    insertarl(Tabla[LISTASENT,mostrar],N);
 
  New(Tabla[SENT,id].cab);
    insertarl(Tabla[SENT,id],id);
    insertarl(Tabla[SENT,id],P);
 
  New(Tabla[SENT,mientras].cab);
    insertarl(Tabla[SENT,mientras],mientras);
    insertarl(Tabla[SENT,mientras],EXPLOG);
    insertarl(Tabla[SENT,mientras],hacer);
    insertarl(Tabla[SENT,mientras],comienzo);
    insertarl(Tabla[SENT,mientras],LISTASENT);
    insertarl(Tabla[SENT,mientras],fin);
 
New(Tabla[SENT,si].cab);
 insertarl(Tabla[SENT,si],si);
 insertarl(Tabla[SENT,si],EXPLOG);
 insertarl(Tabla[SENT,si],entonces);
 insertarl(Tabla[SENT,si],comienzo);
 insertarl(Tabla[SENT,si],LISTASENT);
 insertarl(Tabla[SENT,si],fin);
 insertarl(Tabla[SENT,si],J);
 
New(Tabla[SENT,leer].cab);
 insertarl(Tabla[SENT,leer],leer);
 insertarl(Tabla[SENT,leer],pa);
 insertarl(Tabla[SENT,leer],id);
 insertarl(Tabla[SENT,leer],pc);
 
New(Tabla[SENT,mostrar].cab);
 insertarl(Tabla[SENT,mostrar],mostrar);
 insertarl(Tabla[SENT,mostrar],pa);
 insertarl(Tabla[SENT,mostrar],LISTASAL);
 insertarl(Tabla[SENT,mostrar],pc);
 
 
New(Tabla[N,fin].cab);
 insertarl(Tabla[N,fin],epsilon);
 
New(Tabla[N,id].cab);
 insertarl(Tabla[N,id],LISTASENT);
 
New(Tabla[N,mientras].cab);
 insertarl(Tabla[N,mientras],LISTASENT);
 
New(Tabla[N,si].cab);
 insertarl(Tabla[N,si],LISTASENT);
 
New(Tabla[N,leer].cab);
 insertarl(Tabla[N,leer],LISTASENT);
 
New(Tabla[N,mostrar].cab);
 insertarl(Tabla[N,mostrar],LISTASENT);
 
New(Tabla[P,es].cab);
 insertarl(Tabla[P,es],es);
 insertarl(Tabla[P,es],entero);
 
New(Tabla[P,ig].cab);
 insertarl(Tabla[P,ig],ig);
 insertarl(Tabla[P,ig],EXPARIT);
 
New(Tabla[LISTASAL,id].cab);
 insertarl(Tabla[LISTASAL,id],EXPARIT);
 insertarl(Tabla[LISTASAL,id],M);
 
New(Tabla[LISTASAL,constante].cab);
 insertarl(Tabla[LISTASAL,constante],EXPARIT);
 insertarl(Tabla[LISTASAL,constante],M);
 
New(Tabla[M,pc].cab);
 insertarl(Tabla[M,pc],epsilon);
 
New(Tabla[M,coma].cab);
 insertarl(Tabla[M,coma],coma);
 insertarl(Tabla[M,coma],EXPARIT);
 insertarl(Tabla[M,coma],M);
 
New(Tabla[EXPARIT,id].cab);
 insertarl(Tabla[EXPARIT,id],T2);
 insertarl(Tabla[EXPARIT,id],X);
 insertarl(Tabla[EXPARIT,id],Z);
 insertarl(Tabla[EXPARIT,id],W);
 
New(Tabla[EXPARIT,pa].cab);
 insertarl(Tabla[EXPARIT,pa],T2);
 insertarl(Tabla[EXPARIT,pa],X);
 insertarl(Tabla[EXPARIT,pa],Z);
 insertarl(Tabla[EXPARIT,pa],W);
 
New(Tabla[EXPARIT,constante].cab);
 insertarl(Tabla[EXPARIT,constante],T2);
 insertarl(Tabla[EXPARIT,constante],X);
 insertarl(Tabla[EXPARIT,constante],Z);
 insertarl(Tabla[EXPARIT,constante],W);
 
New(Tabla[J,puntocoma].cab);
 insertarl(Tabla[J,puntocoma],epsilon);
 
New(Tabla[J,sino].cab);
 insertarl(Tabla[J,sino],sino);
 insertarl(Tabla[J,sino],comienzo);
 insertarl(Tabla[J,sino],LISTASENT);
 insertarl(Tabla[J,sino],fin);
 
New(Tabla[W,pc].cab);
 insertarl(Tabla[W,pc],epsilon);
 
New(Tabla[W,hacer].cab);
 insertarl(Tabla[W,hacer],epsilon);
 
New(Tabla[W,coma].cab);
 insertarl(Tabla[W,coma],epsilon);
 
New(Tabla[W,puntocoma].cab);
 insertarl(Tabla[W,puntocoma],epsilon);
 
New(Tabla[W,mas].cab);
 insertarl(Tabla[W,mas],mas);
 insertarl(Tabla[W,mas],T2);
 insertarl(Tabla[W,mas],X);
 insertarl(Tabla[W,mas],Z);
 insertarl(Tabla[W,mas],W);
 
New(Tabla[W,menos].cab);
 insertarl(Tabla[W,menos],menos);
 insertarl(Tabla[W,menos],T2);
 insertarl(Tabla[W,menos],X);
 insertarl(Tabla[W,menos],Z);
 insertarl(Tabla[W,menos],W);
 
New(Tabla[W,mayig].cab);
 insertarl(Tabla[W,mayig],epsilon);
 
New(Tabla[W,may].cab);
 insertarl(Tabla[W,may],epsilon);
 
New(Tabla[W,menig].cab);
 insertarl(Tabla[W,menig],epsilon);
 
New(Tabla[W,men].cab);
 insertarl(Tabla[W,men],epsilon);
 
New(Tabla[W,ig].cab);
 insertarl(Tabla[W,ig],epsilon);
 
New(Tabla[W,dist].cab);
 insertarl(Tabla[W,dist],epsilon);
 
New(Tabla[W,andd].cab);
 insertarl(Tabla[W,andd],epsilon);
 
New(Tabla[W,orr].cab);
 insertarl(Tabla[W,orr],epsilon);
 
New(Tabla[W,entonces].cab);
 insertarl(Tabla[W,entonces],epsilon);
 
New(Tabla[Z,divi].cab);
 insertarl(Tabla[Z,divi],divi);
 insertarl(Tabla[Z,divi],T2);
 insertarl(Tabla[Z,divi],X);
 insertarl(Tabla[Z,divi],Z);
 
New(Tabla[Z,por].cab);
 insertarl(Tabla[Z,por],por);
 insertarl(Tabla[Z,por],T2);
 insertarl(Tabla[Z,por],X);
 insertarl(Tabla[Z,por],Z);
 
New(Tabla[Z,mas].cab);
 insertarl(Tabla[Z,mas],epsilon);
 
New(Tabla[Z,coma].cab);
 insertarl(Tabla[Z,coma],epsilon);
 
New(Tabla[Z,pc].cab);
 insertarl(Tabla[Z,pc],epsilon);
 
New(Tabla[Z,may].cab);
 insertarl(Tabla[Z,may],epsilon);
 
New(Tabla[Z,mayig].cab);
 insertarl(Tabla[Z,mayig],epsilon);
 
New(Tabla[Z,men].cab);
 insertarl(Tabla[Z,men],epsilon);
 
New(Tabla[Z,menig].cab);
 insertarl(Tabla[Z,menig],epsilon);
 
New(Tabla[Z,ig].cab);
 insertarl(Tabla[Z,ig],epsilon);
 
New(Tabla[Z,fin].cab);
 insertarl(Tabla[Z,fin],epsilon);
 
New(Tabla[Z,dist].cab);
 insertarl(Tabla[Z,dist],epsilon);
 
New(Tabla[Z,orr].cab);
 insertarl(Tabla[Z,orr],epsilon);
 
New(Tabla[Z,andd].cab);
 insertarl(Tabla[Z,andd],epsilon);
 
New(Tabla[Z,hacer].cab);
 insertarl(Tabla[Z,hacer],epsilon);
 
New(Tabla[Z,entonces].cab);
 insertarl(Tabla[Z,entonces],epsilon);
 
New(Tabla[Z,menos].cab);
 insertarl(Tabla[Z,menos],epsilon);
 
 
New(Tabla[X,pc].cab);
 insertarl(Tabla[X,pc],epsilon);
 
New(Tabla[X,hacer].cab);
 insertarl(Tabla[X,hacer],epsilon);
 
New(Tabla[X,coma].cab);
 insertarl(Tabla[X,coma],epsilon);
 
New(Tabla[X,divi].cab);
 insertarl(Tabla[X,divi],epsilon);
 
New(Tabla[X,mas].cab);
 insertarl(Tabla[X,mas],epsilon);
 
New(Tabla[X,menos].cab);
 insertarl(Tabla[X,menos],epsilon);
 
New(Tabla[X,por].cab);
 insertarl(Tabla[X,por],epsilon);
 
New(Tabla[X,pot].cab);
 insertarl(Tabla[X,pot],pot);
 insertarl(Tabla[X,pot],T2);
 insertarl(Tabla[X,pot],X);
 
New(Tabla[X,may].cab);
 insertarl(Tabla[X,may],epsilon);
 
New(Tabla[X,men].cab);
 insertarl(Tabla[X,men],epsilon);
 
New(Tabla[X,mayig].cab);
 insertarl(Tabla[X,mayig],epsilon);
 
New(Tabla[X,menig].cab);
 insertarl(Tabla[X,menig],epsilon);
 
New(Tabla[X,ig].cab);
 insertarl(Tabla[X,ig],epsilon);
 
New(Tabla[X,dist].cab);
 insertarl(Tabla[X,dist],epsilon);
 
New(Tabla[X,andd].cab);
 insertarl(Tabla[X,andd],epsilon);
 
New(Tabla[X,orr].cab);
 insertarl(Tabla[X,orr],epsilon);
 
New(Tabla[X,entonces].cab);
 insertarl(Tabla[X,entonces],epsilon);
 
New(Tabla[X,puntocoma].cab);
 insertarl(Tabla[X,puntocoma],epsilon);
 
 
New(Tabla[T2,id].cab);
 insertarl(Tabla[T2,id],id);
 
New(Tabla[T2,pc].cab);
 insertarl(Tabla[T2,pc],pa);
 insertarl(Tabla[T2,pc],EXPARIT);
 insertarl(Tabla[T2,pc],pc);
 
New(Tabla[T2,constante].cab);
 insertarl(Tabla[T2,constante],constante);
 
New(Tabla[EXPLOG,id].cab);
 insertarl(Tabla[EXPLOG,id],D);
 insertarl(Tabla[EXPLOG,id],Y);
 insertarl(Tabla[EXPLOG,id],A);
 
New(Tabla[EXPLOG,pc].cab);
 insertarl(Tabla[EXPLOG,pc],D);
 insertarl(Tabla[EXPLOG,pc],Y);
 insertarl(Tabla[EXPLOG,pc],A);
 
New(Tabla[EXPLOG,constante].cab);
 insertarl(Tabla[EXPLOG,constante],D);
 insertarl(Tabla[EXPLOG,constante],Y);
 insertarl(Tabla[EXPLOG,constante],A);
 
New(Tabla[EXPLOG,nott].cab);
 insertarl(Tabla[EXPLOG,nott],D);
 insertarl(Tabla[EXPLOG,nott],Y);
 insertarl(Tabla[EXPLOG,nott],A);
 
New(Tabla[A,pc].cab);
 insertarl(Tabla[A,pc],epsilon);
 
New(Tabla[A,hacer].cab);
 insertarl(Tabla[A,hacer],epsilon);
 
New(Tabla[A,entonces].cab);
 insertarl(Tabla[A,entonces],epsilon);
 
New(Tabla[A,orr].cab);
 insertarl(Tabla[A,orr],orr);
 insertarl(Tabla[A,orr],D);
 insertarl(Tabla[A,orr],Y);
 insertarl(Tabla[A,orr],A);
 
New(Tabla[D,id].cab);
 insertarl(Tabla[D,id],EXPREL);
 
New(Tabla[D,pc].cab);
 insertarl(Tabla[D,pc],pa);
 insertarl(Tabla[D,pc],EXPLOG);
 insertarl(Tabla[D,pc],pc);
 
New(Tabla[D,constante].cab);
 insertarl(Tabla[D,constante],EXPREL);
 
New(Tabla[D,nott].cab);
 insertarl(Tabla[D,nott],nott);
 insertarl(Tabla[D,nott],pa);
 insertarl(Tabla[D,nott],EXPLOG);
 insertarl(Tabla[D,nott],pc);
 
New(Tabla[EXPREL,id].cab);
 insertarl(Tabla[EXPREL,id],EXPARIT);
 insertarl(Tabla[EXPREL,id],OPREL);
 insertarl(Tabla[EXPREL,id],EXPARIT);
 
New(Tabla[EXPREL,pa].cab);
 insertarl(Tabla[EXPREL,pa],EXPARIT);
 insertarl(Tabla[EXPREL,pa],OPREL);
 insertarl(Tabla[EXPREL,pa],EXPARIT);
 
New(Tabla[EXPREL,constante].cab);
 insertarl(Tabla[EXPREL,constante],EXPARIT);
 insertarl(Tabla[EXPREL,constante],OPREL);
 insertarl(Tabla[EXPREL,constante],EXPARIT);
 
New(Tabla[OPREL,may].cab);
 insertarl(Tabla[OPREL,may],may);
 
New(Tabla[OPREL,men].cab);
 insertarl(Tabla[OPREL,men],men);
 
New(Tabla[OPREL,mayig].cab);
 insertarl(Tabla[OPREL,mayig],mayig);
 
New(Tabla[OPREL,menig].cab);
 insertarl(Tabla[OPREL,menig],menig);
 
New(Tabla[OPREL,dist].cab);
 insertarl(Tabla[OPREL,dist],dist);
 
New(Tabla[OPREL,ig].cab);
 insertarl(Tabla[OPREL,ig],ig);
 
New(Tabla[Y,pc].cab);
 insertarl(Tabla[Y,pc],epsilon);
 
New(Tabla[Y,hacer].cab);
 insertarl(Tabla[Y,hacer],epsilon);
 
New(Tabla[Y,orr].cab);
 insertarl(Tabla[Y,orr],epsilon);
 
New(Tabla[Y,entonces].cab);
 insertarl(Tabla[Y,entonces],epsilon);
 
New(Tabla[Y,andd].cab);
 insertarl(Tabla[Y,andd],andd);
 insertarl(Tabla[Y,andd],D);
 insertarl(Tabla[Y,andd],Y);
end;
 
 procedure analizadorsint(r : string; var s : boolean);
 type
  result = (procesando,exito,errorlex,errorsint);
 var
  tas1:tas;
  pilasint:tpila;
  complex:terminales;
  control:longint;
  lexema:string;
  ts:ttabla;
  resultado:result;
 
begin
 creartablasim(ts);
 creartas(tas1);
 crearp(pilasint);
 insertarp(pilasint,peso);
 insertarp(pilasint,PROGRAMA);
  control:=0;
  assign(f,r);
 {$I-} reset(f); {$I+}
 if ioresult <> 0 then
 begin
    writeln('  Error De Archivo Pulse Una Tecla ');
    readkey;
    halt(1);
 end;
 obtenersigcomplex(control,complex,lexema,ts);
 resultado := procesando;
  while resultado = procesando do
   begin
   {//resultado: (procesando,exito,errorlexico,errorsintantico)}
       eliminarp(pilasint,pilasint.tope^.info);
       if pilasint.tope^.info in [comienzo..peso] then
        begin
          if pilasint.tope^.info=complex then
           begin
            obtenersigcomplex(control,complex,lexema,ts);
            if complex=vacio then
               resultado:=errorlex
              else
               if complex=peso then
                resultado:=exito
           end
          else
             resultado:=errorlex;
        end;
       if pilasint.tope^.info in [PROGRAMA..Y] then
        begin
         if tas1[pilasint.tope^.info,complex].cab=nil then
           resultado:=errorsint
          else
           apilarproducciones(pilasint,tas1[pilasint.tope^.info,complex]);
         end;
       if pilasint.tope^.info=peso then
        resultado:=exito;
   end;
  if resultado=exito then
   s:=true
  else
   s:=false;
 
 end;
 
 {//////////////////////////////////////////////////////////////////}
 
procedure Color(T,F:byte);
 begin
     Textcolor(T);
     Textbackground(F);
 end;
 
procedure Mensaje(U,U1:byte;msj:string);
 begin
     gotoxy(U,U1);
     write(msj);
 end;
 
Procedure pantalla1;
 begin
     clrscr;
     color(15,0);
     Mensaje(30,2,'Without Holidays');
     Mensaje(1,4,'Escriba el nombre del programa:');
     Mensaje(1,7,'Escriba la ruta:');
 end;
 
Procedure rutap;
 begin
     gotoxy(33,4);
     readln(n3);
     gotoxy(18,7);
     readln(p3);
 end;
 
Procedure pantalla2(n:string; r:string; s:boolean);
 begin
     clrscr;
     color(15,0);
     Mensaje(30,2,'Without Holidays');
     Mensaje(1,4,'Programa : ');
     Mensaje(12,4,n);
     Mensaje(1,5,'ruta : ');
     Mensaje(8,5,r);
     if s = true then
         Mensaje(1,7,'Compilo Correctamente')
     else
         Mensaje(1,7,'Error al compilar');
 end;
 
 {/////////////////////////////////////////////////////////////}
 
 
BEGIN
   pantalla1;
   ruta(n3,r);
   analizadorsint(r,s);
   pantalla2(n3,r,s);
   readkey;
END.
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

Consulta Analizador Léxico

Publicado por ramon (2072 intervenciones) el 27/07/2013 21:33:28
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
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
{Lo convierto en programa para estudiarlo mejor funciona pero tendrá que retocar}
 
program prueva;
 uses
   crt;
type
 
  simbolos = (comienzo,fin,id,mientras,si,entero,entonces,leer,mostrar,
  pa,pc,hacer,es,sino,coma,puntocoma,mas,menos,por,divi,pot,constante,may,
  men,ig,dist,mayig,menig,andd,orr,nott,punto,epsilon,vacio,peso,
  PROGRAMA,LISTASENT,SENT,N,P,LISTASAL,M,EXPARIT,J,W,Z,X,T2,EXPLOG,A,D,
  EXPREL,OPREL,Y);
 
 terminales = comienzo..peso;
 
 variables = PROGRAMA..Y;
 
 tdatol = simbolos;
 
 tpunterol = ^tnodo;
 
 tnodo = record
        info:simbolos;
        sig:tpunterol;
       end;
 
 tlista = record
          cab : tpunterol;
          tam : longint;
         end;
 
 tas = array[variables,terminales] of tlista;
 
 tdatop = simbolos;
 tpunterop = ^tnodop;
 tnodop = record
        info : tdatop;
        sig : tpunterop;
       end;
 
 tpila = record
        tope : tpunterop;
        tam : longint;
       end;
 
 tdatotabla = simbolos;
 
 tpunterotabla = ^tnodotabla;
 
 tnodotabla = record
             lex : string;
             comp : tdatotabla;
             sig : tpunterotabla;
            end;
 
 ttabla = record
          cab : tpunterotabla;
          tam : longint;
         end;
 
 
var
 f : text;
 total : longint;
 pila : tpila;
 aux, ant, act : tpunterol;
 aux1, ant1, act1 : tpunterop;
 aux2, ant2, act2 : tpunterotabla;
 p3 : string;
 s : boolean;
 n3, r : string;
 
 
 {////////////////////////////////////////////////////////////////////}
 procedure crearlista(var l:tlista);
 begin
    l.cab := nil;
    l.tam := 0;
  end;
 
  procedure insertarl(var l : tlista; x : tdatol);
  begin
      if l.cab = nil then
      begin
         new(aux);
         inc(l.tam);
         aux^.info := x;
         l.cab := aux;
         aux^.sig := nil;
      end
   else
      begin
         ant := aux;
         new(aux);
         inc(l.tam);
         aux^.info := x;
         ant^.sig := aux;
         aux^.sig := nil;
      end;
       {new(aux);
       inc(l.tam);
   aux^.info:=x;
  if (l.cab=nil) or (x<l.cab^.info) then
   begin
    aux^.sig:=l.cab;
    l.cab:=aux;
   end
  else
   begin
    ant:=l.cab;
    act:=l.cab^.sig;
     while (act<>nil) and (act^.info <= x) do
      begin
       ant:=act;
       act:=act^.sig;
      end;
       aux^.sig:=act;
       ant^.sig:=aux;
   end;}
 
end;
 
function  tamaniolista(l:tlista):longint;
 
begin
 tamaniolista:=l.tam;
end;
 
 procedure crearp(var p:tpila);
 begin
   p.tope := nil;
   p.tam := 0;
 end;
 
 procedure insertarp(var p:tpila; x:tdatop);
 begin
   if p.tope = nil then
      begin
         new(aux1);
         inc(p.tam);
         aux1^.info := x;
         p.tope := aux1;
         aux1^.sig := nil;
      end
   else
      begin
         ant1 := aux1;
         new(aux1);
         inc(p.tam);
         aux1^.info := x;
         ant1^.sig := aux1;
         aux1^.sig := nil;
      end;
  {new(aux);
   aux^.info:=x;
   aux^.sig:=p.tope;
   p.tope:=aux;
   inc(p.tam);}
 
  end;
 
 procedure eliminarp(var p:tpila;var x:tdatop);
 begin
     x := p.tope^.info;
    aux1 := p.tope;
    p.tope := aux1^.sig;
    dispose(aux1);
    dec(p.tam);
 end;
 
  procedure apilarproducciones(var p:tpila;producciones:tlista);
  type
      tvector = array[0..29] of simbolos;
   var
     i, t : byte;
     vecaaux : tvector;
 
  procedure barridol(l : tlista;var vector : tvector);
  begin
     act := l.cab;
     i := 0;
     while (act <> nil) do
    begin
     vector[i] := act^.info;
     act := act^.sig;
     inc(i);
    end;
   end;
 
  begin
     barridol(producciones,vecaaux);
     t := tamaniolista(producciones);
     for i := t downto 1 do
     if vecaaux[i] <> epsilon then
      insertarp(p,vecaaux[i]);
   end;
 
  procedure ruta(var l1:string; var r1:string);
  const
     auxx : string = 'Users\MATIAS\Desktop\Proyecto\';
  Var
    aux1, aux2 : string;
  begin
   aux2:='.txt';
   gotoxy(33,4);
   readln(l1);
   gotoxy(18,7);
   readln(r1);
   if r1 <> ' ' then
   auxx := r1;
   r1 := auxx + l1 + aux2;
 end;
 
  procedure creartabla(var l:ttabla);
  begin
     l.cab:=nil;
     l.tam:=0;
  end;
 
   procedure busqentabla(var l : ttabla; lexema : string;
                         var comp4 : terminales;
                         var aux4 : byte);
  begin
   aux4 := 1;
   act2 := l.cab;
    while (act2 <> nil) do
     begin
      if act2^.lex = lexema then
       comp4 := act2^.comp
      else
       act2 := act2^.sig;
     end;
    if act2 = nil then
     aux4 := 0
  end;
 
 procedure agregartabla(var l : ttabla; lexema : string;comp : terminales);
 begin
    if l.cab = nil then
    begin
       new(aux2);
       inc(l.tam);
       aux2^.lex := lexema;
       aux2^.comp := comp;
       l.cab := aux2;
       aux2^.sig := nil;
    end
  else
     begin
        ant2 := aux2;
        new(aux2);
        inc(l.tam);
        aux2^.lex := lexema;
        aux2^.comp := comp;
        ant2^.sig := aux2;
        aux2^.sig := nil;
     end;
 
    {inc(l.tam);
    new(aux);
    aux^.lex:=lexema;
 aux^.comp:=comp;
  if (l.cab=nil) or (lexema<l.cab^.lex) then
   begin
    aux^.sig:=l.cab;
    l.cab:=aux;
   end
  else
   begin
    ant:=l.cab;
    act:=l.cab^.sig;
     while (act<>nil) and (act^.lex <=lexema) do
      begin
       ant:=act;
       act:=act^.sig;
      end;
    aux^.sig:=act;
    ant^.sig:=aux;
   end;}
 
end;
 
{//////////////////////////////////////////////////////////////}
 
  procedure esid(var control : longint;
                 var lexema : string; var compolex : terminales;
                 var ts : ttabla; var a : byte);
  Const
     q0 = 0;
  Type
     Sigma = (Letra, Digito, Otro);
     Q = 0..3;
     TipoDelta = Array[Q,Sigma] of Q;
  Var
     EstadoActual : Q;
     Delta : TipoDelta;
     b : byte;
     caracter : char;
 
  function CarASimb(Car:char):sigma;
   Begin
       if car in[#97..#122,#65..#90] then
       CarASimb := Letra;
       if car in[#48..#57] then
       CarASimb := Digito;
 
       {Case car of
        'a'..'z', 'A'..'Z':CarASimb:=Letra;
        '0'..'9':CarASimb:=Digito;
       else
       CarASimb:=Otro
       End;}
 
   End;
 
Begin
  Delta[0,Letra] := 1;
  Delta[0,Digito] := 2;
  Delta[0,Otro] := 2;
  Delta[1,letra] := 1;
  Delta[1,digito] := 1;
  Delta[1,otro] := 3;
  Delta[2,letra] := 2;
  Delta[2,digito] := 2;
  Delta[2,otro] := 2;
  lexema := '';
  EstadoActual := q0;
  while (EstadoActual <> 2) and (EstadoActual <> 3) and not eof(f) do
  begin
    read(f,caracter);
    EstadoActual:=Delta[EstadoActual, CarAsimb(Lexema[Control])];
    inc(control);
    {seek(f,control);}
    lexema := lexema + caracter;
    inc(control);
    end;
    if estadoactual <> 3 then
     a := 0
    else
     begin
      a := 1;
 
      delete(lexema,length(lexema),1);
      control := control - 1;
      busqentabla(ts,lexema,compolex,b);
      if b = 0 then
      begin
          compolex := id;
          agregartabla(ts,lexema,compolex);
         end;
    end;
  End;
 
   function esentero(var control : longint;
                     var lexema : string) : byte;
   Const
     q0 = 0;
   Type
      Sigma = (signo, Digito, Otro);
      Q = 0..4;
      TipoDelta = Array[Q,Sigma] of Q;
   Var
     EstadoActual : Q;
     Delta : TipoDelta;
     caracter : char;
 
  function CarASimb(Car:char):sigma;
   Begin
      if car in[#48..#57] then
      CarASimb := Digito
    else
      if car in[#45] then
      CarAsimb := Signo
  else
     CarASimb := Otro;
 
    {Case car of
     '0'..'9':CarASimb:=Digito;
     '-': CarAsimb:=Signo
    else
     CarASimb:=Otro
    End;}
 
   End;
  Begin
     Delta[0,Digito]:=1;
     Delta[0,Signo]:=2;
     Delta[0,Otro]:=3;
     Delta[1,Digito]:=1;
     Delta[1,Signo]:=3;
     Delta[1,otro]:=4;
     Delta[2,Digito]:=1;
     Delta[2,otro]:=3;
     Delta[2,signo]:=3;
     Delta[3,digito]:=3;
     Delta[3,signo]:=3;
     Delta[3,otro]:=3;
     EstadoActual:=q0;
     lexema:='';
   while (EstadoActual <> 3) and (EstadoActual <> 4) and not eof(f) do
   begin
    {seek(f,control);}
    read(f,caracter);
    lexema := lexema + caracter;
    EstadoActual := Delta[EstadoActual, CarAsimb(Lexema[Control])];
    inc(control);
   end;
   if EstadoActual = 3 then
   esentero := 0
 else
    begin
       delete(lexema,length(lexema),1);
       esentero := 1;
       control := control - 1;
    end;
  End;
 
 
  procedure obtenersigcomplex(var control : longint;
              var compolex : terminales; var lexema : string; ts : ttabla);
  var
   caracter : char;
   c : byte;
   begin
      {seek(f,control);}
      if eof(f) then
      compolex := peso
   else
     begin
       read(f,caracter);
     while (caracter in [#0..#32]) and not eof(f) do
      begin
       inc(control);
       read(f,caracter);
      end;
     if eof(f) then
      compolex := peso
     else
      begin
      if caracter in ['=',',','.','(',')',';','>','<','+','-','*','/',
                                                   '^','&','~','|'] then
       case caracter of
        '=': begin
             compolex:=ig;
             inc(control);
             end;
        ';': begin
             compolex:=puntocoma;
             inc(control);
             end;
        ',': begin
             compolex:=coma;
             inc(control);
             end;
        '.': begin
             compolex:=punto;
             inc(control);
             end;
        '(': begin
             compolex:=pa;
             inc(control);
             end;
        ')': begin
             compolex:= pc;
             inc(control);
             end;
        '>': begin
             compolex:= may;
             inc(control);
             end;
        '<': begin
             compolex:= men;
             inc(control);
             end;
        '+': begin
             compolex:= mas;
             inc(control);
             end;
        '-': begin
             compolex:= menos;
             inc(control);
             end;
        '*': begin
             compolex:=por;
             inc(control);
             end;
        '/': begin
             compolex:=divi;
             inc(control);
             end;
        '^': begin
             compolex:=pot;
             inc(control);
             end;
        '&': begin
             compolex:=andd;
             inc(control);
             end;
        '~': begin
             compolex:=nott;
             inc(control);
             end;
        '|': begin
             compolex:=orr;
             inc(control);
             end;
       end
       else
        begin
         esid(control,lexema,compolex,ts,c);
         if c=1 then
           compolex:=compolex
         else
          begin
          control:=control-1;
           if esentero(control,lexema)=1 then
            begin
             lexema:=lexema;
            compolex:=constante;
            end;
          end;
      end;
    end;
  end;
 end;
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