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

comparison anagram/agcore/pgg24.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 /*
3 * AnaGram, A System for Syntax Directed Programming
4 * Copyright 1989-2002 Jerome T. Holland. All Rights Reserved.
5 * See the file COPYING for license and usage terms.
6 *
7 * pgg24.syn - parser generator grammar, rev. 24
8 */
9
10 #include "port.h"
11
12 #include "agdict.h"
13 #include "agstring.h"
14 #include "assert.h"
15 #include "bpe3.h"
16 #include "cint.h"
17 #include "config.h"
18 #include "configparam.h"
19 #include "csexp.h"
20 #include "error.h"
21 #include "lexeme.h"
22 #include "operations.h"
23 #include "p.h"
24 #include "pgg24-defs.h"
25 #include "pgg24.h"
26 #include "rpk.h"
27 #include "rpz.h"
28 #include "rproc.h"
29 #include "rule.h"
30 #include "stacks.h"
31 #include "token.h"
32 #include "tree.h"
33 #include "tsd.h"
34 #include "ut.h"
35
36 //#define INCLUDE_LOGGING
37 #include "log.h"
38 }
39
40 [
41 auto resynch
42 context type = cint
43 default reductions
44 ~declare pcb
45 diagnose errors
46 lines and columns
47 error frame
48 line numbers
49 //~allow macros
50 nest comments
51 parser stack size = 128
52 pointer input
53 ~test range
54 token names
55 parser name = pgg
56 test file mask = "*.syn"
57 //rule coverage
58 distinguish keywords {'.'}
59 parser file name = "#.cpp"
60 line numbers path = "pgg24.syn"
61 ]
62
63 any digit = digit + hex letter
64 anything = ~eof
65 backslash = '\\'
66 blank char = ' ' + tab
67 c literal elem = ~(single quote + double quote + eol chars + backslash + eof)
68 digit = '0-9'
69 double quote = '"'
70 eof = 0 + 26
71 eol chars = carriage return + newline
72 hex letter = 'a-f' + 'A-F'
73 letter = 'a-z' + 'A-Z' + '_'
74 newline = '\n'
75 nonoctal digit = any digit - octal digit
76 octal digit = '0-7'
77 carriage return= '\r'
78 simple c char = ~('{' + '}' + single quote + double quote + eof)
79 simple string char = ~eof - (any digit + double quote + backslash + eol chars)
80 single quote = '\''
81 tab = '\t'
82 vertical space = '\f' + '\v'
83
84 arrow
85 -> "->", blank?...
86
87 comma
88 -> ',', space?
89
90 ellipsis
91 -> "...", blank?...
92
93 equals
94 -> '=', space?
95
96 bang
97 -> '!', space?
98
99 left brace
100 -> '{', space?
101
102 left bracket
103 -> '[', space?
104
105 left parenthesis
106 -> '(', space?
107
108 minus
109 -> '-', space?
110
111 plus
112 -> '+', space?
113
114 right bracket
115 -> ']', blank?...
116
117 right brace
118 -> '}', blank?...
119
120 right parenthesis
121 -> ')', blank?...
122
123 right quote
124 -> single quote, blank?...
125
126 tilde
127 -> '~', space?
128
129 vertical bar
130 -> '|', space?
131
132 (void) syntax definition $
133 -> blank?..., end of line?, [statement list, statement?], eof
134
135 statement list
136 -> production:t, end of line =production(t);
137 -> definition, end of line
138 -> embedded c, end of line =nPrologueSegments = 1;
139 -> configuration section, end of line
140 -> statement list, production:t, end of line =production(t);
141 -> statement list, simple statement, end of line
142
143 (void) statement
144 -> production:t, comment? =production(t);
145 -> simple statement, comment?
146
147 (int) production
148 -> left hand side:type =iws(),type;
149 -> left hand side, right hand side
150 -> production:type, end of line, right hand side =concat_list(),type;
151 -> production, end of line, additional rule spec...
152
153 (void) right hand side
154 -> arrow, rule specs
155
156 (void) simple statement
157 -> definition
158 -> embedded c
159 -> configuration section
160
161 (int) left hand side
162 -> token name list =0;
163 -> type definition:d, token name list =head_list_3(d);
164
165 (void) token name list //left hand side of productions
166 -> token name:x =sws(head_list_2(x));
167 -> token name list, comma, token name:x =aws(head_list_2(x));
168
169 (int) token name
170 -> symbol name =0;
171 -> symbol name, '$', blank?... =1;
172
173 (int) type definition
174 -> left parenthesis, data type, ')', space? =Cast::create();
175
176 (void) wrapper type
177 -> data type =Cast::create().requireWrapper();
178
179 (void) wrapper list
180 -> blank..., left brace, wrappers, list end
181
182 (void) wrappers
183 -> wrapper type
184 -> wrappers, comma, wrapper type
185
186 (void) proper vp rule specs
187 -> vp rule spec:n = sws(n);
188 -> proper vp rule specs, additional vp rule spec
189
190 (void) additional vp rule spec
191 -> vertical bar, vp rule spec:n = aws(n);
192
193 (void) vp rule specs
194 -> empty vp rule, additional vp rule spec
195 -> vp rule specs, additional vp rule spec
196
197 (void) empty vp rule
198 -> proper reduction procedure:pn = sws((iws(),vp_form3(pn)));
199
200 (void) vp rules
201 -> vp rule specs | proper vp rule specs
202
203 (int) vp rule spec
204 -> grammar rule, reduction procedure:s = vp_form3(s);
205
206 (void) rule specs
207 -> reduction procedure:n = sws(form_spec_2(form1(),n));
208 -> rule spec:n = sws(n);
209 -> rule specs, additional rule spec
210
211 (void) additional rule spec
212 -> vertical bar, rule spec:n = aws(n);
213
214 (int) rule spec
215 -> grammar rule, reduction procedure:s =
216 form_spec_2(makeRule(ruleElementStack.pop()),s);
217
218 (void) grammar rule
219 -> init grammar rule, rule element:e, parameter name:p =
220 ruleElementStack.top().push(RuleElement(e,p));
221 -> grammar rule, comma,
222 rule element:e, parameter name:p =
223 ruleElementStack.top().push(RuleElement(e,p));
224
225 init grammar rule
226 -> =ruleElementStack.push(AgStack<RuleElement>());
227
228 (int) reduction procedure
229 -> =0;
230 -> proper reduction procedure
231
232 (int) proper reduction procedure
233 -> equals, embedded c =proc_spec_4(0);
234 -> equals, c expression, ';', blank?... =proc_spec_4(1);
235
236 (void) data type
237 -> type name
238 -> type name, template field
239 -> type name, template field?, abstract declarator =concat_string();
240
241 (void) type name
242 -> symbol name
243 -> "::", !sss("::");, blank?..., symbol name =concat_string();
244 -> type name, "::", !ass("::");, blank?..., symbol name =concat_string();
245
246 (void) abstract declarator
247 -> indirect data type
248 -> direct abstract declarator
249 -> indirect data type, direct abstract declarator =concat_string();
250
251 (void) template field
252 -> template field head, data type, '>', blank?... =acs('>'), concat_string();
253
254 template field head
255 -> '<', blank?... = acs('<');
256 -> template field head, data type, ',', blank?... =acs(','), concat_string();
257
258 (void) direct abstract declarator
259 -> {left parenthesis =scs('(');}, abstract declarator,
260 right parenthesis =concat_string(), acs(')');
261
262 (void) star
263 -> '*', blank?... =sss(" *");
264
265 (void) pointer
266 -> star
267 -> star, symbol name =concat_string();
268
269 (void) indirect data type
270 -> pointer
271 -> indirect data type, pointer =concat_string();
272
273 (void) name string
274 -> letter:c =scs(c);
275 -> name string, letter + digit :c =acs(c);
276 -> name string, blank..., letter + digit :c =acs(' '), acs(c);
277
278 (void) enum fix
279 -> "enum", blank..., letter + digit : c =sss("enum "), acs(c);
280 -> enum fix, letter + digit:c =acs(c);
281 -> enum fix, blank..., letter + digit:c =acs(' '), acs(c);
282
283 (void) symbol name
284 -> name string, blank?...
285
286 (void) blank
287 -> blank char
288 -> c comment
289
290 (void) space
291 -> blank...
292 -> blank..., continuation
293 -> continuation
294
295 (void) continuation
296 -> comment, next line
297 -> next line
298
299 (void) next line
300 -> carriage return?, newline
301 -> carriage return?, newline, blank...
302
303 (void) white
304 -> blank
305 -> carriage return?, newline
306 -> comment, carriage return?, newline
307
308 (void) end of line
309 -> comment, carriage return?, newline
310 -> carriage return?, newline
311 -> end of line, white
312 -> end of line, vertical space //form feed
313
314 (void) comment
315 -> "//", ~eol chars & ~eof?...
316
317 (int) character
318 -> signed number
319 -> '^', 33..126:x, blank?... =x & 0x1f;
320
321 (int) quoted character
322 -> single quote, char const:c, right quote =(character_seen=1),c;
323
324 (int) signed number
325 -> sign:s, simple number:n, blank?... =s*n;
326
327 (int) sign
328 -> plus? =1;
329 -> minus =-1;
330
331 (int) simple number
332 -> decimal number
333 -> octal number:n =n;
334 -> {"0x" | "0X"}, hex number:n =n;
335
336 (int) decimal number
337 -> '1-9':d =d - '0';
338 -> decimal number:n, '0-9':d =10*n + d - '0';
339
340 (int) octal number
341 -> '0' =0;
342 -> octal number:n, '0-7':d =8*n + d - '0';
343
344 (int) hex number
345 -> hex digit:d =d;
346 -> hex number:n, hex digit:d =16*n + d;
347
348 (int) hex digit
349 -> '0-9':d =d-'0';
350 -> 'a-f' + 'A-F':d =(d&7)+9;
351
352 (int) rule element
353 -> token
354 // -> mid rule action:p =vp_8a(p);
355 -> immediate action:p =vp_8a(mid_line(p));
356
357 (int) token
358 -> set union:n =form_element_1(n);
359 -> virtual production
360
361 (CharSetExpression *) set union
362 -> set intersection
363 -> set union:u, plus, set intersection:i =new CharSetUnion(u,i);
364 -> set difference
365
366 (CharSetExpression *) set difference
367 -> set union:u, minus, set intersection:i =new CharSetDifference(u,i);
368
369 (CharSetExpression *) set intersection
370 -> set complement
371 -> set intersection:i, '&', space?, set complement:n =
372 new CharSetIntersection(i,n);
373
374 (CharSetExpression *) set complement
375 -> character set
376 -> tilde, set complement:n = new CharSetComplement(n);
377
378 (int) char const
379 // -> anything -(single quote + backslash + eol chars):c =
380 // case_sensitive ? (c) : agToUpper((char) c);
381 -> anything -(single quote + backslash + eol chars)
382 -> escape sequence
383 -> octal escape
384 -> three octal
385 -> hex escape
386
387 (CharSetExpression *) character set
388 -> character range
389 // -> any character:c =new IndividualCode(c);
390 -> character:c =new IndividualCode(c);
391 -> quoted character:c =new IndividualChar(c);
392 -> symbol name =ss2();
393 -> left parenthesis, set union:x, right parenthesis =x;
394
395 (int)any character
396 -> character
397 -> quoted character
398
399 (CharSetExpression *) character range
400 -> single quote, char const:l, '-',
401 char const:r, right quote =(character_seen=1),new CharRange(l,r);
402 -> any character:l, "..", space?, any character:r =new CodeRange(l,r);
403
404 (void) definition
405 -> symbol name, equals, set union:n =definition_1(n);
406 -> symbol name, equals, virtual production:p =definition_2(p);
407 // -> symbol name, equals, mid rule action:p =definition_2(vp_8a(p));
408 -> symbol name, equals, proc def:p =defineImmediateProc(Procedure(p));
409
410 (void) enum definition
411 -> symbol name = definition_3(enum_base++);
412 -> symbol name, equals, character:n = definition_3(enum_base = n), enum_base++;
413 -> symbol name, equals, quoted character:n = definition_3(enum_base = n), enum_base++;
414
415 (void) enum statement
416 -> "enum", space, left brace, enum definition
417 -> enum statement, comma, enum definition
418
419 (void) keyword string
420 -> keyword string head, string, double quote, blank?...
421
422 (void) string
423 -> string A | string B | string C
424
425 (void) keyword string head
426 -> double quote =ics();
427
428 (int) string char
429 -> simple string char
430 -> escape sequence
431 -> three octal:n =null_warning(n);
432
433 (int) escape sequence
434 -> "\\a" ='\a';
435 -> "\\b" ='\b';
436 -> "\\f" ='\f';
437 -> "\\n" ='\n';
438 -> "\\r" ='\r';
439 -> "\\t" ='\t';
440 -> "\\v" ='\v';
441 -> "\\\\" ='\\';
442 -> "\\?" = '\?';
443 -> "\\'" ='\'';
444 -> "\\\"" ='"';
445
446 {
447 static int null_warning(int n) {
448 if (n == 0) log_error("Null character in string");
449 return n;
450 }
451 }
452
453 (int) one octal
454 -> backslash, '0-7':n =n&7;
455
456 (int) two octal
457 -> one octal:n, '0-7':d =n*8 + (d&7);
458
459 (int) three octal
460 -> two octal:n, '0-7':d =n*8 + (d&7);
461
462 (int) octal escape
463 -> one octal | two octal
464
465 (int) hex escape
466 -> "\\x", hex number:x =x;
467
468 (void) string A
469 -> string char:c =acs(c);
470 -> any digit:c =acs(c);
471 -> string, string char:c =acs(c);
472 -> string A, any digit:c =acs(c);
473 -> string B, nonoctal digit:c =acs(c);
474
475 (void) string B
476 -> octal escape:c =acs(null_warning(c));
477 -> string, octal escape:c =acs(null_warning(c));
478
479 (void) string C
480 -> hex escape:c =acs(null_warning(c));
481 -> string, hex escape:c =acs(null_warning(c));
482
483 (int) parameter name
484 -> =0;
485 -> ':', space?, c name =cVariableList << buildAgString();
486
487 (void) simple name
488 -> letter:c =scs(c);
489 -> simple name, letter + digit:c =acs(c);
490
491 (void) c name
492 -> simple name, blank?...
493
494 (void) configuration section
495 -> '[', configuration parameters, right bracket
496
497 (void) configuration parameters
498 -> blank?..., end of line?, [configuration parameter list, end of line?]
499
500 (void) configuration parameter list
501 -> configuration parameter
502 -> configuration parameter list, end of line, configuration parameter
503
504
505 (void) configuration parameter
506 -> symbol name =ConfigParam::set(1, pggErrorHandler); //gp4(1);
507 -> tilde, symbol name =ConfigParam::set(0, pggErrorHandler); //gp4(0);
508 -> symbol name, equals, data type =ConfigParam::set(pggErrorHandler); //gp2();
509 -> symbol name, equals, keyword string =ConfigParam::set(pggErrorHandler); //gp3();
510 -> enum fix, blank?..., equals, keyword string =ConfigParam::set(pggErrorHandler); //gp3();
511 -> symbol name, equals, signed number:n =ConfigParam::set(n, pggErrorHandler); //gp5(n);
512 -> attribute statement
513 -> keyword kluge, symbol name =concat_string(), ConfigParam::set(1, pggErrorHandler); //gp4(1);
514
515 keyword kluge
516 -> "distinguish", blank... =sss("distinguish ");
517
518 (void) attribute statement
519 -> "left", token list =set_prec(1,0);
520 -> "right", token list =set_prec(0,1);
521 -> "nonassoc", token list =set_prec(0,0);
522 -> "sticky", token list =set_sticky();
523 -> "subgrammar", token list =set_subgrammar();
524 -> "hidden", token list =set_hidden();
525 -> new reserve statement, list end //=new_reserve();
526 -> enum statement, list end
527 -> "disregard", blank..., token:t =disregardList.push(t);
528 -> "extend", blank..., "pcb", blank?..., embedded c =extensionStack.push(cSegmentStack.pop());
529 -> "lexeme", token list =set_lexeme();
530 -> "reserve", blank..., "keywords", token list =set_reserved_words();
531 -> "rename", blank..., "macro", blank...,
532 macro name:oldName, blank..., macro name:newName =at(rename_macro_list,oldName,newName);
533 -> "wrapper", wrapper list
534
535 (int) macro name
536 -> letter =(PCB).pointer-input_base-1;
537 -> macro name, letter + digit
538
539 list end
540 -> [comma | continuation], right brace
541
542 (void) new reserve statement
543 -> "distinguish", blank..., "keywords", blank..., left brace,
544 set union:n =distinguishSets.push(ParseTree(n));
545 -> new reserve statement, comma, set union:n =distinguishSets.push(ParseTree(n));
546
547 (void) token list
548 -> blank..., left brace, tokens, list end
549
550 (void) tokens
551 -> token:t =sws(t);
552 -> tokens, comma, token:t =aws(t);
553
554 (int) virtual production
555 -> keyword string =vp_s();
556 -> keyword string, '?', blank?... =vp_5(vp_s());
557 -> left brace, vp rules, right brace =vp_1();
558 -> left brace, vp rules, "}...", blank?... =vp_2();
559 -> left bracket, proper vp rule specs, right bracket =vp_3();
560 -> left bracket, proper vp rule specs, "]...", blank?... =vp_4();
561 -> set union:n, '?', blank?... =vp_5(form_element_1(n));
562 -> set union:n, "?...", blank?... =vp_6(form_element_1(n));
563 -> set union:n, ellipsis =vp_7(form_element_1(n));
564 -> left brace, proper vp rule specs, "}/...", blank?... =vp_9();
565 -> left bracket, proper vp rule specs, "]/...", blank?... =vp_10();
566
567 /*
568 (int) mid rule action
569 -> bang, embedded c =mid_line(proc_spec_4(0));
570 -> bang, c expression, ';', blank?... =mid_line(proc_spec_4(1));
571 */
572
573 (int) proc def
574 -> bang, embedded c =proc_spec_4(0);
575 -> bang, c expression, ';', blank?... =proc_spec_4(1);
576
577 (int) immediate action
578 -> bang, embedded c =proc_spec_4(0);
579 -> bang, c expression, ';', blank?... =proc_spec_4(1);
580
581 (void) embedded c
582 -> embedded c head, c code:y, right brace =cSegmentStack.top().end = y;
583
584 (void) embedded c head
585 -> '{', [carriage return?, newline]... =cSegmentStack.push(CSegment()); // =copyon();
586
587 (unsigned char *) c code
588 -> =PCB.pointer;
589 -> c code first, c text =PCB.pointer;
590
591 (void) c code first
592 -> simple c char - eol chars
593 -> c comment
594 -> comment, carriage return?, newline
595 -> c character constant, single quote
596 -> c string constant, double quote
597
598 (void) c text
599 ->
600 -> c text, c char
601
602 (void) c char //c char represents the content of embedded c
603 -> simple c char
604 -> '{', c text, '}'
605 -> c comment
606 -> comment, carriage return?, newline
607 -> c character constant, single quote
608 -> c string constant, double quote
609
610 (void) c expression head
611 -> =cSegmentStack.push(CSegment());
612
613 (void) c expression
614 -> c expression head, c chars =cSegmentStack.top().end = PCB.pointer;
615
616 (void) c chars
617 -> c expression char
618 -> c chars, c expression char
619 -> c chars, blank
620
621 (void) c expression char //c char represents the content of embedded C
622 -> simple c char - ';' - eol chars - blank char
623 -> "\\\n"
624 -> c character constant, single quote
625 -> c string constant, double quote
626
627 (void) c comment
628 -> c comment head, "*/"
629
630 (void) c comment head
631 -> "/*"
632 -> c comment head, ~eof
633
634 (void) c comment, c comment head
635 -> c comment head, c comment =
636 {if (nest_comments) PCB.reduction_token = pgg_c_comment_head_token;}
637
638 (void) c string constant
639 -> double quote, [c literal elem | single quote | backslash, anything]...
640
641 (void) c character constant
642 -> single quote, [c literal elem | double quote | backslash, anything]...
643
644 [
645 hidden {
646 arrow, comma, ellipsis, equals, left brace,
647 left bracket, left parenthesis, minus, plus, right bracket,
648 list end,
649 right brace, right parenthesis, right quote, star, tilde,
650 vertical bar, simple statement, token name,
651 rule spec, pointer, indirect data type, name string,
652 blank, space, next line, white, end of line, sign, simple number,
653 one octal, two octal, three octal,
654 string A, string B, string C,
655 simple name, c text, c char, c chars, c expression char,
656 c expression head,
657 c comment head,
658 c code, c name,
659 bang, // complete statement,
660 rule specs, vp rule specs, additional rule spec,
661 data type, template field, abstract declarator,
662 direct abstract declarator, pointer,
663 name string, proper vp rule specs, additional vp rule spec,
664 new reserve statement, anything, //set union, //set intersection, //set complement,
665 enum fix,
666 character range
667 }
668 ]
669
670 {
671 pgg_pcb_type pgcb;
672 #define PCB pgcb
673
674 #define PARSER_STACK_OVERFLOW parse_stack_overflow()
675 #define SYNTAX_ERROR log_syntax_error()
676 #define GET_CONTEXT CONTEXT.y = PCB.line, CONTEXT.x = PCB.column;
677
678 #define REDUCTION_TOKEN_ERROR reduction_token_error()
679
680 CSegment::CSegment()
681 : begin(PCB.pointer), end(PCB.pointer), line(PCB.line)
682 {
683 LOGSECTION("CSegment::CSegment");
684 // Nothing to do
685 }
686
687 static class PggErrorHandler : public ConfigParam::ErrorHandler {
688 void badParam(const char *s){log_error(s);}
689 } pggErrorHandler;
690
691
692 static void reduction_token_error(void) {
693 #ifdef INCLUDE_LOGGING
694 LOGSECTION("reduction_token_error");
695 LOGV(PCB.sn) LCV(PCB.ssx) LCV(PCB.reduction_token);
696 for (int i = 0; i < PCB.ssx; i++) LOGV(i) LCV(PCB.ss[i]);
697 #endif
698 assert(0);
699 }
700
701 static void parse_stack_overflow(void) {
702 reset_stk();
703 log_error("Nesting too deep. Analysis aborted.");
704 errorList.top().setFatal();
705 parse_abort_flag = 1;
706 PCB.exit_flag = AG_SEMANTIC_ERROR_CODE;
707 }
708
709
710 static int head_list_3(int);
711 static void set_prec(int,int);
712
713 // void range(int, int);
714
715 /*
716 static void disregard(int tn) {
717 LOGSECTION("disregard");
718 iws();
719 if (n_disregard_list) {
720 int *p = disregard_list;
721 while (n_disregard_list--) aws(*p++);
722 DEALLOCATE(disregard_list);
723 }
724 xws(tn);
725 disregard_list = build_list();
726 n_disregard_list = fis();
727 }
728 */
729
730 static void pgg24_error(const char *msg, int contextFlag=0) {
731 LOGSECTION("pgg24_error");
732 LOGV(msg);
733 LOGV(contextFlag);
734 LOGV(PCB.line) LCV(PCB.column);
735 LOGV(ERROR_CONTEXT.y) LCV(ERROR_CONTEXT.x);
736
737 int line, column;
738 if (contextFlag) {
739 line = ERROR_CONTEXT.y;
740 column = ERROR_CONTEXT.x;
741 }
742 else {
743 line = PCB.line;
744 column = PCB.column;
745 }
746
747 errorList.push(Error(line, column, msg));
748 }
749
750 static void log_syntax_error(void) {
751 LOGSECTION("log_syntax_error");
752
753 #ifdef INCLUDE_LOGGING
754 {
755 LOGV(PCB.sn) LCV(PCB.ssx) LCV(PCB.token_number);
756 for (int i = 0; i < PCB.ssx; i++) LOGV(i) LCV(PCB.ss[i]);
757 }
758 #endif
759 int flag = PCB.error_frame_token == pgg_c_comment_token ||
760 PCB.error_frame_token == pgg_embedded_c_token;
761 LOGV(flag);
762 reset_stk();
763
764 #ifdef INCLUDE_LOGGING
765 {
766 LOGV(PCB.sn) LCV(PCB.ssx) LCV(PCB.token_number);
767 for (int i = 0; i < PCB.ssx; i++) LOGV(i) LCV(PCB.ss[i]);
768 }
769 #endif
770 ssprintf("%s in %s", PCB.error_message, pgg_token_names[PCB.error_frame_token]);
771 LOGS(string_base);
772
773 pgg24_error(string_base, flag && PCB.token_number == pgg_eof_token);
774 rcs();
775 #ifdef INCLUDE_LOGGING
776 {
777 LOGV(PCB.sn) LCV(PCB.ssx) LCV(PCB.token_number);
778 for (int i = 0; i < PCB.ssx; i++) LOGV(i) LCV(PCB.ss[i]);
779 }
780 #endif
781 LOGS("error logged");
782 errorList.top().setFatal();
783 LOGS("fatal flag set");
784 syntax_error_flag++;
785 #ifdef INCLUDE_LOGGING
786 {
787 LOGV(PCB.sn) LCV(PCB.ssx) LCV(PCB.token_number);
788 for (int i = 0; i < PCB.ssx; i++) LOGV(i) LCV(PCB.ss[i]);
789 }
790 #endif
791 if (errorList.size() < 50) return;
792 log_error("Too many errors. Parse aborted.");
793 errorList.top().setFatal();
794 PCB.exit_flag = AG_SYNTAX_ERROR_CODE;
795 }
796
797 static int head_list_3(int type) {
798 LOGSECTION("head_list_3");
799 LOGV(type);
800 int i, n = tis();
801 for (i = 0; i < n; i ++) {
802 Token token(list_base[i]);
803 int ptt = token->value_type;
804 LOGV(ptt) LCV(type);
805 if (ptt && ptt != type) {
806 ssprintf("Type Redefinition of T%03d: ", (int) token);
807 atkn(token);
808 log_error();
809 }
810 token->value_type = type;
811 /*
812 if (ptt == 0 && token->rp_arg && type == void_token_type) {
813 //ssprintf("Void token, %s, used as parameter", dict_str(tkn_dict,token->token_name));
814 ssprintf("Void token, %s, used as parameter", token->token_name->string.pointer());
815 log_error();
816 }
817 */
818 }
819 return type;
820 }
821
822 static void set_prec(int left, int right){
823 LOGSECTION("set_prec");
824 int n = tis();
825 precedence_level++;
826 while (n--) {
827 Token token(list_base[n]);
828 token->left_associative = left;
829 token->right_associative = right;
830 token->precedence_level = precedence_level;
831 token->operatorCandidate = 1;
832 }
833 rws();
834 }
835
836 static void set_sticky(void){
837 LOGSECTION("set_sticky");
838 int n = tis();
839 while (n--) {
840 Token token(list_base[n]);
841 token->sticky = 1;
842 }
843 rws();
844 }
845
846 static void set_subgrammar(void){
847 LOGSECTION("set_subgrammar");
848 int n = tis();
849 while (n--) {
850 Token token = list_base[n];
851 token->subgrammar = 1;
852 }
853 rws();
854 }
855
856 static void set_hidden(void) {
857 LOGSECTION("set_hidden");
858 int *lb = list_base;
859 int n = tis();
860 //while (n--) map_token_number[*lb++].fine_structure = 1;
861 while (n--) Token(*lb++)->fine_structure = 1;
862 rws();
863 }
864
865 static void set_lexeme(void) {
866 LOGSECTION("set_lexeme");
867 int n = tis();
868 while (n--) {
869 Token token = list_base[n];
870 token->lexeme = 1;
871 }
872 rws();
873 }
874
875 static void set_reserved_words(void) {
876 LOGSECTION("set_reserved_words");
877 int n = tis();
878 while (n--) {
879 Token token(list_base[n]);
880 token->reserved_word = 1;
881 }
882 rws();
883 }
884
885 void parse(void) {
886 pgcb.pointer = input_base;
887 pgg();
888 }
889 }
890