Mercurial > ~dholland > hg > ag > index.cgi

comparison tests/agcl/oldagsrc/cf-old.syn @ 0:13d2b8934445

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Import AnaGram (near-)release tree into Mercurial.
author David A. Holland
date Sat, 22 Dec 2007 17:52:45 -0500
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:13d2b8934445
1 {/*
2 AnaGram Syntax Analyzer.
3 Copyright (c) Parsifal Software, 1993.
4 All Rights Reserved.
5
6 Configuration file module
7 */
8 #include HEADERS
9
10 #include DATA
11 #include ASSERT
12 #include CTYPE
13 #include STDLIB
14 #include STRING
15 #include ARRAYS
16 #include MYALLOC
17 #include CF
18 #include PARAMS
19 #include PF
20
21 }
22 [
23 auto resynch
24 context type = cint
25 grammar token = config file
26 ~declare pcb
27 diagnose errors
28 // enum constant name = "cf_%_token"
29 lines and columns
30 line numbers
31 ~allow macros
32 line numbers
33 error frame
34 nest comments
35 ~test range
36 token names
37 pointer input
38 default token type = int
39 near functions
40 ]
41
42 any digit = digit + hex letter
43 backslash = '\\'
44 blank char = ' ' + '\t'
45 carriage return = '\r'
46 digit = '0-9'
47 double quote = '"'
48 eof = 0 + 26
49 eol chars = newline + carriage return
50 hex letter = 'a-f' + 'A-F'
51 letter = 'a-z' + 'A-Z' + '_'
52 newline = '\n'
53 nonoctal digit = any digit - octal digit
54 octal digit = '0-7'
55 simple string char = ~eof - (any digit + double quote + backslash + eol chars)
56 tab = '\t'
57 vertical space = '\f' + '\v'
58
59 equals
60 -> '=', space?
61
62 minus
63 -> '-', space?
64
65 plus
66 -> '+', space?
67
68 tilde
69 -> '~', space?
70 /*
71 left bracket
72 -> '[', space?
73
74 right bracket
75 -> ']', blank?...
76 */
77 left parenthesis
78 -> '(', space?
79
80 right parenthesis
81 -> ')', blank?...
82
83
84 config file
85 -> blank?..., [global parameter | end of line]/..., eof
86
87 (void) global parameter
88 -> name =cf_gp4(1);
89 -> tilde, name =cf_gp4(0);
90 -> name, equals, data type =cf_gp2();
91 -> name, equals, keyword string =cf_gp3();
92 -> name, equals, number:n =cf_gp5(n);
93 -> "trial", blank..., "copy", blank..., "code", blank?..., equals,
94 trial copy code:n =trial_copy_code = n;
95
96 (unsigned long) trial copy code
97 -> '0-9':d =d-'0';
98 -> trial copy code:n, '0-9':d =10*n + d-'0';
99
100 (void) data type
101 -> name
102 -> name, abstract declarator =concat_string();
103
104 (void) abstract declarator
105 -> indirect data type
106 -> direct abstract declarator
107 -> indirect data type, direct abstract declarator =concat_string();
108
109
110 (void) direct abstract declarator
111 -> {left parenthesis =scs('('),0;}, abstract declarator,
112 right parenthesis =concat_string(), acs(')');
113 /*
114 -> brackets
115 -> direct abstract declarator, brackets =concat_string();
116
117 (void) brackets
118 -> left bracket, right bracket =sss("[]");
119 -> left parenthesis, right parenthesis =sss("()");
120 */
121
122 (void) pointer
123 -> star
124 -> star, name =concat_string();
125
126 (void) star
127 -> '*', blank?... =sss(" *");
128
129 (void) indirect data type
130 -> pointer
131 -> indirect data type, pointer =concat_string();
132
133 (void) name string
134 -> letter:a =scs(a);
135 -> name string, letter + digit :a =acs(a);
136 -> name string, blank..., letter + digit :a =acs(' '), acs(a);
137
138 name
139 -> name string, blank?...
140
141 blank
142 -> blank char
143 -> c comment
144
145 space
146 -> blank...
147 -> blank..., continuation
148 -> continuation
149
150 continuation
151 -> comment, next line
152 -> next line
153
154 next line
155 -> carriage return?, newline
156 -> carriage return?, newline, blank...
157
158 white
159 -> blank
160 -> carriage return?, newline
161 -> comment, carriage return?, newline
162
163 end of line
164 -> comment, carriage return?, newline
165 -> carriage return?, newline
166 -> end of line, white
167 -> end of line, vertical space //form feed
168
169 comment
170 -> "//", ~eol chars & ~eof?...
171
172 decimal number
173 -> '1-9':d =d - '0';
174 -> decimal number:n, '0-9':d =10*n + d - '0';
175
176 octal number
177 -> '0' =0;
178 -> octal number:n, '0-7':d =8*n + d - '0';
179
180 hex number
181 -> "0x" =0;
182 -> "0X" =0;
183 -> hex number:n, '0-9':d =16*n + d - '0';
184 -> hex number:n, 'A-F' + 'a-f':d =16*n + (d&7) + 9;
185
186 simple number
187 -> decimal number
188 -> octal number
189 -> hex number
190
191 number
192 -> sign:s, simple number:n, blank?... =s*n;
193
194 sign
195 -> plus? =1;
196 -> minus =-1;
197
198 keyword string
199 -> keyword string head, string, double quote, blank?...
200
201 string
202 -> string A | string B | string C
203
204 (void) keyword string head
205 -> double quote =ics();
206
207 string char
208 -> simple string char
209 -> escape sequence
210
211 escape sequence
212 -> "\\a" ='\a';
213 -> "\\b" ='\b';
214 -> "\\f" ='\f';
215 -> "\\n" ='\n';
216 -> "\\r" ='\r';
217 -> "\\t" ='\t';
218 -> "\\v" ='\v';
219 -> "\\\\" ='\\';
220 -> "\\?" = '\?';
221 -> "\\'" ='\'';
222 -> "\\\"" ='"';
223 -> three octal:n =n==0?cf_error("Null character in string"),0 : n;
224
225 one octal
226 -> backslash, '0-7':n =n&7;
227
228 two octal
229 -> one octal:n, '0-7':d = n*8 + (d&7);
230
231 three octal
232 -> two octal:n, '0-7':d = n*8 + (d&7);
233
234 octal escape
235 -> {one octal | two octal}:n =
236 n==0?cf_error("Null character in string"),0 : n;
237
238 hex escape
239 -> "\\x", hex number:n =n;
240
241 (void) string A
242 -> string char:c =acs(c);
243 -> any digit:c =acs(c);
244 -> string, string char:c =acs(c);
245 -> string A, any digit:c =acs(c);
246 -> string B, nonoctal digit:c =acs(c);
247
248 (void) string B
249 -> octal escape:n =acs(n);
250 -> string, octal escape:n =acs(n);
251
252 (void) string C
253 -> hex escape:n =acs(n);
254 -> string, hex escape:n =acs(n);
255
256 (void) c comment
257 -> c comment text, "*/"
258
259 (void) c comment text
260 -> "/*"
261 -> c comment text, ~eof
262
263 c comment, c comment text
264 -> c comment text, c comment =
265 {if (nest_comments) PCB.reduction_token = cf_c_comment_text_token;}
266
267 [
268 hidden {
269 left parenthesis, right parenthesis,
270 pointer, indirect data type, name string,
271 space, next line, sign, one octal, two octal, three octal,
272 string A, string B, string C, c comment text, escape sequence,
273 octal escape, hex escape, name string
274 }
275 ]
276
277 {
278
279 #define PARSE_STACK_OVERFLOW\
280 {fprintf(stderr,"Parse stack overflow\n");myabort();}
281 #define SYNTAX_ERROR cf_syn_error()
282 #define GET_CONTEXT CONTEXT.x = PCB.column, CONTEXT.y = PCB.line
283
284 #define N_PARAMS 80
285
286
287 static cf_pcb_type cfcb;
288 #define PCB cfcb
289
290 extern string_dict *param_dict;
291 extern unsigned char *input_base;
292 extern int precedence_level;
293 extern int int_token_type;
294
295 void reset_stack(void);
296 void log_error(void);
297
298 static void cf_gp2(void);
299 static void cf_gp3(void);
300 static void cf_gp4(int);
301 static void cf_gp5(int);
302
303 void acs(int);
304 void scs(int);
305
306 void init_params(void);
307
308 unsigned char *read_file(char *);
309
310 static char *config_file;
311
312 static void cf_error(char *);
313
314 static void cf_bad_param(int pn) {
315 char *dm;
316 if (pn) dm = "Inappropriate value";
317 else dm = "No such parameter";
318 cf_error(dm);
319 rcs();
320 return;
321 }
322
323 void xgp5(int, void bad(int), int);
324
325 static void cf_gp5(int tv) {
326 xgp5(tv,cf_bad_param,0);
327 }
328
329 void xgp4(int, void bad(int), int);
330
331 static void cf_gp4(int tv) {
332 xgp4(tv,cf_bad_param,0);
333 }
334
335 void xgp2(void bad(int), int);
336
337 static void cf_gp2(void) {
338 xgp2(cf_bad_param,0);
339 }
340
341 void xgp3(void bad(int), int);
342
343 static void cf_gp3(void) {
344 xgp3(cf_bad_param,0);
345 }
346
347 static int read_config_file(char *path) {
348 char* file_name = allocate(strlen(path)+20,char);
349 char *cp;
350
351 strcpy(file_name, path);
352 cp = strrchr(file_name,PATH_DELIMITER);
353 /*
354 assert(cp != NULL);
355 strcpy(cp+1,"AnaGram.cfg");
356 */
357 if (cp) cp++;
358 else cp = file_name;
359 strcpy(cp,"AnaGram.cfg");
360 config_file = file_name;
361 cfcb.pointer = input_base = read_file(file_name);
362 return input_base != NULL;
363 }
364
365 static void get_config(char *path) {
366 cfcb.pointer = input_base = read_file(path);
367 if (input_base != NULL) {
368 cf();
369 free(input_base);
370 }
371 input_base = NULL;
372 }
373 int in_cur_dir(char *);
374
375 void read_config(char *path) {
376 if (read_config_file(path)) {
377 cf();
378 free(input_base);
379 free(config_file);
380 }
381 if (in_cur_dir(path)) return;
382 config_file = "AnaGram.cfg";
383 get_config("anagram.cfg");
384 }
385
386 static void cf_error(char *msg) {
387 int eline = PCB.line, ecol = PCB.column;
388
389 if (PCB.token_number == cf_eof_token) {
390 eline = ERROR_CONTEXT.y;
391 ecol = ERROR_CONTEXT.x;
392 }
393 ssprintf("%s, Line %d, Col %d: %s", config_file,
394 eline, ecol, msg);
395 log_error();
396 }
397
398 static void cf_syn_error(void) {
399 reset_stk();
400 cf_error(PCB.error_message);
401 }
402
403 param_number_map *map_param_number;
404
405 static void init_param_val_proc(int *pn, char *name, int v) {
406 param_number_map *mpn;
407
408 *pn = add_string_dict(name,param_dict);
409 check_size(map_param_number,*pn,*pn);
410 mpn = &map_param_number[*pn];
411 /* mpn->value_name = 1; */
412 mpn->value = v;
413 }
414
415
416 #define init_param_val(p,v) \
417 init_param_val_proc(&p##_pn, #p,v)
418
419 static param_number_map *id_param(int *pn, void *p, char *name) {
420 int k = add_string_dict(name,param_dict);
421 param_number_map *mpn;
422
423 check_size(map_param_number, k,3*k/2);
424 *pn = k;
425 mpn = &map_param_number[k];
426 mpn->param = p;
427 return mpn;
428 }
429
430 #define init_param(p, global, implicit)\
431 {param_number_map *mpn = id_param(&p##_pn,&p, #p);\
432 mpn->global = 1;\
433 mpn->implicit = 1;}
434
435 #define init_param_co(p, global, implicit)\
436 {param_number_map *mpn = id_param(&p##_pn,&p, #p);\
437 mpn->global = mpn->config_only = 1;\
438 mpn->implicit = 1;}
439
440 /*
441 #define init_verb(p,param)\
442 {param_number_map *mpn =\
443 &map_param_number[p##_pn = add_string_dict(#p, param_dict)];\
444 mpn->verb = 1;\
445 mpn->value = param##_pn;}
446 */
447 /*
448 #define init_token_param(p,implicit)\
449 {param_number_map *mpn =\
450 &map_param_number[p##_pn = add_string_dict(#p, param_dict)];\
451 mpn->token = 1;\
452 mpn->implicit = 1;}
453 */
454
455 #define init_dict_param(p,global,dict_name)\
456 {param_number_map *mpn = id_param(&p##_pn,&p, #p);\
457 mpn->global = 1;\
458 mpn->dict = dict_name;\
459 mpn->value_id = 1;}
460 /*
461 #define init_literal_param(p,global,first_value)\
462 {param_number_map *mpn = id_param(&p##_pn,&p, #p);\
463 mpn->value = first_value##_pn;\
464 mpn->global = 1;\
465 mpn->dict = param_dict;\
466 mpn->literal = 1;}
467 */
468
469 #define init_proc_param(p,global,proc_name)\
470 {param_number_map *mpn = id_param(&p##_pn,&p, #p);\
471 mpn->global = 1;\
472 mpn->proc = proc_name;\
473 mpn->proc_call = 1;}
474
475 #define init_token_id_param(p,global)\
476 {param_number_map *mpn = id_param(&p##_pn,&p, #p);\
477 mpn->global = 1;\
478 mpn->proc = name_token;\
479 mpn->proc_call = 1;\
480 mpn->token_id = 1;}
481
482 #define dp(p)\
483 static int p##_pn
484
485 dp(on);
486 dp(off);
487
488 extern int allow_macros; dp(allow_macros);
489 int auto_init = 1; dp(auto_init);
490 int auto_resynch = 0; dp(auto_resynch);
491 extern int backtrack; dp(backtrack);
492 int bottom_margin = 3; dp(bottom_margin);
493 int bright_background = 1; dp(bright_background);
494
495 int case_sensitive = 1; dp(case_sensitive);
496 char *compile_command = ""; dp(compile_command);
497 char *context_type = NULL; dp(context_type);
498 char *coverage_file_name = "#.nrc"; dp(coverage_file_name);
499
500 int declare_pcb = 1; dp(declare_pcb);
501 extern int default_input_type; dp(default_input_type);
502 extern int default_token_type; dp(default_token_type);
503 extern int default_reductions; dp(default_reductions);
504 int diagnose_errors = 1; dp(diagnose_errors);
505
506 extern char *edit_command; dp(edit_command);
507 char *enum_constant_name = "$_%_token"; dp(enum_constant_name);
508 int error_frame = 0; dp(error_frame);
509 int error_trace = 0; dp(error_trace);
510 int escape_backslashes = 0; dp(escape_backslashes);
511 int event_driven = 0; dp(event_driven);
512
513 extern int far_tables; dp(far_tables);
514
515 extern int grammar_token; dp(grammar_token);
516 extern char *header_file_name; dp(header_file_name);
517 int input_values = 0; dp(input_values);
518
519 int line_length = 80; dp(line_length);
520 extern int line_numbers; dp(line_numbers);
521 char *line_numbers_path = NULL; dp(line_numbers_path);
522 extern int lines_and_columns; dp(lines_and_columns);
523
524 int main_program = 1; dp(main_program);
525 int max_conflicts = 50; dp(max_conflicts);
526
527 int near_functions = 0; dp(near_functions);
528 int nest_comments = 0; dp(nest_comments);
529
530 int old_style = 0; dp(old_style);
531
532 int page_length = 66; dp(page_length);
533 extern char *parser_file_name; dp(parser_file_name);
534 char *parser_name = "#"; dp(parser_name);
535 int parser_stack_alignment; dp(parser_stack_alignment);
536 int parser_stack_size = 32; dp(parser_stack_size);
537 int pointer_input = 0; dp(pointer_input);
538 char *pointer_type = "unsigned char *"; dp(pointer_type);
539 char *print_file_name = "LPT1"; dp(print_file_name);
540
541 int quick_reference = 1; dp(quick_reference);
542
543 int reduction_choices =0; dp(reduction_choices);
544 int rule_coverage = 0; dp(rule_coverage);
545
546 int tab_spacing = 8; dp(tab_spacing);
547 int test_file_binary = 0; dp(test_file_binary);
548 char *test_file_mask = "*.*"; dp(test_file_mask);
549 extern int test_range; dp(test_range);
550 extern int token_names; dp(token_names);
551 int top_margin = 3; dp(top_margin);
552 extern int traditional_engine; dp(traditional_engine);
553
554 extern int video_mode; dp(video_mode);
555
556 unsigned long trial_copy_code = 0;
557
558
559 /* char *note_file_name = "$.nf"; dp(note_file_name); */
560
561 char *input_type_name = "$_it_type"; /* dp(input_type_name); */
562
563
564 char *control_block_type = "$_pcb_type";
565 char *typedef_name = "$_token_type";
566 char *value_stack_type = "$_vs_type";
567
568
569 extern string_dict *cast_dict;
570 extern string_dict *proc_dict;
571
572
573 extern string_dict *tkn_dict;
574
575 extern int error_token; dp(error_token);
576 /* extern int noise_token; dp(noise_token); */
577 int eof_token = 0; dp(eof_token);
578
579 extern int active_color; dp(active_color);
580 extern int active_bar_color; dp(active_bar_color);
581 extern int inactive_color; dp(inactive_color);
582 extern int inactive_bar_color; dp(inactive_bar_color);
583 extern int backdrop_color; dp(backdrop_color);
584 extern int backdrop_bar_color; dp(backdrop_bar_color);
585
586
587 int id_token(int);
588
589 static int name_token(char *name){
590 sss(name);
591 free(name);
592 ids(tkn_dict);
593 return id_token(fis());
594 }
595
596 void init_params(void) {
597 int n;
598 map_param_number = init_array(N_PARAMS,sizeof(param_number_map));
599
600 init_param_val(off, 0);
601 init_param_val(on, 1);
602
603 /*
604
605 N.B. The following list should be in alphabetical order. Make sure that
606 when you enter a new parameter, you enter it in the right place!
607
608 */
609 init_param(allow_macros, global, implicit);
610 init_param(auto_init, global, implicit);
611 init_param(auto_resynch, global, implicit);
612
613 init_param(backtrack, global, implicit);
614 init_param(bottom_margin, global, int_value);
615 init_param_co(bright_background, global, implicit);
616
617 init_param(case_sensitive, global, implicit);
618 init_param(compile_command, global, string_value);
619 init_param(context_type, global, text_value);
620 init_param(coverage_file_name, global, string_value);
621
622 init_param(declare_pcb, global,implicit);
623 init_dict_param(default_input_type, global, cast_dict);
624 init_param(default_reductions, global, implicit);
625 init_dict_param(default_token_type, global, cast_dict);
626 init_param(diagnose_errors, global, implicit);
627
628 init_param(edit_command, global, string_value);
629 init_param(enum_constant_name, global, string_value);
630 init_token_id_param(eof_token, global);
631 init_param(error_frame, global, implicit);
632 init_token_id_param(error_token, global);
633 init_param(error_trace, global, implicit);
634 init_param(escape_backslashes, global, implicit);
635 init_param(event_driven, global, implicit);
636
637 init_param(far_tables, global, implicit);
638
639 init_token_id_param(grammar_token, global);
640
641 init_param(header_file_name, global, string_value);
642
643 init_param(input_values, global, implicit);
644
645 init_param(line_length, global, int_value);
646 init_param(line_numbers, global, implicit);
647 init_param(line_numbers_path, global, string_value);
648 init_param(lines_and_columns, global, implicit);
649
650 init_param(main_program, global, implicit);
651 init_param(max_conflicts, global, int_value);
652
653 init_param(near_functions, global, implicit);
654 init_param(nest_comments, global, implicit);
655
656 init_param(old_style, global, implicit);
657
658 init_param(page_length, global, int_value);
659 init_param(parser_file_name, global, string_value);
660 init_param(parser_name, global, text_value);
661 init_dict_param(parser_stack_alignment, global, cast_dict);
662 init_param(parser_stack_size, global, int_value);
663 init_param(pointer_input, global, implicit);
664 init_param(pointer_type, global, text_value);
665 init_param(print_file_name, global, string_value);
666
667 init_param(quick_reference, global, implicit);
668
669 init_param(reduction_choices, global, implicit);
670 init_param(rule_coverage, global, implicit);
671
672 init_param(tab_spacing, global, int_value);
673 init_param(test_file_binary, global, implicit);
674 init_param(test_file_mask, global, string_value);
675 init_param(test_range, global, implicit);
676 init_param(token_names, global, implicit);
677 init_param(top_margin, global, int_value);
678 init_param(traditional_engine, global, implicit);
679 init_param_co(video_mode, global, int_value);
680
681
682
683 init_param_co(active_bar_color, global, color_value);
684 init_param_co(active_color, global, color_value);
685 init_param_co(backdrop_bar_color, global, color_value);
686 init_param_co(backdrop_color, global, color_value);
687 init_param_co(inactive_bar_color, global, color_value);
688 init_param_co(inactive_color, global, color_value);
689
690
691 n = param_dict->nsx;
692 assert(n < N_PARAMS);
693 map_param_number = set_array_size(map_param_number, n);
694 }
695 }
696
697
698