/
cifm1.c
4652 lines (4544 loc) · 145 KB
/
cifm1.c
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
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*--------------------------------------------------------------------------*/
/* File:fmt.c */
/*--------------------------------------------------------------------------*/
#define RPIVA 1 /* to fix Borland 4.5 compilation errors - 12/09/95 */
#define NEST_REP_ALLOWED 0
#define DEB_REF 0
#define DEB_VAR 1
/* Modificacoes:
A01 - 25/09/93
Problema:
Existem algumas situacoes em que o ISIS admite que existam brancos
entre elementos de formato e a implementacao CISIS nao permite.
Como exemplo:v20 ( 3,3) -> P/ ISIS correto
v20 ( 3,3 )-> P/ ISIS incorreto
Para corrigir o problema poderia ser feito um levantamento de
todas as situacoes em que branco deveria ser considerado erro.
Discutindo com o Adalberto definimos que o CISIS aceitaria os
dois casos. Assim a implementacao ficou localizada apenas quando
vai selecionar o proximo symbol. Todos os brancos e tabs sao
ignorados.
Efeitos Colaterais:
Outras situacoes serao aceitas pelo CISIS e nao pelo ISIS.
Assim nao teremos compatibilidades a nivel de formato.
Se isso nao for desejavel, a solucao e fazer um levantamento
mais adequado de quais especificacoes devem ter branco.
Alem de "espaco" esta sendo ignorado o "tab". Pensei em
colocar CR LF . Se houver necessidade basta acrescentar no teste
A02 - 26/09/93
Problema:
Existem aplicacoes em em que e' interessante acessar registros
de outras bases de dados via comando REF.
Originalmente no ISIS e no CISIS isto nao e' possivel.
Solucao:
Discuti com Adalberto e fizemos a seguinte alteracao na sintaxe:
REF(<[nome_da_base]>mfn,...) onde
<[nome_da_base]> e' opcional. Quando presente "[" "]" sao
obrigatorios e nome_da_base e' um string.
Exemplos:
REF ( [\cisis\bases\cds]10,v10,v20);
REF (20,v10,v30);
No primeiro caso sera executado o formato "v10,v20" para o registro
10 da base "\cisis\bases\cds" (Provavelmente diferente da base
default passada como parametro para o interpretador).
No segundo caso, o formato sera executado para a base default.
Implementacao:
Nao precisou fazer alteracoes nas estruturas de dados. O nome
da base de dados so e necessario na instrucao READ_MFN.
Nessa instrucao o campo M_ADD nao tinha funcao nenhuma.
Entao o nome da base fica armazenado nesse campo, da mesma
maneira que sao armazenadas as constantes condicionais (U_COND)
Assim o tratamento e liberacao de area alocada ja e' feito
pelo interpretador.
Limitacoes:
A implementacao do nome da base poderia ser mais generica.
Dentro da sequencia "[...]" em vez de ter um string poderiamos
supor que e' um formato.
A analise , geracao de codigo, e interpretacao seriam mais
complicadas.( Mas nao impossiveis...).
Efeitos Colaterais:
Um formato que contenha a nova sintaxe do REF nao sera
aceito pelo ISIS.
Em termos de programas, nao deve haver alteracoes.
Observacao:
O Adalberto vai me ajudar (na verdade acho que fazer tudo) a
implementar a parte de interpretacao. (Nao sei usar direito
os RECORDS...)
A03 - 29/09/93
Problema:
Nao foi implementado o "[dbname]" para o LOOKUP.
O Adalberto tinha discutido mas nao fiz na A02.
Solucao:
Nao existe uma coerencia entre o REF e L. O primeiro :
exige uma expressao numerica , pois corresponde ao mfn.
O segundo supoe que apos o L vem um formato ISIS que vai
gerar uma chave.
Apos a implementacao do "[..]" para REF o Adalberto sugeriu
que a sintaxe para ambos fosse diferente, algo como;
dbname#chave.
Isto fica correto para L mas nao para REF uma vez que apos
o REF e necessario uma expressao numerica e o dbname nunca seria
analisado pelo CISIS.
Implementacao:
A implementacao ficara igual ao REF. de dados. O nome
Limitacoes:
Efeitos Colaterais:
Um formato que contenha a nova sintaxe do L nao sera
aceito pelo ISIS.
Em termos de programas, nao deve haver alteracoes.
Observacao:
O Adalberto vai me ajudar (na verdade acho que fazer tudo) a
implementar a parte de interpretacao. (Nao sei usar direito
os RECORDS...) (Continua Valido...)
A04 - 22/11/93
Problema:
Implementacao da funcao NP(key).
Deve retornar o numero de postings da chave.
Solucao:
Implementacao igual a do LOOKUP porem em vez de
carregar na pilha o MFN, carrega o numero de postings
da chave
A05 - 25/05/97
Problema:
Quando um formato fazia referencia a um arquivo e nesse
arquivo tivessemos "ifs" ocorria erro.
Isso acontece porque na implementacao de referencia a arquivo
a funcao get_ch le o proximo caracter do arquivo, em vez
de pega-lo no string do formato, e nos casos de "ifs" para
descobrir que tipo de expressoes (string ou numerica) sao
referenciadas e' necessario fazer um " look-AHEAD" .
Depois recomeca a pegar os caracteres a partir do ponto
de inicio da expressao. Nesse momento nao temos mais
os caracteres que compoe a expressao.
Solucao:
Alterada a get_ch para armazenar os caracteres do arquivo
em um buffer temporario.
A06 - 15/09/97
Problema:
Permitir que area para analisar constantes do tipo string
possa ter tamanho dinamico. Atualmente e uma area estatica
de tamanho 200.
Solucao:
Fazer com que a variavel str seja alocada dinamicamente.
Se durante o uso a area for toda ocupada fazer uma realocacao.
Muda-se: str e string_length
str_read para realocar variavel
A07 - 05/10/97
Problema:
a) Existia erro em relacao microisis -
o fmt="...'x',###,%,#,'y',..," e fmt="...'x',###,%,'y',..,"
produzem o mesmo resultado: muda de linha entre 'x' e 'y'
Na minha implementacao no segundo caso nao produzia nenhuma linha
b) Implementar o comando NEWLINE (<FMT>);
Solucao:
a) Na execucao de % verificar se apos retirar "muda-linha" tem
#. Em caso afirmativo, ignora essa instrucao.
b) Necessario mudar todas as referencias a crlf no programa, o
que implica em alterar varias rotinas.
A08 - 01/11/99
Problema: Compatibilizar sintaxes Cisis e MicroIsis
Vtt[1..] e Vtt[1..LAST]
Vtt[1]^a e Vtt^a[1]
Permitir o uso das duas formas
Solucao: Quebrar a rotina field_id para que a analise de subfield seja
feita separadamente assim permita verificar se existe indexa
cao antes de "^subfield" ou depois "^subfield"
Acusara erro se for especificado vtt[1]^a[1]
A09 - 01/11/99
Problema: Compatibilizar sintaxes Cisis e MicroIsis
mstname e dbname
Permitir o uso das duas formas
Solucao: Criar uma palavra reservada DB que mapeia no mesmo simbolo que
que mstname
A10 - 01/11/99
Problema: Implementar funcao SS equivalente a funcao Mid
Solucao: Sera criada uma nova funcao, porem a execucao do codigo
sera equivalente ao codigo da Mid.
A11 - 01/11/99
Problema: Compatibilizar funcao date
Solucao: date(1) = MM-DD-AAAA HH:MM:SS
date(2) = MM-DD_AAAA
date(3) = HH:MM:SS
date =
date(DATEONLY) = dd/mm/aa
date(DATETIME) = dd/mm/aa hh:mm:ss
A12 - 05/11/99
Problema: Compatibilizar refencia ao dname com Microisis
Solucao:
*/
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include "cisis.h"
#include "cifmt.h"
/* inicio implementacao [x:y] */
/* como nao podera ser dado intervalo negativo, quando um campo
nao for explicitado com intervalo o default sera colocado como
negativo. Na interpretacao sera usado o seguinte criterio:
Se lower e upper negativos => nao foi indicado intervalo
Para pegar todas as ocorrencias pegar o ABS desses valores
*/
/* fim implementacao [x:y] */
/* Conferir...- deveria estar na cisis.h */
#if PC
#if MSC
#define REALLOC realloc
#else /*MSC*/
#define REALLOC farrealloc
#endif
#endif
#define CISIS_REF_DBN 1 /*A12*/
#define MISIS_REF_DBN 0 /*A12*/
#define DEB_ATFILE 0
#define MAX_INT SHRT_MAX /* +32767 */
#define MIN_INT SHRT_MIN /* -32768 */
#define TRACE_COMP_F 00 /* printf f_d_n in store_field_def() */
#if !CICPP
#define MAX_NESTED_REPEAT 15
#define res_words_length 8 /*21-07-94*/
#define number_length 30
/*A12*/
int separa_nome_base = 0;
/*A06*/
unsigned int string_length=MAX_LITER; /* Valor inicial de tamanho de str */
#endif /* CICPP */
/*#define string_length 200*/ /* este parametro deve ser uma variavel */
/* inicializada c/ o lw */
/* Nao e' possivel, pois o lw so vai ser
conhecido em execucao sindo 14/07/97
*/
#if !CICPP
#define ERRORET 1
#endif /* CICPP */
#define apostrofo '\''
#define crase '`'
#define aspa '\"'
#define exclamacao '!'
#define atsign '@'
#define virgula ','
#define tab '\t'
/*Existe ambiguidade no uso de numeros pelo isis. Na especificacao de
extracao de campos V54.5 , 54.5 NAO pode ser interpretado com numero real.
Assim, precisamos saber na getsymbol se devemos parar quando separamos
um numero inteiro.
Quando classe_numero_procurado=PARSEINTNUMB, estamos querendo pegar
o proximo numero inteiro apenas. Caso contrario, podemos pegar qualquer
numero
*/
#define PARSEINTNUMB 1
#if !CICPP
static int classe_numero_procurado=0;
#define MXOPNFMTFILES 16
#define CUR_FMT_FILE opn_fmtfiles[nopn_fmtfiles]
static int opn_fmtfiles[MXOPNFMTFILES];
static int nopn_fmtfiles= -1;
#ifndef MAXPATH
#define MAXPATH CIMPL
#endif
static char fmtfile[MAXPATH+1];
/*fmt_ref_dbname,*/
typedef char alfa[res_words_length+1];
/* Atencao: Os extremos (firstsym e zzzsym)do enumerado
abaixo NAO podem ser modificados e nem mudados de posicao.
Eles sao usados para e criar vetores .
*/
typedef enum symbol_names {
firstsym,
csym, xsym, dsym, nsym, vsym, ifsym, fisym,
thensym, elsesym, orsym, andsym, notsym, mfnsym, mplsym,
mpusym, mhlsym, mhusym, mdlsym, mdusym, fsym, s_sym,
getenv_sym, putenv_sym,
refsym, asym, psym, ravrsym, valsym, lsym, lwsym,
rupxsym,
rupdsym, systsym, coresym, maxmfnsym, datemktimesym,
rsumsym, rminsym, rmaxsym,
fmtsym, usym, isym,
abrcolch, fchcolch,
comma, slash, ponto,
number_sigx,
number_sign,percent, lparen, rparen, flecha, times, plus,
minus, doispontos, eql, neq, lss, leq, gtr,
geq, space, u_litsym, c_litsym, esc_strsym,number, nullsym,
s_fieldsym,r_litsym,
long_number,float_number,
noccsym, npsym,
ioccsym, continuesym,breaksym,
sizesym, typesym,
mstsym, datesym, date1sym, date2sym,
selsym, casesym, elsecasym, endselsym,
instrsym,
leftsym, datexsym,
rightsym,
midsym,
catsym,
replacsym,
#if CI_XMLELEM
xmlelemsym,
#endif
nl_sym,
lastsym,
intvarsym,
strvarsym,
whilesym,
occsym,
attribsym,
dbsym,
ss_sym,
np2sym,
citypesym,
textsym, /*A12*/
zzzsym } symbol;
#endif /* CICPP */
/*
Vetor sym_to_instruction
Usado para converter simbolo em instrucao para facilitar a geracao de
codigo
*/
#if !CICPP
static instruction_code sym_to_instruction[zzzsym+9];
static char *pfmt ; /* aponta para o formato de entrada */
static char ch = space_char; /* last character read */
static symbol sym; /* last symbol read */
static symbol field_fmt_sym;
static int num ; /* value of last integer number read */
/*f01*/
static LONGX long_num;
static char float_num_str[number_length+1];
/*f01*/
static alfa fmttoken ; /* word being read */
/*A06*/
static char *str;
static int indvar; /* Indice de variaveis numericas vvv */
/* static char str[string_length];*/ /*mudado para dinamico */
static char sub_field_value = 0; /* value of last sub_field_read */
static symbol ssym[128] /* AOT/HB 24/05/2000 - CodeGuard */
= {
zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym,
zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym,
zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym,
zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym,
zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym,
zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym,
zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym,
zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym,
zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym,
zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym,
zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym,
zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym,
zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym,
zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym,
zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym,
zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym, zzzsym
}
;
static int source_index=0; /* index of the source string */
static int last_source_index=0;
LONGX fmt_error=0;
#if ERRORET
LONGX fmt_errof=0;
#endif
#define length_word_buff 256+50+50+50
static char *word_names[zzzsym+9];
static int next_word_buff;
static char word_buff[length_word_buff];
static l_code *head_code ; /* points to the beginning of the intermediate
code. Used only as the linked list head
*/
static l_code *last_instr; /* points to the last instruction generate */
static l_code *p_nulo=nulo; /* AOT 06/04/92 */
static LONGX field_address;
static LONGX address;
static label next_label; /* stores the last generated label */
static int formatting; /* if true , the heading commands for formatting
a field have already been generated */
static l_code actual_inst; /* To be used to store a temporary instruction */
/*char *inst_cnv[100]; */ /* to convert instr_codes from enumerate to string*/
#if PRINT_CODE
char *inst_cnv[zzzzzz+10]; /*repf*/
/* to convert instr_codes from enumerate to string*/
#endif
static int repeatable; /* =true means we are processing repeatable
format */
static int n_instructions; /* keep the number of instructions generated */
/* endereco n_fields; */
/* static int function_in_process; */
/* static int if_expr_in_process; */
/* static int first_function_in_expression; */
#endif /* CICPP */
/*repf*/
#define is_not_rep 0 /* Nao esta processando grupo repetitivo */
#define is_rep 1 /* Processando grupo repetitivo */
#define is_ref 2 /* Processando funco ref */
#if !CICPP
typedef struct repeat_groups{
int repeatable;
int last_format;
}REPEAT_GROUPS;
static REPEAT_GROUPS vet_repeat[MAX_NESTED_REPEAT];
static int top_repeat=0;
/* static int n_ref=0; */ /* qtade de refs aninhados - not used */
static int last_format=is_not_rep;
/*---------- break------------------------------------------------------*/
#define MAX_STACK_BREAKS 100 /* Numero maximo de breaks permitido */
static l_code *stack_breaks[MAX_STACK_BREAKS];
static int top_stack_breaks ;
#endif /* CICPP */
/*A05*/
/*-----------------------------------------------------------------------*/
/* Variaveis para resolver problema de IFs em @files */
/*-------- --------------------------------------------------------------*/
/* Deve ser dinamico */
#define MAX_buff_look_ahead 160
#if !CICPP
int pf_look_ahead= -1;
int pi_look_ahead=0;
char *buff_look_ahead=NULL;
int LOOKING_AHEAD=0;
#endif /* CICPP */
/*-----------------------------------------------------------------------*/
/* Prototype */
/*-------- --------------------------------------------------------------*/
#if !CICPP
#if ANSI
void fmt_finaliza_fmt(int pt_break);
char *store_inst_names(char *str);
void ignora_espacejamento (void);
void parse_fmtfile(void);
int parse_microisis_dbname(void);
int parse_date(void);
static int cabe_proximo_digito(int x);
static symbol analisa_numero(char pstr_num[]);
static symbol analisa_short_int(char pstr_num[]);
static int analisa_mfn(void);
#else
void fmt_finaliza_fmt();
char *store_inst_names();
void ignora_espacejamento();
void parse_fmtfile();
int parse_microisis_dbname();
int pase_date();
static int cabe_proximo_digito();
static symbol analisa_numero();
static symbol analisa_short_int();
static int analisa_mfn();
#endif
#endif /* CICPP */
/*--------------------------------------------------------------------------*/
/* cabe_proximo_digito */
/*--------------------------------------------------------------------------*/
/* Verifica se o numero que esta sendo separado do formato de entrada
tem tamanho dentro do definido
*/
#if CICPP
int FMTSTRU :: cabe_proximo_digito(int x)
#else /* CICPP */
#if ANSI
static int cabe_proximo_digito(int x)
#else /*ANSI*/
static int cabe_proximo_digito(x)
int x;
#endif /*ANSI*/
#endif /* CICPP */
{
if (x > number_length) erro(6000);
return x;
}
/*--------------------------------------------------------------------------*/
/* analisa_numero */
/*--------------------------------------------------------------------------*/
#if CICPP
FMTSTRU :: symbol FMTSTRU :: analisa_short_int(char pstr_num[])
#else /* CICPP */
#if ANSI
static symbol analisa_short_int(char pstr_num[])
#else /*ANSI*/
static symbol analisa_short_int(pstr_num)
char pstr_num[];
#endif /*ANSI*/
#endif /* CICPP */
{
symbol symb;
char keep_ch;
int keep_source_index;
int nn;
keep_ch=ch;
keep_source_index=source_index;
nn=0;
symb=(enum symbol_names)dummy;
while (isdigit(ch)){
symb=number;
pstr_num[cabe_proximo_digito(nn)]=ch;
nn++;
get_ch();
}
pstr_num[cabe_proximo_digito(nn)]='\0';
if (symb==dummy) { /* restaura Contexto*/
ch=keep_ch;
source_index=keep_source_index;
}else{
long_num=atol(pstr_num);
if (long_num>=(LONGX) MIN_INT && long_num<=(LONGX)MAX_INT){
num=(int)long_num;
symb=number;
}else erro(7000);
}
return symb;
}
/*--------------------------------------------------------------------------*/
/* analisa_numero */
/*--------------------------------------------------------------------------*/
#if CICPP
FMTSTRU :: symbol FMTSTRU :: analisa_numero(char pstr_num[])
#else /* CICPP */
#if ANSI
static symbol analisa_numero(char pstr_num[])
#else /*ANSI*/
static symbol analisa_numero(pstr_num)
char pstr_num[];
#endif /*ANSI*/
#endif /* CICPP */
{
#define TRUE 1
#define FALSE 0
symbol symb;
int tem_num;
char keep_ch;
int keep_source_index;
int nn;
keep_ch=ch;
keep_source_index=source_index;
nn=0;
symb=(enum symbol_names)dummy;
while (isdigit(ch)){
symb=long_number;
pstr_num[cabe_proximo_digito(nn)]=ch;
nn++;
get_ch();
}
if (ch=='.') {
pstr_num[cabe_proximo_digito(nn)]=ch;
nn++;
symb=float_number;
get_ch();
}
while(isdigit(ch) ){
pstr_num[cabe_proximo_digito(nn)]=ch;
nn++;
get_ch();
}
if ( (ch=='E') || (ch=='e')) { /* exponencial*/
pstr_num[cabe_proximo_digito(nn)]=ch;
nn++;
symb=float_number;
get_ch();
tem_num=FALSE;
if ((ch=='+')||(ch=='-')) {
pstr_num[cabe_proximo_digito(nn)]=ch;
nn++;
get_ch();
}
while (isdigit(ch)) {
pstr_num[cabe_proximo_digito(nn)]=ch;
nn++;
tem_num=TRUE;
get_ch();
}
if(tem_num==FALSE){
printf("\n Numero invalido");
exit(1);
}
} /* Exponecial*/
pstr_num[cabe_proximo_digito(nn)]='\0';
if (symb==dummy) { /* restaura Contexto*/
ch=keep_ch;
source_index=keep_source_index;
}else
/* Incialmente forca inteiro p/ser long. Depois,se for o caso,
transforma em int
*/
if (symb ==long_number){
long_num=atol(pstr_num);
if (long_num>=(LONGX) MIN_INT && long_num<=(LONGX)MAX_INT){
num=(int)long_num;
symb=number;
}
}
return symb;
}
/*repf*/
/*--------------------------------------------------------------------------*/
/* fmt_pop_breaks */
/*--------------------------------------------------------------------------*/
#if CICPP
label FMTSTRU :: fmt_pop_breaks(int pt_stack_breaks)
#else /* CICPP */
#if ANSI
label fmt_pop_breaks(int pt_stack_breaks)
#else /* ANSI */
label fmt_pop_breaks(pt_stack_breaks)
int pt_stack_breaks;
#endif /* ANSI */
#endif /* CICPP */
{ label lab;
l_code *idx;
lab= -1;
if (pt_stack_breaks<=top_stack_breaks){
lab=gen_next_label();
for (;pt_stack_breaks<=top_stack_breaks;top_stack_breaks--) {
idx = stack_breaks[top_stack_breaks];
/* altera o desvio da instrucao que foi deixada para tras */
idx->info.add=lab;
}
}
return lab;
}
/*--------------------------------------------------------------------------*/
/* fmt_push_breaks */
/*--------------------------------------------------------------------------*/
#if CICPP
void FMTSTRU :: fmt_push_breaks(l_code *idx)
#else /* CICPP */
#if ANSI
void fmt_push_breaks(l_code *idx)
#else /* ANSI */
void fmt_push_breaks(idx)
l_code *idx;
#endif /* ANSI */
#endif /* CICPP */
{
if (top_stack_breaks>=MAX_STACK_BREAKS-1){
erro(333);
}
top_stack_breaks++;
stack_breaks[top_stack_breaks]=idx;
}
/*--------------------------------------------------------------------------*/
/* fmt_pop_repeat */
/*--------------------------------------------------------------------------*/
#if CICPP
void FMTSTRU :: fmt_pop_repeat (void)
#else /* CICPP */
void fmt_pop_repeat ()
#endif /* CICPP */
{
if (top_repeat <= 0) {
fatal("\n Underflow - vetrepeat ");
}
repeatable=vet_repeat[top_repeat].repeatable;
last_format=vet_repeat[top_repeat].last_format;
top_repeat--;
}
/*--------------------------------------------------------------------------*/
/* fmt_push_repeat */
/*--------------------------------------------------------------------------*/
#if CICPP
void FMTSTRU :: fmt_push_repeat (void)
#else /* CICPP */
void fmt_push_repeat ()
#endif /* CICPP */
{
if (top_repeat >= MAX_NESTED_REPEAT) {
fatal("\n Overflow - vetrepeat ");
}
top_repeat++;
vet_repeat[top_repeat].repeatable=repeatable;
vet_repeat[top_repeat].last_format=last_format;
}
/*--------------------------------------------------------------------------*/
/* store_res_word */
/*--------------------------------------------------------------------------*/
#if CICPP
char * FMTSTRU :: store_res_word(char *str)
#else /* CICPP */
#if ANSI
char *store_res_word(char *str)
#else /* ANSI */
char *store_res_word(str)
char *str;
#endif /* ANSI */
#endif /* CICPP */
{
char *temp;
int len;
len=strlen(str);
if (next_word_buff +len >= length_word_buff )
fatal("No room to store word_definitions/length_word_buff");
temp = &word_buff[next_word_buff];
strcpy(temp,str);
next_word_buff=next_word_buff + len +1;
return temp;
}
/*--------------------------------------------------------------------------*/
/* store_inst_names */
/*--------------------------------------------------------------------------*/
#if PRINT_CODE
#if !CICPP
#define inst_name_size 5000
static char inst_name[inst_name_size];
static int inst_next;
#endif /* CICPP */
#if CICPP
char * FMTSTRU :: store_inst_names(char *str)
#else /* CICPP */
#if ANSI
char *store_inst_names(char *str)
#else /* ANSI */
char *store_inst_names(str)
char *str;
#endif /* ANSI */
#endif /* CICPP */
{
char *temp;
int len;
len=strlen(str);
if (inst_next + len +1 >= inst_name_size )
fatal("No room to store inst_names/inst_name_size");
temp = &inst_name[inst_next];
strcpy(temp,str);
inst_next=inst_next + len +1;
return temp;
}
#endif /*PRINT_CODE*/
/*--------------------------------------------------------------------------*/
/* get_ch */
/*--------------------------------------------------------------------------*/
/* Ler o proximo caracter da entrada ou de arquivo
1-Se a entrada for de arquivo utilizando @file podemos ter 2 casos:
a) Se no formato apareceu um IF, varios caracteres podem ter sido
lidos a frente para determinar o tipo de expressao sem, na verdade,
terem sido consumidos. Neste caso eles estao armazenados no
buff_look_ahead.
b) Enquanto nao decide qual tipo de expressao do IF devera ser considerada
os caracters sao armazenados em buff_look_ahead
c) LOOKING_AHEAD = 1 . Esta sendo analizada uma expressa em IF e o
os caracteres devem ser armazenados buf_look_ahead
LOOKING_AHEAD = 0 . Nao esta sendo analizada nenhuma expressao
2-Se nao tem referencia a arquivo, pega o proximo caracter do string
*/
#if CICPP
void FMTSTRU :: get_ch (void)
#else /* CICPP */
void get_ch ()
#endif /* CICPP */
{
/*A05*/
/* Se tem arquivo aberto , Le entrada de arquivo */
if (pi_look_ahead<=pf_look_ahead && LOOKING_AHEAD!=1) {
ch=buff_look_ahead[pi_look_ahead];
pi_look_ahead++;
}else {
if (!(nopn_fmtfiles > -1)){ /* le do fmt de entrada */
ch = pfmt[source_index];
if (ch != null_char )source_index++;
}else { /*le de arquivo */
if (CIREAD(CUR_FMT_FILE,&ch,sizeof(ch)) <= 0) {
CLOSE(CUR_FMT_FILE);
CUR_FMT_FILE= -1;
nopn_fmtfiles--;
ch=0x1A;
};
}
}
if (ch == 0x1A) { /* 13-12-96, 22-01-97 - Control Z */
ch=' '; /* Troquei pra espaco 26-05-97*/
/* sym=comma; tirei porque nao funcionava quando terminava em
incondicional. A rotina str-read separava o string
e voltava na getsymbol com symbolo de coma.
26-05-97 */
}
/* Se estiver analizando expressoes booleanas guarda
o formato */
if (LOOKING_AHEAD){
if (pf_look_ahead<MAX_buff_look_ahead) {
pf_look_ahead++;
buff_look_ahead[pf_look_ahead]=ch;
}else fatal("If expression too long/cifm1/LOOKING_AHEAD" );
}
} /* get_ch */
/*--------------------------------------------------------------------------*/
/* erro */
/*--------------------------------------------------------------------------*/
#if CICPP
void FMTSTRU :: erro (int nerr)
#else /* CICPP */
#if ANSI
void erro (int nerr)
#else /* ANSI */
void erro (nerr)
int nerr;
#endif /* ANSI */
#endif /* CICPP */
{
/* AOT 02/01/91 */
#if !ERRORET
char *p;
#endif
/* AOT 07/01/91 */
/* fatal("Not enough memory for formatting"); */
/* AOT 02/01/91 */
#if ERRORET
if (!fmt_error) {
fmt_error=nerr;
fmt_errof=last_source_index-1;
}
#else
p=s+last_source_index-1;
fprintf(stderr,"%.78s\n^^ %d",p,nerr);
fatal("format error");
#endif
} /* erro */
/*--------------------------------------------------------------------------*/
/* parse_fmtfile */
/*--------------------------------------------------------------------------*/
#if CICPP
void FMTSTRU :: parse_fmtfile(void)
#else /* CICPP */
void parse_fmtfile()
#endif /* CICPP */
{ int i;
int xx;
i=0;
get_ch();
while ( (ch!=virgula) && (ch!=space_char) && (ch!=null_char) &&
(ch!=tab) && (ch!=lf) && (ch!=cr) ) {
fmtfile[i++]=ch;
get_ch();
if (i >= MAXPATH) erro(12300); /* AOT 28/12/94 */
}
fmtfile[i]=null_char;
#if DEB_ATFILE
printf("\Selecionou file=%s",fmtfile);
#endif
if (i==0) erro(12301); /* AOT 28/12/94 */
#if APPENDEXTENSION /* AOT 28/12/94 */
if (strstr(fmtfile,".")==NULL)strcat(fmtfile,".pft");
#endif
#if DEB_ATFILE
printf("\Nome do arquivo Selecionado=%s",fmtfile);
#endif
/* abre o arquivo e guarda na pilha */
nopn_fmtfiles++;
if (nopn_fmtfiles > MXOPNFMTFILES -1 ) erro(12302); /* AOT 28/12/94 */
dbxopt_fatal=0; xx=dbxopen(NULL,fmtfile,NULL); /* AOT 13/12/96 */
if (xx < 0) erro(12303); /* AOT 28/12/94 */
opn_fmtfiles[nopn_fmtfiles]=xx;
}
/*--------------------------------------------------------------------------*/
/* str_read */
/*--------------------------------------------------------------------------*/
#if CICPP
void FMTSTRU :: str_read (char end_ch)
#else /* CICPP */
#if ANSI
void str_read (char end_ch)
#else /* ANSI */
void str_read (end_ch)
char end_ch;
#endif /* ANSI */
#endif /* CICPP */
{
int i = 0;
char *tmp;
get_ch ();
while ((i<string_length) && ((ch != end_ch) && (ch != 0)) )
{ str[i]=ch;
i++;
get_ch ();
if (i==string_length) {
str[string_length]=null_char;
string_length=string_length+(INCR_LITER) ;
#if CICPP
/*-
nao sei qual o comando para realocar em c++ -*/
try
{ tmp=(char *) new char [string_length+1]; }
catch (BAD_ALLOC)
{ tmp=(char *) NULL; string_length= 0; /* HB - string_length e' unsigned e nao pode ser -1 */
fatal("cifm1/str_read/realloc");
/* Nao deixa alocar nada */ }
strcpy(tmp,str);
delete [] (char *)str;
str=tmp;
#else /* CICPP */
/* str=(char *) REALLOC (str,(ALLOPARM) sizeof(char)*(string_length+1));*/
tmp=(char *) ALLOC( (ALLOPARM) sizeof(char)*(string_length+1));
if (tmp != NULL) {
strcpy(tmp,str);
FREE(str);
str=tmp;
}else fatal("cifm1/str_read/realloc");
#endif /* CICPP */
}
}
str[i] = null_char;
if ((ch !=null_char) && (ch != end_ch))
{while ((ch != end_ch) && (ch !=null_char)) get_ch ();
if (ch == null_char) erro (1);
}
get_ch ();
} /* str_read */
/*--------------------------------------------------------------------------*/
#if CICPP
void FMTSTRU :: ignora_espacejamento(void)
#else /* CICPP */
void ignora_espacejamento()
#endif /* CICPP */
{
while ( ch==space_char || ch==lf || ch==tab || ch==cr )
get_ch();
}
/*A01*/
/*--------------------------------------------------------------------------*/
/* getsymbol */
/*--------------------------------------------------------------------------*/
#if CICPP
void FMTSTRU :: getsymbol (void)
#else /* CICPP */
void getsymbol ()
#endif /* CICPP */
{
int ih; /* nowrn (int) - AOT, 22/01/2006 */
int k;
symbol ks;
sym = (enum symbol_names)0;
num = 0;
str[0] = null_char;
fmttoken[0] = null_char;
/*A01*/
ignora_espacejamento();
/*A01*/
last_source_index=source_index;
#if BEFORE990429
#else
/* Tem dois erros: 1) ssym deveria ter 256 elementos
2) memset(ssym,zzzsym,128*sizeof(symbol));
AOT/HB
*/
ih=(int)ch; /* nowrn (int) - AOT, 22/01/2006 */
if (ih < 0 || ih > 127) { /* nowrn (int) - AOT, 22/01/2006 */ /*if (ch < 0 || ch > 127) */
erro (3);
get_ch ();
return;
}
#endif
/*A05*/
while (ssym[ch] == slash) {
int achou;
sym=ssym[ch];
get_ch();
if (ssym[ch] != times) return;
achou=false;
/* ignora comentario */
for (;!achou && ch != null_char ;){
get_ch();
if (ssym[ch] == times){
get_ch();
if (ssym[ch]==slash){
achou=true;
get_ch();
ignora_espacejamento();
}
}
}/*for*/
if (!achou) fatal("cifm1/end_comment");
}
if (ssym[ch] == doispontos) {
sym=doispontos;
get_ch(); /* Verifica o proximo char par a verif atribuicao */
if (ssym[ch] == eql){
get_ch(); /* elimina proximo char */
sym = attribsym ;
}
return;
}
/*A12 */
if (separa_nome_base == 1) {
k=0;
while (isalnum(ch)) {
if (k < number_length) float_num_str[k++]=ch;
get_ch();
}
float_num_str[k]=null_char;
if (k>0)sym=textsym;
return;
}
if (ch == atsign){
#if DEB_ATFILE
printf("\n ASchou @");
#endif
parse_fmtfile();
ch=','; /* 31-10-96 */