diff options
Diffstat (limited to 'BaseTools/Source/C/VfrCompile/Pccts')
128 files changed, 68139 insertions, 0 deletions
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_131.txt b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_131.txt new file mode 100644 index 0000000000..500d84f2e8 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_131.txt @@ -0,0 +1,522 @@ +CHANGES FROM 1.31
+
+This file contains the migration of PCCTS from 1.31 in the order that
+changes were made. 1.32b7 is the last beta before full 1.32.
+Terence Parr, Parr Research Corporation 1995.
+
+
+======================================================================
+1.32b1
+Added Russell Quong to banner, changed banner for output slightly
+Fixed it so that you have before / after actions for C++ in class def
+Fixed bug in optimizer that made it sometimes forget to set internal
+ token pointers. Only showed up when a {...} was in the "wrong spot".
+
+======================================================================
+1.32b2
+Added fixes by Dave Seidel for PC compilers in 32 bit mode (config.h
+and set.h).
+
+======================================================================
+1.32b3
+Fixed hideous bug in code generator for wildcard and for ~token op.
+
+from Dave Seidel
+
+ Added pcnames.bat
+ 1. in antlr/main.c: change strcasecmp() to stricmp()
+
+ 2. in dlg/output.c: use DLEXER_C instead on "DLexer.C"
+
+ 3. in h/PBlackBox.h: use <iostream.h> instead of <stream.h>
+
+======================================================================
+1.32b4
+When the -ft option was used, any path prefix screwed up
+the gate on the .h files
+
+Fixed yet another bug due to the optimizer.
+
+The exception handling thing was a bit wacko:
+
+a : ( A B )? A B
+ | A C
+ ;
+ exception ...
+
+caused an exception if "A C" was the input. In other words,
+it found that A C didn't match the (A B)? pred and caused
+an exception rather than trying the next alt. All I did
+was to change the zzmatch_wsig() macros.
+
+Fixed some problems in gen.c relating to the name of token
+class bit sets in the output.
+
+Added the tremendously cool generalized predicate. For the
+moment, I'll give this bried description.
+
+a : <<predicate>>? blah
+ | foo
+ ;
+
+This implies that (assuming blah and foo are syntactically
+ambiguous) "predicate" indicates the semantic validity of
+applying "blah". If "predicate" is false, "foo" is attempted.
+
+Previously, you had to say:
+
+a : <<LA(1)==ID ? predicate : 1>>? ID
+ | ID
+ ;
+
+Now, you can simply use "predicate" without the ?: operator
+if you turn on ANTLR command line option: "-prc on". This
+tells ANTLR to compute that all by itself. It computes n
+tokens of lookahead where LT(n) or LATEXT(n) is the farthest
+ahead you look.
+
+If you give a predicate using "-prc on" that is followed
+by a construct that can recognize more than one n-sequence,
+you will get a warning from ANTLR. For example,
+
+a : <<isTypeName(LT(1)->getText())>>? (ID|INT)
+ ;
+
+This is wrong because the predicate will be applied to INTs
+as well as ID's. You should use this syntax to make
+the predicate more specific:
+
+a : (ID)? => <<isTypeName(LT(1)->getText())>>? (ID|INT)
+ ;
+
+which says "don't apply the predicate unless ID is the
+current lookahead context".
+
+You cannot currently have anything in the "(context)? =>"
+except sequences such as:
+
+( LPAREN ID | LPAREN SCOPE )? => <<pred>>?
+
+I haven't tested this THAT much, but it does work for the
+C++ grammar.
+
+======================================================================
+1.32b5
+
+Added getLine() to the ANTLRTokenBase and DLGBasedToken classes
+left line() for backward compatibility.
+----
+Removed SORCERER_TRANSFORM from the ast.h stuff.
+-------
+Fixed bug in code gen of ANTLR such that nested syn preds work more
+efficiently now. The ANTLRTokenBuffer was getting very large
+with nested predicates.
+------
+Memory leak is now gone from ANTLRTokenBuf; all tokens are deleted.
+For backward compatibility reasons, you have to say parser->deleteTokens()
+or mytokenbuffer->deleteTokens() but later it will be the default mode.
+Say this after the parser is constructed. E.g.,
+
+ ParserBlackBox<DLGLexer, MyParser, ANTLRToken> p(stdin);
+ p.parser()->deleteTokens();
+ p.parser()->start_symbol();
+
+
+==============================
+1.32b6
+
+Changed so that deleteTokens() will do a delete ((ANTLRTokenBase *))
+on the ptr. This gets the virtual destructor.
+
+Fixed some weird things in the C++ header files (a few return types).
+
+Made the AST routines correspond to the book and SORCERER stuff.
+
+New token stuff: See testcpp/14/test.g
+
+ANTLR accepts a #pragma gc_tokens which says
+[1] Generate label = copy(LT(1)) instead of label=LT(1) for
+ all labeled token references.
+[2] User now has to define ANTLRTokenPtr (as a class or a typedef
+ to just a pointer) as well as the ANTLRToken class itself.
+ See the example.
+
+To delete tokens in token buffer, use deleteTokens() message on parser.
+
+ All tokens that fall off the ANTLRTokenBuffer get deleted
+ which is what currently happens when deleteTokens() message
+ has been sent to token buffer.
+
+We always generate ANTLRTokenPtr instead of 'ANTLRToken *' now.
+Then if no pragma set, ANTLR generates a
+
+ class ANTLRToken;
+ typedef ANTLRToken *ANTLRTokenPtr;
+
+in each file.
+
+Made a warning for x:rule_ref <<$x>>; still no warning for $i's, however.
+class BB {
+
+a : x:b y:A <<$x
+$y>>
+ ;
+
+b : B;
+
+}
+generates
+Antlr parser generator Version 1.32b6 1989-1995
+test.g, line 3: error: There are no token ptrs for rule references: '$x'
+
+===================
+1.32b7:
+
+[With respect to token object garbage collection (GC), 1.32b7
+ backtracks from 1.32b6, but results in better and less intrusive GC.
+ This is the last beta version before full 1.32.]
+
+BIGGEST CHANGES:
+
+o The "#pragma gc_tokens" is no longer used.
+
+o .C files are now .cpp files (hence, makefiles will have to
+ be changed; or you can rerun genmk). This is a good move,
+ but causes some backward incompatibility problems. You can
+ avoid this by changing CPP_FILE_SUFFIX to ".C" in pccts/h/config.h.
+
+o The token object class hierarchy has been flattened to include
+ only three classes: ANTLRAbstractToken, ANTLRCommonToken, and
+ ANTLRCommonNoRefCountToken. The common token now does garbage
+ collection via ref counting.
+
+o "Smart" pointers are now used for garbage collection. That is,
+ ANTLRTokenPtr is used instead of "ANTLRToken *".
+
+o The antlr.1 man page has been cleaned up slightly.
+
+o The SUN C++ compiler now complains less about C++ support code.
+
+o Grammars which subclass ANTLRCommonToken must wrap all token
+ pointer references in mytoken(token_ptr). This is the only
+ serious backward incompatibility. See below.
+
+
+MINOR CHANGES:
+
+--------------------------------------------------------
+1 deleteTokens()
+
+The deleteTokens() message to the parser or token buffer has been changed
+to one of:
+
+ void noGarbageCollectTokens() { inputTokens->noGarbageCollectTokens(); }
+ void garbageCollectTokens() { inputTokens->garbageCollectTokens(); }
+
+The token buffer deletes all non-referenced tokens by default now.
+
+--------------------------------------------------------
+2 makeToken()
+
+The makeToken() message returns a new type. The function should look
+like:
+
+ virtual ANTLRAbstractToken *makeToken(ANTLRTokenType tt,
+ ANTLRChar *txt,
+ int line)
+ {
+ ANTLRAbstractToken *t = new ANTLRCommonToken(tt,txt);
+ t->setLine(line);
+ return t;
+ }
+
+--------------------------------------------------------
+3 TokenType
+
+Changed TokenType-> ANTLRTokenType (often forces changes in AST defs due
+to #[] constructor called to AST(tokentype, string)).
+
+--------------------------------------------------------
+4 AST()
+
+You must define AST(ANTLRTokenPtr t) now in your AST class definition.
+You might also have to include ATokPtr.h above the definition; e.g.,
+if AST is defined in a separate file, such as AST.h, it's a good idea
+to include ATOKPTR_H (ATokPtr.h). For example,
+
+ #include ATOKPTR_H
+ class AST : public ASTBase {
+ protected:
+ ANTLRTokenPtr token;
+ public:
+ AST(ANTLRTokenPtr t) { token = t; }
+ void preorder_action() {
+ char *s = token->getText();
+ printf(" %s", s);
+ }
+ };
+
+Note the use of smart pointers rather than "ANTLRToken *".
+
+--------------------------------------------------------
+5 SUN C++
+
+From robertb oakhill.sps.mot.com Bob Bailey. Changed ANTLR C++ output
+to avoid an error in Sun C++ 3.0.1. Made "public" return value
+structs created to hold multiple return values public.
+
+--------------------------------------------------------
+6 genmk
+
+Fixed genmk so that target List.* is not included anymore. It's
+called SList.* anyway.
+
+--------------------------------------------------------
+7 \r vs \n
+
+Scott Vorthmann <vorth cmu.edu> fixed antlr.g in ANTLR so that \r
+is allowed as the return character as well as \n.
+
+--------------------------------------------------------
+8 Exceptions
+
+Bug in exceptions attached to labeled token/tokclass references. Didn't gen
+code for exceptions. This didn't work:
+
+a : "help" x:ID
+ ;
+ exception[x]
+ catch MismatchedToken : <<printf("eh?\n");>>
+
+Now ANTLR generates (which is kinda big, but necessary):
+
+ if ( !_match_wsig(ID) ) {
+ if ( guessing ) goto fail;
+ _signal=MismatchedToken;
+ switch ( _signal ) {
+ case MismatchedToken :
+ printf("eh?\n");
+ _signal = NoSignal;
+ break;
+ default :
+ goto _handler;
+ }
+ }
+
+which implies that you can recover and continue parsing after a missing/bad
+token reference.
+
+--------------------------------------------------------
+9 genmk
+
+genmk now correctly uses config file for CPP_FILE_SUFFIX stuff.
+
+--------------------------------------------------------
+10 general cleanup / PURIFY
+
+Anthony Green <green vizbiz.com> suggested a bunch of good general
+clean up things for the code; he also suggested a few things to
+help out the "PURIFY" memory allocation checker.
+
+--------------------------------------------------------
+11 $-variable references.
+
+Manuel ORNATO indicated that a $-variable outside of a rule caused
+ANTLR to crash. I fixed this.
+
+12 Tom Moog suggestion
+
+Fail action of semantic predicate needs "{}" envelope. FIXED.
+
+13 references to LT(1).
+
+I have enclosed all assignments such as:
+
+ _t22 = (ANTLRTokenPtr)LT(1);
+
+in "if ( !guessing )" so that during backtracking the reference count
+for token objects is not increased.
+
+
+TOKEN OBJECT GARBAGE COLLECTION
+
+1 INTRODUCTION
+
+The class ANTLRCommonToken is now garbaged collected through a "smart"
+pointer called ANTLRTokenPtr using reference counting. Any token
+object not referenced by your grammar actions is destroyed by the
+ANTLRTokenBuffer when it must make room for more token objects.
+Referenced tokens are then destroyed in your parser when local
+ANTLRTokenPtr objects are deleted. For example,
+
+a : label:ID ;
+
+would be converted to something like:
+
+void yourclass::a(void)
+{
+ zzRULE;
+ ANTLRTokenPtr label=NULL; // used to be ANTLRToken *label;
+ zzmatch(ID);
+ label = (ANTLRTokenPtr)LT(1);
+ consume();
+ ...
+}
+
+When the "label" object is destroyed (it's just a pointer to your
+input token object LT(1)), it decrements the reference count on the
+object created for the ID. If the count goes to zero, the object
+pointed by label is deleted.
+
+To correctly manage the garbage collection, you should use
+ANTLRTokenPtr instead of "ANTLRToken *". Most ANTLR support code
+(visible to the user) has been modified to use the smart pointers.
+
+***************************************************************
+Remember that any local objects that you create are not deleted when a
+lonjmp() is executed. Unfortunately, the syntactic predicates (...)?
+use setjmp()/longjmp(). There are some situations when a few tokens
+will "leak".
+***************************************************************
+
+2 DETAILS
+
+o The default is to perform token object garbage collection.
+ You may use parser->noGarbageCollectTokens() to turn off
+ garbage collection.
+
+
+o The type ANTLRTokenPtr is always defined now (automatically).
+ If you do not wish to use smart pointers, you will have to
+ redefined ANTLRTokenPtr by subclassing, changing the header
+ file or changing ANTLR's code generation (easy enough to
+ do in gen.c).
+
+o If you don't use ParserBlackBox, the new initialization sequence is:
+
+ ANTLRTokenPtr aToken = new ANTLRToken;
+ scan.setToken(mytoken(aToken));
+
+ where mytoken(aToken) gets an ANTLRToken * from the smart pointer.
+
+o Define C++ preprocessor symbol DBG_REFCOUNTTOKEN to see a bunch of
+ debugging stuff for reference counting if you suspect something.
+
+
+3 WHY DO I HAVE TO TYPECAST ALL MY TOKEN POINTERS NOW??????
+
+If you subclass ANTLRCommonToken and then attempt to refer to one of
+your token members via a token pointer in your grammar actions, the
+C++ compiler will complain that your token object does not have that
+member. For example, if you used to do this
+
+<<
+class ANTLRToken : public ANTLRCommonToken {
+ int muck;
+ ...
+};
+>>
+
+class Foo {
+a : t:ID << t->muck = ...; >> ;
+}
+
+Now, you must do change the t->muck reference to:
+
+a : t:ID << mytoken(t)->muck = ...; >> ;
+
+in order to downcast 't' to be an "ANTLRToken *" not the
+"ANTLRAbstractToken *" resulting from ANTLRTokenPtr::operator->().
+The macro is defined as:
+
+/*
+ * Since you cannot redefine operator->() to return one of the user's
+ * token object types, we must down cast. This is a drag. Here's
+ * a macro that helps. template: "mytoken(a-smart-ptr)->myfield".
+ */
+#define mytoken(tp) ((ANTLRToken *)(tp.operator->()))
+
+You have to use macro mytoken(grammar-label) now because smart
+pointers are not specific to a parser's token objects. In other
+words, the ANTLRTokenPtr class has a pointer to a generic
+ANTLRAbstractToken not your ANTLRToken; the ANTLR support code must
+use smart pointers too, but be able to work with any kind of
+ANTLRToken. Sorry about this, but it's C++'s fault not mine. Some
+nebulous future version of the C++ compilers should obviate the need
+to downcast smart pointers with runtime type checking (and by allowing
+different return type of overridden functions).
+
+A way to have backward compatible code is to shut off the token object
+garbage collection; i.e., use parser->noGarbageCollectTokens() and
+change the definition of ANTLRTokenPtr (that's why you get source code
+<wink>).
+
+
+PARSER EXCEPTION HANDLING
+
+I've noticed some weird stuff with the exception handling. I intend
+to give this top priority for the "book release" of ANTLR.
+
+==========
+1.32 Full Release
+
+o Changed Token class hierarchy to be (Thanks to Tom Moog):
+
+ ANTLRAbstractToken
+ ANTLRRefCountToken
+ ANTLRCommonToken
+ ANTLRNoRefCountCommonToken
+
+o Added virtual panic() to ANTLRAbstractToken. Made ANTLRParser::panic()
+ virtual also.
+
+o Cleaned up the dup() stuff in AST hierarchy to use shallowCopy() to
+ make node copies. John Farr at Medtronic suggested this. I.e.,
+ if you want to use dup() with either ANTLR or SORCERER or -transform
+ mode with SORCERER, you must defined shallowCopy() as:
+
+ virtual PCCTS_AST *shallowCopy()
+ {
+ return new AST;
+ p->setDown(NULL);
+ p->setRight(NULL);
+ return p;
+ }
+
+ or
+
+ virtual PCCTS_AST *shallowCopy()
+ {
+ return new AST(*this);
+ }
+
+ if you have defined a copy constructor such as
+
+ AST(const AST &t) // shallow copy constructor
+ {
+ token = t.token;
+ iconst = t.iconst;
+ setDown(NULL);
+ setRight(NULL);
+ }
+
+o Added a warning with -CC and -gk are used together. This is broken,
+ hence a warning is appropriate.
+
+o Added warning when #-stuff is used w/o -gt option.
+
+o Updated MPW installation.
+
+o "Miller, Philip W." <MILLERPW f1groups.fsd.jhuapl.edu> suggested
+ that genmk be use RENAME_OBJ_FLAG RENAME_EXE_FLAG instead of
+ hardcoding "-o" in genmk.c.
+
+o made all exit() calls use EXIT_SUCCESS or EXIT_FAILURE.
+
+===========================================================================
+1.33
+
+EXIT_FAILURE and EXIT_SUCCESS were not always defined. I had to modify
+a bunch of files to use PCCTS_EXIT_XXX, which forces a new version. Sorry
+about that.
+
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133.txt b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133.txt new file mode 100644 index 0000000000..2128c4ff25 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133.txt @@ -0,0 +1,2448 @@ +=======================================================================
+List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
+=======================================================================
+
+ DISCLAIMER
+
+ The software and these notes are provided "as is". They may include
+ typographical or technical errors and their authors disclaims all
+ liability of any kind or nature for damages due to error, fault,
+ defect, or deficiency regardless of cause. All warranties of any
+ kind, either express or implied, including, but not limited to, the
+ implied warranties of merchantability and fitness for a particular
+ purpose are disclaimed.
+
+
+ -------------------------------------------------------
+ Note: Items #153 to #1 are now in a separate file named
+ CHANGES_FROM_133_BEFORE_MR13.txt
+ -------------------------------------------------------
+
+#312. (Changed in MR33) Bug caused by change #299.
+
+ In change #299 a warning message was suppressed when there was
+ no LT(1) in a semantic predicate and max(k,ck) was 1. The
+ changed caused the code which set a default predicate depth for
+ the semantic predicate to be left as 0 rather than set to 1.
+
+ This manifested as an error at line #1559 of mrhost.c
+
+ Reported by Peter Dulimov.
+
+#311. (Changed in MR33) Added sorcer/lib to Makefile.
+
+ Reported by Dale Martin.
+
+#310. (Changed in MR32) In C mode zzastPush was spelled zzastpush in one case.
+
+ Reported by Jean-Claude Durand
+
+#309. (Changed in MR32) Renamed baseName because of VMS name conflict
+
+ Renamed baseName to pcctsBaseName to avoid library name conflict with
+ VMS library routine. Reported by Jean-François PIÉRONNE.
+
+#308. (Changed in MR32) Used "template" as name of formal in C routine
+
+ In astlib.h routine ast_scan a formal was named "template". This caused
+ problems when the C code was compiled with a C++ compiler. Reported by
+ Sabyasachi Dey.
+
+#307. (Changed in MR31) Compiler dependent bug in function prototype generation
+
+ The code which generated function prototypes contained a bug which
+ was compiler/optimization dependent. Under some circumstance an
+ extra character would be included in portions of a function prototype.
+
+ Reported by David Cook.
+
+#306. (Changed in MR30) Validating predicate following a token
+
+ A validating predicate which immediately followed a token match
+ consumed the token after the predicate rather than before. Prior
+ to this fix (in the following example) isValidTimeScaleValue() in
+ the predicate would test the text for TIMESCALE rather than for
+ NUMBER:
+
+ time_scale :
+ TIMESCALE
+ <<isValidTimeScaleValue(LT(1)->getText())>>?
+ ts:NUMBER
+ ( us:MICROSECOND << tVal = ...>>
+ | ns:NANOSECOND << tVal = ... >>
+ )
+
+ Reported by Adalbert Perbandt.
+
+#305. (Changed in MR30) Alternatives with guess blocks inside (...)* blocks.
+
+ In MR14 change #175 fixed a bug in the prediction expressions for guess
+ blocks which were of the form (alpha)? beta. Unfortunately, this
+ resulted in a new bug as exemplified by the example below, which computed
+ the first set for r as {B} rather than {B C}:
+
+ r : ( (A)? B
+ | C
+ )*
+
+ This example doesn't make any sense as A is not a prefix of B, but it
+ illustrates the problem. This bug did not appear for:
+
+ r : ( (A)?
+ | C
+ )*
+
+ because it does not use the (alpha)? beta form.
+
+ Item #175 fixed an asymmetry in ambiguity messages for the following
+ constructs which appear to have identical ambiguities (between repeating
+ the loop vs. exiting the loop). MR30 retains this fix, but the implementation
+ is slightly different.
+
+ r_star : ( (A B)? )* A ;
+ r_plus : ( (A B)? )+ A ;
+
+ Reported by Arpad Beszedes (beszedes inf.u-szeged.hu).
+
+#304. (Changed in MR30) Crash when mismatch between output value counts.
+
+ For a rule such as:
+
+ r1 : r2>[i,j];
+ r2 >[int i, int j] : A;
+
+ If there were extra actuals for the reference to rule r2 from rule r1
+ there antlr would crash. This bug was introduced by change #276.
+
+ Reported by Sinan Karasu.
+
+#303. (Changed in MR30) DLGLexerBase::replchar
+
+ DLGLexerBase::replchar and the C mode routine zzreplchar did not work
+ properly when the new character was 0.
+
+ Reported with fix by Philippe Laporte
+
+#302. (Changed in MR28) Fix significant problems in initial release of MR27.
+
+#301. (Changed in MR27) Default tab stops set to 2 spaces.
+
+ To have antlr generate true tabs rather than spaces, use "antlr -tab 0".
+ To generate 4 spaces per tab stop use "antlr -tab 4"
+
+#300. (Changed in MR27)
+
+ Consider the following methods of constructing an AST from ID:
+
+ rule1!
+ : id:ID << #0 = #[id]; >> ;
+
+ rule2!
+ : id:ID << #0 = #id; >> ;
+
+ rule3
+ : ID ;
+
+ rule4
+ : id:ID << #0 = #id; >> ;
+
+ For rule_2, the AST corresponding to id would always be NULL. This
+ is because the user explicitly suppressed AST construction using the
+ "!" operator on the rule. In MR27 the use of an AST expression
+ such as #id overrides the "!" operator and forces construction of
+ the AST.
+
+ This fix does not apply to C mode ASTs when the ASTs are referenced
+ using numbers rather than symbols.
+
+ For C mode, this requires that the (optional) function/macro zzmk_ast
+ be defined. This functions copies information from an attribute into
+ a previously allocated AST.
+
+ Reported by Jan Langer (jan langernetz.de)
+
+#299. (Changed in MR27) Don't warn if k=1 and semantic predicate missing LT(i)
+
+ If a semantic does not have a reference to LT(i) or (C mode LATEXT(i))
+ then pccts doesn't know how many lookahead tokens to use for context.
+ However, if max(k,ck) is 1 then there is really only one choice and
+ the warning is unnecessary.
+
+#298. (Changed in MR27) Removed "register" for lastpos in dlgauto.c zzgettok
+
+#297. (Changed in MR27) Incorrect prototypes when used with classic C
+
+ There were a number of errors in function headers when antlr was
+ built with compilers that do not have __STDC__ or __cplusplus set.
+
+ The functions which have variable length argument lists now use
+ PCCTS_USE_STDARG rather than __USE_PROTOTYPES__ to determine
+ whether to use stdargs or varargs.
+
+#296. (Changed in MR27) Complex return types in rules.
+
+ The following return type was not properly handled when
+ unpacking a struct with containing multiple return values:
+
+ rule > [int i, IIR_Bool (IIR_Decl::*constraint)()] : ...
+
+ Instead of using "constraint", the program got lost and used
+ an empty string.
+
+ Reported by P.A. Wilsey.
+
+#295. (Changed in MR27) Extra ";" following zzGUESS_DONE sometimes.
+
+ Certain constructs with guess blocks in MR23 led to extra ";"
+ preceding the "else" clause of an "if".
+
+ Reported by P.A. Wilsey.
+
+#294. (Changed in MR27) Infinite loop in antlr for nested blocks
+
+ An oversight in detecting an empty alternative sometimes led
+ to an infinite loop in antlr when it encountered a rule with
+ nested blocks and guess blocks.
+
+ Reported by P.A. Wilsey.
+
+#293. (Changed in MR27) Sorcerer optimization of _t->type()
+
+ Sorcerer generated code may contain many calls to _t->type() in a
+ single statement. This change introduces a temporary variable
+ to eliminate unnnecesary function calls.
+
+ Change implemented by Tom Molteno (tim videoscript.com).
+
+#292. (Changed in MR27)
+
+ WARNING: Item #267 changes the signature of methods in the AST class.
+
+ **** Be sure to revise your AST functions of the same name ***
+
+#291. (Changed in MR24)
+
+ Fix to serious code generation error in MR23 for (...)+ block.
+
+#290. (Changed in MR23)
+
+ Item #247 describes a change in the way {...} blocks handled
+ an error. Consider:
+
+ r1 : {A} b ;
+ b : B;
+
+ with input "C".
+
+ Prior to change #247, the error would resemble "expected B -
+ found C". This is correct but incomplete, and therefore
+ misleading. In #247 it was changed to "expected A, B - found
+ C". This was fine, except for users of parser exception
+ handling because the exception was generated in the epilogue
+ for {...} block rather than in rule b. This made it difficult
+ for users of parser exception handling because B was not
+ expected in that context. Those not using parser exception
+ handling didn't notice the difference.
+
+ The current change restores the behavior prior to #247 when
+ parser exceptions are present, but retains the revised behavior
+ otherwise. This change should be visible only when exceptions
+ are in use and only for {...} blocks and sub-blocks of the form
+ (something|something | something | epsilon) where epsilon represents
+ an empty production and it is the last alternative of a sub-block.
+ In contrast, (something | epsilon | something) should generate the
+ same code as before, even when exceptions are used.
+
+ Reported by Philippe Laporte (philippe at transvirtual.com).
+
+#289. (Changed in MR23) Bug in matching complement of a #tokclass
+
+ Prior to MR23 when a #tokclass was matched in both its complemented form
+ and uncomplemented form, the bit set generated for its first use was used
+ for both cases. However, the prediction expression was correctly computed
+ in both cases. This meant that the second case would never be matched
+ because, for the second appearance, the prediction expression and the
+ set to be matched would be complements of each other.
+
+ Consider:
+
+ #token A "a"
+ #token B "b"
+ #token C "c"
+ #tokclass AB {A B}
+
+ r1 : AB /* alt 1x */
+ | ~AB /* alt 1y */
+ ;
+
+ Prior to MR23, this resulted in alternative 1y being unreachable. Had it
+ been written:
+
+ r2 : ~AB /* alt 2x */
+ : AB /* alt 2y */
+
+ then alternative 2y would have become unreachable.
+
+ This bug was only for the case of complemented #tokclass. For complemented
+ #token the proper code was generated.
+
+#288. (Changed in MR23) #errclass not restricted to choice points
+
+ The #errclass directive is supposed to allow a programmer to define
+ print strings which should appear in syntax error messages as a replacement
+ for some combinations of tokens. For instance:
+
+ #errclass Operator {PLUS MINUS TIMES DIVIDE}
+
+ If a syntax message includes all four of these tokens, and there is no
+ "better" choice of error class, the word "Operator" will be used rather
+ than a list of the four token names.
+
+ Prior to MR23 the #errclass definitions were used only at choice points
+ (which call the FAIL macro). In other cases where there was no choice
+ (e.g. where a single token or token class were matched) the #errclass
+ information was not used.
+
+ With MR23 the #errclass declarations are used for syntax error messages
+ when matching a #tokclass, a wildcard (i.e. "*"), or the complement of a
+ #token or #tokclass (e.g. ~Operator).
+
+ Please note that #errclass may now be defined using #tokclass names
+ (see Item #284).
+
+ Reported by Philip A. Wilsey.
+
+#287. (Changed in MR23) Print name for #tokclass
+
+ Item #148 describes how to give a print name to a #token so that,for
+ example, #token ID could have the expression "identifier" in syntax
+ error messages. This has been extended to #tokclass:
+
+ #token ID("identifier") "[a-zA-Z]+"
+ #tokclass Primitive("primitive type")
+ {INT, FLOAT, CHAR, FLOAT, DOUBLE, BOOL}
+
+ This is really a cosmetic change, since #tokclass names do not appear
+ in any error messages.
+
+#286. (Changed in MR23) Makefile change to use of cd
+
+ In cases where a pccts subdirectory name matched a directory identified
+ in a $CDPATH environment variable the build would fail. All makefile
+ cd commands have been changed from "cd xyz" to "cd ./xyz" in order
+ to avoid this problem.
+
+#285. (Changed in MR23) Check for null pointers in some dlg structures
+
+ An invalid regular expression can cause dlg to build an invalid
+ structure to represent the regular expression even while it issues
+ error messages. Additional pointer checks were added.
+
+ Reported by Robert Sherry.
+
+#284. (Changed in MR23) Allow #tokclass in #errclass definitions
+
+ Previously, a #tokclass reference in the definition of an
+ #errclass was not handled properly. Instead of being expanded
+ into the set of tokens represented by the #tokclass it was
+ treated somewhat like an #errclass. However, in a later phase
+ when all #errclass were expanded into the corresponding tokens
+ the #tokclass reference was not expanded (because it wasn't an
+ #errclass). In effect the reference was ignored.
+
+ This has been fixed.
+
+ Problem reported by Mike Dimmick (mike dimmick.demon.co.uk).
+
+#283. (Changed in MR23) Option -tmake invoke's parser's tmake
+
+ When the string #(...) appears in an action antlr replaces it with
+ a call to ASTBase::tmake(...) to construct an AST. It is sometimes
+ useful to change the tmake routine so that it has access to information
+ in the parser - something which is not possible with a static method
+ in an application where they may be multiple parsers active.
+
+ The antlr option -tmake replaces the call to ASTBase::tmake with a call
+ to a user supplied tmake routine.
+
+#282. (Changed in MR23) Initialization error for DBG_REFCOUNTTOKEN
+
+ When the pre-processor symbol DBG_REFCOUNTTOKEN is defined
+ incorrect code is generated to initialize ANTLRRefCountToken::ctor and
+ dtor.
+
+ Fix reported by Sven Kuehn (sven sevenkuehn.de).
+
+#281. (Changed in MR23) Addition of -noctor option for Sorcerer
+
+ Added a -noctor option to suppress generation of the blank ctor
+ for users who wish to define their own ctor.
+
+ Contributed by Jan Langer (jan langernetz.de).
+
+#280. (Changed in MR23) Syntax error message for EOF token
+
+ The EOF token now receives special treatment in syntax error messages
+ because there is no text matched by the eof token. The token name
+ of the eof token is used unless it is "@" - in which case the string
+ "<eof>" is used.
+
+ Problem reported by Erwin Achermann (erwin.achermann switzerland.org).
+
+#279. (Changed in MR23) Exception groups
+
+ There was a bug in the way that exception groups were attached to
+ alternatives which caused problems when there was a block contained
+ in an alternative. For instance, in the following rule;
+
+ statement : IF S { ELSE S }
+ exception ....
+ ;
+
+ the exception would be attached to the {...} block instead of the
+ entire alternative because it was attached, in error, to the last
+ alternative instead of the last OPEN alternative.
+
+ Reported by Ty Mordane (tymordane hotmail.com).
+
+#278. (Changed in MR23) makefile changes
+
+ Contributed by Tomasz Babczynski (faster lab05-7.ict.pwr.wroc.pl).
+
+ The -cfile option is not absolutely needed: when extension of
+ source file is one of the well-known C/C++ extensions it is
+ treated as C/C++ source
+
+ The gnu make defines the CXX variable as the default C++ compiler
+ name, so I added a line to copy this (if defined) to the CCC var.
+
+ Added a -sor option: after it any -class command defines the class
+ name for sorcerer, not for ANTLR. A file extended with .sor is
+ treated as sorcerer input. Because sorcerer can be called multiple
+ times, -sor option can be repeated. Any files and classes (one class
+ per group) after each -sor makes one tree parser.
+
+ Not implemented:
+
+ 1. Generate dependences for user c/c++ files.
+ 2. Support for -sor in c mode not.
+
+ I have left the old genmk program in the directory as genmk_old.c.
+
+#277. (Changed in MR23) Change in macro for failed semantic predicates
+
+ In the past, a semantic predicate that failed generated a call to
+ the macro zzfailed_pred:
+
+ #ifndef zzfailed_pred
+ #define zzfailed_pred(_p) \
+ if (guessing) { \
+ zzGUESS_FAIL; \
+ } else { \
+ something(_p)
+ }
+ #endif
+
+ If a user wished to use the failed action option for semantic predicates:
+
+ rule : <<my_predicate>>? [my_fail_action] A
+ | ...
+
+
+ the code for my_fail_action would have to contain logic for handling
+ the guess part of the zzfailed_pred macro. The user should not have
+ to be aware of the guess logic in writing the fail action.
+
+ The zzfailed_pred has been rewritten to have three arguments:
+
+ arg 1: the stringized predicate of the semantic predicate
+ arg 2: 0 => there is no user-defined fail action
+ 1 => there is a user-defined fail action
+ arg 3: the user-defined fail action (if defined)
+ otherwise a no-operation
+
+ The zzfailed_pred macro is now defined as:
+
+ #ifndef zzfailed_pred
+ #define zzfailed_pred(_p,_hasuseraction,_useraction) \
+ if (guessing) { \
+ zzGUESS_FAIL; \
+ } else { \
+ zzfailed_pred_action(_p,_hasuseraction,_useraction) \
+ }
+ #endif
+
+
+ With zzfailed_pred_action defined as:
+
+ #ifndef zzfailed_pred_action
+ #define zzfailed_pred_action(_p,_hasuseraction,_useraction) \
+ if (_hasUserAction) { _useraction } else { failedSemanticPredicate(_p); }
+ #endif
+
+ In C++ mode failedSemanticPredicate() is a virtual function.
+ In C mode the default action is a fprintf statement.
+
+ Suggested by Erwin Achermann (erwin.achermann switzerland.org).
+
+#276. (Changed in MR23) Addition of return value initialization syntax
+
+ In an attempt to reduce the problems caused by the PURIFY macro I have
+ added new syntax for initializing the return value of rules and the
+ antlr option "-nopurify".
+
+ A rule with a single return argument:
+
+ r1 > [Foo f = expr] :
+
+ now generates code that resembles:
+
+ Foo r1(void) {
+ Foo _retv = expr;
+ ...
+ }
+
+ A rule with more than one return argument:
+
+ r2 > [Foo f = expr1, Bar b = expr2 ] :
+
+ generates code that resembles:
+
+ struct _rv1 {
+ Foo f;
+ Bar b;
+ }
+
+ _rv1 r2(void) {
+ struct _rv1 _retv;
+ _retv.f = expr1;
+ _retv.b = expr2;
+ ...
+ }
+
+ C++ style comments appearing in the initialization list may cause problems.
+
+#275. (Changed in MR23) Addition of -nopurify option to antlr
+
+ A long time ago the PURIFY macro was introduced to initialize
+ return value arguments and get rid of annying messages from program
+ that checked for unitialized variables.
+
+ This has caused significant annoyance for C++ users that had
+ classes with virtual functions or non-trivial contructors because
+ it would zero the object, including the pointer to the virtual
+ function table. This could be defeated by redefining
+ the PURIFY macro to be empty, but it was a constant surprise to
+ new C++ users of pccts.
+
+ I would like to remove it, but I fear that some existing programs
+ depend on it and would break. My temporary solution is to add
+ an antlr option -nopurify which disables generation of the PURIFY
+ macro call.
+
+ The PURIFY macro should be avoided in favor of the new syntax
+ for initializing return arguments described in item #275.
+
+ To avoid name clash, the PURIFY macro has been renamed PCCTS_PURIFY.
+
+#274. (Changed in MR23) DLexer.cpp renamed to DLexer.h
+ (Changed in MR23) ATokPtr.cpp renamed to ATokPtrImpl.h
+
+ These two files had .cpp extensions but acted like .h files because
+ there were included in other files. This caused problems for many IDE.
+ I have renamed them. The ATokPtrImpl.h was necessary because there was
+ already an ATokPtr.h.
+
+#273. (Changed in MR23) Default win32 library changed to multi-threaded DLL
+
+ The model used for building the Win32 debug and release libraries has changed
+ to multi-threaded DLL.
+
+ To make this change in your MSVC 6 project:
+
+ Project -> Settings
+ Select the C++ tab in the right pane of the dialog box
+ Select "Category: Code Generation"
+ Under "Use run-time library" select one of the following:
+
+ Multi-threaded DLL
+ Debug Multi-threaded DLL
+
+ Suggested by Bill Menees (bill.menees gogallagher.com)
+
+#272. (Changed in MR23) Failed semantic predicate reported via virtual function
+
+ In the past, a failed semantic predicated reported the problem via a
+ macro which used fprintf(). The macro now expands into a call on
+ the virtual function ANTLRParser::failedSemanticPredicate().
+
+#271. (Changed in MR23) Warning for LT(i), LATEXT(i) in token match actions
+
+ An bug (or at least an oddity) is that a reference to LT(1), LA(1),
+ or LATEXT(1) in an action which immediately follows a token match
+ in a rule refers to the token matched, not the token which is in
+ the lookahead buffer. Consider:
+
+ r : abc <<action alpha>> D <<action beta>> E;
+
+ In this case LT(1) in action alpha will refer to the next token in
+ the lookahead buffer ("D"), but LT(1) in action beta will refer to
+ the token matched by D - the preceding token.
+
+ A warning has been added for users about this when an action
+ following a token match contains a reference to LT(1), LA(1), or LATEXT(1).
+
+ This behavior should be changed, but it appears in too many programs
+ now. Another problem, perhaps more significant, is that the obvious
+ fix (moving the consume() call to before the action) could change the
+ order in which input is requested and output appears in existing programs.
+
+ This problem was reported, along with a fix by Benjamin Mandel
+ (beny sd.co.il). However, I felt that changing the behavior was too
+ dangerous for existing code.
+
+#270. (Changed in MR23) Removed static objects from PCCTSAST.cpp
+
+ There were some statically allocated objects in PCCTSAST.cpp
+ These were changed to non-static.
+
+#269. (Changed in MR23) dlg output for initializing static array
+
+ The output from dlg contains a construct similar to the
+ following:
+
+ struct XXX {
+ static const int size;
+ static int array1[5];
+ };
+
+ const int XXX::size = 4;
+ int XXX::array1[size+1];
+
+
+ The problem is that although the expression "size+1" used in
+ the definition of array1 is equal to 5 (the expression used to
+ declare array), it is not considered equivalent by some compilers.
+
+ Reported with fix by Volker H. Simonis (simonis informatik.uni-tuebingen.de)
+
+#268. (Changed in MR23) syn() routine output when k > 1
+
+ The syn() routine is supposed to print out the text of the
+ token causing the syntax error. It appears that it always
+ used the text from the first lookahead token rather than the
+ appropriate one. The appropriate one is computed by comparing
+ the token codes of lookahead token i (for i = 1 to k) with
+ the FIRST(i) set.
+
+ This has been corrected in ANTLRParser::syn().
+
+ Reported by Bill Menees (bill.menees gogallagher.com)
+
+#267. (Changed in MR23) AST traversal functions client data argument
+
+ The AST traversal functions now take an extra (optional) parameter
+ which can point to client data:
+
+ preorder_action(void* pData = NULL)
+ preorder_before_action(void* pData = NULL)
+ preorder_after_action(void* pData = NULL)
+
+ **** Warning: this changes the AST signature. ***
+ **** Be sure to revise your AST functions of the same name ***
+
+ Bill Menees (bill.menees gogallagher.com)
+
+#266. (Changed in MR23) virtual function printMessage()
+
+ Bill Menees (bill.menees gogallagher.com) has completed the
+ tedious taks of replacing all calls to fprintf() with calls
+ to the virtual function printMessage(). For classes which
+ have a pointer to the parser it forwards the printMessage()
+ call to the parser's printMessage() routine.
+
+ This should make it significanly easier to redirect pccts
+ error and warning messages.
+
+#265. (Changed in MR23) Remove "labase++" in C++ mode
+
+ In C++ mode labase++ is called when a token is matched.
+ It appears that labase is not used in C++ mode at all, so
+ this code has been commented out.
+
+#264. (Changed in MR23) Complete rewrite of ParserBlackBox.h
+
+ The parser black box (PBlackBox.h) was completely rewritten
+ by Chris Uzdavinis (chris atdesk.com) to improve its robustness.
+
+#263. (Changed in MR23) -preamble and -preamble_first rescinded
+
+ Changes for item #253 have been rescinded.
+
+#262. (Changed in MR23) Crash with -alpha option during traceback
+
+ Under some circumstances a -alpha traceback was started at the
+ "wrong" time. As a result, internal data structures were not
+ initialized.
+
+ Reported by Arpad Beszedes (beszedes inf.u-szeged.hu).
+
+#261. (Changed in MR23) Defer token fetch for C++ mode
+
+ Item #216 has been revised to indicate that use of the defer fetch
+ option (ZZDEFER_FETCH) requires dlg option -i.
+
+#260. (MR22) Raise default lex buffer size from 8,000 to 32,000 bytes.
+
+ ZZLEXBUFSIZE is the size (in bytes) of the buffer used by dlg
+ generated lexers. The default value has been raised to 32,000 and
+ the value used by antlr, dlg, and sorcerer has also been raised to
+ 32,000.
+
+#259. (MR22) Default function arguments in C++ mode.
+
+ If a rule is declared:
+
+ rr [int i = 0] : ....
+
+ then the declaration generated by pccts resembles:
+
+ void rr(int i = 0);
+
+ however, the definition must omit the default argument:
+
+ void rr(int i) {...}
+
+ In the past the default value was not omitted. In MR22
+ the generated code resembles:
+
+ void rr(int i /* = 0 */ ) {...}
+
+ Implemented by Volker H. Simonis (simonis informatik.uni-tuebingen.de)
+
+
+ Note: In MR23 this was changed so that nested C style comments
+ ("/* ... */") would not cause problems.
+
+#258. (MR22) Using a base class for your parser
+
+ In item #102 (MR10) the class statement was extended to allow one
+ to specify a base class other than ANTLRParser for the generated
+ parser. It turned out that this was less than useful because
+ the constructor still specified ANTLRParser as the base class.
+
+ The class statement now uses the first identifier appearing after
+ the ":" as the name of the base class. For example:
+
+ class MyParser : public FooParser {
+
+ Generates in MyParser.h:
+
+ class MyParser : public FooParser {
+
+ Generates in MyParser.cpp something that resembles:
+
+ MyParser::MyParser(ANTLRTokenBuffer *input) :
+ FooParser(input,1,0,0,4)
+ {
+ token_tbl = _token_tbl;
+ traceOptionValueDefault=1; // MR10 turn trace ON
+ }
+
+ The base class constructor must have a signature similar to
+ that of ANTLRParser.
+
+#257. (MR21a) Removed dlg statement that -i has no effect in C++ mode.
+
+ This was incorrect.
+
+#256. (MR21a) Malformed syntax graph causes crash after error message.
+
+ In the past, certain kinds of errors in the very first grammar
+ element could cause the construction of a malformed graph
+ representing the grammar. This would eventually result in a
+ fatal internal error. The code has been changed to be more
+ resistant to this particular error.
+
+#255. (MR21a) ParserBlackBox(FILE* f)
+
+ This constructor set openByBlackBox to the wrong value.
+
+ Reported by Kees Bakker (kees_bakker tasking.nl).
+
+#254. (MR21a) Reporting syntax error at end-of-file
+
+ When there was a syntax error at the end-of-file the syntax
+ error routine would substitute "<eof>" for the programmer's
+ end-of-file symbol. This substitution is now done only when
+ the programmer does not define his own end-of-file symbol
+ or the symbol begins with the character "@".
+
+ Reported by Kees Bakker (kees_bakker tasking.nl).
+
+#253. (MR21) Generation of block preamble (-preamble and -preamble_first)
+
+ *** This change was rescinded by item #263 ***
+
+ The antlr option -preamble causes antlr to insert the code
+ BLOCK_PREAMBLE at the start of each rule and block. It does
+ not insert code before rules references, token references, or
+ actions. By properly defining the macro BLOCK_PREAMBLE the
+ user can generate code which is specific to the start of blocks.
+
+ The antlr option -preamble_first is similar, but inserts the
+ code BLOCK_PREAMBLE_FIRST(PreambleFirst_123) where the symbol
+ PreambleFirst_123 is equivalent to the first set defined by
+ the #FirstSetSymbol described in Item #248.
+
+ I have not investigated how these options interact with guess
+ mode (syntactic predicates).
+
+#252. (MR21) Check for null pointer in trace routine
+
+ When some trace options are used when the parser is generated
+ without the trace enabled, the current rule name may be a
+ NULL pointer. A guard was added to check for this in
+ restoreState.
+
+ Reported by Douglas E. Forester (dougf projtech.com).
+
+#251. (MR21) Changes to #define zzTRACE_RULES
+
+ The macro zzTRACE_RULES was being use to pass information to
+ AParser.h. If this preprocessor symbol was not properly
+ set the first time AParser.h was #included, the declaration
+ of zzTRACEdata would be omitted (it is used by the -gd option).
+ Subsequent #includes of AParser.h would be skipped because of
+ the #ifdef guard, so the declaration of zzTracePrevRuleName would
+ never be made. The result was that proper compilation was very
+ order dependent.
+
+ The declaration of zzTRACEdata was made unconditional and the
+ problem of removing unused declarations will be left to optimizers.
+
+ Diagnosed by Douglas E. Forester (dougf projtech.com).
+
+#250. (MR21) Option for EXPERIMENTAL change to error sets for blocks
+
+ The antlr option -mrblkerr turns on an experimental feature
+ which is supposed to provide more accurate syntax error messages
+ for k=1, ck=1 grammars. When used with k>1 or ck>1 grammars the
+ behavior should be no worse than the current behavior.
+
+ There is no problem with the matching of elements or the computation
+ of prediction expressions in pccts. The task is only one of listing
+ the most appropriate tokens in the error message. The error sets used
+ in pccts error messages are approximations of the exact error set when
+ optional elements in (...)* or (...)+ are involved. While entirely
+ correct, the error messages are sometimes not 100% accurate.
+
+ There is also a minor philosophical issue. For example, suppose the
+ grammar expects the token to be an optional A followed by Z, and it
+ is X. X, of course, is neither A nor Z, so an error message is appropriate.
+ Is it appropriate to say "Expected Z" ? It is correct, it is accurate,
+ but it is not complete.
+
+ When k>1 or ck>1 the problem of providing the exactly correct
+ list of tokens for the syntax error messages ends up becoming
+ equivalent to evaluating the prediction expression for the
+ alternatives twice. However, for k=1 ck=1 grammars the prediction
+ expression can be computed easily and evaluated cheaply, so I
+ decided to try implementing it to satisfy a particular application.
+ This application uses the error set in an interactive command language
+ to provide prompts which list the alternatives available at that
+ point in the parser. The user can then enter additional tokens to
+ complete the command line. To do this required more accurate error
+ sets then previously provided by pccts.
+
+ In some cases the default pccts behavior may lead to more robust error
+ recovery or clearer error messages then having the exact set of tokens.
+ This is because (a) features like -ge allow the use of symbolic names for
+ certain sets of tokens, so having extra tokens may simply obscure things
+ and (b) the error set is use to resynchronize the parser, so a good
+ choice is sometimes more important than having the exact set.
+
+ Consider the following example:
+
+ Note: All examples code has been abbreviated
+ to the absolute minimum in order to make the
+ examples concise.
+
+ star1 : (A)* Z;
+
+ The generated code resembles:
+
+ old new (with -mrblkerr)
+ --//----------- --------------------
+ for (;;) { for (;;) {
+ match(A); match(A);
+ } }
+ match(Z); if (! A and ! Z) then
+ FAIL(...{A,Z}...);
+ }
+ match(Z);
+
+
+ With input X
+ old message: Found X, expected Z
+ new message: Found X, expected A, Z
+
+ For the example:
+
+ star2 : (A|B)* Z;
+
+ old new (with -mrblkerr)
+ ------------- --------------------
+ for (;;) { for (;;) {
+ if (!A and !B) break; if (!A and !B) break;
+ if (...) { if (...) {
+ <same ...> <same ...>
+ } }
+ else { else {
+ FAIL(...{A,B,Z}...) FAIL(...{A,B}...);
+ } }
+ } }
+ match(B); if (! A and ! B and !Z) then
+ FAIL(...{A,B,Z}...);
+ }
+ match(B);
+
+ With input X
+ old message: Found X, expected Z
+ new message: Found X, expected A, B, Z
+ With input A X
+ old message: Found X, expected Z
+ new message: Found X, expected A, B, Z
+
+ This includes the choice of looping back to the
+ star block.
+
+ The code for plus blocks:
+
+ plus1 : (A)+ Z;
+
+ The generated code resembles:
+
+ old new (with -mrblkerr)
+ ------------- --------------------
+ do { do {
+ match(A); match(A);
+ } while (A) } while (A)
+ match(Z); if (! A and ! Z) then
+ FAIL(...{A,Z}...);
+ }
+ match(Z);
+
+ With input A X
+ old message: Found X, expected Z
+ new message: Found X, expected A, Z
+
+ This includes the choice of looping back to the
+ plus block.
+
+ For the example:
+
+ plus2 : (A|B)+ Z;
+
+ old new (with -mrblkerr)
+ ------------- --------------------
+ do { do {
+ if (A) { <same>
+ match(A); <same>
+ } else if (B) { <same>
+ match(B); <same>
+ } else { <same>
+ if (cnt > 1) break; <same>
+ FAIL(...{A,B,Z}...) FAIL(...{A,B}...);
+ } }
+ cnt++; <same>
+ } }
+
+ match(Z); if (! A and ! B and !Z) then
+ FAIL(...{A,B,Z}...);
+ }
+ match(B);
+
+ With input X
+ old message: Found X, expected A, B, Z
+ new message: Found X, expected A, B
+ With input A X
+ old message: Found X, expected Z
+ new message: Found X, expected A, B, Z
+
+ This includes the choice of looping back to the
+ star block.
+
+#249. (MR21) Changes for DEC/VMS systems
+
+ Jean-François Piéronne (jfp altavista.net) has updated some
+ VMS related command files and fixed some minor problems related
+ to building pccts under the DEC/VMS operating system. For DEC/VMS
+ users the most important differences are:
+
+ a. Revised makefile.vms
+ b. Revised genMMS for genrating VMS style makefiles.
+
+#248. (MR21) Generate symbol for first set of an alternative
+
+ pccts can generate a symbol which represents the tokens which may
+ appear at the start of a block:
+
+ rr : #FirstSetSymbol(rr_FirstSet) ( Foo | Bar ) ;
+
+ This will generate the symbol rr_FirstSet of type SetWordType with
+ elements Foo and Bar set. The bits can be tested using code similar
+ to the following:
+
+ if (set_el(Foo, &rr_FirstSet)) { ...
+
+ This can be combined with the C array zztokens[] or the C++ routine
+ tokenName() to get the print name of the token in the first set.
+
+ The size of the set is given by the newly added enum SET_SIZE, a
+ protected member of the generated parser's class. The number of
+ elements in the generated set will not be exactly equal to the
+ value of SET_SIZE because of synthetic tokens created by #tokclass,
+ #errclass, the -ge option, and meta-tokens such as epsilon, and
+ end-of-file.
+
+ The #FirstSetSymbol must appear immediately before a block
+ such as (...)+, (...)*, and {...}, and (...). It may not appear
+ immediately before a token, a rule reference, or action. However
+ a token or rule reference can be enclosed in a (...) in order to
+ make the use of #pragma FirstSetSymbol legal.
+
+ rr_bad : #FirstSetSymbol(rr_bad_FirstSet) Foo; // Illegal
+
+ rr_ok : #FirstSetSymbol(rr_ok_FirstSet) (Foo); // Legal
+
+ Do not confuse FirstSetSymbol sets with the sets used for testing
+ lookahead. The sets used for FirstSetSymbol have one element per bit,
+ so the number of bytes is approximately the largest token number
+ divided by 8. The sets used for testing lookahead store 8 lookahead
+ sets per byte, so the length of the array is approximately the largest
+ token number.
+
+ If there is demand, a similar routine for follow sets can be added.
+
+#247. (MR21) Misleading error message on syntax error for optional elements.
+
+ ===================================================
+ The behavior has been revised when parser exception
+ handling is used. See Item #290
+ ===================================================
+
+ Prior to MR21, tokens which were optional did not appear in syntax
+ error messages if the block which immediately followed detected a
+ syntax error.
+
+ Consider the following grammar which accepts Number, Word, and Other:
+
+ rr : {Number} Word;
+
+ For this rule the code resembles:
+
+ if (LA(1) == Number) {
+ match(Number);
+ consume();
+ }
+ match(Word);
+
+ Prior to MR21, the error message for input "$ a" would be:
+
+ line 1: syntax error at "$" missing Word
+
+ With MR21 the message will be:
+
+ line 1: syntax error at "$" expecting Word, Number.
+
+ The generate code resembles:
+
+ if ( (LA(1)==Number) ) {
+ zzmatch(Number);
+ consume();
+ }
+ else {
+ if ( (LA(1)==Word) ) {
+ /* nothing */
+ }
+ else {
+ FAIL(... message for both Number and Word ...);
+ }
+ }
+ match(Word);
+
+ The code generated for optional blocks in MR21 is slightly longer
+ than the previous versions, but it should give better error messages.
+
+ The code generated for:
+
+ { a | b | c }
+
+ should now be *identical* to:
+
+ ( a | b | c | )
+
+ which was not the case prior to MR21.
+
+ Reported by Sue Marvin (sue siara.com).
+
+#246. (Changed in MR21) Use of $(MAKE) for calls to make
+
+ Calls to make from the makefiles were replaced with $(MAKE)
+ because of problems when using gmake.
+
+ Reported with fix by Sunil K.Vallamkonda (sunil siara.com).
+
+#245. (Changed in MR21) Changes to genmk
+
+ The following command line options have been added to genmk:
+
+ -cfiles ...
+
+ To add a user's C or C++ files into makefile automatically.
+ The list of files must be enclosed in apostrophes. This
+ option may be specified multiple times.
+
+ -compiler ...
+
+ The name of the compiler to use for $(CCC) or $(CC). The
+ default in C++ mode is "CC". The default in C mode is "cc".
+
+ -pccts_path ...
+
+ The value for $(PCCTS), the pccts directory. The default
+ is /usr/local/pccts.
+
+ Contributed by Tomasz Babczynski (t.babczynski ict.pwr.wroc.pl).
+
+#244. (Changed in MR21) Rename variable "not" in antlr.g
+
+ When antlr.g is compiled with a C++ compiler, a variable named
+ "not" causes problems. Reported by Sinan Karasu
+ (sinan.karasu boeing.com).
+
+#243 (Changed in MR21) Replace recursion with iteration in zzfree_ast
+
+ Another refinement to zzfree_ast in ast.c to limit recursion.
+
+ NAKAJIMA Mutsuki (muc isr.co.jp).
+
+
+#242. (Changed in MR21) LineInfoFormatStr
+
+ Added an #ifndef/#endif around LineInfoFormatStr in pcctscfg.h.
+
+#241. (Changed in MR21) Changed macro PURIFY to a no-op
+
+ ***********************
+ *** NOT IMPLEMENTED ***
+ ***********************
+
+ The PURIFY macro was changed to a no-op because it was causing
+ problems when passing C++ objects.
+
+ The old definition:
+
+ #define PURIFY(r,s) memset((char *) &(r),'\\0',(s));
+
+ The new definition:
+
+ #define PURIFY(r,s) /* nothing */
+#endif
+
+#240. (Changed in MR21) sorcerer/h/sorcerer.h _MATCH and _MATCHRANGE
+
+ Added test for NULL token pointer.
+
+ Suggested by Peter Keller (keller ebi.ac.uk)
+
+#239. (Changed in MR21) C++ mode AParser::traceGuessFail
+
+ If tracing is turned on when the code has been generated
+ without trace code, a failed guess generates a trace report
+ even though there are no other trace reports. This
+ make the behavior consistent with other parts of the
+ trace system.
+
+ Reported by David Wigg (wiggjd sbu.ac.uk).
+
+#238. (Changed in MR21) Namespace version #include files
+
+ Changed reference from CStdio to cstdio (and other
+ #include file names) in the namespace version of pccts.
+ Should have known better.
+
+#237. (Changed in MR21) ParserBlackBox(FILE*)
+
+ In the past, ParserBlackBox would close the FILE in the dtor
+ even though it was not opened by ParserBlackBox. The problem
+ is that there were two constructors, one which accepted a file
+ name and did an fopen, the other which accepted a FILE and did
+ not do an fopen. There is now an extra member variable which
+ remembers whether ParserBlackBox did the open or not.
+
+ Suggested by Mike Percy (mpercy scires.com).
+
+#236. (Changed in MR21) tmake now reports down pointer problem
+
+ When ASTBase::tmake attempts to update the down pointer of
+ an AST it checks to see if the down pointer is NULL. If it
+ is not NULL it does not do the update and returns NULL.
+ An attempt to update the down pointer is almost always a
+ result of a user error. This can lead to difficult to find
+ problems during tree construction.
+
+ With this change, the routine calls a virtual function
+ reportOverwriteOfDownPointer() which calls panic to
+ report the problem. Users who want the old behavior can
+ redefined the virtual function in their AST class.
+
+ Suggested by Sinan Karasu (sinan.karasu boeing.com)
+
+#235. (Changed in MR21) Made ANTLRParser::resynch() virtual
+
+ Suggested by Jerry Evans (jerry swsl.co.uk).
+
+#234. (Changed in MR21) Implicit int for function return value
+
+ ATokenBuffer:bufferSize() did not specify a type for the
+ return value.
+
+ Reported by Hai Vo-Ba (hai fc.hp.com).
+
+#233. (Changed in MR20) Converted to MSVC 6.0
+
+ Due to external circumstances I have had to convert to MSVC 6.0
+ The MSVC 5.0 project files (.dsw and .dsp) have been retained as
+ xxx50.dsp and xxx50.dsw. The MSVC 6.0 files are named xxx60.dsp
+ and xxx60.dsw (where xxx is the related to the directory/project).
+
+#232. (Changed in MR20) Make setwd bit vectors protected in parser.h
+
+ The access for the setwd array in the parser header was not
+ specified. As a result, it would depend on the code which
+ preceded it. In MR20 it will always have access "protected".
+
+ Reported by Piotr Eljasiak (eljasiak zt.gdansk.tpsa.pl).
+
+#231. (Changed in MR20) Error in token buffer debug code.
+
+ When token buffer debugging is selected via the pre-processor
+ symbol DEBUG_TOKENBUFFER there is an erroneous check in
+ AParser.cpp:
+
+ #ifdef DEBUG_TOKENBUFFER
+ if (i >= inputTokens->bufferSize() ||
+ inputTokens->minTokens() < LLk ) /* MR20 Was "<=" */
+ ...
+ #endif
+
+ Reported by David Wigg (wiggjd sbu.ac.uk).
+
+#230. (Changed in MR20) Fixed problem with #define for -gd option
+
+ There was an error in setting zzTRACE_RULES for the -gd (trace) option.
+
+ Reported by Gary Funck (gary intrepid.com).
+
+#229. (Changed in MR20) Additional "const" for literals
+
+ "const" was added to the token name literal table.
+ "const" was added to some panic() and similar routine
+
+#228. (Changed in MR20) dlg crashes on "()"
+
+ The following token defintion will cause DLG to crash.
+
+ #token "()"
+
+ When there is a syntax error in a regular expression
+ many of the dlg routines return a structure which has
+ null pointers. When this is accessed by callers it
+ generates the crash.
+
+ I have attempted to fix the more common cases.
+
+ Reported by Mengue Olivier (dolmen bigfoot.com).
+
+#227. (Changed in MR20) Array overwrite
+
+ Steveh Hand (sassth unx.sas.com) reported a problem which
+ was traced to a temporary array which was not properly
+ resized for deeply nested blocks. This has been fixed.
+
+#226. (Changed in MR20) -pedantic conformance
+
+ G. Hobbelt (i_a mbh.org) and THM made many, many minor
+ changes to create prototypes for all the functions and
+ bring antlr, dlg, and sorcerer into conformance with
+ the gcc -pedantic option.
+
+ This may require uses to add pccts/h/pcctscfg.h to some
+ files or makefiles in order to have __USE_PROTOS defined.
+
+#225 (Changed in MR20) AST stack adjustment in C mode
+
+ The fix in #214 for AST stack adjustment in C mode missed
+ some cases.
+
+ Reported with fix by Ger Hobbelt (i_a mbh.org).
+
+#224 (Changed in MR20) LL(1) and LL(2) with #pragma approx
+
+ This may take a record for the oldest, most trival, lexical
+ error in pccts. The regular expressions for LL(1) and LL(2)
+ lacked an escape for the left and right parenthesis.
+
+ Reported by Ger Hobbelt (i_a mbh.org).
+
+#223 (Changed in MR20) Addition of IBM_VISUAL_AGE directory
+
+ Build files for antlr, dlg, and sorcerer under IBM Visual Age
+ have been contributed by Anton Sergeev (ags mlc.ru). They have
+ been placed in the pccts/IBM_VISUAL_AGE directory.
+
+#222 (Changed in MR20) Replace __STDC__ with __USE_PROTOS
+
+ Most occurrences of __STDC__ replaced with __USE_PROTOS due to
+ complaints from several users.
+
+#221 (Changed in MR20) Added #include for DLexerBase.h to PBlackBox.
+
+ Added #include for DLexerBase.h to PBlackBox.
+
+#220 (Changed in MR19) strcat arguments reversed in #pred parse
+
+ The arguments to strcat are reversed when creating a print
+ name for a hash table entry for use with #pred feature.
+
+ Problem diagnosed and fix reported by Scott Harrington
+ (seh4 ix.netcom.com).
+
+#219. (Changed in MR19) C Mode routine zzfree_ast
+
+ Changes to reduce use of recursion for AST trees with only right
+ links or only left links in the C mode routine zzfree_ast.
+
+ Implemented by SAKAI Kiyotaka (ksakai isr.co.jp).
+
+#218. (Changed in MR19) Changes to support unsigned char in C mode
+
+ Changes to antlr.h and err.h to fix omissions in use of zzchar_t
+
+ Implemented by SAKAI Kiyotaka (ksakai isr.co.jp).
+
+#217. (Changed in MR19) Error message when dlg -i and -CC options selected
+
+ *** This change was rescinded by item #257 ***
+
+ The parsers generated by pccts in C++ mode are not able to support the
+ interactive lexer option (except, perhaps, when using the deferred fetch
+ parser option.(Item #216).
+
+ DLG now warns when both -i and -CC are selected.
+
+ This warning was suggested by David Venditti (07751870267-0001 t-online.de).
+
+#216. (Changed in MR19) Defer token fetch for C++ mode
+
+ Implemented by Volker H. Simonis (simonis informatik.uni-tuebingen.de)
+
+ Normally, pccts keeps the lookahead token buffer completely filled.
+ This requires max(k,ck) tokens of lookahead. For some applications
+ this can cause deadlock problems. For example, there may be cases
+ when the parser can't tell when the input has been completely consumed
+ until the parse is complete, but the parse can't be completed because
+ the input routines are waiting for additional tokens to fill the
+ lookahead buffer.
+
+ When the ANTLRParser class is built with the pre-processor option
+ ZZDEFER_FETCH defined, the fetch of new tokens by consume() is deferred
+ until LA(i) or LT(i) is called.
+
+ To test whether this option has been built into the ANTLRParser class
+ use "isDeferFetchEnabled()".
+
+ Using the -gd trace option with the default tracein() and traceout()
+ routines will defeat the effort to defer the fetch because the
+ trace routines print out information about the lookahead token at
+ the start of the rule.
+
+ Because the tracein and traceout routines are virtual it is
+ easy to redefine them in your parser:
+
+ class MyParser {
+ <<
+ virtual void tracein(ANTLRChar * ruleName)
+ { fprintf(stderr,"Entering: %s\n", ruleName); }
+ virtual void traceout(ANTLRChar * ruleName)
+ { fprintf(stderr,"Leaving: %s\n", ruleName); }
+ >>
+
+ The originals for those routines are pccts/h/AParser.cpp
+
+ This requires use of the dlg option -i (interactive lexer).
+
+ This is implemented only for C++ mode.
+
+ This is experimental. The interaction with guess mode (syntactic
+ predicates)is not known.
+
+#215. (Changed in MR19) Addition of reset() to DLGLexerBase
+
+ There was no obvious way to reset the lexer for reuse. The
+ reset() method now does this.
+
+ Suggested by David Venditti (07751870267-0001 t-online.de).
+
+#214. (Changed in MR19) C mode: Adjust AST stack pointer at exit
+
+ In C mode the AST stack pointer needs to be reset if there will
+ be multiple calls to the ANTLRx macros.
+
+ Reported with fix by Paul D. Smith (psmith baynetworks.com).
+
+#213. (Changed in MR18) Fatal error with -mrhoistk (k>1 hoisting)
+
+ When rearranging code I forgot to un-comment a critical line of
+ code that handles hoisting of predicates with k>1 lookahead. This
+ is now fixed.
+
+ Reported by Reinier van den Born (reinier vnet.ibm.com).
+
+#212. (Changed in MR17) Mac related changes by Kenji Tanaka
+
+ Kenji Tanaka (kentar osa.att.ne.jp) has made a number of changes for
+ Macintosh users.
+
+ a. The following Macintosh MPW files aid in installing pccts on Mac:
+
+ pccts/MPW_Read_Me
+
+ pccts/install68K.mpw
+ pccts/installPPC.mpw
+
+ pccts/antlr/antlr.r
+ pccts/antlr/antlr68K.make
+ pccts/antlr/antlrPPC.make
+
+ pccts/dlg/dlg.r
+ pccts/dlg/dlg68K.make
+ pccts/dlg/dlgPPC.make
+
+ pccts/sorcerer/sor.r
+ pccts/sorcerer/sor68K.make
+ pccts/sorcerer/sorPPC.make
+
+ They completely replace the previous Mac installation files.
+
+ b. The most significant is a change in the MAC_FILE_CREATOR symbol
+ in pcctscfg.h:
+
+ old: #define MAC_FILE_CREATOR 'MMCC' /* Metrowerks C/C++ Text files */
+ new: #define MAC_FILE_CREATOR 'CWIE' /* Metrowerks C/C++ Text files */
+
+ c. Added calls to special_fopen_actions() where necessary.
+
+#211. (Changed in MR16a) C++ style comment in dlg
+
+ This has been fixed.
+
+#210. (Changed in MR16a) Sor accepts \r\n, \r, or \n for end-of-line
+
+ A user requested that Sorcerer be changed to accept other forms
+ of end-of-line.
+
+#209. (Changed in MR16) Name of files changed.
+
+ Old: CHANGES_FROM_1.33
+ New: CHANGES_FROM_133.txt
+
+ Old: KNOWN_PROBLEMS
+ New: KNOWN_PROBLEMS.txt
+
+#208. (Changed in MR16) Change in use of pccts #include files
+
+ There were problems with MS DevStudio when mixing Sorcerer and
+ PCCTS in the same source file. The problem is caused by the
+ redefinition of setjmp in the MS header file setjmp.h. In
+ setjmp.h the pre-processor symbol setjmp was redefined to be
+ _setjmp. A later effort to execute #include <setjmp.h> resulted
+ in an effort to #include <_setjmp.h>. I'm not sure whether this
+ is a bug or a feature. In any case, I decided to fix it by
+ avoiding the use of pre-processor symbols in #include statements
+ altogether. This has the added benefit of making pre-compiled
+ headers work again.
+
+ I've replaced statements:
+
+ old: #include PCCTS_SETJMP_H
+ new: #include "pccts_setjmp.h"
+
+ Where pccts_setjmp.h contains:
+
+ #ifndef __PCCTS_SETJMP_H__
+ #define __PCCTS_SETJMP_H__
+
+ #ifdef PCCTS_USE_NAMESPACE_STD
+ #include <Csetjmp>
+ #else
+ #include <setjmp.h>
+ #endif
+
+ #endif
+
+ A similar change has been made for other standard header files
+ required by pccts and sorcerer: stdlib.h, stdarg.h, stdio.h, etc.
+
+ Reported by Jeff Vincent (JVincent novell.com) and Dale Davis
+ (DalDavis spectrace.com).
+
+#207. (Changed in MR16) dlg reports an invalid range for: [\0x00-\0xff]
+
+ -----------------------------------------------------------------
+ Note from MR23: This fix does not work. I am investigating why.
+ -----------------------------------------------------------------
+
+ dlg will report that this is an invalid range.
+
+ Diagnosed by Piotr Eljasiak (eljasiak no-spam.zt.gdansk.tpsa.pl):
+
+ I think this problem is not specific to unsigned chars
+ because dlg reports no error for the range [\0x00-\0xfe].
+
+ I've found that information on range is kept in field
+ letter (unsigned char) of Attrib struct. Unfortunately
+ the letter value internally is for some reasons increased
+ by 1, so \0xff is represented here as 0.
+
+ That's why dlg complains about the range [\0x00-\0xff] in
+ dlg_p.g:
+
+ if ($$.letter > $2.letter) {
+ error("invalid range ", zzline);
+ }
+
+ The fix is:
+
+ if ($$.letter > $2.letter && 255 != $$2.letter) {
+ error("invalid range ", zzline);
+ }
+
+#206. (Changed in MR16) Free zzFAILtext in ANTLRParser destructor
+
+ The ANTLRParser destructor now frees zzFAILtext.
+
+ Problem and fix reported by Manfred Kogler (km cast.uni-linz.ac.at).
+
+#205. (Changed in MR16) DLGStringReset argument now const
+
+ Changed: void DLGStringReset(DLGChar *s) {...}
+ To: void DLGStringReset(const DLGChar *s) {...}
+
+ Suggested by Dale Davis (daldavis spectrace.com)
+
+#204. (Changed in MR15a) Change __WATCOM__ to __WATCOMC__ in pcctscfg.h
+
+ Reported by Oleg Dashevskii (olegdash my-dejanews.com).
+
+#203. (Changed in MR15) Addition of sorcerer to distribution kit
+
+ I have finally caved in to popular demand. The pccts 1.33mr15
+ kit will include sorcerer. The separate sorcerer kit will be
+ discontinued.
+
+#202. (Changed) in MR15) Organization of MS Dev Studio Projects in Kit
+
+ Previously there was one workspace that contained projects for
+ all three parts of pccts: antlr, dlg, and sorcerer. Now each
+ part (and directory) has its own workspace/project and there
+ is an additional workspace/project to build a library from the
+ .cpp files in the pccts/h directory.
+
+ The library build will create pccts_debug.lib or pccts_release.lib
+ according to the configuration selected.
+
+ If you don't want to build pccts 1.33MR15 you can download a
+ ready-to-run kit for win32 from http://www.polhode.com/win32.zip.
+ The ready-to-run for win32 includes executables, a pre-built static
+ library for the .cpp files in the pccts/h directory, and a sample
+ application
+
+ You will need to define the environment variable PCCTS to point to
+ the root of the pccts directory hierarchy.
+
+#201. (Changed in MR15) Several fixes by K.J. Cummings (cummings peritus.com)
+
+ Generation of SETJMP rather than SETJMP_H in gen.c.
+
+ (Sor B19) Declaration of ref_vars_inits for ref_var_inits in
+ pccts/sorcerer/sorcerer.h.
+
+#200. (Changed in MR15) Remove operator=() in AToken.h
+
+ User reported that WatCom couldn't handle use of
+ explicit operator =(). Replace with equivalent
+ using cast operator.
+
+#199. (Changed in MR15) Don't allow use of empty #tokclass
+
+ Change antlr.g to disallow empty #tokclass sets.
+
+ Reported by Manfred Kogler (km cast.uni-linz.ac.at).
+
+#198. Revised ANSI C grammar due to efforts by Manuel Kessler
+
+ Manuel Kessler (mlkessler cip.physik.uni-wuerzburg.de)
+
+ Allow trailing ... in function parameter lists.
+ Add bit fields.
+ Allow old-style function declarations.
+ Support cv-qualified pointers.
+ Better checking of combinations of type specifiers.
+ Release of memory for local symbols on scope exit.
+ Allow input file name on command line as well as by redirection.
+
+ and other miscellaneous tweaks.
+
+ This is not part of the pccts distribution kit. It must be
+ downloaded separately from:
+
+ http://www.polhode.com/ansi_mr15.zip
+
+#197. (Changed in MR14) Resetting the lookahead buffer of the parser
+
+ Explanation and fix by Sinan Karasu (sinan.karasu boeing.com)
+
+ Consider the code used to prime the lookahead buffer LA(i)
+ of the parser when init() is called:
+
+ void
+ ANTLRParser::
+ prime_lookahead()
+ {
+ int i;
+ for(i=1;i<=LLk; i++) consume();
+ dirty=0;
+ //lap = 0; // MR14 - Sinan Karasu (sinan.karusu boeing.com)
+ //labase = 0; // MR14
+ labase=lap; // MR14
+ }
+
+ When the parser is instantiated, lap=0,labase=0 is set.
+
+ The "for" loop runs LLk times. In consume(), lap = lap +1 (mod LLk) is
+ computed. Therefore, lap(before the loop) == lap (after the loop).
+
+ Now the only problem comes in when one does an init() of the parser
+ after an Eof has been seen. At that time, lap could be non zero.
+ Assume it was lap==1. Now we do a prime_lookahead(). If LLk is 2,
+ then
+
+ consume()
+ {
+ NLA = inputTokens->getToken()->getType();
+ dirty--;
+ lap = (lap+1)&(LLk-1);
+ }
+
+ or expanding NLA,
+
+ token_type[lap&(LLk-1)]) = inputTokens->getToken()->getType();
+ dirty--;
+ lap = (lap+1)&(LLk-1);
+
+ so now we prime locations 1 and 2. In prime_lookahead it used to set
+ lap=0 and labase=0. Now, the next token will be read from location 0,
+ NOT 1 as it should have been.
+
+ This was never caught before, because if a parser is just instantiated,
+ then lap and labase are 0, the offending assignment lines are
+ basically no-ops, since the for loop wraps around back to 0.
+
+#196. (Changed in MR14) Problems with "(alpha)? beta" guess
+
+ Consider the following syntactic predicate in a grammar
+ with 2 tokens of lookahead (k=2 or ck=2):
+
+ rule : ( alpha )? beta ;
+ alpha : S t ;
+ t : T U
+ | T
+ ;
+ beta : S t Z ;
+
+ When antlr computes the prediction expression with one token
+ of lookahead for alts 1 and 2 of rule t it finds an ambiguity.
+
+ Because the grammar has a lookahead of 2 it tries to compute
+ two tokens of lookahead for alts 1 and 2 of t. Alt 1 clearly
+ has a lookahead of (T U). Alt 2 is one token long so antlr
+ tries to compute the follow set of alt 2, which means finding
+ the things which can follow rule t in the context of (alpha)?.
+ This cannot be computed, because alpha is only part of a rule,
+ and antlr can't tell what part of beta is matched by alpha and
+ what part remains to be matched. Thus it impossible for antlr
+ to properly determine the follow set of rule t.
+
+ Prior to 1.33MR14, the follow of (alpha)? was computed as
+ FIRST(beta) as a result of the internal representation of
+ guess blocks.
+
+ With MR14 the follow set will be the empty set for that context.
+
+ Normally, one expects a rule appearing in a guess block to also
+ appear elsewhere. When the follow context for this other use
+ is "ored" with the empty set, the context from the other use
+ results, and a reasonable follow context results. However if
+ there is *no* other use of the rule, or it is used in a different
+ manner then the follow context will be inaccurate - it was
+ inaccurate even before MR14, but it will be inaccurate in a
+ different way.
+
+ For the example given earlier, a reasonable way to rewrite the
+ grammar:
+
+ rule : ( alpha )? beta
+ alpha : S t ;
+ t : T U
+ | T
+ ;
+ beta : alpha Z ;
+
+ If there are no other uses of the rule appearing in the guess
+ block it will generate a test for EOF - a workaround for
+ representing a null set in the lookahead tests.
+
+ If you encounter such a problem you can use the -alpha option
+ to get additional information:
+
+ line 2: error: not possible to compute follow set for alpha
+ in an "(alpha)? beta" block.
+
+ With the antlr -alpha command line option the following information
+ is inserted into the generated file:
+
+ #if 0
+
+ Trace of references leading to attempt to compute the follow set of
+ alpha in an "(alpha)? beta" block. It is not possible for antlr to
+ compute this follow set because it is not known what part of beta has
+ already been matched by alpha and what part remains to be matched.
+
+ Rules which make use of the incorrect follow set will also be incorrect
+
+ 1 #token T alpha/2 line 7 brief.g
+ 2 end alpha alpha/3 line 8 brief.g
+ 2 end (...)? block at start/1 line 2 brief.g
+
+ #endif
+
+ At the moment, with the -alpha option selected the program marks
+ any rules which appear in the trace back chain (above) as rules with
+ possible problems computing follow set.
+
+ Reported by Greg Knapen (gregory.knapen bell.ca).
+
+#195. (Changed in MR14) #line directive not at column 1
+
+ Under certain circunstances a predicate test could generate
+ a #line directive which was not at column 1.
+
+ Reported with fix by David Kågedal (davidk lysator.liu.se)
+ (http://www.lysator.liu.se/~davidk/).
+
+#194. (Changed in MR14) (C Mode only) Demand lookahead with #tokclass
+
+ In C mode with the demand lookahead option there is a bug in the
+ code which handles matches for #tokclass (zzsetmatch and
+ zzsetmatch_wsig).
+
+ The bug causes the lookahead pointer to get out of synchronization
+ with the current token pointer.
+
+ The problem was reported with a fix by Ger Hobbelt (hobbelt axa.nl).
+
+#193. (Changed in MR14) Use of PCCTS_USE_NAMESPACE_STD
+
+ The pcctscfg.h now contains the following definitions:
+
+ #ifdef PCCTS_USE_NAMESPACE_STD
+ #define PCCTS_STDIO_H <Cstdio>
+ #define PCCTS_STDLIB_H <Cstdlib>
+ #define PCCTS_STDARG_H <Cstdarg>
+ #define PCCTS_SETJMP_H <Csetjmp>
+ #define PCCTS_STRING_H <Cstring>
+ #define PCCTS_ASSERT_H <Cassert>
+ #define PCCTS_ISTREAM_H <istream>
+ #define PCCTS_IOSTREAM_H <iostream>
+ #define PCCTS_NAMESPACE_STD namespace std {}; using namespace std;
+ #else
+ #define PCCTS_STDIO_H <stdio.h>
+ #define PCCTS_STDLIB_H <stdlib.h>
+ #define PCCTS_STDARG_H <stdarg.h>
+ #define PCCTS_SETJMP_H <setjmp.h>
+ #define PCCTS_STRING_H <string.h>
+ #define PCCTS_ASSERT_H <assert.h>
+ #define PCCTS_ISTREAM_H <istream.h>
+ #define PCCTS_IOSTREAM_H <iostream.h>
+ #define PCCTS_NAMESPACE_STD
+ #endif
+
+ The runtime support in pccts/h uses these pre-processor symbols
+ consistently.
+
+ Also, antlr and dlg have been changed to generate code which uses
+ these pre-processor symbols rather than having the names of the
+ #include files hard-coded in the generated code.
+
+ This required the addition of "#include pcctscfg.h" to a number of
+ files in pccts/h.
+
+ It appears that this sometimes causes problems for MSVC 5 in
+ combination with the "automatic" option for pre-compiled headers.
+ In such cases disable the "automatic" pre-compiled headers option.
+
+ Suggested by Hubert Holin (Hubert.Holin Bigfoot.com).
+
+#192. (Changed in MR14) Change setText() to accept "const ANTLRChar *"
+
+ Changed ANTLRToken::setText(ANTLRChar *) to setText(const ANTLRChar *).
+ This allows literal strings to be used to initialize tokens. Since
+ the usual token implementation (ANTLRCommonToken) makes a copy of the
+ input string, this was an unnecessary limitation.
+
+ Suggested by Bob McWhirter (bob netwrench.com).
+
+#191. (Changed in MR14) HP/UX aCC compiler compatibility problem
+
+ Needed to explicitly declare zzINF_DEF_TOKEN_BUFFER_SIZE and
+ zzINF_BUFFER_TOKEN_CHUNK_SIZE as ints in pccts/h/AParser.cpp.
+
+ Reported by David Cook (dcook bmc.com).
+
+#190. (Changed in MR14) IBM OS/2 CSet compiler compatibility problem
+
+ Name conflict with "_cs" in pccts/h/ATokenBuffer.cpp
+
+ Reported by David Cook (dcook bmc.com).
+
+#189. (Changed in MR14) -gxt switch in C mode
+
+ The -gxt switch in C mode didn't work because of incorrect
+ initialization.
+
+ Reported by Sinan Karasu (sinan boeing.com).
+
+#188. (Changed in MR14) Added pccts/h/DLG_stream_input.h
+
+ This is a DLG stream class based on C++ istreams.
+
+ Contributed by Hubert Holin (Hubert.Holin Bigfoot.com).
+
+#187. (Changed in MR14) Rename config.h to pcctscfg.h
+
+ The PCCTS configuration file has been renamed from config.h to
+ pcctscfg.h. The problem with the original name is that it led
+ to name collisions when pccts parsers were combined with other
+ software.
+
+ All of the runtime support routines in pccts/h/* have been
+ changed to use the new name. Existing software can continue
+ to use pccts/h/config.h. The contents of pccts/h/config.h is
+ now just "#include "pcctscfg.h".
+
+ I don't have a record of the user who suggested this.
+
+#186. (Changed in MR14) Pre-processor symbol DllExportPCCTS class modifier
+
+ Classes in the C++ runtime support routines are now declared:
+
+ class DllExportPCCTS className ....
+
+ By default, the pre-processor symbol is defined as the empty
+ string. This if for use by MSVC++ users to create DLL classes.
+
+ Suggested by Manfred Kogler (km cast.uni-linz.ac.at).
+
+#185. (Changed in MR14) Option to not use PCCTS_AST base class for ASTBase
+
+ Normally, the ASTBase class is derived from PCCTS_AST which contains
+ functions useful to Sorcerer. If these are not necessary then the
+ user can define the pre-processor symbol "PCCTS_NOT_USING_SOR" which
+ will cause the ASTBase class to replace references to PCCTS_AST with
+ references to ASTBase where necessary.
+
+ The class ASTDoublyLinkedBase will contain a pure virtual function
+ shallowCopy() that was formerly defined in class PCCTS_AST.
+
+ Suggested by Bob McWhirter (bob netwrench.com).
+
+#184. (Changed in MR14) Grammars with no tokens generate invalid tokens.h
+
+ Reported by Hubert Holin (Hubert.Holin bigfoot.com).
+
+#183. (Changed in MR14) -f to specify file with names of grammar files
+
+ In DEC/VMS it is difficult to specify very long command lines.
+ The -f option allows one to place the names of the grammar files
+ in a data file in order to bypass limitations of the DEC/VMS
+ command language interpreter.
+
+ Addition supplied by Bernard Giroud (b_giroud decus.ch).
+
+#182. (Changed in MR14) Output directory option for DEC/VMS
+
+ Fix some problems with the -o option under DEC/VMS.
+
+ Fix supplied by Bernard Giroud (b_giroud decus.ch).
+
+#181. (Changed in MR14) Allow chars > 127 in DLGStringInput::nextChar()
+
+ Changed DLGStringInput to cast the character using (unsigned char)
+ so that languages with character codes greater than 127 work
+ without changes.
+
+ Suggested by Manfred Kogler (km cast.uni-linz.ac.at).
+
+#180. (Added in MR14) ANTLRParser::getEofToken()
+
+ Added "ANTLRToken ANTLRParser::getEofToken() const" to match the
+ setEofToken routine.
+
+ Requested by Manfred Kogler (km cast.uni-linz.ac.at).
+
+#179. (Fixed in MR14) Memory leak for BufFileInput subclass of DLGInputStream
+
+ The BufFileInput class described in Item #142 neglected to release
+ the allocated buffer when an instance was destroyed.
+
+ Reported by Manfred Kogler (km cast.uni-linz.ac.at).
+
+#178. (Fixed in MR14) Bug in "(alpha)? beta" guess blocks first sets
+
+ In 1.33 vanilla, and all maintenance releases prior to MR14
+ there is a bug in the handling of guess blocks which use the
+ "long" form:
+
+ (alpha)? beta
+
+ inside a (...)*, (...)+, or {...} block.
+
+ This problem does *not* apply to the case where beta is omitted
+ or when the syntactic predicate is on the leading edge of an
+ alternative.
+
+ The problem is that both alpha and beta are stored in the
+ syntax diagram, and that some analysis routines would fail
+ to skip the alpha portion when it was not on the leading edge.
+ Consider the following grammar with -ck 2:
+
+ r : ( (A)? B )* C D
+
+ | A B /* forces -ck 2 computation for old antlr */
+ /* reports ambig for alts 1 & 2 */
+
+ | B C /* forces -ck 2 computation for new antlr */
+ /* reports ambig for alts 1 & 3 */
+ ;
+
+ The prediction expression for the first alternative should be
+ LA(1)={B C} LA(2)={B C D}, but previous versions of antlr
+ would compute the prediction expression as LA(1)={A C} LA(2)={B D}
+
+ Reported by Arpad Beszedes (beszedes inf.u-szeged.hu) who provided
+ a very clear example of the problem and identified the probable cause.
+
+#177. (Changed in MR14) #tokdefs and #token with regular expression
+
+ In MR13 the change described by Item #162 caused an existing
+ feature of antlr to fail. Prior to the change it was possible
+ to give regular expression definitions and actions to tokens
+ which were defined via the #tokdefs directive.
+
+ This now works again.
+
+ Reported by Manfred Kogler (km cast.uni-linz.ac.at).
+
+#176. (Changed in MR14) Support for #line in antlr source code
+
+ Note: this was implemented by Arpad Beszedes (beszedes inf.u-szeged.hu).
+
+ In 1.33MR14 it is possible for a pre-processor to generate #line
+ directives in the antlr source and have those line numbers and file
+ names used in antlr error messages and in the #line directives
+ generated by antlr.
+
+ The #line directive may appear in the following forms:
+
+ #line ll "sss" xx xx ...
+
+ where ll represents a line number, "sss" represents the name of a file
+ enclosed in quotation marks, and xxx are arbitrary integers.
+
+ The following form (without "line") is not supported at the moment:
+
+ # ll "sss" xx xx ...
+
+ The result:
+
+ zzline
+
+ is replaced with ll from the # or #line directive
+
+ FileStr[CurFile]
+
+ is updated with the contents of the string (if any)
+ following the line number
+
+ Note
+ ----
+ The file-name string following the line number can be a complete
+ name with a directory-path. Antlr generates the output files from
+ the input file name (by replacing the extension from the file-name
+ with .c or .cpp).
+
+ If the input file (or the file-name from the line-info) contains
+ a path:
+
+ "../grammar.g"
+
+ the generated source code will be placed in "../grammar.cpp" (i.e.
+ in the parent directory). This is inconvenient in some cases
+ (even the -o switch can not be used) so the path information is
+ removed from the #line directive. Thus, if the line-info was
+
+ #line 2 "../grammar.g"
+
+ then the current file-name will become "grammar.g"
+
+ In this way, the generated source code according to the grammar file
+ will always be in the current directory, except when the -o switch
+ is used.
+
+#175. (Changed in MR14) Bug when guess block appears at start of (...)*
+
+ In 1.33 vanilla and all maintenance releases prior to 1.33MR14
+ there is a bug when a guess block appears at the start of a (...)+.
+ Consider the following k=1 (ck=1) grammar:
+
+ rule :
+ ( (STAR)? ZIP )* ID ;
+
+ Prior to 1.33MR14, the generated code resembled:
+
+ ...
+ zzGUESS_BLOCK
+ while ( 1 ) {
+ if ( ! LA(1)==STAR) break;
+ zzGUESS
+ if ( !zzrv ) {
+ zzmatch(STAR);
+ zzCONSUME;
+ zzGUESS_DONE
+ zzmatch(ZIP);
+ zzCONSUME;
+ ...
+
+ Note that the routine uses STAR for the prediction expression
+ rather than ZIP. With 1.33MR14 the generated code resembles:
+
+ ...
+ while ( 1 ) {
+ if ( ! LA(1)==ZIP) break;
+ ...
+
+ This problem existed only with (...)* blocks and was caused
+ by the slightly more complicated graph which represents (...)*
+ blocks. This caused the analysis routine to compute the first
+ set for the alpha part of the "(alpha)? beta" rather than the
+ beta part.
+
+ Both (...)+ and {...} blocks handled the guess block correctly.
+
+ Reported by Arpad Beszedes (beszedes inf.u-szeged.hu) who provided
+ a very clear example of the problem and identified the probable cause.
+
+#174. (Changed in MR14) Bug when action precedes syntactic predicate
+
+ In 1.33 vanilla, and all maintenance releases prior to MR14,
+ there was a bug when a syntactic predicate was immediately
+ preceded by an action. Consider the following -ck 2 grammar:
+
+ rule :
+ <<int i;>>
+ (alpha)? beta C
+ | A B
+ ;
+
+ alpha : A ;
+ beta : A B;
+
+ Prior to MR14, the code generated for the first alternative
+ resembled:
+
+ ...
+ zzGUESS
+ if ( !zzrv && LA(1)==A && LA(2)==A) {
+ alpha();
+ zzGUESS_DONE
+ beta();
+ zzmatch(C);
+ zzCONSUME;
+ } else {
+ ...
+
+ The prediction expression (i.e. LA(1)==A && LA(2)==A) is clearly
+ wrong because LA(2) should be matched to B (first[2] of beta is {B}).
+
+ With 1.33MR14 the prediction expression is:
+
+ ...
+ if ( !zzrv && LA(1)==A && LA(2)==B) {
+ alpha();
+ zzGUESS_DONE
+ beta();
+ zzmatch(C);
+ zzCONSUME;
+ } else {
+ ...
+
+ This will only affect users in which alpha is shorter than
+ than max(k,ck) and there is an action immediately preceding
+ the syntactic predicate.
+
+ This problem was reported by reported by Arpad Beszedes
+ (beszedes inf.u-szeged.hu) who provided a very clear example
+ of the problem and identified the presence of the init-action
+ as the likely culprit.
+
+#173. (Changed in MR13a) -glms for Microsoft style filenames with -gl
+
+ With the -gl option antlr generates #line directives using the
+ exact name of the input files specified on the command line.
+ An oddity of the Microsoft C and C++ compilers is that they
+ don't accept file names in #line directives containing "\"
+ even though these are names from the native file system.
+
+ With -glms option, the "\" in file names appearing in #line
+ directives is replaced with a "/" in order to conform to
+ Microsoft compiler requirements.
+
+ Reported by Erwin Achermann (erwin.achermann switzerland.org).
+
+#172. (Changed in MR13) \r\n in antlr source counted as one line
+
+ Some MS software uses \r\n to indicate a new line. Antlr
+ now recognizes this in counting lines.
+
+ Reported by Edward L. Hepler (elh ece.vill.edu).
+
+#171. (Changed in MR13) #tokclass L..U now allowed
+
+ The following is now allowed:
+
+ #tokclass ABC { A..B C }
+
+ Reported by Dave Watola (dwatola amtsun.jpl.nasa.gov)
+
+#170. (Changed in MR13) Suppression for predicates with lookahead depth >1
+
+ In MR12 the capability for suppression of predicates with lookahead
+ depth=1 was introduced. With MR13 this had been extended to
+ predicates with lookahead depth > 1 and released for use by users
+ on an experimental basis.
+
+ Consider the following grammar with -ck 2 and the predicate in rule
+ "a" with depth 2:
+
+ r1 : (ab)* "@"
+ ;
+
+ ab : a
+ | b
+ ;
+
+ a : (A B)? => <<p(LATEXT(2))>>? A B C
+ ;
+
+ b : A B C
+ ;
+
+ Normally, the predicate would be hoisted into rule r1 in order to
+ determine whether to call rule "ab". However it should *not* be
+ hoisted because, even if p is false, there is a valid alternative
+ in rule b. With "-mrhoistk on" the predicate will be suppressed.
+
+ If "-info p" command line option is present the following information
+ will appear in the generated code:
+
+ while ( (LA(1)==A)
+ #if 0
+
+ Part (or all) of predicate with depth > 1 suppressed by alternative
+ without predicate
+
+ pred << p(LATEXT(2))>>?
+ depth=k=2 ("=>" guard) rule a line 8 t1.g
+ tree context:
+ (root = A
+ B
+ )
+
+ The token sequence which is suppressed: ( A B )
+ The sequence of references which generate that sequence of tokens:
+
+ 1 to ab r1/1 line 1 t1.g
+ 2 ab ab/1 line 4 t1.g
+ 3 to b ab/2 line 5 t1.g
+ 4 b b/1 line 11 t1.g
+ 5 #token A b/1 line 11 t1.g
+ 6 #token B b/1 line 11 t1.g
+
+ #endif
+
+ A slightly more complicated example:
+
+ r1 : (ab)* "@"
+ ;
+
+ ab : a
+ | b
+ ;
+
+ a : (A B)? => <<p(LATEXT(2))>>? (A B | D E)
+ ;
+
+ b : <<q(LATEXT(2))>>? D E
+ ;
+
+
+ In this case, the sequence (D E) in rule "a" which lies behind
+ the guard is used to suppress the predicate with context (D E)
+ in rule b.
+
+ while ( (LA(1)==A || LA(1)==D)
+ #if 0
+
+ Part (or all) of predicate with depth > 1 suppressed by alternative
+ without predicate
+
+ pred << q(LATEXT(2))>>?
+ depth=k=2 rule b line 11 t2.g
+ tree context:
+ (root = D
+ E
+ )
+
+ The token sequence which is suppressed: ( D E )
+ The sequence of references which generate that sequence of tokens:
+
+ 1 to ab r1/1 line 1 t2.g
+ 2 ab ab/1 line 4 t2.g
+ 3 to a ab/1 line 4 t2.g
+ 4 a a/1 line 8 t2.g
+ 5 #token D a/1 line 8 t2.g
+ 6 #token E a/1 line 8 t2.g
+
+ #endif
+ &&
+ #if 0
+
+ pred << p(LATEXT(2))>>?
+ depth=k=2 ("=>" guard) rule a line 8 t2.g
+ tree context:
+ (root = A
+ B
+ )
+
+ #endif
+
+ (! ( LA(1)==A && LA(2)==B ) || p(LATEXT(2)) ) {
+ ab();
+ ...
+
+#169. (Changed in MR13) Predicate test optimization for depth=1 predicates
+
+ When the MR12 generated a test of a predicate which had depth 1
+ it would use the depth >1 routines, resulting in correct but
+ inefficient behavior. In MR13, a bit test is used.
+
+#168. (Changed in MR13) Token expressions in context guards
+
+ The token expressions appearing in context guards such as:
+
+ (A B)? => <<test(LT(1))>>? someRule
+
+ are computed during an early phase of antlr processing. As
+ a result, prior to MR13, complex expressions such as:
+
+ ~B
+ L..U
+ ~L..U
+ TokClassName
+ ~TokClassName
+
+ were not computed properly. This resulted in incorrect
+ context being computed for such expressions.
+
+ In MR13 these context guards are verified for proper semantics
+ in the initial phase and then re-evaluated after complex token
+ expressions have been computed in order to produce the correct
+ behavior.
+
+ Reported by Arpad Beszedes (beszedes inf.u-szeged.hu).
+
+#167. (Changed in MR13) ~L..U
+
+ Prior to MR13, the complement of a token range was
+ not properly computed.
+
+#166. (Changed in MR13) token expression L..U
+
+ The token U was represented as an unsigned char, restricting
+ the use of L..U to cases where U was assigned a token number
+ less than 256. This is corrected in MR13.
+
+#165. (Changed in MR13) option -newAST
+
+ To create ASTs from an ANTLRTokenPtr antlr usually calls
+ "new AST(ANTLRTokenPtr)". This option generates a call
+ to "newAST(ANTLRTokenPtr)" instead. This allows a user
+ to define a parser member function to create an AST object.
+
+ Similar changes for ASTBase::tmake and ASTBase::link were not
+ thought necessary since they do not create AST objects, only
+ use existing ones.
+
+#164. (Changed in MR13) Unused variable _astp
+
+ For many compilations, we have lived with warnings about
+ the unused variable _astp. It turns out that this varible
+ can *never* be used because the code which references it was
+ commented out.
+
+ This investigation was sparked by a note from Erwin Achermann
+ (erwin.achermann switzerland.org).
+
+#163. (Changed in MR13) Incorrect makefiles for testcpp examples
+
+ All the examples in pccts/testcpp/* had incorrect definitions
+ in the makefiles for the symbol "CCC". Instead of CCC=CC they
+ had CC=$(CCC).
+
+ There was an additional problem in testcpp/1/test.g due to the
+ change in ANTLRToken::getText() to a const member function
+ (Item #137).
+
+ Reported by Maurice Mass (maas cuci.nl).
+
+#162. (Changed in MR13) Combining #token with #tokdefs
+
+ When it became possible to change the print-name of a
+ #token (Item #148) it became useful to give a #token
+ statement whose only purpose was to giving a print name
+ to the #token. Prior to this change this could not be
+ combined with the #tokdefs feature.
+
+#161. (Changed in MR13) Switch -gxt inhibits generation of tokens.h
+
+#160. (Changed in MR13) Omissions in list of names for remap.h
+
+ When a user selects the -gp option antlr creates a list
+ of macros in remap.h to rename some of the standard
+ antlr routines from zzXXX to userprefixXXX.
+
+ There were number of omissions from the remap.h name
+ list related to the new trace facility. This was reported,
+ along with a fix, by Bernie Solomon (bernard ug.eds.com).
+
+#159. (Changed in MR13) Violations of classic C rules
+
+ There were a number of violations of classic C style in
+ the distribution kit. This was reported, along with fixes,
+ by Bernie Solomon (bernard ug.eds.com).
+
+#158. (Changed in MR13) #header causes problem for pre-processors
+
+ A user who runs the C pre-processor on antlr source suggested
+ that another syntax be allowed. With MR13 such directives
+ such as #header, #pragma, etc. may be written as "\#header",
+ "\#pragma", etc. For escaping pre-processor directives inside
+ a #header use something like the following:
+
+ \#header
+ <<
+ \#include <stdio.h>
+ >>
+
+#157. (Fixed in MR13) empty error sets for rules with infinite recursion
+
+ When the first set for a rule cannot be computed due to infinite
+ left recursion and it is the only alternative for a block then
+ the error set for the block would be empty. This would result
+ in a fatal error.
+
+ Reported by Darin Creason (creason genedax.com)
+
+#156. (Changed in MR13) DLGLexerBase::getToken() now public
+
+#155. (Changed in MR13) Context behind predicates can suppress
+
+ With -mrhoist enabled the context behind a guarded predicate can
+ be used to suppress other predicates. Consider the following grammar:
+
+ r0 : (r1)+;
+
+ r1 : rp
+ | rq
+ ;
+ rp : <<p LATEXT(1)>>? B ;
+ rq : (A)? => <<q LATEXT(1)>>? (A|B);
+
+ In earlier versions both predicates "p" and "q" would be hoisted into
+ rule r0. With MR12c predicate p is suppressed because the context which
+ follows predicate q includes "B" which can "cover" predicate "p". In
+ other words, in trying to decide in r0 whether to call r1, it doesn't
+ really matter whether p is false or true because, either way, there is
+ a valid choice within r1.
+
+#154. (Changed in MR13) Making hoist suppression explicit using <<nohoist>>
+
+ A common error, even among experienced pccts users, is to code
+ an init-action to inhibit hoisting rather than a leading action.
+ An init-action does not inhibit hoisting.
+
+ This was coded:
+
+ rule1 : <<;>> rule2
+
+ This is what was meant:
+
+ rule1 : <<;>> <<;>> rule2
+
+ With MR13, the user can code:
+
+ rule1 : <<;>> <<nohoist>> rule2
+
+ The following will give an error message:
+
+ rule1 : <<nohoist>> rule2
+
+ If the <<nohoist>> appears as an init-action rather than a leading
+ action an error message is issued. The meaning of an init-action
+ containing "nohoist" is unclear: does it apply to just one
+ alternative or to all alternatives ?
+
+
+
+
+
+
+
+
+ -------------------------------------------------------
+ Note: Items #153 to #1 are now in a separate file named
+ CHANGES_FROM_133_BEFORE_MR13.txt
+ -------------------------------------------------------
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133_BEFORE_MR13.txt b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133_BEFORE_MR13.txt new file mode 100644 index 0000000000..bba5ecdd64 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133_BEFORE_MR13.txt @@ -0,0 +1,3666 @@ +
+ ------------------------------------------------------------
+ This is the second part of a two part file.
+ This is a list of changes to pccts 1.33 prior to MR13
+ For more recent information see CHANGES_FROM_133.txt
+ ------------------------------------------------------------
+
+ DISCLAIMER
+
+ The software and these notes are provided "as is". They may include
+ typographical or technical errors and their authors disclaims all
+ liability of any kind or nature for damages due to error, fault,
+ defect, or deficiency regardless of cause. All warranties of any
+ kind, either express or implied, including, but not limited to, the
+ implied warranties of merchantability and fitness for a particular
+ purpose are disclaimed.
+
+
+#153. (Changed in MR12b) Bug in computation of -mrhoist suppression set
+
+ Consider the following grammar with k=1 and "-mrhoist on":
+
+ r1 : (A)? => ((p>>? x /* l1 */
+ | r2 /* l2 */
+ ;
+ r2 : A /* l4 */
+ | (B)? => <<q>>? y /* l5 */
+ ;
+
+ In earlier versions the mrhoist routine would see that both l1 and
+ l2 contained predicates and would assume that this prevented either
+ from acting to suppress the other predicate. In the example above
+ it didn't realize the A at line l4 is capable of suppressing the
+ predicate at l1 even though alt l2 contains (indirectly) a predicate.
+
+ This is fixed in MR12b.
+
+ Reported by Reinier van den Born (reinier@vnet.ibm.com)
+
+#153. (Changed in MR12a) Bug in computation of -mrhoist suppression set
+
+ An oversight similar to that described in Item #152 appeared in
+ the computation of the set that "covered" a predicate. If a
+ predicate expression included a term such as p=AND(q,r) the context
+ of p was taken to be context(q) & context(r), when it should have
+ been context(q) | context(r). This is fixed in MR12a.
+
+#152. (Changed in MR12) Bug in generation of predicate expressions
+
+ The primary purpose for MR12 is to make quite clear that MR11 is
+ obsolete and to fix the bug related to predicate expressions.
+
+ In MR10 code was added to optimize the code generated for
+ predicate expression tests. Unfortunately, there was a
+ significant oversight in the code which resulted in a bug in
+ the generation of code for predicate expression tests which
+ contained predicates combined using AND:
+
+ r0 : (r1)* "@" ;
+ r1 : (AAA)? => <<p LATEXT(1)>>? r2 ;
+ r2 : (BBB)? => <<q LATEXT(1)>>? Q
+ | (BBB)? => <<r LATEXT(1)>>? Q
+ ;
+
+ In MR11 (and MR10 when using "-mrhoist on") the code generated
+ for r0 to predict r1 would be equivalent to:
+
+ if ( LA(1)==Q &&
+ (LA(1)==AAA && LA(1)==BBB) &&
+ ( p && ( q || r )) ) {
+
+ This is incorrect because it expresses the idea that LA(1)
+ *must* be AAA in order to attempt r1, and *must* be BBB to
+ attempt r2. The result was that r1 became unreachable since
+ both condition can not be simultaneously true.
+
+ The general philosophy of code generation for predicates
+ can be summarized as follows:
+
+ a. If the context is true don't enter an alt
+ for which the corresponding predicate is false.
+
+ If the context is false then it is okay to enter
+ the alt without evaluating the predicate at all.
+
+ b. A predicate created by ORing of predicates has
+ context which is the OR of their individual contexts.
+
+ c. A predicate created by ANDing of predicates has
+ (surprise) context which is the OR of their individual
+ contexts.
+
+ d. Apply these rules recursively.
+
+ e. Remember rule (a)
+
+ The correct code should express the idea that *if* LA(1) is
+ AAA then p must be true to attempt r1, but if LA(1) is *not*
+ AAA then it is okay to attempt r1, provided that *if* LA(1) is
+ BBB then one of q or r must be true.
+
+ if ( LA(1)==Q &&
+ ( !(LA(1)==AAA || LA(1)==BBB) ||
+ ( ! LA(1) == AAA || p) &&
+ ( ! LA(1) == BBB || q || r ) ) ) {
+
+ I believe this is fixed in MR12.
+
+ Reported by Reinier van den Born (reinier@vnet.ibm.com)
+
+#151a. (Changed in MR12) ANTLRParser::getLexer()
+
+ As a result of several requests, I have added public methods to
+ get a pointer to the lexer belonging to a parser.
+
+ ANTLRTokenStream *ANTLRParser::getLexer() const
+
+ Returns a pointer to the lexer being used by the
+ parser. ANTLRTokenStream is the base class of
+ DLGLexer
+
+ ANTLRTokenStream *ANTLRTokenBuffer::getLexer() const
+
+ Returns a pointer to the lexer being used by the
+ ANTLRTokenBuffer. ANTLRTokenStream is the base
+ class of DLGLexer
+
+ You must manually cast the ANTLRTokenStream to your program's
+ lexer class. Because the name of the lexer's class is not fixed.
+ Thus it is impossible to incorporate it into the DLGLexerBase
+ class.
+
+#151b.(Changed in MR12) ParserBlackBox member getLexer()
+
+ The template class ParserBlackBox now has a member getLexer()
+ which returns a pointer to the lexer.
+
+#150. (Changed in MR12) syntaxErrCount and lexErrCount now public
+
+ See Item #127 for more information.
+
+#149. (Changed in MR12) antlr option -info o (letter o for orphan)
+
+ If there is more than one rule which is not referenced by any
+ other rule then all such rules are listed. This is useful for
+ alerting one to rules which are not used, but which can still
+ contribute to ambiguity. For example:
+
+ start : a Z ;
+ unused: a A ;
+ a : (A)+ ;
+
+ will cause an ambiguity report for rule "a" which will be
+ difficult to understand if the user forgets about rule "unused"
+ simply because it is not used in the grammar.
+
+#148. (Changed in MR11) #token names appearing in zztokens,token_tbl
+
+ In a #token statement like the following:
+
+ #token Plus "\+"
+
+ the string "Plus" appears in the zztokens array (C mode) and
+ token_tbl (C++ mode). This string is used in most error
+ messages. In MR11 one has the option of using some other string,
+ (e.g. "+") in those tables.
+
+ In MR11 one can write:
+
+ #token Plus ("+") "\+"
+ #token RP ("(") "\("
+ #token COM ("comment begin") "/\*"
+
+ A #token statement is allowed to appear in more than one #lexclass
+ with different regular expressions. However, the token name appears
+ only once in the zztokens/token_tbl array. This means that only
+ one substitute can be specified for a given #token name. The second
+ attempt to define a substitute name (different from the first) will
+ result in an error message.
+
+#147. (Changed in MR11) Bug in follow set computation
+
+ There is a bug in 1.33 vanilla and all maintenance releases
+ prior to MR11 in the computation of the follow set. The bug is
+ different than that described in Item #82 and probably more
+ common. It was discovered in the ansi.g grammar while testing
+ the "ambiguity aid" (Item #119). The search for a bug started
+ when the ambiguity aid was unable to discover the actual source
+ of an ambiguity reported by antlr.
+
+ The problem appears when an optimization of the follow set
+ computation is used inappropriately. The result is that the
+ follow set used is the "worst case". In other words, the error
+ can lead to false reports of ambiguity. The good news is that
+ if you have a grammar in which you have addressed all reported
+ ambiguities you are ok. The bad news is that you may have spent
+ time fixing ambiguities that were not real, or used k=2 when
+ ck=2 might have been sufficient, and so on.
+
+ The following grammar demonstrates the problem:
+
+ ------------------------------------------------------------
+ expr : ID ;
+
+ start : stmt SEMI ;
+
+ stmt : CASE expr COLON
+ | expr SEMI
+ | plain_stmt
+ ;
+
+ plain_stmt : ID COLON ;
+ ------------------------------------------------------------
+
+ When compiled with k=1 and ck=2 it will report:
+
+ warning: alts 2 and 3 of the rule itself ambiguous upon
+ { IDENTIFIER }, { COLON }
+
+ When antlr analyzes "stmt" it computes the first[1] set of all
+ alternatives. It finds an ambiguity between alts 2 and 3 for ID.
+ It then computes the first[2] set for alternatives 2 and 3 to resolve
+ the ambiguity. In computing the first[2] set of "expr" (which is
+ only one token long) it needs to determine what could follow "expr".
+ Under a certain combination of circumstances antlr forgets that it
+ is trying to analyze "stmt" which can only be followed by SEMI and
+ adds to the first[2] set of "expr" the "global" follow set (including
+ "COLON") which could follow "expr" (under other conditions) in the
+ phrase "CASE expr COLON".
+
+#146. (Changed in MR11) Option -treport for locating "difficult" alts
+
+ It can be difficult to determine which alternatives are causing
+ pccts to work hard to resolve an ambiguity. In some cases the
+ ambiguity is successfully resolved after much CPU time so there
+ is no message at all.
+
+ A rough measure of the amount of work being peformed which is
+ independent of the CPU speed and system load is the number of
+ tnodes created. Using "-info t" gives information about the
+ total number of tnodes created and the peak number of tnodes.
+
+ Tree Nodes: peak 1300k created 1416k lost 0
+
+ It also puts in the generated C or C++ file the number of tnodes
+ created for a rule (at the end of the rule). However this
+ information is not sufficient to locate the alternatives within
+ a rule which are causing the creation of tnodes.
+
+ Using:
+
+ antlr -treport 100000 ....
+
+ causes antlr to list on stdout any alternatives which require the
+ creation of more than 100,000 tnodes, along with the lookahead sets
+ for those alternatives.
+
+ The following is a trivial case from the ansi.g grammar which shows
+ the format of the report. This report might be of more interest
+ in cases where 1,000,000 tuples were created to resolve the ambiguity.
+
+ -------------------------------------------------------------------------
+ There were 0 tuples whose ambiguity could not be resolved
+ by full lookahead
+ There were 157 tnodes created to resolve ambiguity between:
+
+ Choice 1: statement/2 line 475 file ansi.g
+ Choice 2: statement/3 line 476 file ansi.g
+
+ Intersection of lookahead[1] sets:
+
+ IDENTIFIER
+
+ Intersection of lookahead[2] sets:
+
+ LPARENTHESIS COLON AMPERSAND MINUS
+ STAR PLUSPLUS MINUSMINUS ONESCOMPLEMENT
+ NOT SIZEOF OCTALINT DECIMALINT
+ HEXADECIMALINT FLOATONE FLOATTWO IDENTIFIER
+ STRING CHARACTER
+ -------------------------------------------------------------------------
+
+#145. (Documentation) Generation of Expression Trees
+
+ Item #99 was misleading because it implied that the optimization
+ for tree expressions was available only for trees created by
+ predicate expressions and neglected to mention that it required
+ the use of "-mrhoist on". The optimization applies to tree
+ expressions created for grammars with k>1 and for predicates with
+ lookahead depth >1.
+
+ In MR11 the optimized version is always used so the -mrhoist on
+ option need not be specified.
+
+#144. (Changed in MR11) Incorrect test for exception group
+
+ In testing for a rule's exception group the label a pointer
+ is compared against '\0'. The intention is "*pointer".
+
+ Reported by Jeffrey C. Fried (Jeff@Fried.net).
+
+#143. (Changed in MR11) Optional ";" at end of #token statement
+
+ Fixes problem of:
+
+ #token X "x"
+
+ <<
+ parser action
+ >>
+
+ Being confused with:
+
+ #token X "x" <<lexical action>>
+
+#142. (Changed in MR11) class BufFileInput subclass of DLGInputStream
+
+ Alexey Demakov (demakov@kazbek.ispras.ru) has supplied class
+ BufFileInput derived from DLGInputStream which provides a
+ function lookahead(char *string) to test characters in the
+ input stream more than one character ahead.
+
+ The default amount of lookahead is specified by the constructor
+ and defaults to 8 characters. This does *not* include the one
+ character of lookahead maintained internally by DLG in member "ch"
+ and which is not available for testing via BufFileInput::lookahead().
+
+ This is a useful class for overcoming the one-character-lookahead
+ limitation of DLG without resorting to a lexer capable of
+ backtracking (like flex) which is not integrated with antlr as is
+ DLG.
+
+ There are no restrictions on copying or using BufFileInput.* except
+ that the authorship and related information must be retained in the
+ source code.
+
+ The class is located in pccts/h/BufFileInput.* of the kit.
+
+#141. (Changed in MR11) ZZDEBUG_CONSUME for ANTLRParser::consume()
+
+ A debug aid has been added to file ANTLRParser::consume() in
+ file AParser.cpp:
+
+ #ifdef ZZDEBUG_CONSUME_ACTION
+ zzdebug_consume_action();
+ #endif
+
+ Suggested by Sramji Ramanathan (ps@kumaran.com).
+
+#140. (Changed in MR11) #pred to define predicates
+
+ +---------------------------------------------------+
+ | Note: Assume "-prc on" for this entire discussion |
+ +---------------------------------------------------+
+
+ A problem with predicates is that each one is regarded as
+ unique and capable of disambiguating cases where two
+ alternatives have identical lookahead. For example:
+
+ rule : <<pred(LATEXT(1))>>? A
+ | <<pred(LATEXT(1))>>? A
+ ;
+
+ will not cause any error messages or warnings to be issued
+ by earlier versions of pccts. To compare the text of the
+ predicates is an incomplete solution.
+
+ In 1.33MR11 I am introducing the #pred statement in order to
+ solve some problems with predicates. The #pred statement allows
+ one to give a symbolic name to a "predicate literal" or a
+ "predicate expression" in order to refer to it in other predicate
+ expressions or in the rules of the grammar.
+
+ The predicate literal associated with a predicate symbol is C
+ or C++ code which can be used to test the condition. A
+ predicate expression defines a predicate symbol in terms of other
+ predicate symbols using "!", "&&", and "||". A predicate symbol
+ can be defined in terms of a predicate literal, a predicate
+ expression, or *both*.
+
+ When a predicate symbol is defined with both a predicate literal
+ and a predicate expression, the predicate literal is used to generate
+ code, but the predicate expression is used to check for two
+ alternatives with identical predicates in both alternatives.
+
+ Here are some examples of #pred statements:
+
+ #pred IsLabel <<isLabel(LATEXT(1))>>?
+ #pred IsLocalVar <<isLocalVar(LATEXT(1))>>?
+ #pred IsGlobalVar <<isGlobalVar(LATEXT(1)>>?
+ #pred IsVar <<isVar(LATEXT(1))>>? IsLocalVar || IsGlobalVar
+ #pred IsScoped <<isScoped(LATEXT(1))>>? IsLabel || IsLocalVar
+
+ I hope that the use of EBNF notation to describe the syntax of the
+ #pred statement will not cause problems for my readers (joke).
+
+ predStatement : "#pred"
+ CapitalizedName
+ (
+ "<<predicate_literal>>?"
+ | "<<predicate_literal>>?" predOrExpr
+ | predOrExpr
+ )
+ ;
+
+ predOrExpr : predAndExpr ( "||" predAndExpr ) * ;
+
+ predAndExpr : predPrimary ( "&&" predPrimary ) * ;
+
+ predPrimary : CapitalizedName
+ | "!" predPrimary
+ | "(" predOrExpr ")"
+ ;
+
+ What is the purpose of this nonsense ?
+
+ To understand how predicate symbols help, you need to realize that
+ predicate symbols are used in two different ways with two different
+ goals.
+
+ a. Allow simplification of predicates which have been combined
+ during predicate hoisting.
+
+ b. Allow recognition of identical predicates which can't disambiguate
+ alternatives with common lookahead.
+
+ First we will discuss goal (a). Consider the following rule:
+
+ rule0: rule1
+ | ID
+ | ...
+ ;
+
+ rule1: rule2
+ | rule3
+ ;
+
+ rule2: <<isX(LATEXT(1))>>? ID ;
+ rule3: <<!isX(LATEXT(1)>>? ID ;
+
+ When the predicates in rule2 and rule3 are combined by hoisting
+ to create a prediction expression for rule1 the result is:
+
+ if ( LA(1)==ID
+ && ( isX(LATEXT(1) || !isX(LATEXT(1) ) ) { rule1(); ...
+
+ This is inefficient, but more importantly, can lead to false
+ assumptions that the predicate expression distinguishes the rule1
+ alternative with some other alternative with lookahead ID. In
+ MR11 one can write:
+
+ #pred IsX <<isX(LATEXT(1))>>?
+
+ ...
+
+ rule2: <<IsX>>? ID ;
+ rule3: <<!IsX>>? ID ;
+
+ During hoisting MR11 recognizes this as a special case and
+ eliminates the predicates. The result is a prediction
+ expression like the following:
+
+ if ( LA(1)==ID ) { rule1(); ...
+
+ Please note that the following cases which appear to be equivalent
+ *cannot* be simplified by MR11 during hoisting because the hoisting
+ logic only checks for a "!" in the predicate action, not in the
+ predicate expression for a predicate symbol.
+
+ *Not* equivalent and is not simplified during hoisting:
+
+ #pred IsX <<isX(LATEXT(1))>>?
+ #pred NotX <<!isX(LATEXT(1))>>?
+ ...
+ rule2: <<IsX>>? ID ;
+ rule3: <<NotX>>? ID ;
+
+ *Not* equivalent and is not simplified during hoisting:
+
+ #pred IsX <<isX(LATEXT(1))>>?
+ #pred NotX !IsX
+ ...
+ rule2: <<IsX>>? ID ;
+ rule3: <<NotX>>? ID ;
+
+ Now we will discuss goal (b).
+
+ When antlr discovers that there is a lookahead ambiguity between
+ two alternatives it attempts to resolve the ambiguity by searching
+ for predicates in both alternatives. In the past any predicate
+ would do, even if the same one appeared in both alternatives:
+
+ rule: <<p(LATEXT(1))>>? X
+ | <<p(LATEXT(1))>>? X
+ ;
+
+ The #pred statement is a start towards solving this problem.
+ During ambiguity resolution (*not* predicate hoisting) the
+ predicates for the two alternatives are expanded and compared.
+ Consider the following example:
+
+ #pred Upper <<isUpper(LATEXT(1))>>?
+ #pred Lower <<isLower(LATEXT(1))>>?
+ #pred Alpha <<isAlpha(LATEXT(1))>>? Upper || Lower
+
+ rule0: rule1
+ | <<Alpha>>? ID
+ ;
+
+ rule1:
+ | rule2
+ | rule3
+ ...
+ ;
+
+ rule2: <<Upper>>? ID;
+ rule3: <<Lower>>? ID;
+
+ The definition of #pred Alpha expresses:
+
+ a. to test the predicate use the C code "isAlpha(LATEXT(1))"
+
+ b. to analyze the predicate use the information that
+ Alpha is equivalent to the union of Upper and Lower,
+
+ During ambiguity resolution the definition of Alpha is expanded
+ into "Upper || Lower" and compared with the predicate in the other
+ alternative, which is also "Upper || Lower". Because they are
+ identical MR11 will report a problem.
+
+ -------------------------------------------------------------------------
+ t10.g, line 5: warning: the predicates used to disambiguate rule rule0
+ (file t10.g alt 1 line 5 and alt 2 line 6)
+ are identical when compared without context and may have no
+ resolving power for some lookahead sequences.
+ -------------------------------------------------------------------------
+
+ If you use the "-info p" option the output file will contain:
+
+ +----------------------------------------------------------------------+
+ |#if 0 |
+ | |
+ |The following predicates are identical when compared without |
+ | lookahead context information. For some ambiguous lookahead |
+ | sequences they may not have any power to resolve the ambiguity. |
+ | |
+ |Choice 1: rule0/1 alt 1 line 5 file t10.g |
+ | |
+ | The original predicate for choice 1 with available context |
+ | information: |
+ | |
+ | OR expr |
+ | |
+ | pred << Upper>>? |
+ | depth=k=1 rule rule2 line 14 t10.g |
+ | set context: |
+ | ID |
+ | |
+ | pred << Lower>>? |
+ | depth=k=1 rule rule3 line 15 t10.g |
+ | set context: |
+ | ID |
+ | |
+ | The predicate for choice 1 after expansion (but without context |
+ | information): |
+ | |
+ | OR expr |
+ | |
+ | pred << isUpper(LATEXT(1))>>? |
+ | depth=k=1 rule line 1 t10.g |
+ | |
+ | pred << isLower(LATEXT(1))>>? |
+ | depth=k=1 rule line 2 t10.g |
+ | |
+ | |
+ |Choice 2: rule0/2 alt 2 line 6 file t10.g |
+ | |
+ | The original predicate for choice 2 with available context |
+ | information: |
+ | |
+ | pred << Alpha>>? |
+ | depth=k=1 rule rule0 line 6 t10.g |
+ | set context: |
+ | ID |
+ | |
+ | The predicate for choice 2 after expansion (but without context |
+ | information): |
+ | |
+ | OR expr |
+ | |
+ | pred << isUpper(LATEXT(1))>>? |
+ | depth=k=1 rule line 1 t10.g |
+ | |
+ | pred << isLower(LATEXT(1))>>? |
+ | depth=k=1 rule line 2 t10.g |
+ | |
+ | |
+ |#endif |
+ +----------------------------------------------------------------------+
+
+ The comparison of the predicates for the two alternatives takes
+ place without context information, which means that in some cases
+ the predicates will be considered identical even though they operate
+ on disjoint lookahead sets. Consider:
+
+ #pred Alpha
+
+ rule1: <<Alpha>>? ID
+ | <<Alpha>>? Label
+ ;
+
+ Because the comparison of predicates takes place without context
+ these will be considered identical. The reason for comparing
+ without context is that otherwise it would be necessary to re-evaluate
+ the entire predicate expression for each possible lookahead sequence.
+ This would require more code to be written and more CPU time during
+ grammar analysis, and it is not yet clear whether anyone will even make
+ use of the new #pred facility.
+
+ A temporary workaround might be to use different #pred statements
+ for predicates you know have different context. This would avoid
+ extraneous warnings.
+
+ The above example might be termed a "false positive". Comparison
+ without context will also lead to "false negatives". Consider the
+ following example:
+
+ #pred Alpha
+ #pred Beta
+
+ rule1: <<Alpha>>? A
+ | rule2
+ ;
+
+ rule2: <<Alpha>>? A
+ | <<Beta>>? B
+ ;
+
+ The predicate used for alt 2 of rule1 is (Alpha || Beta). This
+ appears to be different than the predicate Alpha used for alt1.
+ However, the context of Beta is B. Thus when the lookahead is A
+ Beta will have no resolving power and Alpha will be used for both
+ alternatives. Using the same predicate for both alternatives isn't
+ very helpful, but this will not be detected with 1.33MR11.
+
+ To properly handle this the predicate expression would have to be
+ evaluated for each distinct lookahead context.
+
+ To determine whether two predicate expressions are identical is
+ difficult. The routine may fail to identify identical predicates.
+
+ The #pred feature also compares predicates to see if a choice between
+ alternatives which is resolved by a predicate which makes the second
+ choice unreachable. Consider the following example:
+
+ #pred A <<A(LATEXT(1)>>?
+ #pred B <<B(LATEXT(1)>>?
+ #pred A_or_B A || B
+
+ r : s
+ | t
+ ;
+ s : <<A_or_B>>? ID
+ ;
+ t : <<A>>? ID
+ ;
+
+ ----------------------------------------------------------------------------
+ t11.g, line 5: warning: the predicate used to disambiguate the
+ first choice of rule r
+ (file t11.g alt 1 line 5 and alt 2 line 6)
+ appears to "cover" the second predicate when compared without context.
+ The second predicate may have no resolving power for some lookahead
+ sequences.
+ ----------------------------------------------------------------------------
+
+#139. (Changed in MR11) Problem with -gp in C++ mode
+
+ The -gp option to add a prefix to rule names did not work in
+ C++ mode. This has been fixed.
+
+ Reported by Alexey Demakov (demakov@kazbek.ispras.ru).
+
+#138. (Changed in MR11) Additional makefiles for non-MSVC++ MS systems
+
+ Sramji Ramanathan (ps@kumaran.com) has supplied makefiles for
+ building antlr and dlg with Win95/NT development tools that
+ are not based on MSVC5. They are pccts/antlr/AntlrMS.mak and
+ pccts/dlg/DlgMS.mak.
+
+ The first line of the makefiles require a definition of PCCTS_HOME.
+
+ These are in additiion to the AntlrMSVC50.* and DlgMSVC50.*
+ supplied by Jeff Vincent (JVincent@novell.com).
+
+#137. (Changed in MR11) Token getType(), getText(), getLine() const members
+
+ --------------------------------------------------------------------
+ If you use ANTLRCommonToken this change probably does not affect you.
+ --------------------------------------------------------------------
+
+ For a long time it has bothered me that these accessor functions
+ in ANTLRAbstractToken were not const member functions. I have
+ refrained from changing them because it require users to modify
+ existing token class definitions which are derived directly
+ from ANTLRAbstractToken. I think it is now time.
+
+ For those who are not used to C++, a "const member function" is a
+ member function which does not modify its own object - the thing
+ to which "this" points. This is quite different from a function
+ which does not modify its arguments
+
+ Most token definitions based on ANTLRAbstractToken have something like
+ the following in order to create concrete definitions of the pure
+ virtual methods in ANTLRAbstractToken:
+
+ class MyToken : public ANTLRAbstractToken {
+ ...
+ ANTLRTokenType getType() {return _type; }
+ int getLine() {return _line; }
+ ANTLRChar * getText() {return _text; }
+ ...
+ }
+
+ The required change is simply to put "const" following the function
+ prototype in the header (.h file) and the definition file (.cpp if
+ it is not inline):
+
+ class MyToken : public ANTLRAbstractToken {
+ ...
+ ANTLRTokenType getType() const {return _type; }
+ int getLine() const {return _line; }
+ ANTLRChar * getText() const {return _text; }
+ ...
+ }
+
+ This was originally proposed a long time ago by Bruce
+ Guenter (bruceg@qcc.sk.ca).
+
+#136. (Changed in MR11) Added getLength() to ANTLRCommonToken
+
+ Classes ANTLRCommonToken and ANTLRCommonTokenNoRefCountToken
+ now have a member function:
+
+ int getLength() const { return strlen(getText()) }
+
+ Suggested by Sramji Ramanathan (ps@kumaran.com).
+
+#135. (Changed in MR11) Raised antlr's own default ZZLEXBUFSIZE to 8k
+
+#134a. (ansi_mr10.zip) T.J. Parr's ANSI C grammar made 1.33MR11 compatible
+
+ There is a typographical error in the definition of BITWISEOREQ:
+
+ #token BITWISEOREQ "!=" should be "\|="
+
+ When this change is combined with the bugfix to the follow set cache
+ problem (Item #147) and a minor rearrangement of the grammar
+ (Item #134b) it becomes a k=1 ck=2 grammar.
+
+#134b. (ansi_mr10.zip) T.J. Parr's ANSI C grammar made 1.33MR11 compatible
+
+ The following changes were made in the ansi.g grammar (along with
+ using -mrhoist on):
+
+ ansi.g
+ ======
+ void tracein(char *) ====> void tracein(const char *)
+ void traceout(char *) ====> void traceout(const char *)
+
+ <LT(1)->getType()==IDENTIFIER ? isTypeName(LT(1)->getText()) : 1>>?
+ ====> <<isTypeName(LT(1)->getText())>>?
+
+ <<(LT(1)->getType()==LPARENTHESIS && LT(2)->getType()==IDENTIFIER) ? \
+ isTypeName(LT(2)->getText()) : 1>>?
+ ====> (LPARENTHESIS IDENTIFIER)? => <<isTypeName(LT(2)->getText())>>?
+
+ <<(LT(1)->getType()==LPARENTHESIS && LT(2)->getType()==IDENTIFIER) ? \
+ isTypeName(LT(2)->getText()) : 1>>?
+ ====> (LPARENTHESIS IDENTIFIER)? => <<isTypeName(LT(2)->getText())>>?
+
+ added to init(): traceOptionValueDefault=0;
+ added to init(): traceOption(-1);
+
+ change rule "statement":
+
+ statement
+ : plain_label_statement
+ | case_label_statement
+ | <<;>> expression SEMICOLON
+ | compound_statement
+ | selection_statement
+ | iteration_statement
+ | jump_statement
+ | SEMICOLON
+ ;
+
+ plain_label_statement
+ : IDENTIFIER COLON statement
+ ;
+
+ case_label_statement
+ : CASE constant_expression COLON statement
+ | DEFAULT COLON statement
+ ;
+
+ support.cpp
+ ===========
+ void tracein(char *) ====> void tracein(const char *)
+ void traceout(char *) ====> void traceout(const char *)
+
+ added to tracein(): ANTLRParser::tracein(r); // call superclass method
+ added to traceout(): ANTLRParser::traceout(r); // call superclass method
+
+ Makefile
+ ========
+ added to AFLAGS: -mrhoist on -prc on
+
+#133. (Changed in 1.33MR11) Make trace options public in ANTLRParser
+
+ In checking T.J. Parr's ANSI C grammar for compatibility with
+ 1.33MR11 discovered that it was inconvenient to have the
+ trace facilities with protected access.
+
+#132. (Changed in 1.33MR11) Recognition of identical predicates in alts
+
+ Prior to 1.33MR11, there would be no ambiguity warning when the
+ very same predicate was used to disambiguate both alternatives:
+
+ test: ref B
+ | ref C
+ ;
+
+ ref : <<pred(LATEXT(1)>>? A
+
+ In 1.33MR11 this will cause the warning:
+
+ warning: the predicates used to disambiguate rule test
+ (file v98.g alt 1 line 1 and alt 2 line 2)
+ are identical and have no resolving power
+
+ ----------------- Note -----------------
+
+ This is different than the following case
+
+ test: <<pred(LATEXT(1))>>? A B
+ | <<pred(LATEXT(1)>>? A C
+ ;
+
+ In this case there are two distinct predicates
+ which have exactly the same text. In the first
+ example there are two references to the same
+ predicate. The problem represented by this
+ grammar will be addressed later.
+
+#131. (Changed in 1.33MR11) Case insensitive command line options
+
+ Command line switches like "-CC" and keywords like "on", "off",
+ and "stdin" are no longer case sensitive in antlr, dlg, and sorcerer.
+
+#130. (Changed in 1.33MR11) Changed ANTLR_VERSION to int from string
+
+ The ANTLR_VERSION was not an integer, making it difficult to
+ perform conditional compilation based on the antlr version.
+
+ Henceforth, ANTLR_VERSION will be:
+
+ (base_version * 10000) + release number
+
+ thus 1.33MR11 will be: 133*100+11 = 13311
+
+ Suggested by Rainer Janssen (Rainer.Janssen@Informatik.Uni-Oldenburg.DE).
+
+#129. (Changed in 1.33MR11) Addition of ANTLR_VERSION to <parserName>.h
+
+ The following code is now inserted into <parserName>.h amd
+ stdpccts.h:
+
+ #ifndef ANTLR_VERSION
+ #define ANTLR_VERSION 13311
+ #endif
+
+ Suggested by Rainer Janssen (Rainer.Janssen@Informatik.Uni-Oldenburg.DE)
+
+#128. (Changed in 1.33MR11) Redundant predicate code in (<<pred>>? ...)+
+
+ Prior to 1.33MR11, the following grammar would generate
+ redundant tests for the "while" condition.
+
+ rule2 : (<<pred>>? X)+ X
+ | B
+ ;
+
+ The code would resemble:
+
+ if (LA(1)==X) {
+ if (pred) {
+ do {
+ if (!pred) {zzfailed_pred(" pred");}
+ zzmatch(X); zzCONSUME;
+ } while (LA(1)==X && pred && pred);
+ } else {...
+
+ With 1.33MR11 the redundant predicate test is omitted.
+
+#127. (Changed in 1.33MR11)
+
+ Count Syntax Errors Count DLG Errors
+ ------------------- ----------------
+
+ C++ mode ANTLRParser:: DLGLexerBase::
+ syntaxErrCount lexErrCount
+ C mode zzSyntaxErrCount zzLexErrCount
+
+ The C mode variables are global and initialized to 0.
+ They are *not* reset to 0 automatically when antlr is
+ restarted.
+
+ The C++ mode variables are public. They are initialized
+ to 0 by the constructors. They are *not* reset to 0 by the
+ ANTLRParser::init() method.
+
+ Suggested by Reinier van den Born (reinier@vnet.ibm.com).
+
+#126. (Changed in 1.33MR11) Addition of #first <<...>>
+
+ The #first <<...>> inserts the specified text in the output
+ files before any other #include statements required by pccts.
+ The only things before the #first text are comments and
+ a #define ANTLR_VERSION.
+
+ Requested by and Esa Pulkkinen (esap@cs.tut.fi) and Alexin
+ Zoltan (alexin@inf.u-szeged.hu).
+
+#125. (Changed in 1.33MR11) Lookahead for (guard)? && <<p>>? predicates
+
+ When implementing the new style of guard predicate (Item #113)
+ in 1.33MR10 I decided to temporarily ignore the problem of
+ computing the "narrowest" lookahead context.
+
+ Consider the following k=1 grammar:
+
+ start : a
+ | b
+ ;
+
+ a : (A)? && <<pred1(LATEXT(1))>>? ab ;
+ b : (B)? && <<pred2(LATEXT(1))>>? ab ;
+
+ ab : A | B ;
+
+ In MR10 the context for both "a" and "b" was {A B} because this is
+ the first set of rule "ab". Normally, this is not a problem because
+ the predicate which follows the guard inhibits any ambiguity report
+ by antlr.
+
+ In MR11 the first set for rule "a" is {A} and for rule "b" it is {B}.
+
+#124. A Note on the New "&&" Style Guarded Predicates
+
+ I've been asked several times, "What is the difference between
+ the old "=>" style guard predicates and the new style "&&" guard
+ predicates, and how do you choose one over the other" ?
+
+ The main difference is that the "=>" does not apply the
+ predicate if the context guard doesn't match, whereas
+ the && form always does. What is the significance ?
+
+ If you have a predicate which is not on the "leading edge"
+ it cannot be hoisted. Suppose you need a predicate that
+ looks at LA(2). You must introduce it manually. The
+ classic example is:
+
+ castExpr :
+ LP typeName RP
+ | ....
+ ;
+
+ typeName : <<isTypeName(LATEXT(1))>>? ID
+ | STRUCT ID
+ ;
+
+ The problem is that typeName isn't on the leading edge
+ of castExpr, so the predicate isTypeName won't be hoisted into
+ castExpr to help make a decision on which production to choose.
+
+ The *first* attempt to fix it is this:
+
+ castExpr :
+ <<isTypeName(LATEXT(2))>>?
+ LP typeName RP
+ | ....
+ ;
+
+ Unfortunately, this won't work because it ignores
+ the problem of STRUCT. The solution is to apply
+ isTypeName() in castExpr if LA(2) is an ID and
+ don't apply it when LA(2) is STRUCT:
+
+ castExpr :
+ (LP ID)? => <<isTypeName(LATEXT(2))>>?
+ LP typeName RP
+ | ....
+ ;
+
+ In conclusion, the "=>" style guarded predicate is
+ useful when:
+
+ a. the tokens required for the predicate
+ are not on the leading edge
+ b. there are alternatives in the expression
+ selected by the predicate for which the
+ predicate is inappropriate
+
+ If (b) were false, then one could use a simple
+ predicate (assuming "-prc on"):
+
+ castExpr :
+ <<isTypeName(LATEXT(2))>>?
+ LP typeName RP
+ | ....
+ ;
+
+ typeName : <<isTypeName(LATEXT(1))>>? ID
+ ;
+
+ So, when do you use the "&&" style guarded predicate ?
+
+ The new-style "&&" predicate should always be used with
+ predicate context. The context guard is in ADDITION to
+ the automatically computed context. Thus it useful for
+ predicates which depend on the token type for reasons
+ other than context.
+
+ The following example is contributed by Reinier van den Born
+ (reinier@vnet.ibm.com).
+
+ +-------------------------------------------------------------------------+
+ | This grammar has two ways to call functions: |
+ | |
+ | - a "standard" call syntax with parens and comma separated args |
+ | - a shell command like syntax (no parens and spacing separated args) |
+ | |
+ | The former also allows a variable to hold the name of the function, |
+ | the latter can also be used to call external commands. |
+ | |
+ | The grammar (simplified) looks like this: |
+ | |
+ | fun_call : ID "(" { expr ("," expr)* } ")" |
+ | /* ID is function name */ |
+ | | "@" ID "(" { expr ("," expr)* } ")" |
+ | /* ID is var containing fun name */ |
+ | ; |
+ | |
+ | command : ID expr* /* ID is function name */ |
+ | | path expr* /* path is external command name */ |
+ | ; |
+ | |
+ | path : ID /* left out slashes and such */ |
+ | | "@" ID /* ID is environment var */ |
+ | ; |
+ | |
+ | expr : .... |
+ | | "(" expr ")"; |
+ | |
+ | call : fun_call |
+ | | command |
+ | ; |
+ | |
+ | Obviously the call is wildly ambiguous. This is more or less how this |
+ | is to be resolved: |
+ | |
+ | A call begins with an ID or an @ followed by an ID. |
+ | |
+ | If it is an ID and if it is an ext. command name -> command |
+ | if followed by a paren -> fun_call |
+ | otherwise -> command |
+ | |
+ | If it is an @ and if the ID is a var name -> fun_call |
+ | otherwise -> command |
+ | |
+ | One can implement these rules quite neatly using && predicates: |
+ | |
+ | call : ("@" ID)? && <<isVarName(LT(2))>>? fun_call |
+ | | (ID)? && <<isExtCmdName>>? command |
+ | | (ID "(")? fun_call |
+ | | command |
+ | ; |
+ | |
+ | This can be done better, so it is not an ideal example, but it |
+ | conveys the principle. |
+ +-------------------------------------------------------------------------+
+
+#123. (Changed in 1.33MR11) Correct definition of operators in ATokPtr.h
+
+ The return value of operators in ANTLRTokenPtr:
+
+ changed: unsigned ... operator !=(...)
+ to: int ... operator != (...)
+ changed: unsigned ... operator ==(...)
+ to: int ... operator == (...)
+
+ Suggested by R.A. Nelson (cowboy@VNET.IBM.COM)
+
+#122. (Changed in 1.33MR11) Member functions to reset DLG in C++ mode
+
+ void DLGFileReset(FILE *f) { input = f; found_eof = 0; }
+ void DLGStringReset(DLGChar *s) { input = s; p = &input[0]; }
+
+ Supplied by R.A. Nelson (cowboy@VNET.IBM.COM)
+
+#121. (Changed in 1.33MR11) Another attempt to fix -o (output dir) option
+
+ Another attempt is made to improve the -o option of antlr, dlg,
+ and sorcerer. This one by JVincent (JVincent@novell.com).
+
+ The current rule:
+
+ a. If -o is not specified than any explicit directory
+ names are retained.
+
+ b. If -o is specified than the -o directory name overrides any
+ explicit directory names.
+
+ c. The directory name of the grammar file is *not* stripped
+ to create the main output file. However it is stil subject
+ to override by the -o directory name.
+
+#120. (Changed in 1.33MR11) "-info f" output to stdout rather than stderr
+
+ Added option 0 (e.g. "-info 0") which is a noop.
+
+#119. (Changed in 1.33MR11) Ambiguity aid for grammars
+
+ The user can ask for additional information on ambiguities reported
+ by antlr to stdout. At the moment, only one ambiguity report can
+ be created in an antlr run.
+
+ This feature is enabled using the "-aa" (Ambiguity Aid) option.
+
+ The following options control the reporting of ambiguities:
+
+ -aa ruleName Selects reporting by name of rule
+ -aa lineNumber Selects reporting by line number
+ (file name not compared)
+
+ -aam Selects "multiple" reporting for a token
+ in the intersection set of the
+ alternatives.
+
+ For instance, the token ID may appear dozens
+ of times in various paths as the program
+ explores the rules which are reachable from
+ the point of an ambiguity. With option -aam
+ every possible path the search program
+ encounters is reported.
+
+ Without -aam only the first encounter is
+ reported. This may result in incomplete
+ information, but the information may be
+ sufficient and much shorter.
+
+ -aad depth Selects the depth of the search.
+ The default value is 1.
+
+ The number of paths to be searched, and the
+ size of the report can grow geometrically
+ with the -ck value if a full search for all
+ contributions to the source of the ambiguity
+ is explored.
+
+ The depth represents the number of tokens
+ in the lookahead set which are matched against
+ the set of ambiguous tokens. A depth of 1
+ means that the search stops when a lookahead
+ sequence of just one token is matched.
+
+ A k=1 ck=6 grammar might generate 5,000 items
+ in a report if a full depth 6 search is made
+ with the Ambiguity Aid. The source of the
+ problem may be in the first token and obscured
+ by the volume of data - I hesitate to call
+ it information.
+
+ When the user selects a depth > 1, the search
+ is first performed at depth=1 for both
+ alternatives, then depth=2 for both alternatives,
+ etc.
+
+ Sample output for rule grammar in antlr.g itself:
+
+ +---------------------------------------------------------------------+
+ | Ambiguity Aid |
+ | |
+ | Choice 1: grammar/70 line 632 file a.g |
+ | Choice 2: grammar/82 line 644 file a.g |
+ | |
+ | Intersection of lookahead[1] sets: |
+ | |
+ | "\}" "class" "#errclass" "#tokclass" |
+ | |
+ | Choice:1 Depth:1 Group:1 ("#errclass") |
+ | 1 in (...)* block grammar/70 line 632 a.g |
+ | 2 to error grammar/73 line 635 a.g |
+ | 3 error error/1 line 894 a.g |
+ | 4 #token "#errclass" error/2 line 895 a.g |
+ | |
+ | Choice:1 Depth:1 Group:2 ("#tokclass") |
+ | 2 to tclass grammar/74 line 636 a.g |
+ | 3 tclass tclass/1 line 937 a.g |
+ | 4 #token "#tokclass" tclass/2 line 938 a.g |
+ | |
+ | Choice:1 Depth:1 Group:3 ("class") |
+ | 2 to class_def grammar/75 line 637 a.g |
+ | 3 class_def class_def/1 line 669 a.g |
+ | 4 #token "class" class_def/3 line 671 a.g |
+ | |
+ | Choice:1 Depth:1 Group:4 ("\}") |
+ | 2 #token "\}" grammar/76 line 638 a.g |
+ | |
+ | Choice:2 Depth:1 Group:5 ("#errclass") |
+ | 1 in (...)* block grammar/83 line 645 a.g |
+ | 2 to error grammar/93 line 655 a.g |
+ | 3 error error/1 line 894 a.g |
+ | 4 #token "#errclass" error/2 line 895 a.g |
+ | |
+ | Choice:2 Depth:1 Group:6 ("#tokclass") |
+ | 2 to tclass grammar/94 line 656 a.g |
+ | 3 tclass tclass/1 line 937 a.g |
+ | 4 #token "#tokclass" tclass/2 line 938 a.g |
+ | |
+ | Choice:2 Depth:1 Group:7 ("class") |
+ | 2 to class_def grammar/95 line 657 a.g |
+ | 3 class_def class_def/1 line 669 a.g |
+ | 4 #token "class" class_def/3 line 671 a.g |
+ | |
+ | Choice:2 Depth:1 Group:8 ("\}") |
+ | 2 #token "\}" grammar/96 line 658 a.g |
+ +---------------------------------------------------------------------+
+
+ For a linear lookahead set ambiguity (where k=1 or for k>1 but
+ when all lookahead sets [i] with i<k all have degree one) the
+ reports appear in the following order:
+
+ for (depth=1 ; depth <= "-aad depth" ; depth++) {
+ for (alternative=1; alternative <=2 ; alternative++) {
+ while (matches-are-found) {
+ group++;
+ print-report
+ };
+ };
+ };
+
+ For reporting a k-tuple ambiguity, the reports appear in the
+ following order:
+
+ for (depth=1 ; depth <= "-aad depth" ; depth++) {
+ while (matches-are-found) {
+ for (alternative=1; alternative <=2 ; alternative++) {
+ group++;
+ print-report
+ };
+ };
+ };
+
+ This is because matches are generated in different ways for
+ linear lookahead and k-tuples.
+
+#118. (Changed in 1.33MR11) DEC VMS makefile and VMS related changes
+
+ Revised makefiles for DEC/VMS operating system for antlr, dlg,
+ and sorcerer.
+
+ Reduced names of routines with external linkage to less than 32
+ characters to conform to DEC/VMS linker limitations.
+
+ Jean-Francois Pieronne discovered problems with dlg and antlr
+ due to the VMS linker not being case sensitive for names with
+ external linkage. In dlg the problem was with "className" and
+ "ClassName". In antlr the problem was with "GenExprSets" and
+ "genExprSets".
+
+ Added genmms, a version of genmk for the DEC/VMS version of make.
+ The source is in directory pccts/support/DECmms.
+
+ All VMS contributions by Jean-Francois Pieronne (jfp@iname.com).
+
+#117. (Changed in 1.33MR10) new EXPERIMENTAL predicate hoisting code
+
+ The hoisting of predicates into rules to create prediction
+ expressions is a problem in antlr. Consider the following
+ example (k=1 with -prc on):
+
+ start : (a)* "@" ;
+ a : b | c ;
+ b : <<isUpper(LATEXT(1))>>? A ;
+ c : A ;
+
+ Prior to 1.33MR10 the code generated for "start" would resemble:
+
+ while {
+ if (LA(1)==A &&
+ (!LA(1)==A || isUpper())) {
+ a();
+ }
+ };
+
+ This code is wrong because it makes rule "c" unreachable from
+ "start". The essence of the problem is that antlr fails to
+ recognize that there can be a valid alternative within "a" even
+ when the predicate <<isUpper(LATEXT(1))>>? is false.
+
+ In 1.33MR10 with -mrhoist the hoisting of the predicate into
+ "start" is suppressed because it recognizes that "c" can
+ cover all the cases where the predicate is false:
+
+ while {
+ if (LA(1)==A) {
+ a();
+ }
+ };
+
+ With the antlr "-info p" switch the user will receive information
+ about the predicate suppression in the generated file:
+
+ --------------------------------------------------------------
+ #if 0
+
+ Hoisting of predicate suppressed by alternative without predicate.
+ The alt without the predicate includes all cases where
+ the predicate is false.
+
+ WITH predicate: line 7 v1.g
+ WITHOUT predicate: line 7 v1.g
+
+ The context set for the predicate:
+
+ A
+
+ The lookahead set for the alt WITHOUT the semantic predicate:
+
+ A
+
+ The predicate:
+
+ pred << isUpper(LATEXT(1))>>?
+ depth=k=1 rule b line 9 v1.g
+ set context:
+ A
+ tree context: null
+
+ Chain of referenced rules:
+
+ #0 in rule start (line 5 v1.g) to rule a
+ #1 in rule a (line 7 v1.g)
+
+ #endif
+ --------------------------------------------------------------
+
+ A predicate can be suppressed by a combination of alternatives
+ which, taken together, cover a predicate:
+
+ start : (a)* "@" ;
+
+ a : b | ca | cb | cc ;
+
+ b : <<isUpper(LATEXT(1))>>? ( A | B | C ) ;
+
+ ca : A ;
+ cb : B ;
+ cc : C ;
+
+ Consider a more complex example in which "c" covers only part of
+ a predicate:
+
+ start : (a)* "@" ;
+
+ a : b
+ | c
+ ;
+
+ b : <<isUpper(LATEXT(1))>>?
+ ( A
+ | X
+ );
+
+ c : A
+ ;
+
+ Prior to 1.33MR10 the code generated for "start" would resemble:
+
+ while {
+ if ( (LA(1)==A || LA(1)==X) &&
+ (! (LA(1)==A || LA(1)==X) || isUpper()) {
+ a();
+ }
+ };
+
+ With 1.33MR10 and -mrhoist the predicate context is restricted to
+ the non-covered lookahead. The code resembles:
+
+ while {
+ if ( (LA(1)==A || LA(1)==X) &&
+ (! (LA(1)==X) || isUpper()) {
+ a();
+ }
+ };
+
+ With the antlr "-info p" switch the user will receive information
+ about the predicate restriction in the generated file:
+
+ --------------------------------------------------------------
+ #if 0
+
+ Restricting the context of a predicate because of overlap
+ in the lookahead set between the alternative with the
+ semantic predicate and one without
+ Without this restriction the alternative without the predicate
+ could not be reached when input matched the context of the
+ predicate and the predicate was false.
+
+ WITH predicate: line 11 v4.g
+ WITHOUT predicate: line 12 v4.g
+
+ The original context set for the predicate:
+
+ A X
+
+ The lookahead set for the alt WITHOUT the semantic predicate:
+
+ A
+
+ The intersection of the two sets
+
+ A
+
+ The original predicate:
+
+ pred << isUpper(LATEXT(1))>>?
+ depth=k=1 rule b line 15 v4.g
+ set context:
+ A X
+ tree context: null
+
+ The new (modified) form of the predicate:
+
+ pred << isUpper(LATEXT(1))>>?
+ depth=k=1 rule b line 15 v4.g
+ set context:
+ X
+ tree context: null
+
+ #endif
+ --------------------------------------------------------------
+
+ The bad news about -mrhoist:
+
+ (a) -mrhoist does not analyze predicates with lookahead
+ depth > 1.
+
+ (b) -mrhoist does not look past a guarded predicate to
+ find context which might cover other predicates.
+
+ For these cases you might want to use syntactic predicates.
+ When a semantic predicate fails during guess mode the guess
+ fails and the next alternative is tried.
+
+ Limitation (a) is illustrated by the following example:
+
+ start : (stmt)* EOF ;
+
+ stmt : cast
+ | expr
+ ;
+ cast : <<isTypename(LATEXT(2))>>? LP ID RP ;
+
+ expr : LP ID RP ;
+
+ This is not much different from the first example, except that
+ it requires two tokens of lookahead context to determine what
+ to do. This predicate is NOT suppressed because the current version
+ is unable to handle predicates with depth > 1.
+
+ A predicate can be combined with other predicates during hoisting.
+ In those cases the depth=1 predicates are still handled. Thus,
+ in the following example the isUpper() predicate will be suppressed
+ by line #4 when hoisted from "bizarre" into "start", but will still
+ be present in "bizarre" in order to predict "stmt".
+
+ start : (bizarre)* EOF ; // #1
+ // #2
+ bizarre : stmt // #3
+ | A // #4
+ ;
+
+ stmt : cast
+ | expr
+ ;
+
+ cast : <<isTypename(LATEXT(2))>>? LP ID RP ;
+
+ expr : LP ID RP ;
+ | <<isUpper(LATEXT(1))>>? A
+
+ Limitation (b) is illustrated by the following example of a
+ context guarded predicate:
+
+ rule : (A)? <<p>>? // #1
+ (A // #2
+ |B // #3
+ ) // #4
+ | <<q>> B // #5
+ ;
+
+ Recall that this means that when the lookahead is NOT A then
+ the predicate "p" is ignored and it attempts to match "A|B".
+ Ideally, the "B" at line #3 should suppress predicate "q".
+ However, the current version does not attempt to look past
+ the guard predicate to find context which might suppress other
+ predicates.
+
+ In some cases -mrhoist will lead to the reporting of ambiguities
+ which were not visible before:
+
+ start : (a)* "@";
+ a : bc | d;
+ bc : b | c ;
+
+ b : <<isUpper(LATEXT(1))>>? A;
+ c : A ;
+
+ d : A ;
+
+ In this case there is a true ambiguity in "a" between "bc" and "d"
+ which can both match "A". Without -mrhoist the predicate in "b"
+ is hoisted into "a" and there is no ambiguity reported. However,
+ with -mrhoist, the predicate in "b" is suppressed by "c" (as it
+ should be) making the ambiguity in "a" apparent.
+
+ The motivations for these changes were hoisting problems reported
+ by Reinier van den Born (reinier@vnet.ibm.com) and several others.
+
+#116. (Changed in 1.33MR10) C++ mode: tracein/traceout rule name is (const char *)
+
+ The prototype for C++ mode routine tracein (and traceout) has changed from
+ "char *" to "const char *".
+
+#115. (Changed in 1.33MR10) Using guess mode with exception handlers in C mode
+
+ The definition of the C mode macros zzmatch_wsig and zzsetmatch_wsig
+ neglected to consider guess mode. When control passed to the rule's
+ parse exception handler the routine would exit without ever closing the
+ guess block. This would lead to unpredictable behavior.
+
+ In 1.33MR10 the behavior of exceptions in C mode and C++ mode should be
+ identical.
+
+#114. (Changed in 1.33MR10) difference in [zz]resynch() between C and C++ modes
+
+ There was a slight difference in the way C and C++ mode resynchronized
+ following a parsing error. The C routine would sometimes skip an extra
+ token before attempting to resynchronize.
+
+ The C routine was changed to match the C++ routine.
+
+#113. (Changed in 1.33MR10) new context guarded pred: (g)? && <<p>>? expr
+
+ The existing context guarded predicate:
+
+ rule : (guard)? => <<p>>? expr
+ | next_alternative
+ ;
+
+ generates code which resembles:
+
+ if (lookahead(expr) && (!guard || pred)) {
+ expr()
+ } else ....
+
+ This is not suitable for some applications because it allows
+ expr() to be invoked when the predicate is false. This is
+ intentional because it is meant to mimic automatically computed
+ predicate context.
+
+ The new context guarded predicate uses the guard information
+ differently because it has a different goal. Consider:
+
+ rule : (guard)? && <<p>>? expr
+ | next_alternative
+ ;
+
+ The new style of context guarded predicate is equivalent to:
+
+ rule : <<guard==true && pred>>? expr
+ | next_alternative
+ ;
+
+ It generates code which resembles:
+
+ if (lookahead(expr) && guard && pred) {
+ expr();
+ } else ...
+
+ Both forms of guarded predicates severely restrict the form of
+ the context guard: it can contain no rule references, no
+ (...)*, no (...)+, and no {...}. It may contain token and
+ token class references, and alternation ("|").
+
+ Addition for 1.33MR11: in the token expression all tokens must
+ be at the same height of the token tree:
+
+ (A ( B | C))? && ... is ok (all height 2)
+ (A ( B | ))? && ... is not ok (some 1, some 2)
+ (A B C D | E F G H)? && ... is ok (all height 4)
+ (A B C D | E )? && ... is not ok (some 4, some 1)
+
+ This restriction is required in order to properly compute the lookahead
+ set for expressions like:
+
+ rule1 : (A B C)? && <<pred>>? rule2 ;
+ rule2 : (A|X) (B|Y) (C|Z);
+
+ This addition was suggested by Rienier van den Born (reinier@vnet.ibm.com)
+
+#112. (Changed in 1.33MR10) failed validation predicate in C guess mode
+
+ John Lilley (jlilley@empathy.com) suggested that failed validation
+ predicates abort a guess rather than reporting a failed error.
+ This was installed in C++ mode (Item #4). Only now was it noticed
+ that the fix was never installed for C mode.
+
+#111. (Changed in 1.33MR10) moved zzTRACEIN to before init action
+
+ When the antlr -gd switch is present antlr generates calls to
+ zzTRACEIN at the start of a rule and zzTRACEOUT at the exit
+ from a rule. Prior to 1.33MR10 Tthe call to zzTRACEIN was
+ after the init-action, which could cause confusion because the
+ init-actions were reported with the name of the enclosing rule,
+ rather than the active rule.
+
+#110. (Changed in 1.33MR10) antlr command line copied to generated file
+
+ The antlr command line is now copied to the generated file near
+ the start.
+
+#109. (Changed in 1.33MR10) improved trace information
+
+ The quality of the trace information provided by the "-gd"
+ switch has been improved significantly. Here is an example
+ of the output from a test program. It shows the rule name,
+ the first token of lookahead, the call depth, and the guess
+ status:
+
+ exit rule gusxx {"?"} depth 2
+ enter rule gusxx {"?"} depth 2
+ enter rule gus1 {"o"} depth 3 guessing
+ guess done - returning to rule gus1 {"o"} at depth 3
+ (guess mode continues - an enclosing guess is still active)
+ guess done - returning to rule gus1 {"Z"} at depth 3
+ (guess mode continues - an enclosing guess is still active)
+ exit rule gus1 {"Z"} depth 3 guessing
+ guess done - returning to rule gusxx {"o"} at depth 2 (guess mode ends)
+ enter rule gus1 {"o"} depth 3
+ guess done - returning to rule gus1 {"o"} at depth 3 (guess mode ends)
+ guess done - returning to rule gus1 {"Z"} at depth 3 (guess mode ends)
+ exit rule gus1 {"Z"} depth 3
+ line 1: syntax error at "Z" missing SC
+ ...
+
+ Rule trace reporting is controlled by the value of the integer
+ [zz]traceOptionValue: when it is positive tracing is enabled,
+ otherwise it is disabled. Tracing during guess mode is controlled
+ by the value of the integer [zz]traceGuessOptionValue. When
+ it is positive AND [zz]traceOptionValue is positive rule trace
+ is reported in guess mode.
+
+ The values of [zz]traceOptionValue and [zz]traceGuessOptionValue
+ can be adjusted by subroutine calls listed below.
+
+ Depending on the presence or absence of the antlr -gd switch
+ the variable [zz]traceOptionValueDefault is set to 0 or 1. When
+ the parser is initialized or [zz]traceReset() is called the
+ value of [zz]traceOptionValueDefault is copied to [zz]traceOptionValue.
+ The value of [zz]traceGuessOptionValue is always initialzed to 1,
+ but, as noted earlier, nothing will be reported unless
+ [zz]traceOptionValue is also positive.
+
+ When the parser state is saved/restored the value of the trace
+ variables are also saved/restored. If a restore causes a change in
+ reporting behavior from on to off or vice versa this will be reported.
+
+ When the -gd option is selected, the macro "#define zzTRACE_RULES"
+ is added to appropriate output files.
+
+ C++ mode
+ --------
+ int traceOption(int delta)
+ int traceGuessOption(int delta)
+ void traceReset()
+ int traceOptionValueDefault
+
+ C mode
+ --------
+ int zzTraceOption(int delta)
+ int zzTraceGuessOption(int delta)
+ void zzTraceReset()
+ int zzTraceOptionValueDefault
+
+ The argument "delta" is added to the traceOptionValue. To
+ turn on trace when inside a particular rule one:
+
+ rule : <<traceOption(+1);>>
+ (
+ rest-of-rule
+ )
+ <<traceOption(-1);>>
+ ; /* fail clause */ <<traceOption(-1);>>
+
+ One can use the same idea to turn *off* tracing within a
+ rule by using a delta of (-1).
+
+ An improvement in the rule trace was suggested by Sramji
+ Ramanathan (ps@kumaran.com).
+
+#108. A Note on Deallocation of Variables Allocated in Guess Mode
+
+ NOTE
+ ------------------------------------------------------
+ This mechanism only works for heap allocated variables
+ ------------------------------------------------------
+
+ The rewrite of the trace provides the machinery necessary
+ to properly free variables or undo actions following a
+ failed guess.
+
+ The macro zzUSER_GUESS_HOOK(guessSeq,zzrv) is expanded
+ as part of the zzGUESS macro. When a guess is opened
+ the value of zzrv is 0. When a longjmp() is executed to
+ undo the guess, the value of zzrv will be 1.
+
+ The macro zzUSER_GUESS_DONE_HOOK(guessSeq) is expanded
+ as part of the zzGUESS_DONE macro. This is executed
+ whether the guess succeeds or fails as part of closing
+ the guess.
+
+ The guessSeq is a sequence number which is assigned to each
+ guess and is incremented by 1 for each guess which becomes
+ active. It is needed by the user to associate the start of
+ a guess with the failure and/or completion (closing) of a
+ guess.
+
+ Guesses are nested. They must be closed in the reverse
+ of the order that they are opened.
+
+ In order to free memory used by a variable during a guess
+ a user must write a routine which can be called to
+ register the variable along with the current guess sequence
+ number provided by the zzUSER_GUESS_HOOK macro. If the guess
+ fails, all variables tagged with the corresponding guess
+ sequence number should be released. This is ugly, but
+ it would require a major rewrite of antlr 1.33 to use
+ some mechanism other than setjmp()/longjmp().
+
+ The order of calls for a *successful* guess would be:
+
+ zzUSER_GUESS_HOOK(guessSeq,0);
+ zzUSER_GUESS_DONE_HOOK(guessSeq);
+
+ The order of calls for a *failed* guess would be:
+
+ zzUSER_GUESS_HOOK(guessSeq,0);
+ zzUSER_GUESS_HOOK(guessSeq,1);
+ zzUSER_GUESS_DONE_HOOK(guessSeq);
+
+ The default definitions of these macros are empty strings.
+
+ Here is an example in C++ mode. The zzUSER_GUESS_HOOK and
+ zzUSER_GUESS_DONE_HOOK macros and myGuessHook() routine
+ can be used without change in both C and C++ versions.
+
+ ----------------------------------------------------------------------
+ <<
+
+ #include "AToken.h"
+
+ typedef ANTLRCommonToken ANTLRToken;
+
+ #include "DLGLexer.h"
+
+ int main() {
+
+ {
+ DLGFileInput in(stdin);
+ DLGLexer lexer(&in,2000);
+ ANTLRTokenBuffer pipe(&lexer,1);
+ ANTLRCommonToken aToken;
+ P parser(&pipe);
+
+ lexer.setToken(&aToken);
+ parser.init();
+ parser.start();
+ };
+
+ fclose(stdin);
+ fclose(stdout);
+ return 0;
+ }
+
+ >>
+
+ <<
+ char *s=NULL;
+
+ #undef zzUSER_GUESS_HOOK
+ #define zzUSER_GUESS_HOOK(guessSeq,zzrv) myGuessHook(guessSeq,zzrv);
+ #undef zzUSER_GUESS_DONE_HOOK
+ #define zzUSER_GUESS_DONE_HOOK(guessSeq) myGuessHook(guessSeq,2);
+
+ void myGuessHook(int guessSeq,int zzrv) {
+ if (zzrv == 0) {
+ fprintf(stderr,"User hook: starting guess #%d\n",guessSeq);
+ } else if (zzrv == 1) {
+ free (s);
+ s=NULL;
+ fprintf(stderr,"User hook: failed guess #%d\n",guessSeq);
+ } else if (zzrv == 2) {
+ free (s);
+ s=NULL;
+ fprintf(stderr,"User hook: ending guess #%d\n",guessSeq);
+ };
+ }
+
+ >>
+
+ #token A "a"
+ #token "[\t \ \n]" <<skip();>>
+
+ class P {
+
+ start : (top)+
+ ;
+
+ top : (which) ? <<fprintf(stderr,"%s is a which\n",s); free(s); s=NULL; >>
+ | other <<fprintf(stderr,"%s is an other\n",s); free(s); s=NULL; >>
+ ; <<if (s != NULL) free(s); s=NULL; >>
+
+ which : which2
+ ;
+
+ which2 : which3
+ ;
+ which3
+ : (label)? <<fprintf(stderr,"%s is a label\n",s);>>
+ | (global)? <<fprintf(stderr,"%s is a global\n",s);>>
+ | (exclamation)? <<fprintf(stderr,"%s is an exclamation\n",s);>>
+ ;
+
+ label : <<s=strdup(LT(1)->getText());>> A ":" ;
+
+ global : <<s=strdup(LT(1)->getText());>> A "::" ;
+
+ exclamation : <<s=strdup(LT(1)->getText());>> A "!" ;
+
+ other : <<s=strdup(LT(1)->getText());>> "other" ;
+
+ }
+ ----------------------------------------------------------------------
+
+ This is a silly example, but illustrates the idea. For the input
+ "a ::" with tracing enabled the output begins:
+
+ ----------------------------------------------------------------------
+ enter rule "start" depth 1
+ enter rule "top" depth 2
+ User hook: starting guess #1
+ enter rule "which" depth 3 guessing
+ enter rule "which2" depth 4 guessing
+ enter rule "which3" depth 5 guessing
+ User hook: starting guess #2
+ enter rule "label" depth 6 guessing
+ guess failed
+ User hook: failed guess #2
+ guess done - returning to rule "which3" at depth 5 (guess mode continues
+ - an enclosing guess is still active)
+ User hook: ending guess #2
+ User hook: starting guess #3
+ enter rule "global" depth 6 guessing
+ exit rule "global" depth 6 guessing
+ guess done - returning to rule "which3" at depth 5 (guess mode continues
+ - an enclosing guess is still active)
+ User hook: ending guess #3
+ enter rule "global" depth 6 guessing
+ exit rule "global" depth 6 guessing
+ exit rule "which3" depth 5 guessing
+ exit rule "which2" depth 4 guessing
+ exit rule "which" depth 3 guessing
+ guess done - returning to rule "top" at depth 2 (guess mode ends)
+ User hook: ending guess #1
+ enter rule "which" depth 3
+ .....
+ ----------------------------------------------------------------------
+
+ Remember:
+
+ (a) Only init-actions are executed during guess mode.
+ (b) A rule can be invoked multiple times during guess mode.
+ (c) If the guess succeeds the rule will be called once more
+ without guess mode so that normal actions will be executed.
+ This means that the init-action might need to distinguish
+ between guess mode and non-guess mode using the variable
+ [zz]guessing.
+
+#107. (Changed in 1.33MR10) construction of ASTs in guess mode
+
+ Prior to 1.33MR10, when using automatic AST construction in C++
+ mode for a rule, an AST would be constructed for elements of the
+ rule even while in guess mode. In MR10 this no longer occurs.
+
+#106. (Changed in 1.33MR10) guess variable confusion
+
+ In C++ mode a guess which failed always restored the parser state
+ using zzGUESS_DONE as part of zzGUESS_FAIL. Prior to 1.33MR10,
+ C mode required an explicit call to zzGUESS_DONE after the
+ call to zzGUESS_FAIL.
+
+ Consider:
+
+ rule : (alpha)? beta
+ | ...
+ ;
+
+ The generated code resembles:
+
+ zzGUESS
+ if (!zzrv && LA(1)==ID) { <==== line #1
+ alpha
+ zzGUESS_DONE
+ beta
+ } else {
+ if (! zzrv) zzGUESS_DONE <==== line #2a
+ ....
+
+ However, in some cases line #2 was rendered:
+
+ if (guessing) zzGUESS_DONE <==== line #2b
+
+ This would work for simple test cases, but would fail in
+ some cases where there was a guess while another guess was active.
+ One kind of failure would be to match up the zzGUESS_DONE at line
+ #2b with the "outer" guess which was still active. The outer
+ guess would "succeed" when only the inner guess should have
+ succeeded.
+
+ In 1.33MR10 the behavior of zzGUESS and zzGUESS_FAIL in C and
+ and C++ mode should be identical.
+
+ The same problem appears in 1.33 vanilla in some places. For
+ example:
+
+ start : { (sub)? } ;
+
+ or:
+
+ start : (
+ B
+ | ( sub )?
+ | C
+ )+
+ ;
+
+ generates incorrect code.
+
+ The general principle is:
+
+ (a) use [zz]guessing only when deciding between a call to zzFAIL
+ or zzGUESS_FAIL
+
+ (b) use zzrv in all other cases
+
+ This problem was discovered while testing changes to item #105.
+ I believe this is now fixed. My apologies.
+
+#105. (Changed in 1.33MR10) guess block as single alt of (...)+
+
+ Prior to 1.33MR10 the following constructs:
+
+ rule_plus : (
+ (sub)?
+ )+
+ ;
+
+ rule_star : (
+ (sub)?
+ )*
+ ;
+
+ generated incorrect code for the guess block (which could result
+ in runtime errors) because of an incorrect optimization of a
+ block with only a single alternative.
+
+ The fix caused some changes to the fix described in Item #49
+ because there are now three code generation sequences for (...)+
+ blocks containing a guess block:
+
+ a. single alternative which is a guess block
+ b. multiple alternatives in which the last is a guess block
+ c. all other cases
+
+ Forms like "rule_star" can have unexpected behavior when there
+ is a syntax error: if the subrule "sub" is not matched *exactly*
+ then "rule_star" will consume no tokens.
+
+ Reported by Esa Pulkkinen (esap@cs.tut.fi).
+
+#104. (Changed in 1.33MR10) -o option for dlg
+
+ There was problem with the code added by item #74 to handle the
+ -o option of dlg. This should fix it.
+
+#103. (Changed in 1.33MR10) ANDed semantic predicates
+
+ Rescinded.
+
+ The optimization was a mistake.
+ The resulting problem is described in Item #150.
+
+#102. (Changed in 1.33MR10) allow "class parser : .... {"
+
+ The syntax of the class statement ("class parser-name {")
+ has been extended to allow for the specification of base
+ classes. An arbirtrary number of tokens may now appear
+ between the class name and the "{". They are output
+ again when the class declaration is generated. For
+ example:
+
+ class Parser : public MyBaseClassANTLRparser {
+
+ This was suggested by a user, but I don't have a record
+ of who it was.
+
+#101. (Changed in 1.33MR10) antlr -info command line switch
+
+ -info
+
+ p - extra predicate information in generated file
+
+ t - information about tnode use:
+ at the end of each rule in generated file
+ summary on stderr at end of program
+
+ m - monitor progress
+ prints name of each rule as it is started
+ flushes output at start of each rule
+
+ f - first/follow set information to stdout
+
+ 0 - no operation (added in 1.33MR11)
+
+ The options may be combined and may appear in any order.
+ For example:
+
+ antlr -info ptm -CC -gt -mrhoist on mygrammar.g
+
+#100a. (Changed in 1.33MR10) Predicate tree simplification
+
+ When the same predicates can be referenced in more than one
+ alternative of a block large predicate trees can be formed.
+
+ The difference that these optimizations make is so dramatic
+ that I have decided to use it even when -mrhoist is not selected.
+
+ Consider the following grammar:
+
+ start : ( all )* ;
+
+ all : a
+ | d
+ | e
+ | f
+ ;
+
+ a : c A B
+ | c A C
+ ;
+
+ c : <<AAA(LATEXT(2))>>?
+ ;
+
+ d : <<BBB(LATEXT(2))>>? B C
+ ;
+
+ e : <<CCC(LATEXT(2))>>? B C
+ ;
+
+ f : e X Y
+ ;
+
+ In rule "a" there is a reference to rule "c" in both alternatives.
+ The length of the predicate AAA is k=2 and it can be followed in
+ alternative 1 only by (A B) while in alternative 2 it can be
+ followed only by (A C). Thus they do not have identical context.
+
+ In rule "all" the alternatives which refer to rules "e" and "f" allow
+ elimination of the duplicate reference to predicate CCC.
+
+ The table below summarized the kind of simplification performed by
+ 1.33MR10. In the table, X and Y stand for single predicates
+ (not trees).
+
+ (OR X (OR Y (OR Z))) => (OR X Y Z)
+ (AND X (AND Y (AND Z))) => (AND X Y Z)
+
+ (OR X (... (OR X Y) ... )) => (OR X (... Y ... ))
+ (AND X (... (AND X Y) ... )) => (AND X (... Y ... ))
+ (OR X (... (AND X Y) ... )) => (OR X (... ... ))
+ (AND X (... (OR X Y) ... )) => (AND X (... ... ))
+
+ (AND X) => X
+ (OR X) => X
+
+ In a test with a complex grammar for a real application, a predicate
+ tree with six OR nodes and 12 leaves was reduced to "(OR X Y Z)".
+
+ In 1.33MR10 there is a greater effort to release memory used
+ by predicates once they are no longer in use.
+
+#100b. (Changed in 1.33MR10) Suppression of extra predicate tests
+
+ The following optimizations require that -mrhoist be selected.
+
+ It is relatively easy to optimize the code generated for predicate
+ gates when they are of the form:
+
+ (AND X Y Z ...)
+ or (OR X Y Z ...)
+
+ where X, Y, Z, and "..." represent individual predicates (leaves) not
+ predicate trees.
+
+ If the predicate is an AND the contexts of the X, Y, Z, etc. are
+ ANDed together to create a single Tree context for the group and
+ context tests for the individual predicates are suppressed:
+
+ --------------------------------------------------
+ Note: This was incorrect. The contexts should be
+ ORed together. This has been fixed. A more
+ complete description is available in item #152.
+ ---------------------------------------------------
+
+ Optimization 1: (AND X Y Z ...)
+
+ Suppose the context for Xtest is LA(1)==LP and the context for
+ Ytest is LA(1)==LP && LA(2)==ID.
+
+ Without the optimization the code would resemble:
+
+ if (lookaheadContext &&
+ !(LA(1)==LP && LA(1)==LP && LA(2)==ID) ||
+ ( (! LA(1)==LP || Xtest) &&
+ (! (LA(1)==LP || LA(2)==ID) || Xtest)
+ )) {...
+
+ With the -mrhoist optimization the code would resemble:
+
+ if (lookaheadContext &&
+ ! (LA(1)==LP && LA(2)==ID) || (Xtest && Ytest) {...
+
+ Optimization 2: (OR X Y Z ...) with identical contexts
+
+ Suppose the context for Xtest is LA(1)==ID and for Ytest
+ the context is also LA(1)==ID.
+
+ Without the optimization the code would resemble:
+
+ if (lookaheadContext &&
+ ! (LA(1)==ID || LA(1)==ID) ||
+ (LA(1)==ID && Xtest) ||
+ (LA(1)==ID && Ytest) {...
+
+ With the -mrhoist optimization the code would resemble:
+
+ if (lookaheadContext &&
+ (! LA(1)==ID) || (Xtest || Ytest) {...
+
+ Optimization 3: (OR X Y Z ...) with distinct contexts
+
+ Suppose the context for Xtest is LA(1)==ID and for Ytest
+ the context is LA(1)==LP.
+
+ Without the optimization the code would resemble:
+
+ if (lookaheadContext &&
+ ! (LA(1)==ID || LA(1)==LP) ||
+ (LA(1)==ID && Xtest) ||
+ (LA(1)==LP && Ytest) {...
+
+ With the -mrhoist optimization the code would resemble:
+
+ if (lookaheadContext &&
+ (zzpf=0,
+ (LA(1)==ID && (zzpf=1) && Xtest) ||
+ (LA(1)==LP && (zzpf=1) && Ytest) ||
+ !zzpf) {
+
+ These may appear to be of similar complexity at first,
+ but the non-optimized version contains two tests of each
+ context while the optimized version contains only one
+ such test, as well as eliminating some of the inverted
+ logic (" !(...) || ").
+
+ Optimization 4: Computation of predicate gate trees
+
+ When generating code for the gates of predicate expressions
+ antlr 1.33 vanilla uses a recursive procedure to generate
+ "&&" and "||" expressions for testing the lookahead. As each
+ layer of the predicate tree is exposed a new set of "&&" and
+ "||" expressions on the lookahead are generated. In many
+ cases the lookahead being tested has already been tested.
+
+ With -mrhoist a lookahead tree is computed for the entire
+ lookahead expression. This means that predicates with identical
+ context or context which is a subset of another predicate's
+ context disappear.
+
+ This is especially important for predicates formed by rules
+ like the following:
+
+ uppperCaseVowel : <<isUpperCase(LATEXT(1))>>? vowel;
+ vowel: : <<isVowel(LATEXT(1))>>? LETTERS;
+
+ These predicates are combined using AND since both must be
+ satisfied for rule upperCaseVowel. They have identical
+ context which makes this optimization very effective.
+
+ The affect of Items #100a and #100b together can be dramatic. In
+ a very large (but real world) grammar one particular predicate
+ expression was reduced from an (unreadable) 50 predicate leaves,
+ 195 LA(1) terms, and 5500 characters to an (easily comprehensible)
+ 3 predicate leaves (all different) and a *single* LA(1) term.
+
+#99. (Changed in 1.33MR10) Code generation for expression trees
+
+ Expression trees are used for k>1 grammars and predicates with
+ lookahead depth >1. This optimization must be enabled using
+ "-mrhoist on". (Clarification added for 1.33MR11).
+
+ In the processing of expression trees, antlr can generate long chains
+ of token comparisons. Prior to 1.33MR10 there were many redundant
+ parenthesis which caused problems for compilers which could handle
+ expressions of only limited complexity. For example, to test an
+ expression tree (root R A B C D), antlr would generate something
+ resembling:
+
+ (LA(1)==R && (LA(2)==A || (LA(2)==B || (LA(2)==C || LA(2)==D)))))
+
+ If there were twenty tokens to test then there would be twenty
+ parenthesis at the end of the expression.
+
+ In 1.33MR10 the generated code for tree expressions resembles:
+
+ (LA(1)==R && (LA(2)==A || LA(2)==B || LA(2)==C || LA(2)==D))
+
+ For "complex" expressions the output is indented to reflect the LA
+ number being tested:
+
+ (LA(1)==R
+ && (LA(2)==A || LA(2)==B || LA(2)==C || LA(2)==D
+ || LA(2)==E || LA(2)==F)
+ || LA(1)==S
+ && (LA(2)==G || LA(2)==H))
+
+
+ Suggested by S. Bochnak (S.Bochnak@@microTool.com.pl),
+
+#98. (Changed in 1.33MR10) Option "-info p"
+
+ When the user selects option "-info p" the program will generate
+ detailed information about predicates. If the user selects
+ "-mrhoist on" additional detail will be provided explaining
+ the promotion and suppression of predicates. The output is part
+ of the generated file and sandwiched between #if 0/#endif statements.
+
+ Consider the following k=1 grammar:
+
+ start : ( all ) * ;
+
+ all : ( a
+ | b
+ )
+ ;
+
+ a : c B
+ ;
+
+ c : <<LATEXT(1)>>?
+ | B
+ ;
+
+ b : <<LATEXT(1)>>? X
+ ;
+
+ Below is an excerpt of the output for rule "start" for the three
+ predicate options (off, on, and maintenance release style hoisting).
+
+ For those who do not wish to use the "-mrhoist on" option for code
+ generation the option can be used in a "diagnostic" mode to provide
+ valuable information:
+
+ a. where one should insert null actions to inhibit hoisting
+ b. a chain of rule references which shows where predicates are
+ being hoisted
+
+ ======================================================================
+ Example of "-info p" with "-mrhoist on"
+ ======================================================================
+ #if 0
+
+ Hoisting of predicate suppressed by alternative without predicate.
+ The alt without the predicate includes all cases where the
+ predicate is false.
+
+ WITH predicate: line 11 v36.g
+ WITHOUT predicate: line 12 v36.g
+
+ The context set for the predicate:
+
+ B
+
+ The lookahead set for alt WITHOUT the semantic predicate:
+
+ B
+
+ The predicate:
+
+ pred << LATEXT(1)>>? depth=k=1 rule c line 11 v36.g
+
+ set context:
+ B
+ tree context: null
+
+ Chain of referenced rules:
+
+ #0 in rule start (line 1 v36.g) to rule all
+ #1 in rule all (line 3 v36.g) to rule a
+ #2 in rule a (line 8 v36.g) to rule c
+ #3 in rule c (line 11 v36.g)
+
+ #endif
+ &&
+ #if 0
+
+ pred << LATEXT(1)>>? depth=k=1 rule b line 15 v36.g
+
+ set context:
+ X
+ tree context: null
+
+ #endif
+ ======================================================================
+ Example of "-info p" with the default -prc setting ( "-prc off")
+ ======================================================================
+ #if 0
+
+ OR
+ pred << LATEXT(1)>>? depth=k=1 rule c line 11 v36.g
+
+ set context:
+ nil
+ tree context: null
+
+ pred << LATEXT(1)>>? depth=k=1 rule b line 15 v36.g
+
+ set context:
+ nil
+ tree context: null
+
+ #endif
+ ======================================================================
+ Example of "-info p" with "-prc on" and "-mrhoist off"
+ ======================================================================
+ #if 0
+
+ OR
+ pred << LATEXT(1)>>? depth=k=1 rule c line 11 v36.g
+
+ set context:
+ B
+ tree context: null
+
+ pred << LATEXT(1)>>? depth=k=1 rule b line 15 v36.g
+
+ set context:
+ X
+ tree context: null
+
+ #endif
+ ======================================================================
+
+#97. (Fixed in 1.33MR10) "Predicate applied for more than one ... "
+
+ In 1.33 vanilla, the grammar listed below produced this message for
+ the first alternative (only) of rule "b":
+
+ warning: predicate applied for >1 lookahead 1-sequences
+ [you may only want one lookahead 1-sequence to apply.
+ Try using a context guard '(...)? =>'
+
+ In 1.33MR10 the message is issued for both alternatives.
+
+ top : (a)*;
+ a : b | c ;
+
+ b : <<PPP(LATEXT(1))>>? ( AAA | BBB )
+ | <<QQQ(LATEXT(1))>>? ( XXX | YYY )
+ ;
+
+ c : AAA | XXX;
+
+#96. (Fixed in 1.33MR10) Guard predicates ignored when -prc off
+
+ Prior to 1.33MR10, guard predicate code was not generated unless
+ "-prc on" was selected.
+
+ This was incorrect, since "-prc off" (the default) is supposed to
+ disable only AUTOMATIC computation of predicate context, not the
+ programmer specified context supplied by guard predicates.
+
+#95. (Fixed in 1.33MR10) Predicate guard context length was k, not max(k,ck)
+
+ Prior to 1.33MR10, predicate guards were computed to k tokens rather
+ than max(k,ck). Consider the following grammar:
+
+ a : ( A B C)? => <<AAA(LATEXT(1))>>? (A|X) (B|Y) (C|Z) ;
+
+ The code generated by 1.33 vanilla with "-k 1 -ck 3 -prc on"
+ for the predicate in "a" resembles:
+
+ if ( (! LA(1)==A) || AAA(LATEXT(1))) {...
+
+ With 1.33MR10 and the same options the code resembles:
+
+ if ( (! (LA(1)==A && LA(2)==B && LA(3)==C) || AAA(LATEXT(1))) {...
+
+#94. (Fixed in 1.33MR10) Predicates followed by rule references
+
+ Prior to 1.33MR10, a semantic predicate which referenced a token
+ which was off the end of the rule caused an incomplete context
+ to be computed (with "-prc on") for the predicate under some circum-
+ stances. In some cases this manifested itself as illegal C code
+ (e.g. "LA(2)==[Ep](1)" in the k=2 examples below:
+
+ all : ( a ) *;
+
+ a : <<AAA(LATEXT(2))>>? ID X
+ | <<BBB(LATEXT(2))>>? Y
+ | Z
+ ;
+
+ This might also occur when the semantic predicate was followed
+ by a rule reference which was shorter than the length of the
+ semantic predicate:
+
+ all : ( a ) *;
+
+ a : <<AAA(LATEXT(2))>>? ID X
+ | <<BBB(LATEXT(2))>>? y
+ | Z
+ ;
+
+ y : Y ;
+
+ Depending on circumstance, the resulting context might be too
+ generous because it was too short, or too restrictive because
+ of missing alternatives.
+
+#93. (Changed in 1.33MR10) Definition of Purify macro
+
+ Ofer Ben-Ami (gremlin@cs.huji.ac.il) has supplied a definition
+ for the Purify macro:
+
+ #define PURIFY(r, s) memset((char *) &(r), '\0', (s));
+
+ Note: This may not be the right thing to do for C++ objects that
+ have constructors. Reported by Bonny Rais (bonny@werple.net.au).
+
+ For those cases one should #define PURIFY to an empty macro in the
+ #header or #first actions.
+
+#92. (Fixed in 1.33MR10) Guarded predicates and hoisting
+
+ When a guarded predicate participates in hoisting it is linked into
+ a predicate expression tree. Prior to 1.33MR10 this link was never
+ cleared and the next time the guard was used to construct a new
+ tree the link could contain a spurious reference to another element
+ which had previosly been joined to it in the semantic predicate tree.
+
+ For example:
+
+ start : ( all ) *;
+ all : ( a | b ) ;
+
+ start2 : ( all2 ) *;
+ all2 : ( a ) ;
+
+ a : (A)? => <<AAA(LATEXT(1))>>? A ;
+ b : (B)? => <<BBB(LATEXT(1))>>? B ;
+
+ Prior to 1.33MR10 the code for "start2" would include a spurious
+ reference to the BBB predicate which was left from constructing
+ the predicate tree for rule "start" (i.e. or(AAA,BBB) ).
+
+ In 1.33MR10 this problem is avoided by cloning the original guard
+ each time it is linked into a predicate tree.
+
+#91. (Changed in 1.33MR10) Extensive changes to semantic pred hoisting
+
+ ============================================
+ This has been rendered obsolete by Item #117
+ ============================================
+
+#90. (Fixed in 1.33MR10) Semantic pred with LT(i) and i>max(k,ck)
+
+ There is a bug in antlr 1.33 vanilla and all maintenance releases
+ prior to 1.33MR10 which allows semantic predicates to reference
+ an LT(i) or LATEXT(i) where i is larger than max(k,ck). When
+ this occurs antlr will attempt to mark the ith element of an array
+ in which there are only max(k,ck) elements. The result cannot
+ be predicted.
+
+ Using LT(i) or LATEXT(i) for i>max(k,ck) is reported as an error
+ in 1.33MR10.
+
+#89. Rescinded
+
+#88. (Fixed in 1.33MR10) Tokens used in semantic predicates in guess mode
+
+ Consider the behavior of a semantic predicate during guess mode:
+
+ rule : a:A (
+ <<test($a)>>? b:B
+ | c:C
+ );
+
+ Prior to MR10 the assignment of the token or attribute to
+ $a did not occur during guess mode, which would cause the
+ semantic predicate to misbehave because $a would be null.
+
+ In 1.33MR10 a semantic predicate with a reference to an
+ element label (such as $a) forces the assignment to take
+ place even in guess mode.
+
+ In order to work, this fix REQUIRES use of the $label format
+ for token pointers and attributes referenced in semantic
+ predicates.
+
+ The fix does not apply to semantic predicates using the
+ numeric form to refer to attributes (e.g. <<test($1)>>?).
+ The user will receive a warning for this case.
+
+ Reported by Rob Trout (trout@mcs.cs.kent.edu).
+
+#87. (Fixed in 1.33MR10) Malformed guard predicates
+
+ Context guard predicates may contain only references to
+ tokens. They may not contain references to (...)+ and
+ (...)* blocks. This is now checked. This replaces the
+ fatal error message in item #78 with an appropriate
+ (non-fatal) error messge.
+
+ In theory, context guards should be allowed to reference
+ rules. However, I have not had time to fix this.
+ Evaluation of the guard takes place before all rules have
+ been read, making it difficult to resolve a forward reference
+ to rule "zzz" - it hasn't been read yet ! To postpone evaluation
+ of the guard until all rules have been read is too much
+ for the moment.
+
+#86. (Fixed in 1.33MR10) Unequal set size in set_sub
+
+ Routine set_sub() in pccts/support/set/set.h did not work
+ correctly when the sets were of unequal sizes. Rewrote
+ set_equ to make it simpler and remove unnecessary and
+ expensive calls to set_deg(). This routine was not used
+ in 1.33 vanila.
+
+#85. (Changed in 1.33MR10) Allow redefinition of MaxNumFiles
+
+ Raised the maximum number of input files to 99 from 20.
+ Put a #ifndef/#endif around the "#define MaxNumFiles 99".
+
+#84. (Fixed in 1.33MR10) Initialize zzBadTok in macro zzRULE
+
+ Initialize zzBadTok to NULL in zzRULE macro of AParser.h.
+ in order to get rid of warning messages.
+
+#83. (Fixed in 1.33MR10) False warnings with -w2 for #tokclass
+
+ When -w2 is selected antlr gives inappropriate warnings about
+ #tokclass names not having any associated regular expressions.
+ Since a #tokclass is not a "real" token it will never have an
+ associated regular expression and there should be no warning.
+
+ Reported by Derek Pappas (derek.pappas@eng.sun.com)
+
+#82. (Fixed in 1.33MR10) Computation of follow sets with multiple cycles
+
+ Reinier van den Born (reinier@vnet.ibm.com) reported a problem
+ in the computation of follow sets by antlr. The problem (bug)
+ exists in 1.33 vanilla and all maintenance releases prior to 1.33MR10.
+
+ The problem involves the computation of follow sets when there are
+ cycles - rules which have mutual references. I believe the problem
+ is restricted to cases where there is more than one cycle AND
+ elements of those cycles have rules in common. Even when this
+ occurs it may not affect the code generated - but it might. It
+ might also lead to undetected ambiguities.
+
+ There were no changes in antlr or dlg output from the revised version.
+
+ The following fragment demonstates the problem by giving different
+ follow sets (option -pa) for var_access when built with k=1 and ck=2 on
+ 1.33 vanilla and 1.33MR10:
+
+ echo_statement : ECHO ( echo_expr )*
+ ;
+
+ echo_expr : ( command )?
+ | expression
+ ;
+
+ command : IDENTIFIER
+ { concat }
+ ;
+
+ expression : operand ( OPERATOR operand )*
+ ;
+
+ operand : value
+ | START command END
+ ;
+
+ value : concat
+ | TYPE operand
+ ;
+
+ concat : var_access { CONCAT value }
+ ;
+
+ var_access : IDENTIFIER { INDEX }
+
+ ;
+#81. (Changed in 1.33MR10) C mode use of attributes and ASTs
+
+ Reported by Isaac Clark (irclark@mindspring.com).
+
+ C mode code ignores attributes returned by rules which are
+ referenced using element labels when ASTs are enabled (-gt option).
+
+ 1. start : r:rule t:Token <<$start=$r;>>
+
+ The $r refrence will not work when combined with
+ the -gt option.
+
+ 2. start : t:Token <<$start=$t;>>
+
+ The $t reference works in all cases.
+
+ 3. start : rule <<$0=$1;>>
+
+ Numeric labels work in all cases.
+
+ With MR10 the user will receive an error message for case 1 when
+ the -gt option is used.
+
+#80. (Fixed in 1.33MR10) (...)? as last alternative of block
+
+ A construct like the following:
+
+ rule : a
+ | (b)?
+ ;
+
+ does not make sense because there is no alternative when
+ the guess block fails. This is now reported as a warning
+ to the user.
+
+ Previously, there was a code generation error for this case:
+ the guess block was not "closed" when the guess failed.
+ This could cause an infinite loop or other problems. This
+ is now fixed.
+
+ Example problem:
+
+ #header<<
+ #include <stdio.h>
+ #include "charptr.h"
+ >>
+
+ <<
+ #include "charptr.c"
+ main ()
+ {
+ ANTLR(start(),stdin);
+ }
+ >>
+
+ #token "[\ \t]+" << zzskip(); >>
+ #token "[\n]" << zzline++; zzskip(); >>
+
+ #token Word "[a-z]+"
+ #token Number "[0-9]+"
+
+
+ start : (test1)?
+ | (test2)?
+ ;
+ test1 : (Word Word Word Word)?
+ | (Word Word Word Number)?
+ ;
+ test2 : (Word Word Number Word)?
+ | (Word Word Number Number)?
+ ;
+
+ Test data which caused infinite loop:
+
+ a 1 a a
+
+#79. (Changed in 1.33MR10) Use of -fh with multiple parsers
+
+ Previously, antlr always used the pre-processor symbol
+ STDPCCTS_H as a gate for the file stdpccts.h. This
+ caused problems when there were multiple parsers defined
+ because they used the same gate symbol.
+
+ In 1.33MR10, the -fh filename is used to generate the
+ gate file for stdpccts.h. For instance:
+
+ antlr -fh std_parser1.h
+
+ generates the pre-processor symbol "STDPCCTS_std_parser1_H".
+
+ Reported by Ramanathan Santhanam (ps@kumaran.com).
+
+#78. (Changed in 1.33MR9) Guard predicates that refer to rules
+
+ ------------------------
+ Please refer to Item #87
+ ------------------------
+
+ Guard predicates are processed during an early phase
+ of antlr (during parsing) before all data structures
+ are completed.
+
+ There is an apparent bug in earlier versions of 1.33
+ which caused guard predicates which contained references
+ to rules (rather than tokens) to reference a structure
+ which hadn't yet been initialized.
+
+ In some cases (perhaps all cases) references to rules
+ in guard predicates resulted in the use of "garbage".
+
+#79. (Changed in 1.33MR9) Jeff Vincent (JVincent@novell.com)
+
+ Previously, the maximum length file name was set
+ arbitrarily to 300 characters in antlr, dlg, and sorcerer.
+
+ The config.h file now attempts to define the maximum length
+ filename using _MAX_PATH from stdlib.h before falling back
+ to using the value 300.
+
+#78. (Changed in 1.33MR9) Jeff Vincent (JVincent@novell.com)
+
+ Put #ifndef/#endif around definition of ZZLEXBUFSIZE in
+ antlr.
+
+#77. (Changed in 1.33MR9) Arithmetic overflow for very large grammars
+
+ In routine HandleAmbiguities() antlr attempts to compute the
+ number of possible elements in a set that is order of
+ number-of-tokens raised to the number-of-lookahead-tokens power.
+ For large grammars or large lookahead (e.g. -ck 7) this can
+ cause arithmetic overflow.
+
+ With 1.33MR9, arithmetic overflow in this computation is reported
+ the first time it happens. The program continues to run and
+ the program branches based on the assumption that the computed
+ value is larger than any number computed by counting actual cases
+ because 2**31 is larger than the number of bits in most computers.
+
+ Before 1.33MR9 overflow was not reported. The behavior following
+ overflow is not predictable by anyone but the original author.
+
+ NOTE
+
+ In 1.33MR10 the warning message is suppressed.
+ The code which detects the overflow allows the
+ computation to continue without an error. The
+ error message itself made made users worry.
+
+#76. (Changed in 1.33MR9) Jeff Vincent (JVincent@novell.com)
+
+ Jeff Vincent has convinced me to make ANTLRCommonToken and
+ ANTLRCommonNoRefCountToken use variable length strings
+ allocated from the heap rather than fixed length strings.
+ By suitable definition of setText(), the copy constructor,
+ and operator =() it is possible to maintain "copy" semantics.
+ By "copy" semantics I mean that when a token is copied from
+ an existing token it receives its own, distinct, copy of the
+ text allocated from the heap rather than simply a pointer
+ to the original token's text.
+
+ ============================================================
+ W * A * R * N * I * N * G
+ ============================================================
+
+ It is possible that this may cause problems for some users.
+ For those users I have included the old version of AToken.h as
+ pccts/h/AToken_traditional.h.
+
+#75. (Changed in 1.33MR9) Bruce Guenter (bruceg@qcc.sk.ca)
+
+ Make DLGStringInput const correct. Since this is infrequently
+ subclassed, it should affect few users, I hope.
+
+#74. (Changed in 1.33MR9) -o (output directory) option
+
+ Antlr does not properly handle the -o output directory option
+ when the filename of the grammar contains a directory part. For
+ example:
+
+ antlr -o outdir pccts_src/myfile.g
+
+ causes antlr create a file called "outdir/pccts_src/myfile.cpp.
+ It SHOULD create outdir/myfile.cpp
+
+ The suggested code fix has been installed in antlr, dlg, and
+ Sorcerer.
+
+#73. (Changed in 1.33MR9) Hoisting of semantic predicates and -mrhoist
+
+ ============================================
+ This has been rendered obsolete by Item #117
+ ============================================
+
+#72. (Changed in 1.33MR9) virtual saveState()/restoreState()/guess_XXX
+
+ The following methods in ANTLRParser were made virtual at
+ the request of S. Bochnak (S.Bochnak@microTool.com.pl):
+
+ saveState() and restoreState()
+ guess(), guess_fail(), and guess_done()
+
+#71. (Changed in 1.33MR9) Access to omitted command line argument
+
+ If a switch requiring arguments is the last thing on the
+ command line, and the argument is omitted, antlr would core.
+
+ antlr test.g -prc
+
+ instead of
+
+ antlr test.g -prc off
+
+#70. (Changed in 1.33MR9) Addition of MSVC .dsp and .mak build files
+
+ The following MSVC .dsp and .mak files for pccts and sorcerer
+ were contributed by Stanislaw Bochnak (S.Bochnak@microTool.com.pl)
+ and Jeff Vincent (JVincent@novell.com)
+
+ PCCTS Distribution Kit
+ ----------------------
+ pccts/PCCTSMSVC50.dsw
+
+ pccts/antlr/AntlrMSVC50.dsp
+ pccts/antlr/AntlrMSVC50.mak
+
+ pccts/dlg/DlgMSVC50.dsp
+ pccts/dlg/DlgMSVC50.mak
+
+ pccts/support/msvc.dsp
+
+ Sorcerer Distribution Kit
+ -------------------------
+ pccts/sorcerer/SorcererMSVC50.dsp
+ pccts/sorcerer/SorcererMSVC50.mak
+
+ pccts/sorcerer/lib/msvc.dsp
+
+#69. (Changed in 1.33MR9) Change "unsigned int" to plain "int"
+
+ Declaration of max_token_num in misc.c as "unsigned int"
+ caused comparison between signed and unsigned ints giving
+ warning message without any special benefit.
+
+#68. (Changed in 1.33MR9) Add void return for dlg internal_error()
+
+ Get rid of "no return value" message in internal_error()
+ in file dlg/support.c and dlg/dlg.h.
+
+#67. (Changed in Sor) sor.g: lisp() has no return value
+
+ Added a "void" for the return type.
+
+#66. (Added to Sor) sor.g: ZZLEXBUFSIZE enclosed in #ifndef/#endif
+
+ A user needed to be able to change the ZZLEXBUFSIZE for
+ sor. Put the definition of ZZLEXBUFSIZE inside #ifndef/#endif
+
+#65. (Changed in 1.33MR9) PCCTSAST::deepCopy() and ast_dup() bug
+
+ Jeff Vincent (JVincent@novell.com) found that deepCopy()
+ made new copies of only the direct descendents. No new
+ copies were made of sibling nodes, Sibling pointers are
+ set to zero by shallowCopy().
+
+ PCCTS_AST::deepCopy() has been changed to make a
+ deep copy in the traditional sense.
+
+ The deepCopy() routine depends on the behavior of
+ shallowCopy(). In all sor examples I've found,
+ shallowCopy() zeroes the right and down pointers.
+
+ Original Tree Original deepCopy() Revised deepCopy
+ ------------- ------------------- ----------------
+ a->b->c A A
+ | | |
+ d->e->f D D->E->F
+ | | |
+ g->h->i G G->H->I
+ | |
+ j->k J->K
+
+ While comparing deepCopy() for C++ mode with ast_dup for
+ C mode I found a problem with ast_dup().
+
+ Routine ast_dup() has been changed to make a deep copy
+ in the traditional sense.
+
+ Original Tree Original ast_dup() Revised ast_dup()
+ ------------- ------------------- ----------------
+ a->b->c A->B->C A
+ | | |
+ d->e->f D->E->F D->E->F
+ | | |
+ g->h->i G->H->I G->H->I
+ | | |
+ j->k J->K J->K
+
+
+ I believe this affects transform mode sorcerer programs only.
+
+#64. (Changed in 1.33MR9) anltr/hash.h prototype for killHashTable()
+
+#63. (Changed in 1.33MR8) h/charptr.h does not zero pointer after free
+
+ The charptr.h routine now zeroes the pointer after free().
+
+ Reported by Jens Tingleff (jensting@imaginet.fr)
+
+#62. (Changed in 1.33MR8) ANTLRParser::resynch had static variable
+
+ The static variable "consumed" in ANTLRParser::resynch was
+ changed into an instance variable of the class with the
+ name "resynchConsumed".
+
+ Reported by S.Bochnak@microTool.com.pl
+
+#61. (Changed in 1.33MR8) Using rule>[i,j] when rule has no return values
+
+ Previously, the following code would cause antlr to core when
+ it tried to generate code for rule1 because rule2 had no return
+ values ("upward inheritance"):
+
+ rule1 : <<int i; int j>>
+ rule2 > [i,j]
+ ;
+
+ rule2 : Anything ;
+
+ Reported by S.Bochnak@microTool.com.pl
+
+ Verified correct operation of antlr MR8 when missing or extra
+ inheritance arguments for all combinations. When there are
+ missing or extra arguments code will still be generated even
+ though this might cause the invocation of a subroutine with
+ the wrong number of arguments.
+
+#60. (Changed in 1.33MR7) Major changes to exception handling
+
+ There were significant problems in the handling of exceptions
+ in 1.33 vanilla. The general problem is that it can only
+ process one level of exception handler. For example, a named
+ exception handler, an exception handler for an alternative, or
+ an exception for a subrule always went to the rule's exception
+ handler if there was no "catch" which matched the exception.
+
+ In 1.33MR7 the exception handlers properly "nest". If an
+ exception handler does not have a matching "catch" then the
+ nextmost outer exception handler is checked for an appropriate
+ "catch" clause, and so on until an exception handler with an
+ appropriate "catch" is found.
+
+ There are still undesirable features in the way exception
+ handlers are implemented, but I do not have time to fix them
+ at the moment:
+
+ The exception handlers for alternatives are outside the
+ block containing the alternative. This makes it impossible
+ to access variables declared in a block or to resume the
+ parse by "falling through". The parse can still be easily
+ resumed in other ways, but not in the most natural fashion.
+
+ This results in an inconsistentcy between named exception
+ handlers and exception handlers for alternatives. When
+ an exception handler for an alternative "falls through"
+ it goes to the nextmost outer handler - not the "normal
+ action".
+
+ A major difference between 1.33MR7 and 1.33 vanilla is
+ the default action after an exception is caught:
+
+ 1.33 Vanilla
+ ------------
+ In 1.33 vanilla the signal value is set to zero ("NoSignal")
+ and the code drops through to the code following the exception.
+ For named exception handlers this is the "normal action".
+ For alternative exception handlers this is the rule's handler.
+
+ 1.33MR7
+ -------
+ In 1.33MR7 the signal value is NOT automatically set to zero.
+
+ There are two cases:
+
+ For named exception handlers: if the signal value has been
+ set to zero the code drops through to the "normal action".
+
+ For all other cases the code branches to the nextmost outer
+ exception handler until it reaches the handler for the rule.
+
+ The following macros have been defined for convenience:
+
+ C/C++ Mode Name
+ --------------------
+ (zz)suppressSignal
+ set signal & return signal arg to 0 ("NoSignal")
+ (zz)setSignal(intValue)
+ set signal & return signal arg to some value
+ (zz)exportSignal
+ copy the signal value to the return signal arg
+
+ I'm not sure why PCCTS make a distinction between the local
+ signal value and the return signal argument, but I'm loathe
+ to change the code. The burden of copying the local signal
+ value to the return signal argument can be given to the
+ default signal handler, I suppose.
+
+#59. (Changed in 1.33MR7) Prototypes for some functions
+
+ Added prototypes for the following functions to antlr.h
+
+ zzconsumeUntil()
+ zzconsumeUntilToken()
+
+#58. (Changed in 1.33MR7) Added defintion of zzbufsize to dlgauto.h
+
+#57. (Changed in 1.33MR7) Format of #line directive
+
+ Previously, the -gl directive for line 1234 would
+ resemble: "# 1234 filename.g". This caused problems
+ for some compilers/pre-processors. In MR7 it generates
+ "#line 1234 filename.g".
+
+#56. (Added in 1.33MR7) Jan Mikkelsen <janm@zeta.org.au>
+
+ Move PURIFY macro invocaton to after rule's init action.
+
+#55. (Fixed in 1.33MR7) Unitialized variables in ANTLRParser
+
+ Member variables inf_labase and inf_last were not initialized.
+ (See item #50.)
+
+#54. (Fixed in 1.33MR6) Brad Schick (schick@interacess.com)
+
+ Previously, the following constructs generated the same
+ code:
+
+ rule1 : (A B C)?
+ | something-else
+ ;
+
+ rule2 : (A B C)? ()
+ | something-else
+ ;
+
+ In all versions of pccts rule1 guesses (A B C) and then
+ consume all three tokens if the guess succeeds. In MR6
+ rule2 guesses (A B C) but consumes NONE of the tokens
+ when the guess succeeds because "()" matches epsilon.
+
+#53. (Explanation for 1.33MR6) What happens after an exception is caught ?
+
+ The Book is silent about what happens after an exception
+ is caught.
+
+ The following code fragment prints "Error Action" followed
+ by "Normal Action".
+
+ test : Word ex:Number <<printf("Normal Action\n");>>
+ exception[ex]
+ catch NoViableAlt:
+ <<printf("Error Action\n");>>
+ ;
+
+ The reason for "Normal Action" is that the normal flow of the
+ program after a user-written exception handler is to "drop through".
+ In the case of an exception handler for a rule this results in
+ the exection of a "return" statement. In the case of an
+ exception handler attached to an alternative, rule, or token
+ this is the code that would have executed had there been no
+ exception.
+
+ The user can achieve the desired result by using a "return"
+ statement.
+
+ test : Word ex:Number <<printf("Normal Action\n");>>
+ exception[ex]
+ catch NoViableAlt:
+ <<printf("Error Action\n"); return;>>
+ ;
+
+ The most powerful mechanism for recovery from parse errors
+ in pccts is syntactic predicates because they provide
+ backtracking. Exceptions allow "return", "break",
+ "consumeUntil(...)", "goto _handler", "goto _fail", and
+ changing the _signal value.
+
+#52. (Fixed in 1.33MR6) Exceptions without syntactic predicates
+
+ The following generates bad code in 1.33 if no syntactic
+ predicates are present in the grammar.
+
+ test : Word ex:Number <<printf("Normal Action\n");>>
+ exception[ex]
+ catch NoViableAlt:
+ <<printf("Error Action\n");>>
+
+ There is a reference to a guess variable. In C mode
+ this causes a compiler error. In C++ mode it generates
+ an extraneous check on member "guessing".
+
+ In MR6 correct code is generated for both C and C++ mode.
+
+#51. (Added to 1.33MR6) Exception operator "@" used without exceptions
+
+ In MR6 added a warning when the exception operator "@" is
+ used and no exception group is defined. This is probably
+ a case where "\@" or "@" is meant.
+
+#50. (Fixed in 1.33MR6) Gunnar Rxnning (gunnar@candleweb.no)
+ http://www.candleweb.no/~gunnar/
+
+ Routines zzsave_antlr_state and zzrestore_antlr_state don't
+ save and restore all the data needed when switching states.
+
+ Suggested patch applied to antlr.h and err.h for MR6.
+
+#49. (Fixed in 1.33MR6) Sinan Karasu (sinan@boeing.com)
+
+ Generated code failed to turn off guess mode when leaving a
+ (...)+ block which contained a guess block. The result was
+ an infinite loop. For example:
+
+ rule : (
+ (x)?
+ | y
+ )+
+
+ Suggested code fix implemented in MR6. Replaced
+
+ ... else if (zzcnt>1) break;
+
+ with:
+
+ C++ mode:
+ ... else if (zzcnt>1) {if (!zzrv) zzGUESS_DONE; break;};
+ C mode:
+ ... else if (zzcnt>1) {if (zzguessing) zzGUESS_DONE; break;};
+
+#48. (Fixed in 1.33MR6) Invalid exception element causes core
+
+ A label attached to an invalid construct can cause
+ pccts to crash while processing the exception associated
+ with the label. For example:
+
+ rule : t:(B C)
+ exception[t] catch MismatchedToken: <<printf(...);>>
+
+ Version MR6 generates the message:
+
+ reference in exception handler to undefined label 't'
+
+#47. (Fixed in 1.33MR6) Manuel Ornato
+
+ Under some circumstances involving a k >1 or ck >1
+ grammar and a loop block (i.e. (...)* ) pccts will
+ fail to detect a syntax error and loop indefinitely.
+ The problem did not exist in 1.20, but has existed
+ from 1.23 to the present.
+
+ Fixed in MR6.
+
+ ---------------------------------------------------
+ Complete test program
+ ---------------------------------------------------
+ #header<<
+ #include <stdio.h>
+ #include "charptr.h"
+ >>
+
+ <<
+ #include "charptr.c"
+ main ()
+ {
+ ANTLR(global(),stdin);
+ }
+ >>
+
+ #token "[\ \t]+" << zzskip(); >>
+ #token "[\n]" << zzline++; zzskip(); >>
+
+ #token B "b"
+ #token C "c"
+ #token D "d"
+ #token E "e"
+ #token LP "\("
+ #token RP "\)"
+
+ #token ANTLREOF "@"
+
+ global : (
+ (E liste)
+ | liste
+ | listed
+ ) ANTLREOF
+ ;
+
+ listeb : LP ( B ( B | C )* ) RP ;
+ listec : LP ( C ( B | C )* ) RP ;
+ listed : LP ( D ( B | C )* ) RP ;
+ liste : ( listeb | listec )* ;
+
+ ---------------------------------------------------
+ Sample data causing infinite loop
+ ---------------------------------------------------
+ e (d c)
+ ---------------------------------------------------
+
+#46. (Fixed in 1.33MR6) Robert Richter
+ (Robert.Richter@infotech.tu-chemnitz.de)
+
+ This item from the list of known problems was
+ fixed by item #18 (below).
+
+#45. (Fixed in 1.33MR6) Brad Schick (schick@interaccess.com)
+
+ The dependency scanner in VC++ mistakenly sees a
+ reference to an MPW #include file even though properly
+ #ifdef/#endif in config.h. The suggested workaround
+ has been implemented:
+
+ #ifdef MPW
+ .....
+ #define MPW_CursorCtl_Header <CursorCtl.h>
+ #include MPW_CursorCtl_Header
+ .....
+ #endif
+
+#44. (Fixed in 1.33MR6) cast malloc() to (char *) in charptr.c
+
+ Added (char *) cast for systems where malloc returns "void *".
+
+#43. (Added to 1.33MR6) Bruce Guenter (bruceg@qcc.sk.ca)
+
+ Add setLeft() and setUp methods to ASTDoublyLinkedBase
+ for symmetry with setRight() and setDown() methods.
+
+#42. (Fixed in 1.33MR6) Jeff Katcher (jkatcher@nortel.ca)
+
+ C++ style comment in antlr.c corrected.
+
+#41. (Added in 1.33MR6) antlr -stdout
+
+ Using "antlr -stdout ..." forces the text that would
+ normally go to the grammar.c or grammar.cpp file to
+ stdout.
+
+#40. (Added in 1.33MR6) antlr -tab to change tab stops
+
+ Using "antlr -tab number ..." changes the tab stops
+ for the grammar.c or grammar.cpp file. The number
+ must be between 0 and 8. Using 0 gives tab characters,
+ values between 1 and 8 give the appropriate number of
+ space characters.
+
+#39. (Fixed in 1.33MR5) Jan Mikkelsen <janm@zeta.org.au>
+
+ Commas in function prototype still not correct under
+ some circumstances. Suggested code fix installed.
+
+#38. (Fixed in 1.33MR5) ANTLRTokenBuffer constructor
+
+ Have ANTLRTokenBuffer ctor initialize member "parser" to null.
+
+#37. (Fixed in 1.33MR4) Bruce Guenter (bruceg@qcc.sk.ca)
+
+ In ANTLRParser::FAIL(int k,...) released memory pointed to by
+ f[i] (as well as f itself. Should only free f itself.
+
+#36. (Fixed in 1.33MR3) Cortland D. Starrett (cort@shay.ecn.purdue.edu)
+
+ Neglected to properly declare isDLGmaxToken() when fixing problem
+ reported by Andreas Magnusson.
+
+ Undo "_retv=NULL;" change which caused problems for return values
+ from rules whose return values weren't pointers.
+
+ Failed to create bin directory if it didn't exist.
+
+#35. (Fixed in 1.33MR2) Andreas Magnusson
+(Andreas.Magnusson@mailbox.swipnet.se)
+
+ Repair bug introduced by 1.33MR1 for #tokdefs. The original fix
+ placed "DLGmaxToken=9999" and "DLGminToken=0" in the TokenType enum
+ in order to fix a problem with an aggresive compiler assigning an 8
+ bit enum which might be too narrow. This caused #tokdefs to assume
+ that there were 9999 real tokens. The repair to the fix causes antlr to
+ ignore TokenTypes "DLGmaxToken" and "DLGminToken" in a #tokdefs file.
+
+#34. (Added to 1.33MR1) Add public DLGLexerBase::set_line(int newValue)
+
+ Previously there was no public function for changing the line
+ number maintained by the lexer.
+
+#33. (Fixed in 1.33MR1) Franklin Chen (chen@adi.com)
+
+ Accidental use of EXIT_FAILURE rather than PCCTS_EXIT_FAILURE
+ in pccts/h/AParser.cpp.
+
+#32. (Fixed in 1.33MR1) Franklin Chen (chen@adi.com)
+
+ In PCCTSAST.cpp lines 405 and 466: Change
+
+ free (t)
+ to
+ free ( (char *)t );
+
+ to match prototype.
+
+#31. (Added to 1.33MR1) Pointer to parser in ANTLRTokenBuffer
+ Pointer to parser in DLGLexerBase
+
+ The ANTLRTokenBuffer class now contains a pointer to the
+ parser which is using it. This is established by the
+ ANTLRParser constructor calling ANTLRTokenBuffer::
+ setParser(ANTLRParser *p).
+
+ When ANTLRTokenBuffer::setParser(ANTLRParser *p) is
+ called it saves the pointer to the parser and then
+ calls ANTLRTokenStream::setParser(ANTLRParser *p)
+ so that the lexer can also save a pointer to the
+ parser.
+
+ There is also a function getParser() in each class
+ with the obvious purpose.
+
+ It is possible that these functions will return NULL
+ under some circumstances (e.g. a non-DLG lexer is used).
+
+#30. (Added to 1.33MR1) function tokenName(int token) standard
+
+ The generated parser class now includes the
+ function:
+
+ static const ANTLRChar * tokenName(int token)
+
+ which returns a pointer to the "name" corresponding
+ to the token.
+
+ The base class (ANTLRParser) always includes the
+ member function:
+
+ const ANTLRChar * parserTokenName(int token)
+
+ which can be accessed by objects which have a pointer
+ to an ANTLRParser, but do not know the name of the
+ parser class (e.g. ANTLRTokenBuffer and DLGLexerBase).
+
+#29. (Added to 1.33MR1) Debugging DLG lexers
+
+ If the pre-processor symbol DEBUG_LEXER is defined
+ then DLexerBase will include code for printing out
+ key information about tokens which are recognized.
+
+ The debug feature of the lexer is controlled by:
+
+ int previousDebugValue=lexer.debugLexer(newValue);
+
+ a value of 0 disables output
+ a value of 1 enables output
+
+ Even if the lexer debug code is compiled into DLexerBase
+ it must be enabled before any output is generated. For
+ example:
+
+ DLGFileInput in(stdin);
+ MyDLG lexer(&in,2000);
+
+ lexer.setToken(&aToken);
+
+ #if DEBUG_LEXER
+ lexer.debugLexer(1); // enable debug information
+ #endif
+
+#28. (Added to 1.33MR1) More control over DLG header
+
+ Version 1.33MR1 adds the following directives to PCCTS
+ for C++ mode:
+
+ #lexprefix <<source code>>
+
+ Adds source code to the DLGLexer.h file
+ after the #include "DLexerBase.h" but
+ before the start of the class definition.
+
+ #lexmember <<source code>>
+
+ Adds source code to the DLGLexer.h file
+ as part of the DLGLexer class body. It
+ appears immediately after the start of
+ the class and a "public: statement.
+
+#27. (Fixed in 1.33MR1) Comments in DLG actions
+
+ Previously, DLG would not recognize comments as a special case.
+ Thus, ">>" in the comments would cause errors. This is fixed.
+
+#26. (Fixed in 1.33MR1) Removed static variables from error routines
+
+ Previously, the existence of statically allocated variables
+ in some of the parser's member functions posed a danger when
+ there was more than one parser active.
+
+ Replaced with dynamically allocated/freed variables in 1.33MR1.
+
+#25. (Fixed in 1.33MR1) Use of string literals in semantic predicates
+
+ Previously, it was not possible to place a string literal in
+ a semantic predicate because it was not properly "stringized"
+ for the report of a failed predicate.
+
+#24. (Fixed in 1.33MR1) Continuation lines for semantic predicates
+
+ Previously, it was not possible to continue semantic
+ predicates across a line because it was not properly
+ "stringized" for the report of a failed predicate.
+
+ rule : <<ifXYZ()>>?[ a very
+ long statement ]
+
+#23. (Fixed in 1.33MR1) {...} envelope for failed semantic predicates
+
+ Previously, there was a code generation error for failed
+ semantic predicates:
+
+ rule : <<xyz()>>?[ stmt1; stmt2; ]
+
+ which generated code which resembled:
+
+ if (! xyz()) stmt1; stmt2;
+
+ It now puts the statements in a {...} envelope:
+
+ if (! xyz()) { stmt1; stmt2; };
+
+#22. (Fixed in 1.33MR1) Continuation of #token across lines using "\"
+
+ Previously, it was not possible to continue a #token regular
+ expression across a line. The trailing "\" and newline caused
+ a newline to be inserted into the regular expression by DLG.
+
+ Fixed in 1.33MR1.
+
+#21. (Fixed in 1.33MR1) Use of ">>" (right shift operator in DLG actions
+
+ It is now possible to use the C++ right shift operator ">>"
+ in DLG actions by using the normal escapes:
+
+ #token "shift-right" << value=value \>\> 1;>>
+
+#20. (Version 1.33/19-Jan-97 Karl Eccleson <karle@microrobotics.co.uk>
+ P.A. Keller (P.A.Keller@bath.ac.uk)
+
+ There is a problem due to using exceptions with the -gh option.
+
+ Suggested fix now in 1.33MR1.
+
+#19. (Fixed in 1.33MR1) Tom Piscotti and John Lilley
+
+ There were problems suppressing messages to stdin and stdout
+ when running in a window environment because some functions
+ which uses fprint were not virtual.
+
+ Suggested change now in 1.33MR1.
+
+ I believe all functions containing error messages (excluding those
+ indicating internal inconsistency) have been placed in functions
+ which are virtual.
+
+#18. (Version 1.33/ 22-Nov-96) John Bair (jbair@iftime.com)
+
+ Under some combination of options a required "return _retv" is
+ not generated.
+
+ Suggested fix now in 1.33MR1.
+
+#17. (Version 1.33/3-Sep-96) Ron House (house@helios.usq.edu.au)
+
+ The routine ASTBase::predorder_action omits two "tree->"
+ prefixes, which results in the preorder_action belonging
+ to the wrong node to be invoked.
+
+ Suggested fix now in 1.33MR1.
+
+#16. (Version 1.33/7-Jun-96) Eli Sternheim <eli@interhdl.com>
+
+ Routine consumeUntilToken() does not check for end-of-file
+ condition.
+
+ Suggested fix now in 1.33MR1.
+
+#15. (Version 1.33/8 Apr 96) Asgeir Olafsson <olafsson@cstar.ac.com>
+
+ Problem with tree duplication of doubly linked ASTs in ASTBase.cpp.
+
+ Suggested fix now in 1.33MR1.
+
+#14. (Version 1.33/28-Feb-96) Andreas.Magnusson@mailbox.swipnet.se
+
+ Problem with definition of operator = (const ANTLRTokenPtr rhs).
+
+ Suggested fix now in 1.33MR1.
+
+#13. (Version 1.33/13-Feb-96) Franklin Chen (chen@adi.com)
+
+ Sun C++ Compiler 3.0.1 can't compile testcpp/1 due to goto in
+ block with destructors.
+
+ Apparently fixed. Can't locate "goto".
+
+#12. (Version 1.33/10-Nov-95) Minor problems with 1.33 code
+
+ The following items have been fixed in 1.33MR1:
+
+ 1. pccts/antlr/main.c line 142
+
+ "void" appears in classic C code
+
+ 2. no makefile in support/genmk
+
+ 3. EXIT_FAILURE/_SUCCESS instead of PCCTS_EXIT_FAILURE/_SUCCESS
+
+ pccts/h/PCCTSAST.cpp
+ pccts/h/DLexerBase.cpp
+ pccts/testcpp/6/test.g
+
+ 4. use of "signed int" isn't accepted by AT&T cfront
+
+ pccts/h/PCCTSAST.h line 42
+
+ 5. in call to ANTLRParser::FAIL the var arg err_k is passed as
+ "int" but is declared "unsigned int".
+
+ 6. I believe that a failed validation predicate still does not
+ get put in a "{...}" envelope, despite the release notes.
+
+ 7. The #token ">>" appearing in the DLG grammar description
+ causes DLG to generate the string literal "\>\>" which
+ is non-conforming and will cause some compilers to
+ complain (scan.c function act10 line 143 of source code).
+
+#11. (Version 1.32b6) Dave Kuhlman (dkuhlman@netcom.com)
+
+ Problem with file close in gen.c. Already fixed in 1.33.
+
+#10. (Version 1.32b6/29-Aug-95)
+
+ pccts/antlr/main.c contains a C++ style comments on lines 149
+ and 176 which causes problems for most C compilers.
+
+ Already fixed in 1.33.
+
+#9. (Version 1.32b4/14-Mar-95) dlgauto.h #include "config.h"
+
+ The file pccts/h/dlgauto.h should probably contain a #include
+ "config.h" as it uses the #define symbol __USE_PROTOS.
+
+ Added to 1.33MR1.
+
+#8. (Version 1.32b4/6-Mar-95) Michael T. Richter (mtr@igs.net)
+
+ In C++ output mode anonymous tokens from in-line regular expressions
+ can create enum values which are too wide for the datatype of the enum
+ assigned by the C++ compiler.
+
+ Fixed in 1.33MR1.
+
+#7. (Version 1.32b4/6-Mar-95) C++ does not imply __STDC__
+
+ In err.h the combination of # directives assumes that a C++
+ compiler has __STDC__ defined. This is not necessarily true.
+
+ This problem also appears in the use of __USE_PROTOS which
+ is appropriate for both Standard C and C++ in antlr/gen.c
+ and antlr/lex.c
+
+ Fixed in 1.33MR1.
+
+#6. (Version 1.32 ?/15-Feb-95) Name conflict for "TokenType"
+
+ Already fixed in 1.33.
+
+#5. (23-Jan-95) Douglas_Cuthbertson.JTIDS@jtids_qmail.hanscom.af.mil
+
+ The fail action following a semantic predicate is not enclosed in
+ "{...}". This can lead to problems when the fail action contains
+ more than one statement.
+
+ Fixed in 1.33MR1.
+
+#4 . (Version 1.33/31-Mar-96) jlilley@empathy.com (John Lilley)
+
+ Put briefly, a semantic predicate ought to abort a guess if it fails.
+
+ Correction suggested by J. Lilley has been added to 1.33MR1.
+
+#3 . (Version 1.33) P.A.Keller@bath.ac.uk
+
+ Extra commas are placed in the K&R style argument list for rules
+ when using both exceptions and ASTs.
+
+ Fixed in 1.33MR1.
+
+#2. (Version 1.32b6/2-Oct-95) Brad Schick <schick@interaccess.com>
+
+ Construct #[] generates zzastnew() in C++ mode.
+
+ Already fixed in 1.33.
+
+#1. (Version 1.33) Bob Bailey (robert@oakhill.sps.mot.com)
+
+ Previously, config.h assumed that all PC systems required
+ "short" file names. The user can now override that
+ assumption with "#define LONGFILENAMES".
+
+ Added to 1.33MR1.
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_SUMMARY.txt b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_SUMMARY.txt new file mode 100644 index 0000000000..91defae169 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_SUMMARY.txt @@ -0,0 +1,2049 @@ +======================================================================
+
+ CHANGES_SUMMARY.TXT
+
+ A QUICK overview of changes from 1.33 in reverse order
+
+ A summary of additions rather than bug fixes and minor code changes.
+
+ Numbers refer to items in CHANGES_FROM_133*.TXT
+ which may contain additional information.
+
+ DISCLAIMER
+
+ The software and these notes are provided "as is". They may include
+ typographical or technical errors and their authors disclaims all
+ liability of any kind or nature for damages due to error, fault,
+ defect, or deficiency regardless of cause. All warranties of any
+ kind, either express or implied, including, but not limited to, the
+ implied warranties of merchantability and fitness for a particular
+ purpose are disclaimed.
+
+======================================================================
+
+#258. You can specify a user-defined base class for your parser
+
+ The base class must constructor must have a signature similar to
+ that of ANTLRParser.
+
+#253. Generation of block preamble (-preamble and -preamble_first)
+
+ The antlr option -preamble causes antlr to insert the code
+ BLOCK_PREAMBLE at the start of each rule and block.
+
+ The antlr option -preamble_first is similar, but inserts the
+ code BLOCK_PREAMBLE_FIRST(PreambleFirst_123) where the symbol
+ PreambleFirst_123 is equivalent to the first set defined by
+ the #FirstSetSymbol described in Item #248.
+
+#248. Generate symbol for first set of an alternative
+
+ rr : #FirstSetSymbol(rr_FirstSet) ( Foo | Bar ) ;
+
+#216. Defer token fetch for C++ mode
+
+ When the ANTLRParser class is built with the pre-processor option
+ ZZDEFER_FETCH defined, the fetch of new tokens by consume() is deferred
+ until LA(i) or LT(i) is called.
+
+#215. Use reset() to reset DLGLexerBase
+#188. Added pccts/h/DLG_stream_input.h
+#180. Added ANTLRParser::getEofToken()
+#173. -glms for Microsoft style filenames with -gl
+#170. Suppression for predicates with lookahead depth >1
+
+ Consider the following grammar with -ck 2 and the predicate in rule
+ "a" with depth 2:
+
+ r1 : (ab)* "@"
+ ;
+
+ ab : a
+ | b
+ ;
+
+ a : (A B)? => <<p(LATEXT(2))>>? A B C
+ ;
+
+ b : A B C
+ ;
+
+ Normally, the predicate would be hoisted into rule r1 in order to
+ determine whether to call rule "ab". However it should *not* be
+ hoisted because, even if p is false, there is a valid alternative
+ in rule b. With "-mrhoistk on" the predicate will be suppressed.
+
+ If "-info p" command line option is present the following information
+ will appear in the generated code:
+
+ while ( (LA(1)==A)
+ #if 0
+
+ Part (or all) of predicate with depth > 1 suppressed by alternative
+ without predicate
+
+ pred << p(LATEXT(2))>>?
+ depth=k=2 ("=>" guard) rule a line 8 t1.g
+ tree context:
+ (root = A
+ B
+ )
+
+ The token sequence which is suppressed: ( A B )
+ The sequence of references which generate that sequence of tokens:
+
+ 1 to ab r1/1 line 1 t1.g
+ 2 ab ab/1 line 4 t1.g
+ 3 to b ab/2 line 5 t1.g
+ 4 b b/1 line 11 t1.g
+ 5 #token A b/1 line 11 t1.g
+ 6 #token B b/1 line 11 t1.g
+
+ #endif
+
+ A slightly more complicated example:
+
+ r1 : (ab)* "@"
+ ;
+
+ ab : a
+ | b
+ ;
+
+ a : (A B)? => <<p(LATEXT(2))>>? (A B | D E)
+ ;
+
+ b : <<q(LATEXT(2))>>? D E
+ ;
+
+
+ In this case, the sequence (D E) in rule "a" which lies behind
+ the guard is used to suppress the predicate with context (D E)
+ in rule b.
+
+ while ( (LA(1)==A || LA(1)==D)
+ #if 0
+
+ Part (or all) of predicate with depth > 1 suppressed by alternative
+ without predicate
+
+ pred << q(LATEXT(2))>>?
+ depth=k=2 rule b line 11 t2.g
+ tree context:
+ (root = D
+ E
+ )
+
+ The token sequence which is suppressed: ( D E )
+ The sequence of references which generate that sequence of tokens:
+
+ 1 to ab r1/1 line 1 t2.g
+ 2 ab ab/1 line 4 t2.g
+ 3 to a ab/1 line 4 t2.g
+ 4 a a/1 line 8 t2.g
+ 5 #token D a/1 line 8 t2.g
+ 6 #token E a/1 line 8 t2.g
+
+ #endif
+ &&
+ #if 0
+
+ pred << p(LATEXT(2))>>?
+ depth=k=2 ("=>" guard) rule a line 8 t2.g
+ tree context:
+ (root = A
+ B
+ )
+
+ #endif
+
+ (! ( LA(1)==A && LA(2)==B ) || p(LATEXT(2)) ) {
+ ab();
+ ...
+
+#165. (Changed in MR13) option -newAST
+
+ To create ASTs from an ANTLRTokenPtr antlr usually calls
+ "new AST(ANTLRTokenPtr)". This option generates a call
+ to "newAST(ANTLRTokenPtr)" instead. This allows a user
+ to define a parser member function to create an AST object.
+
+#161. (Changed in MR13) Switch -gxt inhibits generation of tokens.h
+
+#158. (Changed in MR13) #header causes problem for pre-processors
+
+ A user who runs the C pre-processor on antlr source suggested
+ that another syntax be allowed. With MR13 such directives
+ such as #header, #pragma, etc. may be written as "\#header",
+ "\#pragma", etc. For escaping pre-processor directives inside
+ a #header use something like the following:
+
+ \#header
+ <<
+ \#include <stdio.h>
+ >>
+
+#155. (Changed in MR13) Context behind predicates can suppress
+
+ With -mrhoist enabled the context behind a guarded predicate can
+ be used to suppress other predicates. Consider the following grammar:
+
+ r0 : (r1)+;
+
+ r1 : rp
+ | rq
+ ;
+ rp : <<p LATEXT(1)>>? B ;
+ rq : (A)? => <<q LATEXT(1)>>? (A|B);
+
+ In earlier versions both predicates "p" and "q" would be hoisted into
+ rule r0. With MR12c predicate p is suppressed because the context which
+ follows predicate q includes "B" which can "cover" predicate "p". In
+ other words, in trying to decide in r0 whether to call r1, it doesn't
+ really matter whether p is false or true because, either way, there is
+ a valid choice within r1.
+
+#154. (Changed in MR13) Making hoist suppression explicit using <<nohoist>>
+
+ A common error, even among experienced pccts users, is to code
+ an init-action to inhibit hoisting rather than a leading action.
+ An init-action does not inhibit hoisting.
+
+ This was coded:
+
+ rule1 : <<;>> rule2
+
+ This is what was meant:
+
+ rule1 : <<;>> <<;>> rule2
+
+ With MR13, the user can code:
+
+ rule1 : <<;>> <<nohoist>> rule2
+
+ The following will give an error message:
+
+ rule1 : <<nohoist>> rule2
+
+ If the <<nohoist>> appears as an init-action rather than a leading
+ action an error message is issued. The meaning of an init-action
+ containing "nohoist" is unclear: does it apply to just one
+ alternative or to all alternatives ?
+
+#151a. Addition of ANTLRParser::getLexer(), ANTLRTokenStream::getLexer()
+
+ You must manually cast the ANTLRTokenStream to your program's
+ lexer class. Because the name of the lexer's class is not fixed.
+ Thus it is impossible to incorporate it into the DLGLexerBase
+ class.
+
+#151b.(Changed in MR12) ParserBlackBox member getLexer()
+
+#150. (Changed in MR12) syntaxErrCount and lexErrCount now public
+
+#149. (Changed in MR12) antlr option -info o (letter o for orphan)
+
+ If there is more than one rule which is not referenced by any
+ other rule then all such rules are listed. This is useful for
+ alerting one to rules which are not used, but which can still
+ contribute to ambiguity.
+
+#148. (Changed in MR11) #token names appearing in zztokens,token_tbl
+
+ One can write:
+
+ #token Plus ("+") "\+"
+ #token RP ("(") "\("
+ #token COM ("comment begin") "/\*"
+
+ The string in parenthesis will be used in syntax error messages.
+
+#146. (Changed in MR11) Option -treport for locating "difficult" alts
+
+ It can be difficult to determine which alternatives are causing
+ pccts to work hard to resolve an ambiguity. In some cases the
+ ambiguity is successfully resolved after much CPU time so there
+ is no message at all.
+
+ A rough measure of the amount of work being peformed which is
+ independent of the CPU speed and system load is the number of
+ tnodes created. Using "-info t" gives information about the
+ total number of tnodes created and the peak number of tnodes.
+
+ Tree Nodes: peak 1300k created 1416k lost 0
+
+ It also puts in the generated C or C++ file the number of tnodes
+ created for a rule (at the end of the rule). However this
+ information is not sufficient to locate the alternatives within
+ a rule which are causing the creation of tnodes.
+
+ Using:
+
+ antlr -treport 100000 ....
+
+ causes antlr to list on stdout any alternatives which require the
+ creation of more than 100,000 tnodes, along with the lookahead sets
+ for those alternatives.
+
+ The following is a trivial case from the ansi.g grammar which shows
+ the format of the report. This report might be of more interest
+ in cases where 1,000,000 tuples were created to resolve the ambiguity.
+
+ -------------------------------------------------------------------------
+ There were 0 tuples whose ambiguity could not be resolved
+ by full lookahead
+ There were 157 tnodes created to resolve ambiguity between:
+
+ Choice 1: statement/2 line 475 file ansi.g
+ Choice 2: statement/3 line 476 file ansi.g
+
+ Intersection of lookahead[1] sets:
+
+ IDENTIFIER
+
+ Intersection of lookahead[2] sets:
+
+ LPARENTHESIS COLON AMPERSAND MINUS
+ STAR PLUSPLUS MINUSMINUS ONESCOMPLEMENT
+ NOT SIZEOF OCTALINT DECIMALINT
+ HEXADECIMALINT FLOATONE FLOATTWO IDENTIFIER
+ STRING CHARACTER
+ -------------------------------------------------------------------------
+
+#143. (Changed in MR11) Optional ";" at end of #token statement
+
+ Fixes problem of:
+
+ #token X "x"
+
+ <<
+ parser action
+ >>
+
+ Being confused with:
+
+ #token X "x" <<lexical action>>
+
+#142. (Changed in MR11) class BufFileInput subclass of DLGInputStream
+
+ Alexey Demakov (demakov@kazbek.ispras.ru) has supplied class
+ BufFileInput derived from DLGInputStream which provides a
+ function lookahead(char *string) to test characters in the
+ input stream more than one character ahead.
+ The class is located in pccts/h/BufFileInput.* of the kit.
+
+#140. #pred to define predicates
+
+ +---------------------------------------------------+
+ | Note: Assume "-prc on" for this entire discussion |
+ +---------------------------------------------------+
+
+ A problem with predicates is that each one is regarded as
+ unique and capable of disambiguating cases where two
+ alternatives have identical lookahead. For example:
+
+ rule : <<pred(LATEXT(1))>>? A
+ | <<pred(LATEXT(1))>>? A
+ ;
+
+ will not cause any error messages or warnings to be issued
+ by earlier versions of pccts. To compare the text of the
+ predicates is an incomplete solution.
+
+ In 1.33MR11 I am introducing the #pred statement in order to
+ solve some problems with predicates. The #pred statement allows
+ one to give a symbolic name to a "predicate literal" or a
+ "predicate expression" in order to refer to it in other predicate
+ expressions or in the rules of the grammar.
+
+ The predicate literal associated with a predicate symbol is C
+ or C++ code which can be used to test the condition. A
+ predicate expression defines a predicate symbol in terms of other
+ predicate symbols using "!", "&&", and "||". A predicate symbol
+ can be defined in terms of a predicate literal, a predicate
+ expression, or *both*.
+
+ When a predicate symbol is defined with both a predicate literal
+ and a predicate expression, the predicate literal is used to generate
+ code, but the predicate expression is used to check for two
+ alternatives with identical predicates in both alternatives.
+
+ Here are some examples of #pred statements:
+
+ #pred IsLabel <<isLabel(LATEXT(1))>>?
+ #pred IsLocalVar <<isLocalVar(LATEXT(1))>>?
+ #pred IsGlobalVar <<isGlobalVar(LATEXT(1)>>?
+ #pred IsVar <<isVar(LATEXT(1))>>? IsLocalVar || IsGlobalVar
+ #pred IsScoped <<isScoped(LATEXT(1))>>? IsLabel || IsLocalVar
+
+ I hope that the use of EBNF notation to describe the syntax of the
+ #pred statement will not cause problems for my readers (joke).
+
+ predStatement : "#pred"
+ CapitalizedName
+ (
+ "<<predicate_literal>>?"
+ | "<<predicate_literal>>?" predOrExpr
+ | predOrExpr
+ )
+ ;
+
+ predOrExpr : predAndExpr ( "||" predAndExpr ) * ;
+
+ predAndExpr : predPrimary ( "&&" predPrimary ) * ;
+
+ predPrimary : CapitalizedName
+ | "!" predPrimary
+ | "(" predOrExpr ")"
+ ;
+
+ What is the purpose of this nonsense ?
+
+ To understand how predicate symbols help, you need to realize that
+ predicate symbols are used in two different ways with two different
+ goals.
+
+ a. Allow simplification of predicates which have been combined
+ during predicate hoisting.
+
+ b. Allow recognition of identical predicates which can't disambiguate
+ alternatives with common lookahead.
+
+ First we will discuss goal (a). Consider the following rule:
+
+ rule0: rule1
+ | ID
+ | ...
+ ;
+
+ rule1: rule2
+ | rule3
+ ;
+
+ rule2: <<isX(LATEXT(1))>>? ID ;
+ rule3: <<!isX(LATEXT(1)>>? ID ;
+
+ When the predicates in rule2 and rule3 are combined by hoisting
+ to create a prediction expression for rule1 the result is:
+
+ if ( LA(1)==ID
+ && ( isX(LATEXT(1) || !isX(LATEXT(1) ) ) { rule1(); ...
+
+ This is inefficient, but more importantly, can lead to false
+ assumptions that the predicate expression distinguishes the rule1
+ alternative with some other alternative with lookahead ID. In
+ MR11 one can write:
+
+ #pred IsX <<isX(LATEXT(1))>>?
+
+ ...
+
+ rule2: <<IsX>>? ID ;
+ rule3: <<!IsX>>? ID ;
+
+ During hoisting MR11 recognizes this as a special case and
+ eliminates the predicates. The result is a prediction
+ expression like the following:
+
+ if ( LA(1)==ID ) { rule1(); ...
+
+ Please note that the following cases which appear to be equivalent
+ *cannot* be simplified by MR11 during hoisting because the hoisting
+ logic only checks for a "!" in the predicate action, not in the
+ predicate expression for a predicate symbol.
+
+ *Not* equivalent and is not simplified during hoisting:
+
+ #pred IsX <<isX(LATEXT(1))>>?
+ #pred NotX <<!isX(LATEXT(1))>>?
+ ...
+ rule2: <<IsX>>? ID ;
+ rule3: <<NotX>>? ID ;
+
+ *Not* equivalent and is not simplified during hoisting:
+
+ #pred IsX <<isX(LATEXT(1))>>?
+ #pred NotX !IsX
+ ...
+ rule2: <<IsX>>? ID ;
+ rule3: <<NotX>>? ID ;
+
+ Now we will discuss goal (b).
+
+ When antlr discovers that there is a lookahead ambiguity between
+ two alternatives it attempts to resolve the ambiguity by searching
+ for predicates in both alternatives. In the past any predicate
+ would do, even if the same one appeared in both alternatives:
+
+ rule: <<p(LATEXT(1))>>? X
+ | <<p(LATEXT(1))>>? X
+ ;
+
+ The #pred statement is a start towards solving this problem.
+ During ambiguity resolution (*not* predicate hoisting) the
+ predicates for the two alternatives are expanded and compared.
+ Consider the following example:
+
+ #pred Upper <<isUpper(LATEXT(1))>>?
+ #pred Lower <<isLower(LATEXT(1))>>?
+ #pred Alpha <<isAlpha(LATEXT(1))>>? Upper || Lower
+
+ rule0: rule1
+ | <<Alpha>>? ID
+ ;
+
+ rule1:
+ | rule2
+ | rule3
+ ...
+ ;
+
+ rule2: <<Upper>>? ID;
+ rule3: <<Lower>>? ID;
+
+ The definition of #pred Alpha expresses:
+
+ a. to test the predicate use the C code "isAlpha(LATEXT(1))"
+
+ b. to analyze the predicate use the information that
+ Alpha is equivalent to the union of Upper and Lower,
+
+ During ambiguity resolution the definition of Alpha is expanded
+ into "Upper || Lower" and compared with the predicate in the other
+ alternative, which is also "Upper || Lower". Because they are
+ identical MR11 will report a problem.
+
+ -------------------------------------------------------------------------
+ t10.g, line 5: warning: the predicates used to disambiguate rule rule0
+ (file t10.g alt 1 line 5 and alt 2 line 6)
+ are identical when compared without context and may have no
+ resolving power for some lookahead sequences.
+ -------------------------------------------------------------------------
+
+ If you use the "-info p" option the output file will contain:
+
+ +----------------------------------------------------------------------+
+ |#if 0 |
+ | |
+ |The following predicates are identical when compared without |
+ | lookahead context information. For some ambiguous lookahead |
+ | sequences they may not have any power to resolve the ambiguity. |
+ | |
+ |Choice 1: rule0/1 alt 1 line 5 file t10.g |
+ | |
+ | The original predicate for choice 1 with available context |
+ | information: |
+ | |
+ | OR expr |
+ | |
+ | pred << Upper>>? |
+ | depth=k=1 rule rule2 line 14 t10.g |
+ | set context: |
+ | ID |
+ | |
+ | pred << Lower>>? |
+ | depth=k=1 rule rule3 line 15 t10.g |
+ | set context: |
+ | ID |
+ | |
+ | The predicate for choice 1 after expansion (but without context |
+ | information): |
+ | |
+ | OR expr |
+ | |
+ | pred << isUpper(LATEXT(1))>>? |
+ | depth=k=1 rule line 1 t10.g |
+ | |
+ | pred << isLower(LATEXT(1))>>? |
+ | depth=k=1 rule line 2 t10.g |
+ | |
+ | |
+ |Choice 2: rule0/2 alt 2 line 6 file t10.g |
+ | |
+ | The original predicate for choice 2 with available context |
+ | information: |
+ | |
+ | pred << Alpha>>? |
+ | depth=k=1 rule rule0 line 6 t10.g |
+ | set context: |
+ | ID |
+ | |
+ | The predicate for choice 2 after expansion (but without context |
+ | information): |
+ | |
+ | OR expr |
+ | |
+ | pred << isUpper(LATEXT(1))>>? |
+ | depth=k=1 rule line 1 t10.g |
+ | |
+ | pred << isLower(LATEXT(1))>>? |
+ | depth=k=1 rule line 2 t10.g |
+ | |
+ | |
+ |#endif |
+ +----------------------------------------------------------------------+
+
+ The comparison of the predicates for the two alternatives takes
+ place without context information, which means that in some cases
+ the predicates will be considered identical even though they operate
+ on disjoint lookahead sets. Consider:
+
+ #pred Alpha
+
+ rule1: <<Alpha>>? ID
+ | <<Alpha>>? Label
+ ;
+
+ Because the comparison of predicates takes place without context
+ these will be considered identical. The reason for comparing
+ without context is that otherwise it would be necessary to re-evaluate
+ the entire predicate expression for each possible lookahead sequence.
+ This would require more code to be written and more CPU time during
+ grammar analysis, and it is not yet clear whether anyone will even make
+ use of the new #pred facility.
+
+ A temporary workaround might be to use different #pred statements
+ for predicates you know have different context. This would avoid
+ extraneous warnings.
+
+ The above example might be termed a "false positive". Comparison
+ without context will also lead to "false negatives". Consider the
+ following example:
+
+ #pred Alpha
+ #pred Beta
+
+ rule1: <<Alpha>>? A
+ | rule2
+ ;
+
+ rule2: <<Alpha>>? A
+ | <<Beta>>? B
+ ;
+
+ The predicate used for alt 2 of rule1 is (Alpha || Beta). This
+ appears to be different than the predicate Alpha used for alt1.
+ However, the context of Beta is B. Thus when the lookahead is A
+ Beta will have no resolving power and Alpha will be used for both
+ alternatives. Using the same predicate for both alternatives isn't
+ very helpful, but this will not be detected with 1.33MR11.
+
+ To properly handle this the predicate expression would have to be
+ evaluated for each distinct lookahead context.
+
+ To determine whether two predicate expressions are identical is
+ difficult. The routine may fail to identify identical predicates.
+
+ The #pred feature also compares predicates to see if a choice between
+ alternatives which is resolved by a predicate which makes the second
+ choice unreachable. Consider the following example:
+
+ #pred A <<A(LATEXT(1)>>?
+ #pred B <<B(LATEXT(1)>>?
+ #pred A_or_B A || B
+
+ r : s
+ | t
+ ;
+ s : <<A_or_B>>? ID
+ ;
+ t : <<A>>? ID
+ ;
+
+ ----------------------------------------------------------------------------
+ t11.g, line 5: warning: the predicate used to disambiguate the
+ first choice of rule r
+ (file t11.g alt 1 line 5 and alt 2 line 6)
+ appears to "cover" the second predicate when compared without context.
+ The second predicate may have no resolving power for some lookahead
+ sequences.
+ ----------------------------------------------------------------------------
+
+#132. (Changed in 1.33MR11) Recognition of identical predicates in alts
+
+ Prior to 1.33MR11, there would be no ambiguity warning when the
+ very same predicate was used to disambiguate both alternatives:
+
+ test: ref B
+ | ref C
+ ;
+
+ ref : <<pred(LATEXT(1)>>? A
+
+ In 1.33MR11 this will cause the warning:
+
+ warning: the predicates used to disambiguate rule test
+ (file v98.g alt 1 line 1 and alt 2 line 2)
+ are identical and have no resolving power
+
+ ----------------- Note -----------------
+
+ This is different than the following case
+
+ test: <<pred(LATEXT(1))>>? A B
+ | <<pred(LATEXT(1)>>? A C
+ ;
+
+ In this case there are two distinct predicates
+ which have exactly the same text. In the first
+ example there are two references to the same
+ predicate. The problem represented by this
+ grammar will be addressed later.
+
+
+#127. (Changed in 1.33MR11)
+
+ Count Syntax Errors Count DLG Errors
+ ------------------- ----------------
+
+ C++ mode ANTLRParser:: DLGLexerBase::
+ syntaxErrCount lexErrCount
+ C mode zzSyntaxErrCount zzLexErrCount
+
+ The C mode variables are global and initialized to 0.
+ They are *not* reset to 0 automatically when antlr is
+ restarted.
+
+ The C++ mode variables are public. They are initialized
+ to 0 by the constructors. They are *not* reset to 0 by the
+ ANTLRParser::init() method.
+
+ Suggested by Reinier van den Born (reinier@vnet.ibm.com).
+
+#126. (Changed in 1.33MR11) Addition of #first <<...>>
+
+ The #first <<...>> inserts the specified text in the output
+ files before any other #include statements required by pccts.
+ The only things before the #first text are comments and
+ a #define ANTLR_VERSION.
+
+ Requested by and Esa Pulkkinen (esap@cs.tut.fi) and Alexin
+ Zoltan (alexin@inf.u-szeged.hu).
+
+#124. A Note on the New "&&" Style Guarded Predicates
+
+ I've been asked several times, "What is the difference between
+ the old "=>" style guard predicates and the new style "&&" guard
+ predicates, and how do you choose one over the other" ?
+
+ The main difference is that the "=>" does not apply the
+ predicate if the context guard doesn't match, whereas
+ the && form always does. What is the significance ?
+
+ If you have a predicate which is not on the "leading edge"
+ it is cannot be hoisted. Suppose you need a predicate that
+ looks at LA(2). You must introduce it manually. The
+ classic example is:
+
+ castExpr :
+ LP typeName RP
+ | ....
+ ;
+
+ typeName : <<isTypeName(LATEXT(1))>>? ID
+ | STRUCT ID
+ ;
+
+ The problem is that isTypeName() isn't on the leading edge
+ of typeName, so it won't be hoisted into castExpr to help
+ make a decision on which production to choose.
+
+ The *first* attempt to fix it is this:
+
+ castExpr :
+ <<isTypeName(LATEXT(2))>>?
+ LP typeName RP
+ | ....
+ ;
+
+ Unfortunately, this won't work because it ignores
+ the problem of STRUCT. The solution is to apply
+ isTypeName() in castExpr if LA(2) is an ID and
+ don't apply it when LA(2) is STRUCT:
+
+ castExpr :
+ (LP ID)? => <<isTypeName(LATEXT(2))>>?
+ LP typeName RP
+ | ....
+ ;
+
+ In conclusion, the "=>" style guarded predicate is
+ useful when:
+
+ a. the tokens required for the predicate
+ are not on the leading edge
+ b. there are alternatives in the expression
+ selected by the predicate for which the
+ predicate is inappropriate
+
+ If (b) were false, then one could use a simple
+ predicate (assuming "-prc on"):
+
+ castExpr :
+ <<isTypeName(LATEXT(2))>>?
+ LP typeName RP
+ | ....
+ ;
+
+ typeName : <<isTypeName(LATEXT(1))>>? ID
+ ;
+
+ So, when do you use the "&&" style guarded predicate ?
+
+ The new-style "&&" predicate should always be used with
+ predicate context. The context guard is in ADDITION to
+ the automatically computed context. Thus it useful for
+ predicates which depend on the token type for reasons
+ other than context.
+
+ The following example is contributed by Reinier van den Born
+ (reinier@vnet.ibm.com).
+
+ +-------------------------------------------------------------------------+
+ | This grammar has two ways to call functions: |
+ | |
+ | - a "standard" call syntax with parens and comma separated args |
+ | - a shell command like syntax (no parens and spacing separated args) |
+ | |
+ | The former also allows a variable to hold the name of the function, |
+ | the latter can also be used to call external commands. |
+ | |
+ | The grammar (simplified) looks like this: |
+ | |
+ | fun_call : ID "(" { expr ("," expr)* } ")" |
+ | /* ID is function name */ |
+ | | "@" ID "(" { expr ("," expr)* } ")" |
+ | /* ID is var containing fun name */ |
+ | ; |
+ | |
+ | command : ID expr* /* ID is function name */ |
+ | | path expr* /* path is external command name */ |
+ | ; |
+ | |
+ | path : ID /* left out slashes and such */ |
+ | | "@" ID /* ID is environment var */ |
+ | ; |
+ | |
+ | expr : .... |
+ | | "(" expr ")"; |
+ | |
+ | call : fun_call |
+ | | command |
+ | ; |
+ | |
+ | Obviously the call is wildly ambiguous. This is more or less how this |
+ | is to be resolved: |
+ | |
+ | A call begins with an ID or an @ followed by an ID. |
+ | |
+ | If it is an ID and if it is an ext. command name -> command |
+ | if followed by a paren -> fun_call |
+ | otherwise -> command |
+ | |
+ | If it is an @ and if the ID is a var name -> fun_call |
+ | otherwise -> command |
+ | |
+ | One can implement these rules quite neatly using && predicates: |
+ | |
+ | call : ("@" ID)? && <<isVarName(LT(2))>>? fun_call |
+ | | (ID)? && <<isExtCmdName>>? command |
+ | | (ID "(")? fun_call |
+ | | command |
+ | ; |
+ | |
+ | This can be done better, so it is not an ideal example, but it |
+ | conveys the principle. |
+ +-------------------------------------------------------------------------+
+
+#122. (Changed in 1.33MR11) Member functions to reset DLG in C++ mode
+
+ void DLGFileReset(FILE *f) { input = f; found_eof = 0; }
+ void DLGStringReset(DLGChar *s) { input = s; p = &input[0]; }
+
+ Supplied by R.A. Nelson (cowboy@VNET.IBM.COM)
+
+#119. (Changed in 1.33MR11) Ambiguity aid for grammars
+
+ The user can ask for additional information on ambiguities reported
+ by antlr to stdout. At the moment, only one ambiguity report can
+ be created in an antlr run.
+
+ This feature is enabled using the "-aa" (Ambiguity Aid) option.
+
+ The following options control the reporting of ambiguities:
+
+ -aa ruleName Selects reporting by name of rule
+ -aa lineNumber Selects reporting by line number
+ (file name not compared)
+
+ -aam Selects "multiple" reporting for a token
+ in the intersection set of the
+ alternatives.
+
+ For instance, the token ID may appear dozens
+ of times in various paths as the program
+ explores the rules which are reachable from
+ the point of an ambiguity. With option -aam
+ every possible path the search program
+ encounters is reported.
+
+ Without -aam only the first encounter is
+ reported. This may result in incomplete
+ information, but the information may be
+ sufficient and much shorter.
+
+ -aad depth Selects the depth of the search.
+ The default value is 1.
+
+ The number of paths to be searched, and the
+ size of the report can grow geometrically
+ with the -ck value if a full search for all
+ contributions to the source of the ambiguity
+ is explored.
+
+ The depth represents the number of tokens
+ in the lookahead set which are matched against
+ the set of ambiguous tokens. A depth of 1
+ means that the search stops when a lookahead
+ sequence of just one token is matched.
+
+ A k=1 ck=6 grammar might generate 5,000 items
+ in a report if a full depth 6 search is made
+ with the Ambiguity Aid. The source of the
+ problem may be in the first token and obscured
+ by the volume of data - I hesitate to call
+ it information.
+
+ When the user selects a depth > 1, the search
+ is first performed at depth=1 for both
+ alternatives, then depth=2 for both alternatives,
+ etc.
+
+ Sample output for rule grammar in antlr.g itself:
+
+ +---------------------------------------------------------------------+
+ | Ambiguity Aid |
+ | |
+ | Choice 1: grammar/70 line 632 file a.g |
+ | Choice 2: grammar/82 line 644 file a.g |
+ | |
+ | Intersection of lookahead[1] sets: |
+ | |
+ | "\}" "class" "#errclass" "#tokclass" |
+ | |
+ | Choice:1 Depth:1 Group:1 ("#errclass") |
+ | 1 in (...)* block grammar/70 line 632 a.g |
+ | 2 to error grammar/73 line 635 a.g |
+ | 3 error error/1 line 894 a.g |
+ | 4 #token "#errclass" error/2 line 895 a.g |
+ | |
+ | Choice:1 Depth:1 Group:2 ("#tokclass") |
+ | 2 to tclass grammar/74 line 636 a.g |
+ | 3 tclass tclass/1 line 937 a.g |
+ | 4 #token "#tokclass" tclass/2 line 938 a.g |
+ | |
+ | Choice:1 Depth:1 Group:3 ("class") |
+ | 2 to class_def grammar/75 line 637 a.g |
+ | 3 class_def class_def/1 line 669 a.g |
+ | 4 #token "class" class_def/3 line 671 a.g |
+ | |
+ | Choice:1 Depth:1 Group:4 ("\}") |
+ | 2 #token "\}" grammar/76 line 638 a.g |
+ | |
+ | Choice:2 Depth:1 Group:5 ("#errclass") |
+ | 1 in (...)* block grammar/83 line 645 a.g |
+ | 2 to error grammar/93 line 655 a.g |
+ | 3 error error/1 line 894 a.g |
+ | 4 #token "#errclass" error/2 line 895 a.g |
+ | |
+ | Choice:2 Depth:1 Group:6 ("#tokclass") |
+ | 2 to tclass grammar/94 line 656 a.g |
+ | 3 tclass tclass/1 line 937 a.g |
+ | 4 #token "#tokclass" tclass/2 line 938 a.g |
+ | |
+ | Choice:2 Depth:1 Group:7 ("class") |
+ | 2 to class_def grammar/95 line 657 a.g |
+ | 3 class_def class_def/1 line 669 a.g |
+ | 4 #token "class" class_def/3 line 671 a.g |
+ | |
+ | Choice:2 Depth:1 Group:8 ("\}") |
+ | 2 #token "\}" grammar/96 line 658 a.g |
+ +---------------------------------------------------------------------+
+
+ For a linear lookahead set ambiguity (where k=1 or for k>1 but
+ when all lookahead sets [i] with i<k all have degree one) the
+ reports appear in the following order:
+
+ for (depth=1 ; depth <= "-aad depth" ; depth++) {
+ for (alternative=1; alternative <=2 ; alternative++) {
+ while (matches-are-found) {
+ group++;
+ print-report
+ };
+ };
+ };
+
+ For reporting a k-tuple ambiguity, the reports appear in the
+ following order:
+
+ for (depth=1 ; depth <= "-aad depth" ; depth++) {
+ while (matches-are-found) {
+ for (alternative=1; alternative <=2 ; alternative++) {
+ group++;
+ print-report
+ };
+ };
+ };
+
+ This is because matches are generated in different ways for
+ linear lookahead and k-tuples.
+
+#117. (Changed in 1.33MR10) new EXPERIMENTAL predicate hoisting code
+
+ The hoisting of predicates into rules to create prediction
+ expressions is a problem in antlr. Consider the following
+ example (k=1 with -prc on):
+
+ start : (a)* "@" ;
+ a : b | c ;
+ b : <<isUpper(LATEXT(1))>>? A ;
+ c : A ;
+
+ Prior to 1.33MR10 the code generated for "start" would resemble:
+
+ while {
+ if (LA(1)==A &&
+ (!LA(1)==A || isUpper())) {
+ a();
+ }
+ };
+
+ This code is wrong because it makes rule "c" unreachable from
+ "start". The essence of the problem is that antlr fails to
+ recognize that there can be a valid alternative within "a" even
+ when the predicate <<isUpper(LATEXT(1))>>? is false.
+
+ In 1.33MR10 with -mrhoist the hoisting of the predicate into
+ "start" is suppressed because it recognizes that "c" can
+ cover all the cases where the predicate is false:
+
+ while {
+ if (LA(1)==A) {
+ a();
+ }
+ };
+
+ With the antlr "-info p" switch the user will receive information
+ about the predicate suppression in the generated file:
+
+ --------------------------------------------------------------
+ #if 0
+
+ Hoisting of predicate suppressed by alternative without predicate.
+ The alt without the predicate includes all cases where
+ the predicate is false.
+
+ WITH predicate: line 7 v1.g
+ WITHOUT predicate: line 7 v1.g
+
+ The context set for the predicate:
+
+ A
+
+ The lookahead set for the alt WITHOUT the semantic predicate:
+
+ A
+
+ The predicate:
+
+ pred << isUpper(LATEXT(1))>>?
+ depth=k=1 rule b line 9 v1.g
+ set context:
+ A
+ tree context: null
+
+ Chain of referenced rules:
+
+ #0 in rule start (line 5 v1.g) to rule a
+ #1 in rule a (line 7 v1.g)
+
+ #endif
+ --------------------------------------------------------------
+
+ A predicate can be suppressed by a combination of alternatives
+ which, taken together, cover a predicate:
+
+ start : (a)* "@" ;
+
+ a : b | ca | cb | cc ;
+
+ b : <<isUpper(LATEXT(1))>>? ( A | B | C ) ;
+
+ ca : A ;
+ cb : B ;
+ cc : C ;
+
+ Consider a more complex example in which "c" covers only part of
+ a predicate:
+
+ start : (a)* "@" ;
+
+ a : b
+ | c
+ ;
+
+ b : <<isUpper(LATEXT(1))>>?
+ ( A
+ | X
+ );
+
+ c : A
+ ;
+
+ Prior to 1.33MR10 the code generated for "start" would resemble:
+
+ while {
+ if ( (LA(1)==A || LA(1)==X) &&
+ (! (LA(1)==A || LA(1)==X) || isUpper()) {
+ a();
+ }
+ };
+
+ With 1.33MR10 and -mrhoist the predicate context is restricted to
+ the non-covered lookahead. The code resembles:
+
+ while {
+ if ( (LA(1)==A || LA(1)==X) &&
+ (! (LA(1)==X) || isUpper()) {
+ a();
+ }
+ };
+
+ With the antlr "-info p" switch the user will receive information
+ about the predicate restriction in the generated file:
+
+ --------------------------------------------------------------
+ #if 0
+
+ Restricting the context of a predicate because of overlap
+ in the lookahead set between the alternative with the
+ semantic predicate and one without
+ Without this restriction the alternative without the predicate
+ could not be reached when input matched the context of the
+ predicate and the predicate was false.
+
+ WITH predicate: line 11 v4.g
+ WITHOUT predicate: line 12 v4.g
+
+ The original context set for the predicate:
+
+ A X
+
+ The lookahead set for the alt WITHOUT the semantic predicate:
+
+ A
+
+ The intersection of the two sets
+
+ A
+
+ The original predicate:
+
+ pred << isUpper(LATEXT(1))>>?
+ depth=k=1 rule b line 15 v4.g
+ set context:
+ A X
+ tree context: null
+
+ The new (modified) form of the predicate:
+
+ pred << isUpper(LATEXT(1))>>?
+ depth=k=1 rule b line 15 v4.g
+ set context:
+ X
+ tree context: null
+
+ #endif
+ --------------------------------------------------------------
+
+ The bad news about -mrhoist:
+
+ (a) -mrhoist does not analyze predicates with lookahead
+ depth > 1.
+
+ (b) -mrhoist does not look past a guarded predicate to
+ find context which might cover other predicates.
+
+ For these cases you might want to use syntactic predicates.
+ When a semantic predicate fails during guess mode the guess
+ fails and the next alternative is tried.
+
+ Limitation (a) is illustrated by the following example:
+
+ start : (stmt)* EOF ;
+
+ stmt : cast
+ | expr
+ ;
+ cast : <<isTypename(LATEXT(2))>>? LP ID RP ;
+
+ expr : LP ID RP ;
+
+ This is not much different from the first example, except that
+ it requires two tokens of lookahead context to determine what
+ to do. This predicate is NOT suppressed because the current version
+ is unable to handle predicates with depth > 1.
+
+ A predicate can be combined with other predicates during hoisting.
+ In those cases the depth=1 predicates are still handled. Thus,
+ in the following example the isUpper() predicate will be suppressed
+ by line #4 when hoisted from "bizarre" into "start", but will still
+ be present in "bizarre" in order to predict "stmt".
+
+ start : (bizarre)* EOF ; // #1
+ // #2
+ bizarre : stmt // #3
+ | A // #4
+ ;
+
+ stmt : cast
+ | expr
+ ;
+
+ cast : <<isTypename(LATEXT(2))>>? LP ID RP ;
+
+ expr : LP ID RP ;
+ | <<isUpper(LATEXT(1))>>? A
+
+ Limitation (b) is illustrated by the following example of a
+ context guarded predicate:
+
+ rule : (A)? <<p>>? // #1
+ (A // #2
+ |B // #3
+ ) // #4
+ | <<q>> B // #5
+ ;
+
+ Recall that this means that when the lookahead is NOT A then
+ the predicate "p" is ignored and it attempts to match "A|B".
+ Ideally, the "B" at line #3 should suppress predicate "q".
+ However, the current version does not attempt to look past
+ the guard predicate to find context which might suppress other
+ predicates.
+
+ In some cases -mrhoist will lead to the reporting of ambiguities
+ which were not visible before:
+
+ start : (a)* "@";
+ a : bc | d;
+ bc : b | c ;
+
+ b : <<isUpper(LATEXT(1))>>? A;
+ c : A ;
+
+ d : A ;
+
+ In this case there is a true ambiguity in "a" between "bc" and "d"
+ which can both match "A". Without -mrhoist the predicate in "b"
+ is hoisted into "a" and there is no ambiguity reported. However,
+ with -mrhoist, the predicate in "b" is suppressed by "c" (as it
+ should be) making the ambiguity in "a" apparent.
+
+ The motivations for these changes were hoisting problems reported
+ by Reinier van den Born (reinier@vnet.ibm.com) and several others.
+
+#113. (Changed in 1.33MR10) new context guarded pred: (g)? && <<p>>? expr
+
+ The existing context guarded predicate:
+
+ rule : (guard)? => <<p>>? expr
+ | next_alternative
+ ;
+
+ generates code which resembles:
+
+ if (lookahead(expr) && (!guard || pred)) {
+ expr()
+ } else ....
+
+ This is not suitable for some applications because it allows
+ expr() to be invoked when the predicate is false. This is
+ intentional because it is meant to mimic automatically computed
+ predicate context.
+
+ The new context guarded predicate uses the guard information
+ differently because it has a different goal. Consider:
+
+ rule : (guard)? && <<p>>? expr
+ | next_alternative
+ ;
+
+ The new style of context guarded predicate is equivalent to:
+
+ rule : <<guard==true && pred>>? expr
+ | next_alternative
+ ;
+
+ It generates code which resembles:
+
+ if (lookahead(expr) && guard && pred) {
+ expr();
+ } else ...
+
+ Both forms of guarded predicates severely restrict the form of
+ the context guard: it can contain no rule references, no
+ (...)*, no (...)+, and no {...}. It may contain token and
+ token class references, and alternation ("|").
+
+ Addition for 1.33MR11: in the token expression all tokens must
+ be at the same height of the token tree:
+
+ (A ( B | C))? && ... is ok (all height 2)
+ (A ( B | ))? && ... is not ok (some 1, some 2)
+ (A B C D | E F G H)? && ... is ok (all height 4)
+ (A B C D | E )? && ... is not ok (some 4, some 1)
+
+ This restriction is required in order to properly compute the lookahead
+ set for expressions like:
+
+ rule1 : (A B C)? && <<pred>>? rule2 ;
+ rule2 : (A|X) (B|Y) (C|Z);
+
+ This addition was suggested by Rienier van den Born (reinier@vnet.ibm.com)
+
+#109. (Changed in 1.33MR10) improved trace information
+
+ The quality of the trace information provided by the "-gd"
+ switch has been improved significantly. Here is an example
+ of the output from a test program. It shows the rule name,
+ the first token of lookahead, the call depth, and the guess
+ status:
+
+ exit rule gusxx {"?"} depth 2
+ enter rule gusxx {"?"} depth 2
+ enter rule gus1 {"o"} depth 3 guessing
+ guess done - returning to rule gus1 {"o"} at depth 3
+ (guess mode continues - an enclosing guess is still active)
+ guess done - returning to rule gus1 {"Z"} at depth 3
+ (guess mode continues - an enclosing guess is still active)
+ exit rule gus1 {"Z"} depth 3 guessing
+ guess done - returning to rule gusxx {"o"} at depth 2 (guess mode ends)
+ enter rule gus1 {"o"} depth 3
+ guess done - returning to rule gus1 {"o"} at depth 3 (guess mode ends)
+ guess done - returning to rule gus1 {"Z"} at depth 3 (guess mode ends)
+ exit rule gus1 {"Z"} depth 3
+ line 1: syntax error at "Z" missing SC
+ ...
+
+ Rule trace reporting is controlled by the value of the integer
+ [zz]traceOptionValue: when it is positive tracing is enabled,
+ otherwise it is disabled. Tracing during guess mode is controlled
+ by the value of the integer [zz]traceGuessOptionValue. When
+ it is positive AND [zz]traceOptionValue is positive rule trace
+ is reported in guess mode.
+
+ The values of [zz]traceOptionValue and [zz]traceGuessOptionValue
+ can be adjusted by subroutine calls listed below.
+
+ Depending on the presence or absence of the antlr -gd switch
+ the variable [zz]traceOptionValueDefault is set to 0 or 1. When
+ the parser is initialized or [zz]traceReset() is called the
+ value of [zz]traceOptionValueDefault is copied to [zz]traceOptionValue.
+ The value of [zz]traceGuessOptionValue is always initialzed to 1,
+ but, as noted earlier, nothing will be reported unless
+ [zz]traceOptionValue is also positive.
+
+ When the parser state is saved/restored the value of the trace
+ variables are also saved/restored. If a restore causes a change in
+ reporting behavior from on to off or vice versa this will be reported.
+
+ When the -gd option is selected, the macro "#define zzTRACE_RULES"
+ is added to appropriate output files.
+
+ C++ mode
+ --------
+ int traceOption(int delta)
+ int traceGuessOption(int delta)
+ void traceReset()
+ int traceOptionValueDefault
+
+ C mode
+ --------
+ int zzTraceOption(int delta)
+ int zzTraceGuessOption(int delta)
+ void zzTraceReset()
+ int zzTraceOptionValueDefault
+
+ The argument "delta" is added to the traceOptionValue. To
+ turn on trace when inside a particular rule one:
+
+ rule : <<traceOption(+1);>>
+ (
+ rest-of-rule
+ )
+ <<traceOption(-1);>>
+ ; /* fail clause */ <<traceOption(-1);>>
+
+ One can use the same idea to turn *off* tracing within a
+ rule by using a delta of (-1).
+
+ An improvement in the rule trace was suggested by Sramji
+ Ramanathan (ps@kumaran.com).
+
+#108. A Note on Deallocation of Variables Allocated in Guess Mode
+
+ NOTE
+ ------------------------------------------------------
+ This mechanism only works for heap allocated variables
+ ------------------------------------------------------
+
+ The rewrite of the trace provides the machinery necessary
+ to properly free variables or undo actions following a
+ failed guess.
+
+ The macro zzUSER_GUESS_HOOK(guessSeq,zzrv) is expanded
+ as part of the zzGUESS macro. When a guess is opened
+ the value of zzrv is 0. When a longjmp() is executed to
+ undo the guess, the value of zzrv will be 1.
+
+ The macro zzUSER_GUESS_DONE_HOOK(guessSeq) is expanded
+ as part of the zzGUESS_DONE macro. This is executed
+ whether the guess succeeds or fails as part of closing
+ the guess.
+
+ The guessSeq is a sequence number which is assigned to each
+ guess and is incremented by 1 for each guess which becomes
+ active. It is needed by the user to associate the start of
+ a guess with the failure and/or completion (closing) of a
+ guess.
+
+ Guesses are nested. They must be closed in the reverse
+ of the order that they are opened.
+
+ In order to free memory used by a variable during a guess
+ a user must write a routine which can be called to
+ register the variable along with the current guess sequence
+ number provided by the zzUSER_GUESS_HOOK macro. If the guess
+ fails, all variables tagged with the corresponding guess
+ sequence number should be released. This is ugly, but
+ it would require a major rewrite of antlr 1.33 to use
+ some mechanism other than setjmp()/longjmp().
+
+ The order of calls for a *successful* guess would be:
+
+ zzUSER_GUESS_HOOK(guessSeq,0);
+ zzUSER_GUESS_DONE_HOOK(guessSeq);
+
+ The order of calls for a *failed* guess would be:
+
+ zzUSER_GUESS_HOOK(guessSeq,0);
+ zzUSER_GUESS_HOOK(guessSeq,1);
+ zzUSER_GUESS_DONE_HOOK(guessSeq);
+
+ The default definitions of these macros are empty strings.
+
+ Here is an example in C++ mode. The zzUSER_GUESS_HOOK and
+ zzUSER_GUESS_DONE_HOOK macros and myGuessHook() routine
+ can be used without change in both C and C++ versions.
+
+ ----------------------------------------------------------------------
+ <<
+
+ #include "AToken.h"
+
+ typedef ANTLRCommonToken ANTLRToken;
+
+ #include "DLGLexer.h"
+
+ int main() {
+
+ {
+ DLGFileInput in(stdin);
+ DLGLexer lexer(&in,2000);
+ ANTLRTokenBuffer pipe(&lexer,1);
+ ANTLRCommonToken aToken;
+ P parser(&pipe);
+
+ lexer.setToken(&aToken);
+ parser.init();
+ parser.start();
+ };
+
+ fclose(stdin);
+ fclose(stdout);
+ return 0;
+ }
+
+ >>
+
+ <<
+ char *s=NULL;
+
+ #undef zzUSER_GUESS_HOOK
+ #define zzUSER_GUESS_HOOK(guessSeq,zzrv) myGuessHook(guessSeq,zzrv);
+ #undef zzUSER_GUESS_DONE_HOOK
+ #define zzUSER_GUESS_DONE_HOOK(guessSeq) myGuessHook(guessSeq,2);
+
+ void myGuessHook(int guessSeq,int zzrv) {
+ if (zzrv == 0) {
+ fprintf(stderr,"User hook: starting guess #%d\n",guessSeq);
+ } else if (zzrv == 1) {
+ free (s);
+ s=NULL;
+ fprintf(stderr,"User hook: failed guess #%d\n",guessSeq);
+ } else if (zzrv == 2) {
+ free (s);
+ s=NULL;
+ fprintf(stderr,"User hook: ending guess #%d\n",guessSeq);
+ };
+ }
+
+ >>
+
+ #token A "a"
+ #token "[\t \ \n]" <<skip();>>
+
+ class P {
+
+ start : (top)+
+ ;
+
+ top : (which) ? <<fprintf(stderr,"%s is a which\n",s); free(s); s=NULL; >>
+ | other <<fprintf(stderr,"%s is an other\n",s); free(s); s=NULL; >>
+ ; <<if (s != NULL) free(s); s=NULL; >>
+
+ which : which2
+ ;
+
+ which2 : which3
+ ;
+ which3
+ : (label)? <<fprintf(stderr,"%s is a label\n",s);>>
+ | (global)? <<fprintf(stderr,"%s is a global\n",s);>>
+ | (exclamation)? <<fprintf(stderr,"%s is an exclamation\n",s);>>
+ ;
+
+ label : <<s=strdup(LT(1)->getText());>> A ":" ;
+
+ global : <<s=strdup(LT(1)->getText());>> A "::" ;
+
+ exclamation : <<s=strdup(LT(1)->getText());>> A "!" ;
+
+ other : <<s=strdup(LT(1)->getText());>> "other" ;
+
+ }
+ ----------------------------------------------------------------------
+
+ This is a silly example, but illustrates the idea. For the input
+ "a ::" with tracing enabled the output begins:
+
+ ----------------------------------------------------------------------
+ enter rule "start" depth 1
+ enter rule "top" depth 2
+ User hook: starting guess #1
+ enter rule "which" depth 3 guessing
+ enter rule "which2" depth 4 guessing
+ enter rule "which3" depth 5 guessing
+ User hook: starting guess #2
+ enter rule "label" depth 6 guessing
+ guess failed
+ User hook: failed guess #2
+ guess done - returning to rule "which3" at depth 5 (guess mode continues
+ - an enclosing guess is still active)
+ User hook: ending guess #2
+ User hook: starting guess #3
+ enter rule "global" depth 6 guessing
+ exit rule "global" depth 6 guessing
+ guess done - returning to rule "which3" at depth 5 (guess mode continues
+ - an enclosing guess is still active)
+ User hook: ending guess #3
+ enter rule "global" depth 6 guessing
+ exit rule "global" depth 6 guessing
+ exit rule "which3" depth 5 guessing
+ exit rule "which2" depth 4 guessing
+ exit rule "which" depth 3 guessing
+ guess done - returning to rule "top" at depth 2 (guess mode ends)
+ User hook: ending guess #1
+ enter rule "which" depth 3
+ .....
+ ----------------------------------------------------------------------
+
+ Remember:
+
+ (a) Only init-actions are executed during guess mode.
+ (b) A rule can be invoked multiple times during guess mode.
+ (c) If the guess succeeds the rule will be called once more
+ without guess mode so that normal actions will be executed.
+ This means that the init-action might need to distinguish
+ between guess mode and non-guess mode using the variable
+ [zz]guessing.
+
+#101. (Changed in 1.33MR10) antlr -info command line switch
+
+ -info
+
+ p - extra predicate information in generated file
+
+ t - information about tnode use:
+ at the end of each rule in generated file
+ summary on stderr at end of program
+
+ m - monitor progress
+ prints name of each rule as it is started
+ flushes output at start of each rule
+
+ f - first/follow set information to stdout
+
+ 0 - no operation (added in 1.33MR11)
+
+ The options may be combined and may appear in any order.
+ For example:
+
+ antlr -info ptm -CC -gt -mrhoist on mygrammar.g
+
+#100a. (Changed in 1.33MR10) Predicate tree simplification
+
+ When the same predicates can be referenced in more than one
+ alternative of a block large predicate trees can be formed.
+
+ The difference that these optimizations make is so dramatic
+ that I have decided to use it even when -mrhoist is not selected.
+
+ Consider the following grammar:
+
+ start : ( all )* ;
+
+ all : a
+ | d
+ | e
+ | f
+ ;
+
+ a : c A B
+ | c A C
+ ;
+
+ c : <<AAA(LATEXT(2))>>?
+ ;
+
+ d : <<BBB(LATEXT(2))>>? B C
+ ;
+
+ e : <<CCC(LATEXT(2))>>? B C
+ ;
+
+ f : e X Y
+ ;
+
+ In rule "a" there is a reference to rule "c" in both alternatives.
+ The length of the predicate AAA is k=2 and it can be followed in
+ alternative 1 only by (A B) while in alternative 2 it can be
+ followed only by (A C). Thus they do not have identical context.
+
+ In rule "all" the alternatives which refer to rules "e" and "f" allow
+ elimination of the duplicate reference to predicate CCC.
+
+ The table below summarized the kind of simplification performed by
+ 1.33MR10. In the table, X and Y stand for single predicates
+ (not trees).
+
+ (OR X (OR Y (OR Z))) => (OR X Y Z)
+ (AND X (AND Y (AND Z))) => (AND X Y Z)
+
+ (OR X (... (OR X Y) ... )) => (OR X (... Y ... ))
+ (AND X (... (AND X Y) ... )) => (AND X (... Y ... ))
+ (OR X (... (AND X Y) ... )) => (OR X (... ... ))
+ (AND X (... (OR X Y) ... )) => (AND X (... ... ))
+
+ (AND X) => X
+ (OR X) => X
+
+ In a test with a complex grammar for a real application, a predicate
+ tree with six OR nodes and 12 leaves was reduced to "(OR X Y Z)".
+
+ In 1.33MR10 there is a greater effort to release memory used
+ by predicates once they are no longer in use.
+
+#100b. (Changed in 1.33MR10) Suppression of extra predicate tests
+
+ The following optimizations require that -mrhoist be selected.
+
+ It is relatively easy to optimize the code generated for predicate
+ gates when they are of the form:
+
+ (AND X Y Z ...)
+ or (OR X Y Z ...)
+
+ where X, Y, Z, and "..." represent individual predicates (leaves) not
+ predicate trees.
+
+ If the predicate is an AND the contexts of the X, Y, Z, etc. are
+ ANDed together to create a single Tree context for the group and
+ context tests for the individual predicates are suppressed:
+
+ --------------------------------------------------
+ Note: This was incorrect. The contexts should be
+ ORed together. This has been fixed. A more
+ complete description is available in item #152.
+ ---------------------------------------------------
+
+ Optimization 1: (AND X Y Z ...)
+
+ Suppose the context for Xtest is LA(1)==LP and the context for
+ Ytest is LA(1)==LP && LA(2)==ID.
+
+ Without the optimization the code would resemble:
+
+ if (lookaheadContext &&
+ !(LA(1)==LP && LA(1)==LP && LA(2)==ID) ||
+ ( (! LA(1)==LP || Xtest) &&
+ (! (LA(1)==LP || LA(2)==ID) || Xtest)
+ )) {...
+
+ With the -mrhoist optimization the code would resemble:
+
+ if (lookaheadContext &&
+ ! (LA(1)==LP && LA(2)==ID) || (Xtest && Ytest) {...
+
+ Optimization 2: (OR X Y Z ...) with identical contexts
+
+ Suppose the context for Xtest is LA(1)==ID and for Ytest
+ the context is also LA(1)==ID.
+
+ Without the optimization the code would resemble:
+
+ if (lookaheadContext &&
+ ! (LA(1)==ID || LA(1)==ID) ||
+ (LA(1)==ID && Xtest) ||
+ (LA(1)==ID && Ytest) {...
+
+ With the -mrhoist optimization the code would resemble:
+
+ if (lookaheadContext &&
+ (! LA(1)==ID) || (Xtest || Ytest) {...
+
+ Optimization 3: (OR X Y Z ...) with distinct contexts
+
+ Suppose the context for Xtest is LA(1)==ID and for Ytest
+ the context is LA(1)==LP.
+
+ Without the optimization the code would resemble:
+
+ if (lookaheadContext &&
+ ! (LA(1)==ID || LA(1)==LP) ||
+ (LA(1)==ID && Xtest) ||
+ (LA(1)==LP && Ytest) {...
+
+ With the -mrhoist optimization the code would resemble:
+
+ if (lookaheadContext &&
+ (zzpf=0,
+ (LA(1)==ID && (zzpf=1) && Xtest) ||
+ (LA(1)==LP && (zzpf=1) && Ytest) ||
+ !zzpf) {
+
+ These may appear to be of similar complexity at first,
+ but the non-optimized version contains two tests of each
+ context while the optimized version contains only one
+ such test, as well as eliminating some of the inverted
+ logic (" !(...) || ").
+
+ Optimization 4: Computation of predicate gate trees
+
+ When generating code for the gates of predicate expressions
+ antlr 1.33 vanilla uses a recursive procedure to generate
+ "&&" and "||" expressions for testing the lookahead. As each
+ layer of the predicate tree is exposed a new set of "&&" and
+ "||" expressions on the lookahead are generated. In many
+ cases the lookahead being tested has already been tested.
+
+ With -mrhoist a lookahead tree is computed for the entire
+ lookahead expression. This means that predicates with identical
+ context or context which is a subset of another predicate's
+ context disappear.
+
+ This is especially important for predicates formed by rules
+ like the following:
+
+ uppperCaseVowel : <<isUpperCase(LATEXT(1))>>? vowel;
+ vowel: : <<isVowel(LATEXT(1))>>? LETTERS;
+
+ These predicates are combined using AND since both must be
+ satisfied for rule upperCaseVowel. They have identical
+ context which makes this optimization very effective.
+
+ The affect of Items #100a and #100b together can be dramatic. In
+ a very large (but real world) grammar one particular predicate
+ expression was reduced from an (unreadable) 50 predicate leaves,
+ 195 LA(1) terms, and 5500 characters to an (easily comprehensible)
+ 3 predicate leaves (all different) and a *single* LA(1) term.
+
+#98. (Changed in 1.33MR10) Option "-info p"
+
+ When the user selects option "-info p" the program will generate
+ detailed information about predicates. If the user selects
+ "-mrhoist on" additional detail will be provided explaining
+ the promotion and suppression of predicates. The output is part
+ of the generated file and sandwiched between #if 0/#endif statements.
+
+ Consider the following k=1 grammar:
+
+ start : ( all ) * ;
+
+ all : ( a
+ | b
+ )
+ ;
+
+ a : c B
+ ;
+
+ c : <<LATEXT(1)>>?
+ | B
+ ;
+
+ b : <<LATEXT(1)>>? X
+ ;
+
+ Below is an excerpt of the output for rule "start" for the three
+ predicate options (off, on, and maintenance release style hoisting).
+
+ For those who do not wish to use the "-mrhoist on" option for code
+ generation the option can be used in a "diagnostic" mode to provide
+ valuable information:
+
+ a. where one should insert null actions to inhibit hoisting
+ b. a chain of rule references which shows where predicates are
+ being hoisted
+
+ ======================================================================
+ Example of "-info p" with "-mrhoist on"
+ ======================================================================
+ #if 0
+
+ Hoisting of predicate suppressed by alternative without predicate.
+ The alt without the predicate includes all cases where the
+ predicate is false.
+
+ WITH predicate: line 11 v36.g
+ WITHOUT predicate: line 12 v36.g
+
+ The context set for the predicate:
+
+ B
+
+ The lookahead set for alt WITHOUT the semantic predicate:
+
+ B
+
+ The predicate:
+
+ pred << LATEXT(1)>>? depth=k=1 rule c line 11 v36.g
+
+ set context:
+ B
+ tree context: null
+
+ Chain of referenced rules:
+
+ #0 in rule start (line 1 v36.g) to rule all
+ #1 in rule all (line 3 v36.g) to rule a
+ #2 in rule a (line 8 v36.g) to rule c
+ #3 in rule c (line 11 v36.g)
+
+ #endif
+ &&
+ #if 0
+
+ pred << LATEXT(1)>>? depth=k=1 rule b line 15 v36.g
+
+ set context:
+ X
+ tree context: null
+
+ #endif
+ ======================================================================
+ Example of "-info p" with the default -prc setting ( "-prc off")
+ ======================================================================
+ #if 0
+
+ OR
+ pred << LATEXT(1)>>? depth=k=1 rule c line 11 v36.g
+
+ set context:
+ nil
+ tree context: null
+
+ pred << LATEXT(1)>>? depth=k=1 rule b line 15 v36.g
+
+ set context:
+ nil
+ tree context: null
+
+ #endif
+ ======================================================================
+ Example of "-info p" with "-prc on" and "-mrhoist off"
+ ======================================================================
+ #if 0
+
+ OR
+ pred << LATEXT(1)>>? depth=k=1 rule c line 11 v36.g
+
+ set context:
+ B
+ tree context: null
+
+ pred << LATEXT(1)>>? depth=k=1 rule b line 15 v36.g
+
+ set context:
+ X
+ tree context: null
+
+ #endif
+ ======================================================================
+
+#60. (Changed in 1.33MR7) Major changes to exception handling
+
+ There were significant problems in the handling of exceptions
+ in 1.33 vanilla. The general problem is that it can only
+ process one level of exception handler. For example, a named
+ exception handler, an exception handler for an alternative, or
+ an exception for a subrule always went to the rule's exception
+ handler if there was no "catch" which matched the exception.
+
+ In 1.33MR7 the exception handlers properly "nest". If an
+ exception handler does not have a matching "catch" then the
+ nextmost outer exception handler is checked for an appropriate
+ "catch" clause, and so on until an exception handler with an
+ appropriate "catch" is found.
+
+ There are still undesirable features in the way exception
+ handlers are implemented, but I do not have time to fix them
+ at the moment:
+
+ The exception handlers for alternatives are outside the
+ block containing the alternative. This makes it impossible
+ to access variables declared in a block or to resume the
+ parse by "falling through". The parse can still be easily
+ resumed in other ways, but not in the most natural fashion.
+
+ This results in an inconsistentcy between named exception
+ handlers and exception handlers for alternatives. When
+ an exception handler for an alternative "falls through"
+ it goes to the nextmost outer handler - not the "normal
+ action".
+
+ A major difference between 1.33MR7 and 1.33 vanilla is
+ the default action after an exception is caught:
+
+ 1.33 Vanilla
+ ------------
+ In 1.33 vanilla the signal value is set to zero ("NoSignal")
+ and the code drops through to the code following the exception.
+ For named exception handlers this is the "normal action".
+ For alternative exception handlers this is the rule's handler.
+
+ 1.33MR7
+ -------
+ In 1.33MR7 the signal value is NOT automatically set to zero.
+
+ There are two cases:
+
+ For named exception handlers: if the signal value has been
+ set to zero the code drops through to the "normal action".
+
+ For all other cases the code branches to the nextmost outer
+ exception handler until it reaches the handler for the rule.
+
+ The following macros have been defined for convenience:
+
+ C/C++ Mode Name
+ --------------------
+ (zz)suppressSignal
+ set signal & return signal arg to 0 ("NoSignal")
+ (zz)setSignal(intValue)
+ set signal & return signal arg to some value
+ (zz)exportSignal
+ copy the signal value to the return signal arg
+
+ I'm not sure why PCCTS make a distinction between the local
+ signal value and the return signal argument, but I'm loathe
+ to change the code. The burden of copying the local signal
+ value to the return signal argument can be given to the
+ default signal handler, I suppose.
+
+#53. (Explanation for 1.33MR6) What happens after an exception is caught ?
+
+ The Book is silent about what happens after an exception
+ is caught.
+
+ The following code fragment prints "Error Action" followed
+ by "Normal Action".
+
+ test : Word ex:Number <<printf("Normal Action\n");>>
+ exception[ex]
+ catch NoViableAlt:
+ <<printf("Error Action\n");>>
+ ;
+
+ The reason for "Normal Action" is that the normal flow of the
+ program after a user-written exception handler is to "drop through".
+ In the case of an exception handler for a rule this results in
+ the exection of a "return" statement. In the case of an
+ exception handler attached to an alternative, rule, or token
+ this is the code that would have executed had there been no
+ exception.
+
+ The user can achieve the desired result by using a "return"
+ statement.
+
+ test : Word ex:Number <<printf("Normal Action\n");>>
+ exception[ex]
+ catch NoViableAlt:
+ <<printf("Error Action\n"); return;>>
+ ;
+
+ The most powerful mechanism for recovery from parse errors
+ in pccts is syntactic predicates because they provide
+ backtracking. Exceptions allow "return", "break",
+ "consumeUntil(...)", "goto _handler", "goto _fail", and
+ changing the _signal value.
+
+#41. (Added in 1.33MR6) antlr -stdout
+
+ Using "antlr -stdout ..." forces the text that would
+ normally go to the grammar.c or grammar.cpp file to
+ stdout.
+
+#40. (Added in 1.33MR6) antlr -tab to change tab stops
+
+ Using "antlr -tab number ..." changes the tab stops
+ for the grammar.c or grammar.cpp file. The number
+ must be between 0 and 8. Using 0 gives tab characters,
+ values between 1 and 8 give the appropriate number of
+ space characters.
+
+#34. (Added to 1.33MR1) Add public DLGLexerBase::set_line(int newValue)
+
+ Previously there was no public function for changing the line
+ number maintained by the lexer.
+
+#28. (Added to 1.33MR1) More control over DLG header
+
+ Version 1.33MR1 adds the following directives to PCCTS
+ for C++ mode:
+
+ #lexprefix <<source code>>
+
+ Adds source code to the DLGLexer.h file
+ after the #include "DLexerBase.h" but
+ before the start of the class definition.
+
+ #lexmember <<source code>>
+
+ Adds source code to the DLGLexer.h file
+ as part of the DLGLexer class body. It
+ appears immediately after the start of
+ the class and a "public: statement.
+
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/KNOWN_PROBLEMS.txt b/BaseTools/Source/C/VfrCompile/Pccts/KNOWN_PROBLEMS.txt new file mode 100644 index 0000000000..5a9b22e1bd --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/KNOWN_PROBLEMS.txt @@ -0,0 +1,241 @@ +
+ =======================================================
+ Known Problems In PCCTS - Last revised 14 November 1998
+ =======================================================
+
+#17. The dlg fix for handling characters up to 255 is incorrect.
+
+ See item #207.
+
+ Reported by Frank Hartmann.
+
+#16. A note about "&&" predicates (Mike Dimmick)
+
+ Mike Dimmick has pointed out a potential pitfall in the use of the
+ "&&" style predicate. Consider:
+
+ r0: (g)? => <<P>>? r1
+ | ...
+ ;
+ r1: A | B;
+
+ If the context guard g is not a subset of the lookahead context for r1
+ (in other words g is neither A nor B) then the code may execute r1
+ even when the lookahead context is not satisfied. This is an error
+ by the person coding the grammer, and the error should be reported to
+ the user, but it isn't. expect. Some examples I've run seem to
+ indicate that such an error actually results in the rule becoming
+ unreachable.
+
+ When g is properly coded the code is correct, the problem is when g
+ is not properly coded.
+
+ A second problem reported by Mike Dimmick is that the test for a
+ failed validation predicate is equivalent to a test on the predicate
+ along. In other words, if the "&&" has not been hoisted then it may
+ falsely report a validation error.
+
+#15. (Changed in MR23) Warning for LT(i), LATEXT(i) in token match actions
+
+ An bug (or at least an oddity) is that a reference to LT(1), LA(1),
+ or LATEXT(1) in an action which immediately follows a token match
+ in a rule refers to the token matched, not the token which is in
+ the lookahead buffer. Consider:
+
+ r : abc <<action alpha>> D <<action beta>> E;
+
+ In this case LT(1) in action alpha will refer to the next token in
+ the lookahead buffer ("D"), but LT(1) in action beta will refer to
+ the token matched by D - the preceding token.
+
+ A warning has been added which warns users about this when an action
+ following a token match contains a reference to LT(1), LA(1), or LATEXT(1).
+
+ This behavior should be changed, but it appears in too many programs
+ now. Another problem, perhaps more significant, is that the obvious
+ fix (moving the consume() call to before the action) could change the
+ order in which input is requested and output appears in existing programs.
+
+ This problem was reported, along with a fix by Benjamin Mandel
+ (beny@sd.co.il). However, I felt that changing the behavior was too
+ dangerous for existing code.
+
+#14. Parsing bug in dlg
+
+ THM: I have been unable to reproduce this problem.
+
+ Reported by Rick Howard Mijenix Corporation (rickh@mijenix.com).
+
+ The regular expression parser (in rexpr.c) fails while
+ trying to parse the following regular expression:
+
+ {[a-zA-Z]:}(\\\\[a-zA-Z0-9]*)+
+
+ See my comment in the following excerpt from rexpr.c:
+
+ /*
+ * <regExpr> ::= <andExpr> ( '|' {<andExpr>} )*
+ *
+ * Return -1 if syntax error
+ * Return 0 if none found
+ * Return 1 if a regExrp was found
+ */
+ static
+ regExpr(g)
+ GraphPtr g;
+ {
+ Graph g1, g2;
+
+ if ( andExpr(&g1) == -1 )
+ {
+ return -1;
+ }
+
+ while ( token == '|' )
+ {
+ int a;
+ next();
+ a = andExpr(&g2);
+ if ( a == -1 ) return -1; /* syntax error below */
+ else if ( !a ) return 1; /* empty alternative */
+ g1 = BuildNFA_AorB(g1, g2);
+ }
+
+ if ( token!='\0' ) return -1;
+ *****
+ ***** It appears to fail here becuause token is 125 - the closing '}'
+ ***** If I change it to:
+ ***** if ( token!='\0' && token!='}' && token!= ')' ) return -1;
+ *****
+ ***** It succeeds, but I'm not sure this is the corrrect approach.
+ *****
+ *g = g1;
+ return 1;
+ }
+
+#13. dlg reports an invalid range for: [\0x00-\0xff]
+
+ Diagnosed by Piotr Eljasiak (eljasiak@no-spam.zt.gdansk.tpsa.pl):
+
+ Fixed in MR16.
+
+#12. Strings containing comment actions
+
+ Sequences that looked like C style comments appearing in string
+ literals are improperly parsed by antlr/dlg.
+
+ << fprintf(out," /* obsolete */ ");
+
+ For this case use:
+
+ << fprintf(out," \/\* obsolete \*\/ ");
+
+ Reported by K.J. Cummings (cummings@peritus.com).
+
+#11. User hook for deallocation of variables on guess fail
+
+ The mechanism outlined in Item #108 works only for
+ heap allocated variables.
+
+#10. Label re-initialization in ( X {y:Y} )*
+
+ If a label assignment is optional and appears in a
+ (...)* or (...)+ block it will not be reset to NULL
+ when it is skipped by a subsequent iteration.
+
+ Consider the example:
+
+ ( X { y:Y })* Z
+
+ with input:
+
+ X Y X Z
+
+ The first time through the block Y will be matched and
+ y will be set to point to the token. On the second
+ iteration of the (...)* block there is no match for Y.
+ But y will not be reset to NULL, as the user might
+ expect, it will contain a reference to the Y that was
+ matched in the first iteration.
+
+ The work-around is to manually reset y:
+
+ ( X << y = NULL; >> { y:Y } )* Z
+
+ or
+
+ ( X ( y:Y | << y = NULL; >> /* epsilon */ ) )* Z
+
+ Reported by Jeff Vincent (JVincent@novell.com).
+
+#9. PCCTAST.h PCCTSAST::setType() is a noop
+
+#8. #tokdefs with ~Token and .
+
+ THM: I have been unable to reproduce this problem.
+
+ When antlr uses #tokdefs to define tokens the fields of
+ #errclass and #tokclass do not get properly defined.
+ When it subsequently attempts to take the complement of
+ the set of tokens (using ~Token or .) it can refer to
+ tokens which don't have names, generating a fatal error.
+
+#7. DLG crashes on some invalid inputs
+
+ THM: In MR20 have fixed the most common cases.
+
+ The following token defintion will cause DLG to crash.
+
+ #token "()"
+
+ Reported by Mengue Olivier (dolmen@bigfoot.com).
+
+#6. On MS systems \n\r is treated as two new lines
+
+ Fixed.
+
+#5. Token expressions in #tokclass
+
+ #errclass does not support TOK1..TOK2 or ~TOK syntax.
+ #tokclass does not support ~TOKEN syntax
+
+ A workaround for #errclass TOK1..TOK2 is to use a
+ #tokclass.
+
+ Reported by Dave Watola (dwatola@amtsun.jpl.nasa.gov)
+
+#4. A #tokdef must appear "early" in the grammar file.
+
+ The "early" section of the grammar file is the only
+ place where the following directives may appear:
+
+ #header
+ #first
+ #tokdefs
+ #parser
+
+ Any other kind of statement signifiies the end of the
+ "early" section.
+
+#3. Use of PURIFY macro for C++ mode
+
+ Item #93 of the CHANGES_FROM_1.33 describes the use of
+ the PURIFY macro to zero arguments to be passed by
+ upward inheritance.
+
+ #define PURIFY(r, s) memset((char *) &(r), '\0', (s));
+
+ This may not be the right thing to do for C++ objects that
+ have constructors. Reported by Bonny Rais (bonny@werple.net.au).
+
+ For those cases one should #define PURIFY to be an empty macro
+ in the #header or #first actions.
+
+#2. Fixed in 1.33MR10 - See CHANGES_FROM_1.33 Item #80.
+
+#1. The quality of support for systems with 8.3 file names leaves
+ much to be desired. Since the kit is distributed using the
+ long file names and the make file uses long file names it requires
+ some effort to generate. This will probably not be changed due
+ to the large number of systems already written using the long
+ file names.
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/MPW_Read_Me b/BaseTools/Source/C/VfrCompile/Pccts/MPW_Read_Me new file mode 100644 index 0000000000..70a9d1bcad --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/MPW_Read_Me @@ -0,0 +1,21 @@ +
+1. You can control the creator type of generated files by changing a value of
+ #if control statement.
+
+
+ pccts:h:pcctscfg.h
+
+ line 225-231
+
+ #if 0
+ #define MAC_FILE_CREATOR 'MPS ' /* MPW Text files */
+ #endif
+ #if 0
+ #define MAC_FILE_CREATOR 'KAHL' /* THINK C/Symantec C++ Text files */
+ #endif
+ #if 0
+ #define MAC_FILE_CREATOR 'CWIE' /* Metrowerks C/C++ Text files */
+ #endif
+
+2. If you want to build 68K version. You must convert all source files to Macintosh
+ format before compile.
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/Makefile b/BaseTools/Source/C/VfrCompile/Pccts/Makefile new file mode 100644 index 0000000000..57eeda5934 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/Makefile @@ -0,0 +1,15 @@ +#
+# Main makefile for PCCTS 1.33MR33 /* MRXXX */
+#
+pccts:
+ pushd . & cd antlr & $(MAKE) /nologo /f AntlrMS.mak & popd
+ pushd . & cd dlg & $(MAKE) /nologo /f DlgMS.mak & popd
+
+clean:
+ pushd . & cd antlr & $(MAKE) /nologo /f AntlrMS.mak clean & popd
+ pushd . & cd dlg & $(MAKE) /nologo /f DlgMS.mak clean & popd
+
+cleanall:
+ pushd . & cd antlr & $(MAKE) /nologo /f AntlrMS.mak cleanall & popd
+ pushd . & cd dlg & $(MAKE) /nologo /f DlgMS.mak cleanall & popd
+
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/NOTES.bcc b/BaseTools/Source/C/VfrCompile/Pccts/NOTES.bcc new file mode 100644 index 0000000000..1ac05b17c5 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/NOTES.bcc @@ -0,0 +1,184 @@ +March 95
+Version 1.32 of pccts
+
+At the moment this file is available via anonymous FTP at
+
+ Node: marvin.ecn.purdue.edu
+ File: pub/pccts/1.32/NOTES.BCC
+
+Mail corrections or additions to David Seidel <71333.1575@compuserve.com>
+===============================================================================
+Notes on Building PCCTS 1.32 with Borland C++
+
+David Seidel, Innovative Data Concepts Incorporated
+CompuServe: 71333,1575
+Internet: 71333.1575@compuserve.com
+ dseidel@delphi.com
+
+I have gotten ANTLR and DLG to succesfully build with BCC 4.0, but have found
+from experience that ANTLR, in particular, is likely to run out of memory
+with grammars over a certain size, or with larger values for the -k and -ck
+options. Now that BCC 4.02 and the new Borland Power Pack for DOS is now
+available, I feel that there is no excuse not to build these tools as
+32-bit executables, as they ought to be.
+
+For people without the Power Pack, the makefiles below should be fairly easily
+modified to build 16-bit real-mode executables, but I don't really recommend
+it. As an alternative, you might consider the highly regarded DJGPP compiler
+(a DOS port of the Gnu GCC compiler, with a DOS extender included). Hopefully
+some other PCCTS who has DJGPP can provode whatever advice is necessary. The
+Watcom compiler is also an excellent possibility (albeit a commercial one),
+and I hope to make available Watcom makefiles in the near future.
+
+Here are the makefiles I am using. Both makefiles use a compiler configuration
+file that contains compiler switches such as optimization settings. I call
+this file bor32.cfg and keep a copy in both the ANTLR and DLG subdirectories.
+
+==== File: bor32.cfg (cut here) ===============================================
+-w-
+-RT-
+-x-
+-N-
+-k-
+-d
+-O2-e-l
+-Z
+-D__STDC__=1
+==== End of file bor32.cfg (cut here) =========================================
+
+==== File: antlr\bor32.mak (cut here) =========================================
+#
+# ANTLR 1.32 Makefile for Borland C++ 4.02 with DPMI 32-bit DOS extender by
+# David Seidel
+# Innovative Data Concepts Incorporated
+# 71333.1575@compuserve.com (or) dseidel@delphi.com
+#
+# Notes: 1. Compiler switches (optimization etc.) are contained in the
+# file bor32.cfg.
+# 2. This makefile requires Borland C++ 4.02 or greater with
+# the DOS Power Pack add-on package.
+# 3. Change the BCCDIR macro below to the topmost directory in
+# which BCC is installed on your system.
+#
+
+BCCDIR = d:\bc4
+CC = bcc32
+SET = ..\support\set
+PCCTS_H = ..\h
+ANTLR = ..\bin\antlr
+DLG = ..\bin\dlg
+CFLAGS = -I$(BCCDIR)\include -I. -I$(SET) -I$(PCCTS_H) -DUSER_ZZSYN \
+ +bor32.cfg
+LIBS = dpmi32 cw32
+OBJ_EXT = obj
+OBJS = antlr.obj scan.obj err.obj bits.obj build.obj fset2.obj fset.obj \
+ gen.obj globals.obj hash.obj lex.obj main.obj misc.obj pred.obj dialog.obj \
+ set.obj
+
+.c.obj:
+ $(CC) -c $(CFLAGS) {$&.c }
+
+antlr.exe: $(OBJS)
+ tlink32 @&&|
+-Tpe -ax -c -s -L$(BCCDIR)\lib +
+$(BCCDIR)\lib\c0x32 $**
+$@
+
+$(LIBS)
+;
+|
+ copy *.exe ..\bin
+
+
+# *********** Target list of PC machines ***********
+#
+# Don't worry about the ambiguity messages coming from antlr
+# for making antlr.c etc... [should be 10 of them, I think]
+#
+
+# leave this commented out for initial build!
+#antlr.c stdpccts.h parser.dlg tokens.h err.c : antlr.g
+# $(ANTLR) antlr.g
+
+antlr.$(OBJ_EXT): antlr.c mode.h tokens.h
+
+scan.$(OBJ_EXT): scan.c mode.h tokens.h
+
+# leave this commented out for initial build!
+#scan.c mode.h: parser.dlg
+# $(DLG) -C2 parser.dlg scan.c
+
+set.$(OBJ_EXT): $(SET)\set.c
+ $(CC) -c $(CFLAGS) $(SET)\set.c
+
+==== End of file antlr\bor32.mak (cut here) ===================================
+
+==== File: dlg\bor32.mak (cut here) ===========================================
+#
+# DLG 1.32 Makefile for Borland C++ 4.02 with DPMI 32-bit DOS extender by
+# David Seidel
+# Innovative Data Concepts Incorporated
+# 71333.1575@compuserve.com (or) dseidel@delphi.com
+#
+# Notes: 1. Compiler switches (optimization etc.) are contained in the
+# file bor32.cfg.
+# 2. This makefile requires Borland C++ 4.02 or greater with
+# the DOS Power Pack add-on package.
+# 3. Change the BCCDIR macro below to the topmost directory in
+# which BCC is installed on your system.
+#
+
+
+BCCDIR = d:\bc4
+CC = bcc32
+SET = ..\support\set
+PCCTS_H = ..\h
+ANTLR = ..\bin\antlr
+DLG = ..\bin\dlg
+CFLAGS = -I$(BCCDIR)\include -I. -I$(SET) -I$(PCCTS_H) -DUSER_ZZSYN \
+ +bor32.cfg
+LIBS = dpmi32 cw32
+OBJ_EXT = obj
+OBJS = dlg_p.obj dlg_a.obj main.obj err.obj support.obj \
+ output.obj relabel.obj automata.obj set.obj
+
+.c.obj:
+ $(CC) -c $(CFLAGS) {$&.c }
+
+dlg.exe : $(OBJS)
+ tlink32 @&&|
+-Tpe -ax -c -s -L$(BCCDIR)\lib +
+c0x32 $**
+$@
+
+$(LIBS)
+;
+|
+ copy *.exe ..\bin
+
+dlg_p.obj: dlg_p.c
+
+dlg_a.obj: dlg_a.c
+
+main.obj: main.c
+
+err.obj: err.c
+
+support.obj: support.c
+
+output.obj: output.c
+
+relabel.obj: relabel.c
+
+automata.obj: automata.c
+
+set.$(OBJ_EXT): $(SET)\set.c
+ $(CC) -c $(CFLAGS) $(SET)\set.c
+
+==== End of file dlg\bor32.mak (cut here) =====================================
+
+
+
+
+
+
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/NOTES.msvc b/BaseTools/Source/C/VfrCompile/Pccts/NOTES.msvc new file mode 100644 index 0000000000..86f8ed66e0 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/NOTES.msvc @@ -0,0 +1,189 @@ +
+ Microsoft Visual C Stuff
+
+
+[Tom Moog 2-Oct-98
+
+ Users of Microsoft Visual C++ should download a separate
+ ready-to-run zip file from my web site. It contains
+ binaries, static library, and a sample project.
+]
+
+[
+ Two notes added by Tom Moog 23-Sep-97. I believe the *.dsp and
+ *.mak files that were once at the end of this file are now obsolete.
+
+ The following MSVC .dsp and .mak files for pccts and sorcerer
+ were contributed by Stanislaw Bochnak (S.Bochnak@microtool.com.pl)
+ and Jeff Vincent (jvincent@novell.com)
+
+ PCCTS Distribution Kit
+ ----------------------
+ pccts/antlr/AntlrMSVC50.dsp
+ pccts/antlr/AntlrMSVC50.mak
+
+ pccts/dlg/DlgMSVC50.dsp
+ pccts/dlg/DlgMSVC50.mak
+
+ pccts/support/genmk/watgenmk.mak
+ pccts/support/msvc.dsp
+
+ Sorcerer Distribution Kit
+ -------------------------
+ pccts/sorcerer/SorcererMSVC50.dsp
+ pccts/sorcerer/SorcererMSVC50.mak
+
+ pccts/sorcerer/lib/msvc.dsp
+
+ I do not have an MS based computer. If you discover problems
+ please report them so as to save trouble for others in the future.
+]
+
+[
+ Modified by Terence Parr (September 1995) to change .C to .cpp
+]
+
+[
+ This file contains notes on MSVC for Windows NT console execs by Dave
+ Seidel and an explanation of flags etc.. by John Hall; good luck,
+ Terence
+]
+
+===============================================================================
+Date: Sat, 31 Dec 1994 11:40:36 -0500 (EST)
+From: David Seidel <75342.2034@compuserve.com>
+
+I've succesfully build 1.31b3 with djgpp for DOS and MSVC 2.0 for Windows
+NT. The only (minor) problem I had was that GNU make (version 3.71, in the
+djgpp port) complained about "multiple targets" in both the antlr and dlg
+makefiles. I got around the error by, in each makefile, commenting out the
+$(SRC) dependency, for example:
+
+ antlr: $(OBJ) #$(SRC)
+
+I don't know why this is happenning, since you haven't changed that part of
+the makefile at all, and I think this used to work ok...
+
+Here are the makefiles I built from within the MSVC 2.0 environment for antlr
+and dlg and Windows NT console executables. Please feel free to pass them
+on. Of course, as soon as 1.31 "goes gold", I will send you nice new
+binaries. I'm not going to bother to keep doing both Borland and djgpp for
+DOS however. Instead, I'll just keep the djgpp version up to date and also
+provide WinNT binaries.
+
+Dave
+===============================================================================
+
+ How to port PCCTS 1.10 (and 1.32 hopefully) to Visual C++
+
+ By
+
+ John Hall <jhall@ivy.wpi.edu>
+
+Here is how to compile an ANTLR grammar in Visual C++. These steps
+describe how to have your ANTLR grammar parse the input file the user
+selects when they choose File Open in your Windows application. (Even
+if you aren't using Visual C++, the steps should be portable enough to
+other compilers.)
+
+ * Make sure that ANTLR and DLG generate ANSI code (use the -ga
+ switch).
+
+ * Set the following compiler flags in Visual C++ (these are in the
+ Memory Model category of the compiler options in the Project
+ Options menu):
+
+ FLAG MEANING
+ ==== ==============================================================
+ /AL Large memory model (multiple data segments; data items must be
+ smaller than 64K).
+
+ /Gtn Allocates all items whose size is greater than or equal to n
+ in a new data segment. (I let n be 256: /Gt256.)
+
+ /Gx- All references to data items are done with far addressing in
+ case they are placed in a far segment.
+
+ * Add the following member variable to the attributes section of your
+ derived CDocument class (you will need to make sure you also
+ include stdio.h):
+
+ FILE *fp;
+
+ * Add the following method to your derived CDocument class:
+
+ BOOL CAppDoc::OnOpenDocument(const char* pszPathName)
+ {
+ // Call CDocument's OnOpenDocument to do housekeeping for us
+ // DON'T add anything to the loading section of Serialize
+ if (!CDocument::OnOpenDocument(pszPathName))
+ return FALSE;
+
+ // Open input file
+ if ((fp = fopen(pszPathName, "r")) == NULL)
+ return FALSE;
+
+ // Parse input file
+ ANTLR(start(), fp);
+
+ // Close input file
+ fclose(fp);
+ return TRUE;
+ }
+
+ (Note: additional code may be necessary, depending on your parser.
+ For example, if your parser uses PCCTS's symbol table library, you
+ will need to insert calls to zzs_init and zzs_done.)
+
+ * Compile the generated C files as C++ files. (I renamed the files
+ to have a .CPP extension to fool Visual C++ into thinking they were
+ C++ files. One might also use the /Tp switch, but that switch
+ requires you separately include the filename.) [I used this step
+ as an easy out for all the external linking errors I was getting
+ that I couldn't fix by declaring things extern "C".]
+
+ * Make sure the __STDC__ portion of the generated files gets
+ compiled. (Either define __STDC__ yourself or else change all
+ occurrences of __STDC__ to __cplusplus in the generated files. You
+ can define __STDC__ in the Preprocessor category of the compiler
+ options.)
+
+ ================================================================
+ = Note 23-Sep-97: This is probably not necessary any more. =
+ = With 1.33MRxxx the use of __STDC__ was replaced with the =
+ = macro __USE_PROTOS to control the compilation of prototypes. =
+ ================================================================
+
+That last step is important for Visual C++, but may not apply to other
+compilers. For C++ compilers, whether __STDC__ is defined is
+implementation dependent (ARM, page 379). Apparently, Visual C++ does
+not to define it; it also does not support "old style" C function
+definitions (which is okay, according to page 404 of the ARM). Those
+two things together caused problems when trying to port the code.
+When it saw this:
+
+#ifdef __STDC__
+void
+globals(AST **_root)
+#else
+globals(_root)
+AST **_root;
+#endif
+
+it skipped the __STDC__ section and tried to process the "old style"
+function definition, where it choked.
+
+When you finally get your parser to compile and link without error,
+you may get General Protection Fault errors at run time. The problem
+I had was that a NULL was passed to a variable argument function
+without an explicit cast. The function grabbed a pointer (32-bits)
+off the stack using va_arg, but the NULL was passed silently as the
+integer 0 (16 bits), making the resulting pointer was invalid. (This
+was in PCCTS's sample C parser.)
+
+There is one other thing I might suggest to help you avoid a run-time
+error. Make sure you redefine the default error reporting function,
+zzsyn. To do this, put "#define USER_ZZSYN" in your #header section
+and put your own zzsyn somewhere. You can then pop up a MessageBox or
+print the error to some output window.
+===============================================================================
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/README b/BaseTools/Source/C/VfrCompile/Pccts/README new file mode 100644 index 0000000000..d089b638b4 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/README @@ -0,0 +1,159 @@ +
+ Parr Research Corporation
+ with
+ Purdue University Electrical Engineering
+ and
+ University of Minnesota, AHPCRC
+
+ Terence Parr
+ Russell Quong
+ Will Cohen
+ Hank Dietz
+
+
+A central place for information about PCCTS 1.33 is:
+
+ http://www.polhode.com/pccts.html
+
+The maintenance release is available from:
+
+ http://www.polhode.com/pccts133mr.zip
+
+There is a ready-to-run version for win32 for Microsoft Visual Studio
+at the same site. It is available from:
+
+ http://www.polhode.com/win32.zip
+
+New users should visit http://www.polhode.com/pccts.html in
+order to get the following document:
+
+ "Notes For New Users of PCCTS"
+
+This is a Postscript file of about 40 pages which is extremely
+useful for someone starting out. It is a based on 1.33mr21
+
+When you have a little more experience, be sure to review the
+following documents in the distribution kit:
+
+ CHANGES_FROM_133.txt
+ CHANGES_FROM_133_BEFORE_MR13.txt
+ KNOWN_PROBLEMS.txt
+
+-------------------------------------------------------------------------
+ INSTALLATION (Unix)
+-------------------------------------------------------------------------
+0. Download http://www.polhode.com/pccts133mr.zip
+
+1. Unzip the distribution kit to your preferred location.
+ If there are newline problems try using zip -a ...
+
+2. cd to the main pccts directory.
+
+3. make
+
+ This will create:
+
+ antlr
+ dlg
+ sorcerer
+ genmk
+
+4. Copy to /usr/local/bin or /usr/local/bin if you like. If you
+ don't wish to then add pccts/bin to your path.
+
+5. To get an up-to-date list of program options execute the
+ program with no command line options. To get up-to-date
+ documentation read CHANGES_FROM_133*.txt and KNOWN_PROBLEMS.txt
+ at:
+
+ http://www.polhode.com/pccts.html
+
+6. You need not create a library. The makefile created by genmk
+ assumes that the files are not part of a library.
+
+ If you wish to create a library from elements of pccts/h:
+
+ If the first letter of the filename is lowercase (uppercase) it is
+ related to the code generated using the pccts C mode (C++ mode).
+ Some of the .c and .cpp files in the h directory are not meant to
+ be placed in a library and will not compile because they are meant
+ to be #include in pccts generated files which are grammar specific.
+
+ For C++ users place the following elements in the library:
+
+ AParser.cpp
+ ASTBase.cpp
+ ATokenBuffer.cpp
+ BufFileInput.cpp (optional)
+ DLexerBase.cpp
+ PCCTSAST.cpp
+ SList.cpp
+
+-------------------------------------------------------------------------
+ INSTALLATION (Win32)
+-------------------------------------------------------------------------
+
+I've tried to keep the win32 kit to the minimum necessary to get
+up and running. The complete kit contains additional information
+(some historical), source code, and DevStudio projects for
+rebuilding pccts from the source code.
+
+The kit is now distributed with both MSVC 5 and MSVC6 style projects.
+
+0. Download http://www.polhode.com/win32.zip.
+
+ You may also wish to download:
+
+ http://www.polhode.com/CHANGES_FROM_133.txt
+ http://www.polhode.com/CHANGES_FROM_133_BEFORE_MR13.txt
+ http://www.polhode.com/KNOWN_PROBLEMS.txt
+
+1. Unzip the distribution kit to your preferred location.
+
+ This will create:
+
+ a pccts directory tree
+ pccts/bin/*.exe
+ pccts/lib/*.lib
+ pccts/h/*
+ sorcerer/lib/*
+ sorcerer/h/*
+
+ an example directory tree
+ pccts\example\calcAST\*
+ pccts\example\simple\*
+
+2. Define the environment variable PCCTS to point to the main
+ pccts directory.
+
+3. Try building the simple project: pccts\example\simple\simple50.dsw
+ or simple60.dsw.
+
+4. Try building the complex project: pccts\example\calcAST\calcAST50.dsw
+ or calcAST60.dsw.
+
+-------------------------------------------------------------------------
+ INSTALLATION (DEC/VMS)
+-------------------------------------------------------------------------
+
+DEC/VMS support added by Piéronne Jean-François (jfp@altavista.net)
+
+0. Download http://www.polhode.com/pccts133mr.zip
+
+1. Unzip the distribution kit to your preferred location.
+
+2. set default to the main pccts directory.
+
+3. @makefile.vms
+
+ This will create in directory [.bin]:
+
+ antlr.exe
+ dlg.exe
+ sorcerer.exe
+ genmk.exe
+
+5. To get an up-to-date list of program options execute the
+ program with no command line options. To get up-to-date
+ documentation read CHANGES_FROM_133*.txt and KNOWN_PROBLEMS.txt
+ at http://www.polhode.com/pccts.html.
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/RIGHTS b/BaseTools/Source/C/VfrCompile/Pccts/RIGHTS new file mode 100644 index 0000000000..9db175ff40 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/RIGHTS @@ -0,0 +1,26 @@ +
+SOFTWARE RIGHTS
+
+We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+Set (PCCTS) -- PCCTS is in the public domain. An individual or
+company may do whatever they wish with source code distributed with
+PCCTS or the code generated by PCCTS, including the incorporation of
+PCCTS, or its output, into commerical software.
+
+We encourage users to develop software with PCCTS. However, we do ask
+that credit is given to us for developing PCCTS. By "credit", we mean
+that if you incorporate our source code into one of your programs
+(commercial product, research project, or otherwise) that you
+acknowledge this fact somewhere in the documentation, research report,
+etc... If you like PCCTS and have developed a nice tool with the
+output, please mention that you developed it using PCCTS. In
+addition, we ask that this header remain intact in our source code.
+As long as these guidelines are kept, we expect to continue enhancing
+this system and expect to make other tools available as they are
+completed.
+
+ANTLR 1.33
+Terence Parr
+Parr Research Corporation
+with Purdue University and AHPCRC, University of Minnesota
+1989-1995
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/AntlrDDK.mak b/BaseTools/Source/C/VfrCompile/Pccts/antlr/AntlrDDK.mak new file mode 100644 index 0000000000..71b7c6b0b1 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/AntlrDDK.mak @@ -0,0 +1,233 @@ +# PCCTS directory
+
+# You will need to set the LIB variable similar to this.
+# LIB="C:/Program Files/Microsoft Visual Studio .NET 2003/Vc7/lib;c:/Microsoft Visual Studio .NET 2003/Vc7/PlatformSDK/Lib"
+
+# PCCTS_HOME=<your PCCTS_HOME>
+PCCTS_HOME=$(WORKSPACE)\Tools\CCode\Source\Pccts
+ANTLR_SRC=$(PCCTS_HOME)\antlr
+PCCTS_H=$(PCCTS_HOME)\h
+
+
+# Support directories
+SET=$(PCCTS_HOME)\support\set
+
+
+# Compiler stuff
+CC = cl
+CFLAGS = /nologo -I "." -I "$(PCCTS_H)" -I "$(SET)" -D "USER_ZZSYN" -D "PC" \
+ -D "ZZLEXBUFSIZE=65536" -D "LONGFILENAMES" /Zi /W3 -D__USE_PROTOS /wd4700
+
+ANTLR_OBJS = antlr.obj scan.obj err.obj bits.obj build.obj fset2.obj \
+ fset.obj gen.obj globals.obj hash.obj lex.obj main.obj \
+ misc.obj pred.obj egman.obj mrhoist.obj fcache.obj
+
+SUPPORT_OBJS = set.obj
+
+# Dependencies
+
+$(WORKSPACE)\Tools\bin\antlr.exe: $(ANTLR_OBJS) $(SUPPORT_OBJS)
+ $(CC) $(CFLAGS) -o antlr.exe bufferoverflowu.lib $(ANTLR_OBJS) $(SUPPORT_OBJS)
+ del *.obj
+ move antlr.exe $(WORKSPACE)\Tools\bin
+
+
+antlr.obj: $(ANTLR_SRC)\antlr.c \
+ $(PCCTS_H)\antlr.h \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\mode.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+ $(ANTLR_SRC)\tokens.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\antlr.c
+
+scan.obj: $(ANTLR_SRC)\scan.c \
+ $(PCCTS_H)\antlr.h \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgauto.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\mode.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+ $(ANTLR_SRC)\tokens.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\scan.c
+
+err.obj: $(ANTLR_SRC)\err.c \
+ $(PCCTS_H)\antlr.h \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(PCCTS_H)\err.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+ $(ANTLR_SRC)\tokens.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\err.c
+
+bits.obj: $(ANTLR_SRC)\bits.c \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\bits.c
+
+build.obj: $(ANTLR_SRC)\build.c \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\build.c
+
+fset2.obj: $(ANTLR_SRC)\fset2.c \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\fset2.c
+
+fset.obj: $(ANTLR_SRC)\fset.c \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\fset.c
+
+gen.obj: $(ANTLR_SRC)\gen.c \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\gen.c
+
+globals.obj: $(ANTLR_SRC)\globals.c \
+ $(PCCTS_H)\config.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\globals.c
+
+hash.obj: $(ANTLR_SRC)\hash.c \
+ $(PCCTS_H)\config.h \
+ $(ANTLR_SRC)\hash.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\hash.c
+
+lex.obj: $(ANTLR_SRC)\lex.c \
+ $(PCCTS_H)\config.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\lex.c
+
+main.obj: $(ANTLR_SRC)\main.c \
+ $(PCCTS_H)\antlr.h \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\mode.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\stdpccts.h \
+ $(ANTLR_SRC)\syn.h \
+ $(ANTLR_SRC)\tokens.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\main.c
+
+misc.obj: $(ANTLR_SRC)\misc.c \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\misc.c
+
+pred.obj: $(ANTLR_SRC)\pred.c \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\pred.c
+
+egman.obj: $(ANTLR_SRC)\egman.c \
+ $(PCCTS_H)\config.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\egman.c
+
+mrhoist.obj: $(ANTLR_SRC)\mrhoist.c \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\mrhoist.c
+
+fcache.obj: $(ANTLR_SRC)\fcache.c \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\fcache.c
+
+set.obj: $(SET)\set.c \
+ $(PCCTS_H)\config.h \
+ $(SET)\set.h \
+
+ $(CC) -c $(CFLAGS) $(SET)\set.c
+
+clean:
+ del *.obj
+
+distclean:
+ del *.obj
+ del $(WORKSPACE)\Tools\bin\antlr.exe
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/AntlrMS.mak b/BaseTools/Source/C/VfrCompile/Pccts/antlr/AntlrMS.mak new file mode 100644 index 0000000000..8d87547a50 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/AntlrMS.mak @@ -0,0 +1,238 @@ +# PCCTS directory
+
+# You will need to set the LIB variable similar to this.
+# LIB="C:/Program Files/Microsoft Visual Studio .NET 2003/Vc7/lib;c:/Microsoft Visual Studio .NET 2003/Vc7/PlatformSDK/Lib"
+
+# PCCTS_HOME=<your PCCTS_HOME>
+PCCTS_HOME=$(BASE_TOOLS_PATH)\Source\C\VfrCompile\Pccts
+ANTLR_SRC=$(PCCTS_HOME)\antlr
+PCCTS_H=$(PCCTS_HOME)\h
+
+
+# Support directories
+SET=$(PCCTS_HOME)\support\set
+
+
+# Compiler stuff
+CC = cl
+CFLAGS = /nologo -I "." -I "$(PCCTS_H)" -I "$(SET)" -D "USER_ZZSYN" -D "PC" \
+ -D "ZZLEXBUFSIZE=65536" /D "LONGFILENAMES" /Zi /W3 -D__USE_PROTOS /wd4700 \
+ /D _CRT_SECURE_NO_DEPRECATE /D _CRT_NONSTDC_NO_DEPRECATE
+
+ANTLR_OBJS = antlr.obj scan.obj err.obj bits.obj build.obj fset2.obj \
+ fset.obj gen.obj globals.obj hash.obj lex.obj main.obj \
+ misc.obj pred.obj egman.obj mrhoist.obj fcache.obj
+
+SUPPORT_OBJS = set.obj
+
+# Dependencies
+
+$(EDK_TOOLS_PATH)\Bin\Win32\antlr.exe: $(ANTLR_OBJS) $(SUPPORT_OBJS)
+ $(CC) $(CFLAGS) -Feantlr.exe $(ANTLR_OBJS) $(SUPPORT_OBJS)
+ copy antlr.exe $(EDK_TOOLS_PATH)\Bin\Win32
+
+
+antlr.obj: $(ANTLR_SRC)\antlr.c \
+ $(PCCTS_H)\antlr.h \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\mode.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+ $(ANTLR_SRC)\tokens.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\antlr.c
+
+scan.obj: $(ANTLR_SRC)\scan.c \
+ $(PCCTS_H)\antlr.h \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgauto.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\mode.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+ $(ANTLR_SRC)\tokens.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\scan.c
+
+err.obj: $(ANTLR_SRC)\err.c \
+ $(PCCTS_H)\antlr.h \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(PCCTS_H)\err.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+ $(ANTLR_SRC)\tokens.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\err.c
+
+bits.obj: $(ANTLR_SRC)\bits.c \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\bits.c
+
+build.obj: $(ANTLR_SRC)\build.c \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\build.c
+
+fset2.obj: $(ANTLR_SRC)\fset2.c \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\fset2.c
+
+fset.obj: $(ANTLR_SRC)\fset.c \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\fset.c
+
+gen.obj: $(ANTLR_SRC)\gen.c \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\gen.c
+
+globals.obj: $(ANTLR_SRC)\globals.c \
+ $(PCCTS_H)\config.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\globals.c
+
+hash.obj: $(ANTLR_SRC)\hash.c \
+ $(PCCTS_H)\config.h \
+ $(ANTLR_SRC)\hash.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\hash.c
+
+lex.obj: $(ANTLR_SRC)\lex.c \
+ $(PCCTS_H)\config.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\lex.c
+
+main.obj: $(ANTLR_SRC)\main.c \
+ $(PCCTS_H)\antlr.h \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\mode.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\stdpccts.h \
+ $(ANTLR_SRC)\syn.h \
+ $(ANTLR_SRC)\tokens.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\main.c
+
+misc.obj: $(ANTLR_SRC)\misc.c \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\misc.c
+
+pred.obj: $(ANTLR_SRC)\pred.c \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\pred.c
+
+egman.obj: $(ANTLR_SRC)\egman.c \
+ $(PCCTS_H)\config.h \
+ $(SET)\set.h \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\egman.c
+
+mrhoist.obj: $(ANTLR_SRC)\mrhoist.c \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\mrhoist.c
+
+fcache.obj: $(ANTLR_SRC)\fcache.c \
+ $(ANTLR_SRC)\generic.h \
+ $(ANTLR_SRC)\hash.h \
+ $(ANTLR_SRC)\proto.h \
+ $(ANTLR_SRC)\syn.h \
+
+ $(CC) -c $(CFLAGS) $(ANTLR_SRC)\fcache.c
+
+set.obj: $(SET)\set.c \
+ $(PCCTS_H)\config.h \
+ $(SET)\set.h \
+
+ $(CC) -c $(CFLAGS) $(SET)\set.c
+
+clean:
+ -del *.obj
+ -del *.ilk
+ -del *.pdb
+
+cleanall:
+ -del *.obj
+ -del *.ilk
+ -del *.pdb
+ -del *.exe
+ -del $(EDK_TOOLS_PATH)\Bin\Win32\antlr.exe
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/AntlrPPC.mak b/BaseTools/Source/C/VfrCompile/Pccts/antlr/AntlrPPC.mak new file mode 100644 index 0000000000..9ede60d64c --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/AntlrPPC.mak @@ -0,0 +1,101 @@ +# Target: antlrPPC
+# Sources: ::support:set:set.c
+# antlr.c
+# bits.c
+# build.c
+# egman.c
+# err.c
+# fcache.c
+# fset2.c
+# fset.c
+# gen.c
+# globals.c
+# hash.c
+# lex.c
+# main.c
+# misc.c
+# mrhoist.c
+# pred.c
+# scan.c
+# Created: Sunday, May 17, 1998 10:24:53 PM
+# Author: Kenji Tanaka
+MAKEFILE = antlrPPC.make
+¥MondoBuild¥ = {MAKEFILE} # Make blank to avoid rebuilds when makefile is modified
+Includes = ¶
+ -i "::h:" ¶
+ -i "::support:set:"
+Sym¥PPC =
+ObjDir¥PPC = :Obj:
+PPCCOptions = {Includes} {Sym¥PPC} -w off -d MPW -d __STDC__=1 -d USER_ZZSYN
+Objects¥PPC = ¶
+ "{ObjDir¥PPC}set.c.x" ¶
+ "{ObjDir¥PPC}antlr.c.x" ¶
+ "{ObjDir¥PPC}bits.c.x" ¶
+ "{ObjDir¥PPC}build.c.x" ¶
+ "{ObjDir¥PPC}egman.c.x" ¶
+ "{ObjDir¥PPC}err.c.x" ¶
+ "{ObjDir¥PPC}fcache.c.x" ¶
+ "{ObjDir¥PPC}fset2.c.x" ¶
+ "{ObjDir¥PPC}fset.c.x" ¶
+ "{ObjDir¥PPC}gen.c.x" ¶
+ "{ObjDir¥PPC}globals.c.x" ¶
+ "{ObjDir¥PPC}hash.c.x" ¶
+ "{ObjDir¥PPC}lex.c.x" ¶
+ "{ObjDir¥PPC}main.c.x" ¶
+ "{ObjDir¥PPC}misc.c.x" ¶
+ "{ObjDir¥PPC}mrhoist.c.x" ¶
+ "{ObjDir¥PPC}pred.c.x" ¶
+ "{ObjDir¥PPC}scan.c.x"
+antlrPPC ÄÄ {¥MondoBuild¥} {Objects¥PPC}
+ PPCLink ¶
+ -o {Targ} {Sym¥PPC} ¶
+ {Objects¥PPC} ¶
+ -t 'MPST' ¶
+ -c 'MPS ' ¶
+ "{SharedLibraries}InterfaceLib" ¶
+ "{SharedLibraries}StdCLib" ¶
+ #"{SharedLibraries}MathLib" ¶
+ "{PPCLibraries}StdCRuntime.o" ¶
+ "{PPCLibraries}PPCCRuntime.o" ¶
+ "{PPCLibraries}PPCToolLibs.o"
+"{ObjDir¥PPC}set.c.x" Ä {¥MondoBuild¥} "::support:set:set.c"
+ {PPCC} "::support:set:set.c" -o {Targ} {PPCCOptions}
+"{ObjDir¥PPC}antlr.c.x" Ä {¥MondoBuild¥} antlr.c
+ {PPCC} antlr.c -o {Targ} {PPCCOptions}
+"{ObjDir¥PPC}bits.c.x" Ä {¥MondoBuild¥} bits.c
+ {PPCC} bits.c -o {Targ} {PPCCOptions}
+"{ObjDir¥PPC}build.c.x" Ä {¥MondoBuild¥} build.c
+ {PPCC} build.c -o {Targ} {PPCCOptions}
+"{ObjDir¥PPC}egman.c.x" Ä {¥MondoBuild¥} egman.c
+ {PPCC} egman.c -o {Targ} {PPCCOptions}
+"{ObjDir¥PPC}err.c.x" Ä {¥MondoBuild¥} err.c
+ {PPCC} err.c -o {Targ} {PPCCOptions}
+"{ObjDir¥PPC}fcache.c.x" Ä {¥MondoBuild¥} fcache.c
+ {PPCC} fcache.c -o {Targ} {PPCCOptions}
+"{ObjDir¥PPC}fset2.c.x" Ä {¥MondoBuild¥} fset2.c
+ {PPCC} fset2.c -o {Targ} {PPCCOptions}
+"{ObjDir¥PPC}fset.c.x" Ä {¥MondoBuild¥} fset.c
+ {PPCC} fset.c -o {Targ} {PPCCOptions}
+"{ObjDir¥PPC}gen.c.x" Ä {¥MondoBuild¥} gen.c
+ {PPCC} gen.c -o {Targ} {PPCCOptions}
+"{ObjDir¥PPC}globals.c.x" Ä {¥MondoBuild¥} globals.c
+ {PPCC} globals.c -o {Targ} {PPCCOptions}
+"{ObjDir¥PPC}hash.c.x" Ä {¥MondoBuild¥} hash.c
+ {PPCC} hash.c -o {Targ} {PPCCOptions}
+"{ObjDir¥PPC}lex.c.x" Ä {¥MondoBuild¥} lex.c
+ {PPCC} lex.c -o {Targ} {PPCCOptions}
+"{ObjDir¥PPC}main.c.x" Ä {¥MondoBuild¥} main.c
+ {PPCC} main.c -o {Targ} {PPCCOptions}
+"{ObjDir¥PPC}misc.c.x" Ä {¥MondoBuild¥} misc.c
+ {PPCC} misc.c -o {Targ} {PPCCOptions}
+"{ObjDir¥PPC}mrhoist.c.x" Ä {¥MondoBuild¥} mrhoist.c
+ {PPCC} mrhoist.c -o {Targ} {PPCCOptions}
+"{ObjDir¥PPC}pred.c.x" Ä {¥MondoBuild¥} pred.c
+ {PPCC} pred.c -o {Targ} {PPCCOptions}
+"{ObjDir¥PPC}scan.c.x" Ä {¥MondoBuild¥} scan.c
+ {PPCC} scan.c -o {Targ} {PPCCOptions}
+
+antlrPPC ÄÄ antlr.r
+ Rez antlr.r -o antlrPPC -a
+Install Ä antlrPPC
+ Duplicate -y antlrPPC "{MPW}"Tools:antlr
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/README b/BaseTools/Source/C/VfrCompile/Pccts/antlr/README new file mode 100644 index 0000000000..d7fc95916e --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/README @@ -0,0 +1,19 @@ + ANTLR 1.33
+
+This directory contains the files necessary to build ANTLR.
+
+If you do a "make scrub", ANTLR will have to run on antlr.g and DLG
+will have to run on parser.dlg. Either
+
+(1) ANTLR uses the previous antlr in that directory to rebuild itself
+(2) Needs to find antlr on the search path
+
+You will find that running "antlr -gh antlr.g" will result in about
+10 ambiguity warnings. These are normal. Don't worry.
+
+If you do a "make clean" right after installation, ANTLR and DLG should
+not need to run; only the C files will compile.
+
+Don't forget to go into the makefile to uncomment the appropriate
+definitions for your OS/architecture/compiler or see the appropriate
+NOTES.?? file.
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.1 b/BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.1 new file mode 100644 index 0000000000..acfa85b066 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.1 @@ -0,0 +1,209 @@ +.TH ANTLR 1 "September 1995" "ANTLR" "PCCTS Manual Pages"
+.SH NAME
+antlr \- ANother Tool for Language Recognition
+.SH SYNTAX
+.LP
+\fBantlr\fR [\fIoptions\fR] \fIgrammar_files\fR
+.SH DESCRIPTION
+.PP
+\fIAntlr\fP converts an extended form of context-free grammar into a
+set of C functions which directly implement an efficient form of
+deterministic recursive-descent LL(k) parser. Context-free grammars
+may be augmented with predicates to allow semantics to influence
+parsing; this allows a form of context-sensitive parsing. Selective
+backtracking is also available to handle non-LL(k) and even
+non-LALR(k) constructs. \fIAntlr\fP also produces a definition of a
+lexer which can be automatically converted into C code for a DFA-based
+lexer by \fIdlg\fR. Hence, \fIantlr\fR serves a function much like
+that of \fIyacc\fR, however, it is notably more flexible and is more
+integrated with a lexer generator (\fIantlr\fR directly generates
+\fIdlg\fR code, whereas \fIyacc\fR and \fIlex\fR are given independent
+descriptions). Unlike \fIyacc\fR which accepts LALR(1) grammars,
+\fIantlr\fR accepts LL(k) grammars in an extended BNF notation \(em
+which eliminates the need for precedence rules.
+.PP
+Like \fIyacc\fR grammars, \fIantlr\fR grammars can use
+automatically-maintained symbol attribute values referenced as dollar
+variables. Further, because \fIantlr\fR generates top-down parsers,
+arbitrary values may be inherited from parent rules (passed like
+function parameters). \fIAntlr\fP also has a mechanism for creating
+and manipulating abstract-syntax-trees.
+.PP
+There are various other niceties in \fIantlr\fR, including the ability to
+spread one grammar over multiple files or even multiple grammars in a single
+file, the ability to generate a version of the grammar with actions stripped
+out (for documentation purposes), and lots more.
+.SH OPTIONS
+.IP "\fB-ck \fIn\fR"
+Use up to \fIn\fR symbols of lookahead when using compressed (linear
+approximation) lookahead. This type of lookahead is very cheap to
+compute and is attempted before full LL(k) lookahead, which is of
+exponential complexity in the worst case. In general, the compressed
+lookahead can be much deeper (e.g, \f(CW-ck 10\fP) than the full
+lookahead (which usually must be less than 4).
+.IP \fB-CC\fP
+Generate C++ output from both ANTLR and DLG.
+.IP \fB-cr\fP
+Generate a cross-reference for all rules. For each rule, print a list
+of all other rules that reference it.
+.IP \fB-e1\fP
+Ambiguities/errors shown in low detail (default).
+.IP \fB-e2\fP
+Ambiguities/errors shown in more detail.
+.IP \fB-e3\fP
+Ambiguities/errors shown in excruciating detail.
+.IP "\fB-fe\fP file"
+Rename \fBerr.c\fP to file.
+.IP "\fB-fh\fP file"
+Rename \fBstdpccts.h\fP header (turns on \fB-gh\fP) to file.
+.IP "\fB-fl\fP file"
+Rename lexical output, \fBparser.dlg\fP, to file.
+.IP "\fB-fm\fP file"
+Rename file with lexical mode definitions, \fBmode.h\fP, to file.
+.IP "\fB-fr\fP file"
+Rename file which remaps globally visible symbols, \fBremap.h\fP, to file.
+.IP "\fB-ft\fP file"
+Rename \fBtokens.h\fP to file.
+.IP \fB-ga\fP
+Generate ANSI-compatible code (default case). This has not been
+rigorously tested to be ANSI XJ11 C compliant, but it is close. The
+normal output of \fIantlr\fP is currently compilable under both K&R,
+ANSI C, and C++\(emthis option does nothing because \fIantlr\fP
+generates a bunch of #ifdef's to do the right thing depending on the
+language.
+.IP \fB-gc\fP
+Indicates that \fIantlr\fP should generate no C code, i.e., only
+perform analysis on the grammar.
+.IP \fB-gd\fP
+C code is inserted in each of the \fIantlr\fR generated parsing functions to
+provide for user-defined handling of a detailed parse trace. The inserted
+code consists of calls to the user-supplied macros or functions called
+\fBzzTRACEIN\fR and \fBzzTRACEOUT\fP. The only argument is a
+\fIchar *\fR pointing to a C-style string which is the grammar rule
+recognized by the current parsing function. If no definition is given
+for the trace functions, upon rule entry and exit, a message will be
+printed indicating that a particular rule as been entered or exited.
+.IP \fB-ge\fP
+Generate an error class for each non-terminal.
+.IP \fB-gh\fP
+Generate \fBstdpccts.h\fP for non-ANTLR-generated files to include.
+This file contains all defines needed to describe the type of parser
+generated by \fIantlr\fP (e.g. how much lookahead is used and whether
+or not trees are constructed) and contains the \fBheader\fP action
+specified by the user.
+.IP \fB-gk\fP
+Generate parsers that delay lookahead fetches until needed. Without
+this option, \fIantlr\fP generates parsers which always have \fIk\fP
+tokens of lookahead available.
+.IP \fB-gl\fP
+Generate line info about grammar actions in C parser of the form
+\fB#\ \fIline\fP\ "\fIfile\fP"\fR which makes error messages from
+the C/C++ compiler make more sense as they will \*Qpoint\*U into the
+grammar file not the resulting C file. Debugging is easier as well,
+because you will step through the grammar not C file.
+.IP \fB-gs\fR
+Do not generate sets for token expression lists; instead generate a
+\fB||\fP-separated sequence of \fBLA(1)==\fItoken_number\fR. The
+default is to generate sets.
+.IP \fB-gt\fP
+Generate code for Abstract-Syntax Trees.
+.IP \fB-gx\fP
+Do not create the lexical analyzer files (dlg-related). This option
+should be given when the user wishes to provide a customized lexical
+analyzer. It may also be used in \fImake\fR scripts to cause only the
+parser to be rebuilt when a change not affecting the lexical structure
+is made to the input grammars.
+.IP "\fB-k \fIn\fR"
+Set k of LL(k) to \fIn\fR; i.e. set tokens of look-ahead (default==1).
+.IP "\fB-o\fP dir
+Directory where output files should go (default="."). This is very
+nice for keeping the source directory clear of ANTLR and DLG spawn.
+.IP \fB-p\fP
+The complete grammar, collected from all input grammar files and
+stripped of all comments and embedded actions, is listed to
+\fBstdout\fP. This is intended to aid in viewing the entire grammar
+as a whole and to eliminate the need to keep actions concisely stated
+so that the grammar is easier to read. Hence, it is preferable to
+embed even complex actions directly in the grammar, rather than to
+call them as subroutines, since the subroutine call overhead will be
+saved.
+.IP \fB-pa\fP
+This option is the same as \fB-p\fP except that the output is
+annotated with the first sets determined from grammar analysis.
+.IP "\fB-prc on\fR
+Turn on the computation and hoisting of predicate context.
+.IP "\fB-prc off\fR
+Turn off the computation and hoisting of predicate context. This
+option makes 1.10 behave like the 1.06 release with option \fB-pr\fR
+on. Context computation is off by default.
+.IP "\fB-rl \fIn\fR
+Limit the maximum number of tree nodes used by grammar analysis to
+\fIn\fP. Occasionally, \fIantlr\fP is unable to analyze a grammar
+submitted by the user. This rare situation can only occur when the
+grammar is large and the amount of lookahead is greater than one. A
+nonlinear analysis algorithm is used by PCCTS to handle the general
+case of LL(k) parsing. The average complexity of analysis, however, is
+near linear due to some fancy footwork in the implementation which
+reduces the number of calls to the full LL(k) algorithm. An error
+message will be displayed, if this limit is reached, which indicates
+the grammar construct being analyzed when \fIantlr\fP hit a
+non-linearity. Use this option if \fIantlr\fP seems to go out to
+lunch and your disk start thrashing; try \fIn\fP=10000 to start. Once
+the offending construct has been identified, try to remove the
+ambiguity that \fIantlr\fP was trying to overcome with large lookahead
+analysis. The introduction of (...)? backtracking blocks eliminates
+some of these problems\ \(em \fIantlr\fP does not analyze alternatives
+that begin with (...)? (it simply backtracks, if necessary, at run
+time).
+.IP \fB-w1\fR
+Set low warning level. Do not warn if semantic predicates and/or
+(...)? blocks are assumed to cover ambiguous alternatives.
+.IP \fB-w2\fR
+Ambiguous parsing decisions yield warnings even if semantic predicates
+or (...)? blocks are used. Warn if predicate context computed and
+semantic predicates incompletely disambiguate alternative productions.
+.IP \fB-\fR
+Read grammar from standard input and generate \fBstdin.c\fP as the
+parser file.
+.SH "SPECIAL CONSIDERATIONS"
+.PP
+\fIAntlr\fP works... we think. There is no implicit guarantee of
+anything. We reserve no \fBlegal\fP rights to the software known as
+the Purdue Compiler Construction Tool Set (PCCTS) \(em PCCTS is in the
+public domain. An individual or company may do whatever they wish
+with source code distributed with PCCTS or the code generated by
+PCCTS, including the incorporation of PCCTS, or its output, into
+commercial software. We encourage users to develop software with
+PCCTS. However, we do ask that credit is given to us for developing
+PCCTS. By "credit", we mean that if you incorporate our source code
+into one of your programs (commercial product, research project, or
+otherwise) that you acknowledge this fact somewhere in the
+documentation, research report, etc... If you like PCCTS and have
+developed a nice tool with the output, please mention that you
+developed it using PCCTS. As long as these guidelines are followed,
+we expect to continue enhancing this system and expect to make other
+tools available as they are completed.
+.SH FILES
+.IP *.c
+output C parser.
+.IP *.cpp
+output C++ parser when C++ mode is used.
+.IP \fBparser.dlg\fP
+output \fIdlg\fR lexical analyzer.
+.IP \fBerr.c\fP
+token string array, error sets and error support routines. Not used in
+C++ mode.
+.IP \fBremap.h\fP
+file that redefines all globally visible parser symbols. The use of
+the #parser directive creates this file. Not used in
+C++ mode.
+.IP \fBstdpccts.h\fP
+list of definitions needed by C files, not generated by PCCTS, that
+reference PCCTS objects. This is not generated by default. Not used in
+C++ mode.
+.IP \fBtokens.h\fP
+output \fI#defines\fR for tokens used and function prototypes for
+functions generated for rules.
+.SH "SEE ALSO"
+.LP
+dlg(1), pccts(1)
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.c new file mode 100644 index 0000000000..8aaef794e1 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.c @@ -0,0 +1,3564 @@ +/*
+ * A n t l r T r a n s l a t i o n H e a d e r
+ *
+ * Terence Parr, Will Cohen, and Hank Dietz: 1989-2001
+ * Purdue University Electrical Engineering
+ * With AHPCRC, University of Minnesota
+ * ANTLR Version 1.33MR33
+ *
+ * ..\bin\antlr -gh antlr.g
+ *
+ */
+
+#define ANTLR_VERSION 13333
+#include "pcctscfg.h"
+#include "pccts_stdio.h"
+
+#include "pcctscfg.h"
+#include "set.h"
+#include <ctype.h>
+#include "syn.h"
+#include "hash.h"
+#include "generic.h"
+#define zzcr_attr(attr,tok,t)
+#define zzSET_SIZE 20
+#include "antlr.h"
+#include "tokens.h"
+#include "dlgdef.h"
+#include "mode.h"
+
+/* MR23 In order to remove calls to PURIFY use the antlr -nopurify option */
+
+#ifndef PCCTS_PURIFY
+#define PCCTS_PURIFY(r,s) memset((char *) &(r),'\0',(s));
+#endif
+
+ANTLR_INFO
+
+
+/* MR20 G. Hobbelt For Borland C++ 4.x & 5.x compiling with ALL warnings enabled */
+#if defined(__TURBOC__)
+#pragma warn -aus /* unused assignment of 'xxx' */
+#endif
+
+
+#ifdef __USE_PROTOS
+static void chkToken(char *, char *, char *, int);
+#else
+static void chkToken();
+#endif
+
+#ifdef __USE_PROTOS
+static int isDLGmaxToken(char *Token); /* MR3 */
+#else
+static int isDLGmaxToken(); /* MR3 */
+#endif
+
+static int class_nest_level = 0;
+
+/* MR20 G. Hobbelt extern definitions moved to antlr.h */
+
+
+
+void
+#ifdef __USE_PROTOS
+grammar(void)
+#else
+grammar()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ Graph g;
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ for (;;) {
+ if ( !((setwd1[LA(1)]&0x1))) break;
+ if ( (LA(1)==94) ) {
+ zzmatch(94); zzCONSUME;
+ zzmatch(Action);
+
+ if ( HdrAction==NULL ) {
+ HdrAction = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(HdrAction!=NULL, "rule grammar: cannot allocate header action");
+ strcpy(HdrAction, LATEXT(1));
+ }
+ else warn("additional #header statement ignored");
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==95) ) {
+ zzmatch(95); zzCONSUME;
+ zzmatch(Action);
+
+ if ( FirstAction==NULL ) {
+ FirstAction = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(FirstAction!=NULL, "rule grammar: cannot allocate #first action");
+ strcpy(FirstAction, LATEXT(1));
+ } else {
+ warn("additional #first statement ignored");
+ };
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==96) ) {
+ zzmatch(96); zzCONSUME;
+ zzmatch(QuotedTerm);
+
+ if ( GenCC ) {
+ warn("#parser meta-op incompatible with -CC; ignored");
+ }
+ else {
+ if ( strcmp(ParserName,"zzparser")==0 ) {
+ ParserName=StripQuotes(mystrdup(LATEXT(1)));
+ if ( RulePrefix[0]!='\0' )
+ {
+ warn("#parser meta-op incompatible with '-gp prefix'; '-gp' ignored");
+ RulePrefix[0]='\0';
+ }
+ }
+ else warn("additional #parser statement ignored");
+ }
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==97) ) {
+ zzmatch(97); zzCONSUME;
+ zzmatch(QuotedTerm);
+ {
+ char *fname;
+ zzantlr_state st; FILE *f; struct zzdlg_state dst;
+ UserTokenDefsFile = mystrdup(LATEXT(1));
+ zzsave_antlr_state(&st);
+ zzsave_dlg_state(&dst);
+ fname = mystrdup(LATEXT(1));
+ f = fopen(StripQuotes(fname), "r");
+ if ( f==NULL ) {warn(eMsg1("cannot open token defs file '%s'", fname+1));}
+ else {
+ ANTLRm(enum_file(fname+1), f, PARSE_ENUM_FILE);
+ UserDefdTokens = 1;
+ }
+ zzrestore_antlr_state(&st);
+ zzrestore_dlg_state(&dst);
+ }
+ zzCONSUME;
+
+ }
+ else break; /* MR6 code for exiting loop "for sure" */
+ }
+ }
+ }
+ zzLOOP(zztasp2);
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ for (;;) {
+ if ( !((setwd1[LA(1)]&0x2))) break;
+ if ( (LA(1)==Action) ) {
+ zzmatch(Action);
+ {
+ UserAction *ua = newUserAction(LATEXT(1));
+ ua->file = action_file; ua->line = action_line;
+ if ( class_nest_level>0 ) list_add(&class_before_actions, ua);
+ else list_add(&BeforeActions, ua);
+ }
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==108) ) {
+ laction();
+ }
+ else {
+ if ( (LA(1)==109) ) {
+ lmember();
+ }
+ else {
+ if ( (LA(1)==110) ) {
+ lprefix();
+ }
+ else {
+ if ( (LA(1)==116) ) {
+ aLexclass();
+ }
+ else {
+ if ( (LA(1)==120) ) {
+ token();
+ }
+ else {
+ if ( (LA(1)==117) ) {
+ error();
+ }
+ else {
+ if ( (LA(1)==118) ) {
+ tclass();
+ }
+ else {
+ if ( (LA(1)==111) ) {
+ aPred();
+ }
+ else {
+ if ( (LA(1)==133) ) {
+ default_exception_handler();
+ }
+ else {
+ if ( (LA(1)==99) ) {
+ class_def();
+ }
+ else {
+ if ( (LA(1)==98) ) {
+ zzmatch(98);
+
+ if ( class_nest_level==0 )
+ warn("missing class definition for trailing '}'");
+ class_nest_level--;
+ zzCONSUME;
+
+ }
+ else break; /* MR6 code for exiting loop "for sure" */
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ zzLOOP(zztasp2);
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ rule();
+ g=zzaArg(zztasp1,3); SynDiag = (Junction *) zzaArg(zztasp1,3 ).left;
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ for (;;) {
+ if ( !((setwd1[LA(1)]&0x4))) break;
+ if ( (LA(1)==NonTerminal) ) {
+ rule();
+ if ( zzaArg(zztasp2,1 ).left!=NULL ) {
+ g.right = NULL;
+
+/* MR21a */ /* Avoid use of a malformed graph when CannotContinue */
+ /* MR21a */ /* is already set */
+ /* MR21a */
+ /* MR21a */ if (! (CannotContinue && g.left == NULL)) {
+ /* MR21a */ g = Or(g, zzaArg(zztasp2,1));
+ /* MR21a */ }
+ /* MR21a */ }
+ }
+ else {
+ if ( (LA(1)==116) ) {
+ aLexclass();
+ }
+ else {
+ if ( (LA(1)==120) ) {
+ token();
+ }
+ else {
+ if ( (LA(1)==117) ) {
+ error();
+ }
+ else {
+ if ( (LA(1)==118) ) {
+ tclass();
+ }
+ else {
+ if ( (LA(1)==111) ) {
+ aPred();
+ }
+ else {
+ if ( (LA(1)==99) ) {
+ class_def();
+ }
+ else {
+ if ( (LA(1)==98) ) {
+ zzmatch(98);
+
+ if ( class_nest_level==0 )
+ warn("missing class definition for trailing '}'");
+ class_nest_level--;
+ zzCONSUME;
+
+ }
+ else break; /* MR6 code for exiting loop "for sure" */
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ zzLOOP(zztasp2);
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ for (;;) {
+ if ( !((setwd1[LA(1)]&0x8))) break;
+ if ( (LA(1)==Action) ) {
+ zzmatch(Action);
+ {
+ UserAction *ua = newUserAction(LATEXT(1));
+ ua->file = action_file; ua->line = action_line;
+ if ( class_nest_level>0 ) list_add(&class_after_actions, ua);
+ else list_add(&AfterActions, ua);
+ }
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==108) ) {
+ laction();
+ }
+ else {
+ if ( (LA(1)==109) ) {
+ lmember();
+ }
+ else {
+ if ( (LA(1)==110) ) {
+ lprefix();
+ }
+ else {
+ if ( (LA(1)==117) ) {
+ error();
+ }
+ else {
+ if ( (LA(1)==118) ) {
+ tclass();
+ }
+ else {
+ if ( (LA(1)==99) ) {
+ class_def();
+ }
+ else {
+ if ( (LA(1)==111) ) {
+ aPred();
+ }
+ else {
+ if ( (LA(1)==98) ) {
+ zzmatch(98);
+
+ if ( class_nest_level==0 )
+ warn("missing class definition for trailing '}'");
+ class_nest_level--;
+ zzCONSUME;
+
+ }
+ else break; /* MR6 code for exiting loop "for sure" */
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ zzLOOP(zztasp2);
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ zzmatch(Eof); zzCONSUME;
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ CannotContinue=TRUE;
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd1, 0x10);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+class_def(void)
+#else
+class_def()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ int go=1; char name[MaxRuleName+1];
+ zzmatch(99); zzCONSUME;
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==NonTerminal) ) {
+ zzmatch(NonTerminal);
+ if(go) strncpy(name,LATEXT(1),MaxRuleName);
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==TokenTerm) ) {
+ zzmatch(TokenTerm);
+ if(go) strncpy(name,LATEXT(1),MaxRuleName);
+ zzCONSUME;
+
+ }
+ else {zzFAIL(1,zzerr1,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+
+ if ( CurrentClassName[0]!='\0' && strcmp(CurrentClassName,name)!=0
+ && GenCC ) {
+ err("only one grammar class allowed in this release");
+ go = 0;
+ }
+ else strcpy(CurrentClassName, name);
+ if ( !GenCC ) { err("class meta-op used without C++ option"); }
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ while ( (setwd1[LA(1)]&0x20) ) {
+ zzsetmatch(zzerr2, zzerr3);
+ if (ClassDeclStuff == NULL) {
+ /* MR10 */ ClassDeclStuff=(char *)calloc(MaxClassDeclStuff+1,sizeof(char));
+ /* MR10 */ };
+ /* MR10 */ strncat(ClassDeclStuff," ",MaxClassDeclStuff);
+ /* MR10 */ strncat(ClassDeclStuff,LATEXT(1),MaxClassDeclStuff);
+ /* MR22 */ do {
+ /* MR22 */ if (0 == strcmp(LATEXT(1),"public")) break;
+ /* MR22 */ if (0 == strcmp(LATEXT(1),"private")) break;
+ /* MR22 */ if (0 == strcmp(LATEXT(1),"protected")) break;
+ /* MR22 */ if (0 == strcmp(LATEXT(1),"virtual")) break;
+ /* MR22 */ if (0 == strcmp(LATEXT(1),",")) break;
+ /* MR22 */ if (0 == strcmp(LATEXT(1),":")) break;
+ /* MR22 */ if (BaseClassName != NULL) break;
+ /* MR22 */ BaseClassName=(char *)calloc(strlen(LATEXT(1))+1,sizeof(char));
+ /* MR22 */ require(BaseClassName!=NULL, "rule grammar: cannot allocate base class name");
+ /* MR22 */ strcpy(BaseClassName,LATEXT(1));
+ /* MR22 */ } while (0);
+ /* MR10 */
+ zzCONSUME;
+
+ zzLOOP(zztasp2);
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ zzmatch(102);
+
+ no_classes_found = 0;
+ if ( class_nest_level>=1 ) {warn("cannot have nested classes");}
+ else class_nest_level++;
+ zzCONSUME;
+
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ CannotContinue=TRUE;
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd1, 0x40);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+rule(void)
+#else
+rule()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+
+
+ ExceptionGroup *eg;
+ RuleEntry *q; Junction *p; Graph r; int f, l; ECnode *e;
+ set toksrefd, rulesrefd;
+ char *pdecl=NULL, *ret=NULL, *a; CurRetDef = CurParmDef = NULL;
+ CurExGroups = NULL;
+ CurElementLabels = NULL;
+ CurAstLabelsInActions = NULL; /* MR27 */
+ /* We want a new element label hash table for each rule */
+ if ( Elabel!=NULL ) killHashTable(Elabel);
+ Elabel = newHashTable();
+ attribsRefdFromAction = empty;
+ zzmatch(NonTerminal);
+ q=NULL;
+ if ( hash_get(Rname, LATEXT(1))!=NULL ) {
+ err(eMsg1("duplicate rule definition: '%s'",LATEXT(1)));
+ CannotContinue=TRUE;
+ }
+ else
+ {
+ q = (RuleEntry *)hash_add(Rname,
+ LATEXT(1),
+ (Entry *)newRuleEntry(LATEXT(1)));
+ CurRule = q->str;
+ }
+ CurRuleNode = q;
+ f = CurFile; l = zzline;
+ NumRules++;
+ zzCONSUME;
+
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==103) ) {
+ zzmatch(103);
+ if ( q!=NULL ) q->noAST = TRUE;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd1[LA(1)]&0x80) ) {
+ }
+ else {zzFAIL(1,zzerr4,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ ;
+ if ( (setwd2[LA(1)]&0x1) ) {
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ if ( (LA(1)==104) ) {
+ zzmatch(104); zzCONSUME;
+ }
+ else {
+ if ( (LA(1)==PassAction) ) {
+ }
+ else {zzFAIL(1,zzerr5,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+ zzmatch(PassAction);
+ pdecl = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(pdecl!=NULL, "rule rule: cannot allocate param decl");
+ strcpy(pdecl, LATEXT(1));
+ CurParmDef = pdecl;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd2[LA(1)]&0x2) ) {
+ }
+ else {zzFAIL(1,zzerr6,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==105) ) {
+ zzmatch(105); zzCONSUME;
+ zzmatch(PassAction);
+ ret = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(ret!=NULL, "rule rule: cannot allocate ret type");
+ strcpy(ret, LATEXT(1));
+ CurRetDef = ret;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd2[LA(1)]&0x4) ) {
+ }
+ else {zzFAIL(1,zzerr7,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==QuotedTerm) ) {
+ zzmatch(QuotedTerm);
+ if ( q!=NULL ) q->egroup=mystrdup(LATEXT(1));
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==106) ) {
+ }
+ else {zzFAIL(1,zzerr8,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+
+ if ( GenEClasseForRules && q!=NULL ) {
+ e = newECnode;
+ require(e!=NULL, "cannot allocate error class node");
+ if ( q->egroup == NULL ) {a = q->str; a[0] = (char)toupper(a[0]);}
+ else a = q->egroup;
+ if ( Tnum( a ) == 0 )
+ {
+ e->tok = addTname( a );
+ list_add(&eclasses, (char *)e);
+ if ( q->egroup == NULL ) a[0] = (char)tolower(a[0]);
+ /* refers to itself */
+ list_add(&(e->elist), mystrdup(q->str));
+ }
+ else {
+ warn(eMsg1("default errclass for '%s' would conflict with token/errclass/tokclass",a));
+ if ( q->egroup == NULL ) a[0] = (char)tolower(a[0]);
+ free((char *)e);
+ }
+ }
+ BlkLevel++;
+ if (BlkLevel >= MAX_BLK_LEVEL) fatal("Blocks nested too deeply");
+ /* MR23 */ CurBlockID_array[BlkLevel] = CurBlockID;
+ /* MR23 */ CurAltNum_array[BlkLevel] = CurAltNum;
+ zzmatch(106);
+ inAlt=1;
+ zzCONSUME;
+
+ block( &toksrefd, &rulesrefd );
+ r = makeBlk(zzaArg(zztasp1,7),0, NULL /* pFirstSetSymbol */ );
+ CurRuleBlk = (Junction *)r.left;
+ CurRuleBlk->blockid = CurBlockID;
+ CurRuleBlk->jtype = RuleBlk;
+ if ( q!=NULL ) CurRuleBlk->rname = q->str;
+ CurRuleBlk->file = f;
+ CurRuleBlk->line = l;
+ CurRuleBlk->pdecl = pdecl;
+ CurRuleBlk->ret = ret;
+ CurRuleBlk->lock = makelocks();
+ CurRuleBlk->pred_lock = makelocks();
+ CurRuleBlk->tokrefs = toksrefd;
+ CurRuleBlk->rulerefs = rulesrefd;
+ p = newJunction(); /* add EndRule Node */
+ ((Junction *)r.right)->p1 = (Node *)p;
+ r.right = (Node *) p;
+ p->jtype = EndRule;
+ p->lock = makelocks();
+ p->pred_lock = makelocks();
+ CurRuleBlk->end = p;
+ if ( q!=NULL ) q->rulenum = NumRules;
+ zzaArg(zztasp1,7) = r;
+
+ /* MR23 */ CurBlockID_array[BlkLevel] = (-1);
+ /* MR23 */ CurAltNum_array[BlkLevel] = (-1);
+ --BlkLevel;
+ altFixup();leFixup();egFixup();
+ zzmatch(107);
+ inAlt=0;
+ zzCONSUME;
+
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==Action) ) {
+ zzmatch(Action);
+ a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(a!=NULL, "rule rule: cannot allocate error action");
+ strcpy(a, LATEXT(1));
+ CurRuleBlk->erraction = a;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd2[LA(1)]&0x8) ) {
+ }
+ else {zzFAIL(1,zzerr9,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ while ( (LA(1)==133) ) {
+ eg = exception_group();
+
+ if ( eg!=NULL ) {
+ list_add(&CurExGroups, (void *)eg);
+ if (eg->label == NULL || *eg->label=='\0' ) q->has_rule_exception = 1;
+ }
+ zzLOOP(zztasp2);
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ if ( q==NULL ) zzaArg(zztasp1,0 ).left = NULL; else zzaArg(zztasp1,0) = zzaArg(zztasp1,7);
+ CurRuleBlk->exceptions = CurExGroups;
+ CurRuleBlk->el_labels = CurElementLabels;
+ CurRuleNode->ast_labels_in_actions = CurAstLabelsInActions;
+ CurRuleNode = NULL;
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ CannotContinue=TRUE;
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd2, 0x10);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+laction(void)
+#else
+laction()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ char *a;
+ zzmatch(108); zzCONSUME;
+ zzmatch(Action);
+
+ a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(a!=NULL, "rule laction: cannot allocate action");
+ strcpy(a, LATEXT(1));
+ list_add(&LexActions, a);
+ zzCONSUME;
+
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ CannotContinue=TRUE;
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd2, 0x20);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+lmember(void)
+#else
+lmember()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ char *a;
+ zzmatch(109); zzCONSUME;
+ zzmatch(Action);
+
+ /* MR1 */ if (! GenCC) {
+ /* MR1 */ err("Use #lexmember only in C++ mode (to insert code in DLG class header");
+ /* MR1 */ } else {
+ /* MR1 */ a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ /* MR1 */ require(a!=NULL, "rule lmember: cannot allocate action");
+ /* MR1 */ strcpy(a, LATEXT(1));
+ /* MR1 */ list_add(&LexMemberActions, a);
+ /* MR1 */ };
+ /* MR1 */
+ zzCONSUME;
+
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ CannotContinue=TRUE;
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd2, 0x40);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+lprefix(void)
+#else
+lprefix()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ char *a;
+ zzmatch(110); zzCONSUME;
+ zzmatch(Action);
+
+ /* MR1 */ if (! GenCC) {
+ /* MR1 */ err("Use #lexprefix only in C++ mode (to insert code in DLG class header");
+ /* MR1 */ } else {
+ /* MR1 */ a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ /* MR1 */ require(a!=NULL, "rule lprefix: cannot allocate action");
+ /* MR1 */ strcpy(a, LATEXT(1));
+ /* MR1 */ list_add(&LexPrefixActions, a);
+ /* MR1 */ };
+ /* MR1 */
+ zzCONSUME;
+
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ CannotContinue=TRUE;
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd2, 0x80);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+aPred(void)
+#else
+aPred()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ PredEntry *predEntry=NULL;
+ char *name=NULL;
+ Predicate *predExpr=NULL;
+ char *predLiteral=NULL;
+ int save_file;
+ int save_line;
+ int predExprPresent=0;
+ zzmatch(111);
+
+ MR_usingPredNames=1; /* will need to use -mrhoist version of genPredTree */
+ zzCONSUME;
+
+ zzmatch(TokenTerm);
+ name=mystrdup(LATEXT(1));
+ zzCONSUME;
+
+
+ /* don't free - referenced in predicates */
+
+ CurPredName=(char *)calloc(1,strlen(name) + 10);
+ strcat(CurPredName,"#pred ");
+ strcat(CurPredName,name);
+
+ predEntry=(PredEntry *) hash_get(Pname,name);
+ if (predEntry != NULL) {
+ warnFL(eMsg1("#pred %s previously defined - ignored",name),
+ FileStr[action_file],action_line);
+ name=NULL;
+};
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==Pred) ) {
+ zzmatch(Pred);
+ predLiteral=mystrdup(LATEXT(1));
+ save_line=action_line;
+ save_file=action_file;
+ zzCONSUME;
+
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ if ( (setwd3[LA(1)]&0x1) ) {
+ predExpr = predOrExpr();
+
+ predExprPresent=1;
+ }
+ else {
+ if ( (setwd3[LA(1)]&0x2) ) {
+ }
+ else {zzFAIL(1,zzerr10,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+ if (predLiteral != NULL && name != NULL) {
+
+ /*
+ * predExpr may be NULL due to syntax errors
+ * or simply omitted by the user
+ */
+
+ predEntry=newPredEntry(name);
+ predEntry->file=save_file;
+ predEntry->line=save_line;
+ predExpr=MR_predFlatten(predExpr);
+ predEntry->predLiteral=predLiteral;
+ if (! predExprPresent || predExpr == NULL) {
+ predExpr=new_pred();
+ predExpr->expr=predLiteral;
+ predExpr->source=newActionNode();
+ predExpr->source->action=predExpr->expr;
+ predExpr->source->rname=CurPredName;
+ predExpr->source->line=action_line;
+ predExpr->source->file=action_file;
+ predExpr->source->is_predicate=1;
+ predExpr->k=predicateLookaheadDepth(predExpr->source);
+ };
+ predEntry->pred=predExpr;
+ hash_add(Pname,name,(Entry *)predEntry);
+ predExpr=NULL;
+ };
+ predicate_free(predExpr);
+ }
+ else {
+ if ( (setwd3[LA(1)]&0x4) ) {
+ save_line=zzline; save_file=CurFile;
+ predExpr = predOrExpr();
+
+ if (predExpr != NULL && name != NULL) {
+ predEntry=newPredEntry(name);
+ predEntry->file=CurFile;
+ predEntry->line=zzline;
+ predExpr=MR_predFlatten(predExpr);
+ predEntry->pred=predExpr;
+ hash_add(Pname,name,(Entry *)predEntry);
+ predExpr=NULL;
+ };
+ predicate_free(predExpr);
+ }
+ else {zzFAIL(1,zzerr11,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==107) ) {
+ zzmatch(107); zzCONSUME;
+ }
+ else {
+ if ( (setwd3[LA(1)]&0x8) ) {
+ }
+ else {zzFAIL(1,zzerr12,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ predicate_free(predExpr);
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd3, 0x10);
+ }
+}
+
+Predicate *
+#ifdef __USE_PROTOS
+predOrExpr(void)
+#else
+predOrExpr()
+#endif
+{
+ Predicate * _retv;
+ zzRULE;
+ zzBLOCK(zztasp1);
+ PCCTS_PURIFY(_retv,sizeof(Predicate * ))
+ zzMake0;
+ {
+ Predicate *ORnode;
+ Predicate *predExpr;
+ Predicate **tail=NULL;
+ predExpr = predAndExpr();
+
+
+ ORnode=new_pred();
+ ORnode->expr=PRED_OR_LIST;
+ if (predExpr != NULL) {
+ ORnode->down=predExpr;
+ tail=&predExpr->right;
+ };
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ while ( (LA(1)==112) ) {
+ zzmatch(112); zzCONSUME;
+ predExpr = predAndExpr();
+
+
+ if (predExpr != NULL) {
+ *tail=predExpr;
+ tail=&predExpr->right;
+ };
+ zzLOOP(zztasp2);
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+
+ _retv=ORnode;
+ ORnode=NULL;
+ zzEXIT(zztasp1);
+ return _retv;
+fail:
+ zzEXIT(zztasp1);
+ predicate_free(ORnode);
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd3, 0x20);
+ return _retv;
+ }
+}
+
+Predicate *
+#ifdef __USE_PROTOS
+predAndExpr(void)
+#else
+predAndExpr()
+#endif
+{
+ Predicate * _retv;
+ zzRULE;
+ zzBLOCK(zztasp1);
+ PCCTS_PURIFY(_retv,sizeof(Predicate * ))
+ zzMake0;
+ {
+ Predicate *ANDnode;
+ Predicate *predExpr;
+ Predicate **tail=NULL;
+ predExpr = predPrimary();
+
+
+ ANDnode=new_pred();
+ ANDnode->expr=PRED_AND_LIST;
+ if (predExpr != NULL) {
+ ANDnode->down=predExpr;
+ tail=&predExpr->right;
+ };
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ while ( (LA(1)==113) ) {
+ zzmatch(113); zzCONSUME;
+ predExpr = predPrimary();
+
+
+ if (predExpr != NULL) {
+ *tail=predExpr;
+ tail=&predExpr->right;
+ };
+ zzLOOP(zztasp2);
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+
+ _retv=ANDnode;
+ ANDnode=NULL;
+ zzEXIT(zztasp1);
+ return _retv;
+fail:
+ zzEXIT(zztasp1);
+ predicate_free(ANDnode);
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd3, 0x40);
+ return _retv;
+ }
+}
+
+Predicate *
+#ifdef __USE_PROTOS
+predPrimary(void)
+#else
+predPrimary()
+#endif
+{
+ Predicate * _retv;
+ zzRULE;
+ zzBLOCK(zztasp1);
+ PCCTS_PURIFY(_retv,sizeof(Predicate * ))
+ zzMake0;
+ {
+
+ char *name=NULL;
+ PredEntry *predEntry=NULL;
+ Predicate *predExpr=NULL;
+ if ( (LA(1)==TokenTerm) ) {
+ zzmatch(TokenTerm);
+ name=mystrdup(LATEXT(1));
+ zzCONSUME;
+
+
+ predEntry=(PredEntry *) hash_get(Pname,name);
+ if (predEntry == NULL) {
+ warnFL(eMsg1("no previously defined #pred with name \"%s\"",name),
+ FileStr[CurFile],zzline);
+ name=NULL;
+ _retv=NULL;
+ } else {
+ predExpr=predicate_dup(predEntry->pred);
+ predExpr->predEntry=predEntry;
+ _retv=predExpr;
+ };
+ }
+ else {
+ if ( (LA(1)==114) ) {
+ zzmatch(114); zzCONSUME;
+ predExpr = predOrExpr();
+
+ zzmatch(115);
+
+ _retv=predExpr;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==103) ) {
+ zzmatch(103); zzCONSUME;
+ predExpr = predPrimary();
+
+
+ predExpr->inverted=!predExpr->inverted;
+ _retv=predExpr;
+ }
+ else {zzFAIL(1,zzerr13,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ }
+ zzEXIT(zztasp1);
+ return _retv;
+fail:
+ zzEXIT(zztasp1);
+
+ predicate_free(predExpr);
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd3, 0x80);
+ return _retv;
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+aLexclass(void)
+#else
+aLexclass()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ zzmatch(116); zzCONSUME;
+ zzmatch(TokenTerm);
+ lexclass(mystrdup(LATEXT(1)));
+ zzCONSUME;
+
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ CannotContinue=TRUE;
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd4, 0x1);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+error(void)
+#else
+error()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ char *t=NULL; ECnode *e; int go=1; TermEntry *p;
+ zzmatch(117); zzCONSUME;
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ ;
+ if ( (LA(1)==TokenTerm) ) {
+ zzmatch(TokenTerm);
+ t=mystrdup(LATEXT(1));
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==QuotedTerm) ) {
+ zzmatch(QuotedTerm);
+ t=mystrdup(LATEXT(1));
+ zzCONSUME;
+
+ }
+ else {zzFAIL(1,zzerr14,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ e = newECnode;
+ require(e!=NULL, "cannot allocate error class node");
+ e->lexclass = CurrentLexClass;
+ if ( Tnum( (t=StripQuotes(t)) ) == 0 )
+ {
+ if ( hash_get(Texpr, t) != NULL )
+ warn(eMsg1("errclass name conflicts with regular expression '%s'",t));
+ e->tok = addTname( t );
+ set_orel(e->tok, &imag_tokens);
+ require((p=(TermEntry *)hash_get(Tname, t)) != NULL,
+ "hash table mechanism is broken");
+ p->classname = 1; /* entry is errclass name, not token */
+ list_add(&eclasses, (char *)e);
+ }
+ else
+ {
+ warn(eMsg1("redefinition of errclass or conflict w/token or tokclass '%s'; ignored",t));
+ free( (char *)e );
+ go=0;
+}
+ zzmatch(102); zzCONSUME;
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==NonTerminal) ) {
+ zzmatch(NonTerminal);
+ if ( go ) t=mystrdup(LATEXT(1));
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==TokenTerm) ) {
+ zzmatch(TokenTerm);
+ if ( go ) t=mystrdup(LATEXT(1));
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==QuotedTerm) ) {
+ zzmatch(QuotedTerm);
+ if ( go ) t=mystrdup(LATEXT(1));
+ zzCONSUME;
+
+ }
+ else {zzFAIL(1,zzerr15,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ if ( go ) list_add(&(e->elist), t);
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ while ( (setwd4[LA(1)]&0x2) ) {
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ if ( (LA(1)==NonTerminal) ) {
+ zzmatch(NonTerminal);
+ if ( go ) t=mystrdup(LATEXT(1));
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==TokenTerm) ) {
+ zzmatch(TokenTerm);
+ if ( go ) t=mystrdup(LATEXT(1));
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==QuotedTerm) ) {
+ zzmatch(QuotedTerm);
+ if ( go ) t=mystrdup(LATEXT(1));
+ zzCONSUME;
+
+ }
+ else {zzFAIL(1,zzerr16,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+ if ( go ) list_add(&(e->elist), t);
+ zzLOOP(zztasp2);
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ zzmatch(98); zzCONSUME;
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ CannotContinue=TRUE;
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd4, 0x4);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+tclass(void)
+#else
+tclass()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ char *t=NULL; TCnode *e; int go=1,tok,totok; TermEntry *p, *term, *toterm;
+ char *akaString=NULL; int save_file; int save_line;
+ char *totext=NULL;
+ zzmatch(118); zzCONSUME;
+ zzmatch(TokenTerm);
+ t=mystrdup(LATEXT(1));
+ zzCONSUME;
+
+ e = newTCnode;
+ require(e!=NULL, "cannot allocate token class node");
+ e->lexclass = CurrentLexClass;
+ if ( Tnum( t ) == 0 )
+ {
+ e->tok = addTname( t );
+ set_orel(e->tok, &imag_tokens);
+ set_orel(e->tok, &tokclasses);
+ require((p=(TermEntry *)hash_get(Tname, t)) != NULL,
+ "hash table mechanism is broken");
+ p->classname = 1; /* entry is class name, not token */
+ p->tclass = e; /* save ptr to this tclass def */
+ list_add(&tclasses, (char *)e);
+ }
+ else
+ {
+ warn(eMsg1("redefinition of tokclass or conflict w/token '%s'; ignored",t));
+ free( (char *)e );
+ go=0;
+}
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==114) ) {
+ zzmatch(114); zzCONSUME;
+ zzmatch(QuotedTerm);
+ akaString=mystrdup(StripQuotes(LATEXT(1)));
+ /* MR11 */ save_file=CurFile;save_line=zzline;
+ /* MR23 */
+ zzCONSUME;
+
+ zzmatch(115); zzCONSUME;
+ }
+ else {
+ if ( (LA(1)==102) ) {
+ }
+ else {zzFAIL(1,zzerr17,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+
+ /* MR23 */ if (p!= NULL && akaString != NULL) {
+ /* MR23 */ if (p->akaString != NULL) {
+ /* MR23 */ if (strcmp(p->akaString,akaString) != 0) {
+ /* MR23 */ warnFL(eMsg2("this #tokclass statment conflicts with a previous #tokclass %s(\"%s\") statement",
+ /* MR23 */ t,p->akaString),
+ /* MR23 */ FileStr[save_file],save_line);
+ /* MR23 */ };
+ /* MR23 */ } else {
+ /* MR23 */ p->akaString=akaString;
+ /* MR23 */ };
+ /* MR23 */ };
+ /* MR23 */
+ zzmatch(102); zzCONSUME;
+ {
+ zzBLOCK(zztasp2);
+ int zzcnt=1;
+ zzMake0;
+ {
+ do {
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ if ( (LA(1)==TokenTerm) ) {
+ zzmatch(TokenTerm);
+ if ( go ) {
+ term = (TermEntry *) hash_get(Tname, LATEXT(1));
+ if ( term==NULL && UserDefdTokens ) {
+ err("implicit token definition not allowed with #tokdefs");
+ go = 0;
+ }
+ else {t=mystrdup(LATEXT(1)); tok=addTname(LATEXT(1));}
+ }
+ zzCONSUME;
+
+ {
+ zzBLOCK(zztasp4);
+ zzMake0;
+ {
+ if ( (LA(1)==119) ) {
+ zzmatch(119); zzCONSUME;
+ zzmatch(TokenTerm);
+ if ( go ) {
+ toterm = (TermEntry *) hash_get(Tname, LATEXT(1));
+ if ( toterm==NULL && UserDefdTokens ) {
+ err("implicit token definition not allowed with #tokdefs");
+ go = 0;
+ } else {
+ totext=mystrdup(LATEXT(1)); totok=addTname(LATEXT(1));
+ }
+ }
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd4[LA(1)]&0x8) ) {
+ }
+ else {zzFAIL(1,zzerr18,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp4);
+ }
+ }
+ }
+ else {
+ if ( (LA(1)==QuotedTerm) ) {
+ zzmatch(QuotedTerm);
+ if ( go ) {
+ term = (TermEntry *) hash_get(Texpr, LATEXT(1));
+ if ( term==NULL && UserDefdTokens ) {
+ err("implicit token definition not allowed with #tokdefs");
+ go = 0;
+ }
+ else {t=mystrdup(LATEXT(1)); tok=addTexpr(LATEXT(1));}
+ }
+ zzCONSUME;
+
+ }
+ else {zzFAIL(1,zzerr19,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+ if ( go ) {
+ if (totext == NULL) {
+ list_add(&(e->tlist), t);
+ } else {
+ list_add(&(e->tlist),"..");
+ list_add(&(e->tlist),t);
+ list_add(&(e->tlist),totext);
+ }
+ totext=NULL;
+ }
+ zzLOOP(zztasp2);
+ } while ( (setwd4[LA(1)]&0x10) );
+ zzEXIT(zztasp2);
+ }
+ }
+ zzmatch(98); zzCONSUME;
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ CannotContinue=TRUE;
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd4, 0x20);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+token(void)
+#else
+token()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ char *t=NULL, *e=NULL, *a=NULL; int tnum=0;
+ char *akaString=NULL; TermEntry *te;int save_file=0,save_line=0;
+ zzmatch(120);
+ tokenActionActive=1;
+ zzCONSUME;
+
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==TokenTerm) ) {
+ zzmatch(TokenTerm);
+ t=mystrdup(LATEXT(1));
+ zzCONSUME;
+
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ if ( (LA(1)==114) ) {
+ zzmatch(114); zzCONSUME;
+ zzmatch(QuotedTerm);
+ akaString=mystrdup(StripQuotes(LATEXT(1)));
+ /* MR11 */ save_file=CurFile;save_line=zzline;
+ /* MR11 */
+ zzCONSUME;
+
+ zzmatch(115); zzCONSUME;
+ }
+ else {
+ if ( (setwd4[LA(1)]&0x40) ) {
+ }
+ else {zzFAIL(1,zzerr20,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ if ( (LA(1)==121) ) {
+ zzmatch(121); zzCONSUME;
+ zzmatch(122);
+ tnum = atoi(LATEXT(1));
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd4[LA(1)]&0x80) ) {
+ }
+ else {zzFAIL(1,zzerr21,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+ }
+ else {
+ if ( (setwd5[LA(1)]&0x1) ) {
+ }
+ else {zzFAIL(1,zzerr22,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==QuotedTerm) ) {
+ zzmatch(QuotedTerm);
+ e=mystrdup(LATEXT(1));
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd5[LA(1)]&0x2) ) {
+ }
+ else {zzFAIL(1,zzerr23,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==Action) ) {
+ zzmatch(Action);
+
+ a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(a!=NULL, "rule token: cannot allocate action");
+ strcpy(a, LATEXT(1));
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd5[LA(1)]&0x4) ) {
+ }
+ else {zzFAIL(1,zzerr24,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==107) ) {
+ zzmatch(107); zzCONSUME;
+ }
+ else {
+ if ( (setwd5[LA(1)]&0x8) ) {
+ }
+ else {zzFAIL(1,zzerr25,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ chkToken(t, e, a, tnum);
+ if (t != NULL) {
+ te=(TermEntry *)hash_get(Tname,t);
+ if (te != NULL && akaString != NULL) {
+ if (te->akaString != NULL) {
+ if (strcmp(te->akaString,akaString) != 0) {
+ warnFL(eMsg2("this #token statment conflicts with a previous #token %s(\"%s\") statement",
+ t,te->akaString),
+ FileStr[save_file],save_line);
+ };
+ } else {
+ te->akaString=akaString;
+ };
+ };
+ };
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ CannotContinue=TRUE;
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd5, 0x10);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+block(set * toksrefd,set * rulesrefd)
+#else
+block(toksrefd,rulesrefd)
+ set *toksrefd;
+set *rulesrefd ;
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+
+ Graph g, b;
+ set saveblah;
+ int saveinalt = inAlt;
+ ExceptionGroup *eg;
+ * toksrefd = empty;
+ * rulesrefd = empty;
+ set_clr(AST_nodes_refd_in_actions);
+ CurBlockID++;
+ /* MR23 */ CurBlockID_array[BlkLevel] = CurBlockID;
+ CurAltNum = 1;
+ /* MR23 */ CurAltNum_array[BlkLevel] = CurAltNum;
+ saveblah = attribsRefdFromAction;
+ attribsRefdFromAction = empty;
+ alt( toksrefd,rulesrefd );
+ b = g = zzaArg(zztasp1,1);
+
+ if ( ((Junction *)g.left)->p1->ntype == nAction )
+ {
+ ActionNode *actionNode=(ActionNode *)
+ ( ( (Junction *)g.left) ->p1);
+ if (!actionNode->is_predicate )
+ {
+ actionNode->init_action = TRUE;
+ /* MR12c */ if (actionNode->noHoist) {
+ /* MR12c */ errFL("<<nohoist>> appears as init-action - use <<>> <<nohoist>>",
+ /* MR12c */ FileStr[actionNode->file],actionNode->line);
+ /* MR12c */ };
+ }
+ }
+ ((Junction *)g.left)->blockid = CurBlockID;
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ while ( (LA(1)==133) ) {
+ eg = exception_group();
+
+
+ if ( eg!=NULL ) {
+ /* MR7 ***** eg->altID = makeAltID(CurBlockID,CurAltNum); *****/
+ /* MR7 ***** CurAltStart->exception_label = eg->altID; *****/
+ list_add(&CurExGroups, (void *)eg);
+ }
+ zzLOOP(zztasp2);
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ CurAltNum++;
+ /* MR23 */ CurAltNum_array[BlkLevel] = CurAltNum;
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ while ( (LA(1)==123) ) {
+ zzmatch(123);
+ inAlt=1;
+ zzCONSUME;
+
+ alt( toksrefd,rulesrefd );
+ g = Or(g, zzaArg(zztasp2,2));
+
+ ((Junction *)g.left)->blockid = CurBlockID;
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ while ( (LA(1)==133) ) {
+ eg = exception_group();
+
+
+ if ( eg!=NULL ) {
+ /* MR7 ***** eg->altID = makeAltID(CurBlockID,CurAltNum); *****/
+ /* MR7 ***** CurAltStart->exception_label = eg->altID; *****/
+ list_add(&CurExGroups, (void *)eg);
+ }
+ zzLOOP(zztasp3);
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+ CurAltNum++;
+ /* MR23 */ CurAltNum_array[BlkLevel] = CurAltNum;
+ zzLOOP(zztasp2);
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ zzaArg(zztasp1,0) = b;
+ attribsRefdFromAction = saveblah; inAlt = saveinalt;
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ CannotContinue=TRUE;
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd5, 0x20);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+alt(set * toksrefd,set * rulesrefd)
+#else
+alt(toksrefd,rulesrefd)
+ set *toksrefd;
+set *rulesrefd ;
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ int n=0; Graph g; int e_num=0, old_not=0; Node *node; set elems, dif;
+ int first_on_line = 1, use_def_MT_handler = 0;
+ g.left=NULL; g.right=NULL;
+
+ CurAltStart = NULL;
+ elems = empty;
+ inAlt = 1;
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==88) ) {
+ zzmatch(88);
+ use_def_MT_handler = 1;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd5[LA(1)]&0x40) ) {
+ }
+ else {zzFAIL(1,zzerr26,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ ;
+ while ( (setwd5[LA(1)]&0x80) ) {
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ old_not=0;
+ if ( (LA(1)==124) ) {
+ zzmatch(124);
+ old_not=1;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd6[LA(1)]&0x1) ) {
+ }
+ else {zzFAIL(1,zzerr27,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+ node = element( old_not, first_on_line, use_def_MT_handler );
+
+ if ( node!=NULL && node->ntype!=nAction ) first_on_line = 0;
+
+ if ( zzaArg(zztasp2,2 ).left!=NULL ) {
+ g = Cat(g, zzaArg(zztasp2,2));
+ n++;
+ if ( node!=NULL ) {
+ if ( node->ntype!=nAction ) e_num++;
+ /* record record number of all rule and token refs */
+ if ( node->ntype==nToken ) {
+ TokNode *tk = (TokNode *)((Junction *)zzaArg(zztasp2,2 ).left)->p1;
+ tk->elnum = e_num;
+ set_orel(e_num, &elems);
+ }
+ else if ( node->ntype==nRuleRef ) {
+ RuleRefNode *rn = (RuleRefNode *)((Junction *)zzaArg(zztasp2,2 ).left)->p1;
+ rn->elnum = e_num;
+ set_orel(e_num, rulesrefd);
+ }
+ }
+ }
+ zzLOOP(zztasp2);
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ if ( n == 0 ) g = emptyAlt();
+ zzaArg(zztasp1,0) = g;
+ /* We want to reduce number of LT(i) calls and the number of
+ * local attribute variables in C++ mode (for moment, later we'll
+ * do for C also). However, if trees are being built, they
+ * require most of the attrib variables to create the tree nodes
+ * with; therefore, we gen a token ptr for each token ref in C++
+ */
+ if ( GenCC && !GenAST )
+ {
+ /* This now free's the temp set -ATG 5/6/95 */
+ set temp;
+ temp = set_and(elems, attribsRefdFromAction);
+ set_orin( toksrefd, temp);
+ set_free(temp);
+}
+else set_orin( toksrefd, elems);
+if ( GenCC ) {
+ dif = set_dif(attribsRefdFromAction, elems);
+ if ( set_deg(dif)>0 )
+ err("one or more $i in action(s) refer to non-token elements");
+ set_free(dif);
+}
+set_free(elems);
+set_free(attribsRefdFromAction);
+inAlt = 0;
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ CannotContinue=TRUE;
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd6, 0x2);
+ }
+}
+
+LabelEntry *
+#ifdef __USE_PROTOS
+element_label(void)
+#else
+element_label()
+#endif
+{
+ LabelEntry * _retv;
+ zzRULE;
+ zzBLOCK(zztasp1);
+ PCCTS_PURIFY(_retv,sizeof(LabelEntry * ))
+ zzMake0;
+ {
+ TermEntry *t=NULL; LabelEntry *l=NULL; RuleEntry *r=NULL; char *lab;
+ zzmatch(LABEL);
+ lab = mystrdup(LATEXT(1));
+ zzCONSUME;
+
+
+ UsedNewStyleLabel = 1;
+ if ( UsedOldStyleAttrib ) err("cannot mix with new-style labels with old-style $i");
+ t = (TermEntry *) hash_get(Tname, lab);
+ if ( t==NULL ) t = (TermEntry *) hash_get(Texpr, lab);
+ if ( t==NULL ) r = (RuleEntry *) hash_get(Rname, lab);
+ if ( t!=NULL ) {
+ err(eMsg1("label definition clashes with token/tokclass definition: '%s'", lab));
+ _retv = NULL;
+ }
+ else if ( r!=NULL ) {
+ err(eMsg1("label definition clashes with rule definition: '%s'", lab));
+ _retv = NULL;
+ }
+ else {
+ /* we don't clash with anybody else */
+ l = (LabelEntry *) hash_get(Elabel, lab);
+ if ( l==NULL ) { /* ok to add new element label */
+ l = (LabelEntry *)hash_add(Elabel,
+ lab,
+ (Entry *)newLabelEntry(lab));
+ /* add to list of element labels for this rule */
+ list_add(&CurElementLabels, (void *)lab);
+ /* MR7 */ leAdd(l); /* list of labels waiting for exception group definitions */
+ _retv = l;
+ }
+ else {
+ err(eMsg1("label definitions must be unique per rule: '%s'", lab));
+ _retv = NULL;
+}
+}
+ zzmatch(106); zzCONSUME;
+ zzEXIT(zztasp1);
+ return _retv;
+fail:
+ zzEXIT(zztasp1);
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd6, 0x4);
+ return _retv;
+ }
+}
+
+Node *
+#ifdef __USE_PROTOS
+element(int old_not,int first_on_line,int use_def_MT_handler)
+#else
+element(old_not,first_on_line,use_def_MT_handler)
+ int old_not;
+int first_on_line;
+int use_def_MT_handler ;
+#endif
+{
+ Node * _retv;
+ zzRULE;
+ zzBLOCK(zztasp1);
+ PCCTS_PURIFY(_retv,sizeof(Node * ))
+ zzMake0;
+ {
+
+ Attrib blk;
+ Predicate *pred = NULL;
+ int local_use_def_MT_handler=0;
+ ActionNode *act;
+ RuleRefNode *rr;
+ set toksrefd, rulesrefd;
+ TermEntry *term;
+ TokNode *p=NULL; RuleRefNode *q; int approx=0;
+ LabelEntry *label=NULL;
+ int predMsgDone=0;
+ int semDepth=0;
+ int ampersandStyle;
+ int height; /* MR11 */
+ int equal_height; /* MR11 */
+
+ char* pFirstSetSymbol = NULL; /* MR21 */
+
+ _retv = NULL;
+ if ( (setwd6[LA(1)]&0x8) ) {
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==LABEL) ) {
+ label = element_label();
+
+ }
+ else {
+ if ( (setwd6[LA(1)]&0x10) ) {
+ }
+ else {zzFAIL(1,zzerr28,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==TokenTerm) ) {
+ zzmatch(TokenTerm);
+
+ term = (TermEntry *) hash_get(Tname, LATEXT(1));
+ if ( term==NULL && UserDefdTokens ) {
+ err("implicit token definition not allowed with #tokdefs");
+ zzaRet.left = zzaRet.right = NULL;
+ }
+ else {
+ zzaRet = buildToken(LATEXT(1));
+ p=((TokNode *)((Junction *)zzaRet.left)->p1);
+ term = (TermEntry *) hash_get(Tname, LATEXT(1));
+ require( term!= NULL, "hash table mechanism is broken");
+ p->tclass = term->tclass;
+ p->complement = old_not;
+ if ( label!=NULL ) {
+ p->el_label = label->str;
+ label->elem = (Node *)p;
+ }
+ }
+ zzCONSUME;
+
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ if ( (LA(1)==119) ) {
+ zzmatch(119); zzCONSUME;
+ {
+ zzBLOCK(zztasp4);
+ zzMake0;
+ {
+ if ( (LA(1)==QuotedTerm) ) {
+ zzmatch(QuotedTerm);
+ if ( p!=NULL ) setUpperRange(p, LATEXT(1));
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==TokenTerm) ) {
+ zzmatch(TokenTerm);
+ if ( p!=NULL ) setUpperRange(p, LATEXT(1));
+ zzCONSUME;
+
+ }
+ else {zzFAIL(1,zzerr29,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp4);
+ }
+ }
+ }
+ else {
+ if ( (setwd6[LA(1)]&0x20) ) {
+ }
+ else {zzFAIL(1,zzerr30,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+
+ if ( p!=NULL && (p->upper_range!=0 || p->tclass || old_not) )
+ list_add(&MetaTokenNodes, (void *)p);
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ if ( (LA(1)==125) ) {
+ zzmatch(125);
+ if ( p!=NULL ) p->astnode=ASTroot;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd6[LA(1)]&0x40) ) {
+ if ( p!=NULL ) p->astnode=ASTchild;
+ }
+ else {
+ if ( (LA(1)==103) ) {
+ zzmatch(103);
+ if ( p!=NULL ) p->astnode=ASTexclude;
+ zzCONSUME;
+
+ }
+ else {zzFAIL(1,zzerr31,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ if ( (LA(1)==88) ) {
+ zzmatch(88);
+ local_use_def_MT_handler = 1;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd6[LA(1)]&0x80) ) {
+ }
+ else {zzFAIL(1,zzerr32,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+
+ if ( p!=NULL && first_on_line ) {
+ CurAltStart = (Junction *)zzaRet.left;
+ altAdd(CurAltStart); /* MR7 */
+ p->altstart = CurAltStart;
+ }
+ if ( p!=NULL )
+ p->use_def_MT_handler = use_def_MT_handler || local_use_def_MT_handler;
+ _retv = (Node *)p;
+ }
+ else {
+ if ( (LA(1)==QuotedTerm) ) {
+ zzmatch(QuotedTerm);
+
+ term = (TermEntry *) hash_get(Texpr, LATEXT(1));
+ if ( term==NULL && UserDefdTokens ) {
+ err("implicit token definition not allowed with #tokdefs");
+ zzaRet.left = zzaRet.right = NULL;
+ }
+ else {
+ zzaRet = buildToken(LATEXT(1)); p=((TokNode *)((Junction *)zzaRet.left)->p1);
+ p->complement = old_not;
+ if ( label!=NULL ) {
+ p->el_label = label->str;
+ label->elem = (Node *)p;
+ }
+ }
+ zzCONSUME;
+
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ if ( (LA(1)==119) ) {
+ zzmatch(119); zzCONSUME;
+ {
+ zzBLOCK(zztasp4);
+ zzMake0;
+ {
+ if ( (LA(1)==QuotedTerm) ) {
+ zzmatch(QuotedTerm);
+ if ( p!=NULL ) setUpperRange(p, LATEXT(1));
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==TokenTerm) ) {
+ zzmatch(TokenTerm);
+ if ( p!=NULL ) setUpperRange(p, LATEXT(1));
+ zzCONSUME;
+
+ }
+ else {zzFAIL(1,zzerr33,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp4);
+ }
+ }
+ }
+ else {
+ if ( (setwd7[LA(1)]&0x1) ) {
+ }
+ else {zzFAIL(1,zzerr34,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ if ( (LA(1)==125) ) {
+ zzmatch(125);
+ if ( p!=NULL ) p->astnode=ASTroot;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd7[LA(1)]&0x2) ) {
+ if ( p!=NULL ) p->astnode=ASTchild;
+ }
+ else {
+ if ( (LA(1)==103) ) {
+ zzmatch(103);
+ if ( p!=NULL ) p->astnode=ASTexclude;
+ zzCONSUME;
+
+ }
+ else {zzFAIL(1,zzerr35,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ if ( (LA(1)==88) ) {
+ zzmatch(88);
+ local_use_def_MT_handler = 1;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd7[LA(1)]&0x4) ) {
+ }
+ else {zzFAIL(1,zzerr36,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+
+ if ( p!=NULL && (p->upper_range!=0 || p->tclass || old_not) )
+ list_add(&MetaTokenNodes, (void *)p);
+
+ if ( first_on_line ) {
+ CurAltStart = (Junction *)zzaRet.left;
+ altAdd(CurAltStart); /* MR7 */
+ p->altstart = CurAltStart;
+ }
+ if ( p!=NULL )
+ p->use_def_MT_handler = use_def_MT_handler || local_use_def_MT_handler;
+ _retv = (Node *)p;
+ }
+ else {
+ if ( (LA(1)==WildCard) ) {
+ if ( old_not ) warn("~ WILDCARD is an undefined operation (implies 'nothing')");
+ zzmatch(WildCard);
+ zzaRet = buildWildCard(LATEXT(1)); p=((TokNode *)((Junction *)zzaRet.left)->p1);
+ zzCONSUME;
+
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ if ( (LA(1)==125) ) {
+ zzmatch(125);
+ p->astnode=ASTroot;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd7[LA(1)]&0x8) ) {
+ p->astnode=ASTchild;
+ }
+ else {
+ if ( (LA(1)==103) ) {
+ zzmatch(103);
+ p->astnode=ASTexclude;
+ zzCONSUME;
+
+ }
+ else {zzFAIL(1,zzerr37,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+ list_add(&MetaTokenNodes, (void *)p);
+
+ if ( first_on_line ) {
+ CurAltStart = (Junction *)zzaRet.left;
+ altAdd(CurAltStart); /* MR7 */
+ p->altstart = CurAltStart;
+ if ( label!=NULL ) {
+ p->el_label = label->str;
+ label->elem = (Node *)p;
+ }
+ }
+ _retv = (Node *)p;
+ }
+ else {
+ if ( (LA(1)==NonTerminal) ) {
+ if ( old_not ) warn("~ NONTERMINAL is an undefined operation");
+ zzmatch(NonTerminal);
+ zzaRet = buildRuleRef(LATEXT(1));
+ zzCONSUME;
+
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ if ( (LA(1)==103) ) {
+ zzmatch(103);
+ q = (RuleRefNode *) ((Junction *)zzaRet.left)->p1;
+ q->astnode=ASTexclude;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd7[LA(1)]&0x10) ) {
+ }
+ else {zzFAIL(1,zzerr38,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ if ( (setwd7[LA(1)]&0x20) ) {
+ {
+ zzBLOCK(zztasp4);
+ zzMake0;
+ {
+ if ( (LA(1)==104) ) {
+ zzmatch(104); zzCONSUME;
+ }
+ else {
+ if ( (LA(1)==PassAction) ) {
+ }
+ else {zzFAIL(1,zzerr39,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp4);
+ }
+ }
+ zzmatch(PassAction);
+ addParm(((Junction *)zzaRet.left)->p1, LATEXT(1));
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd7[LA(1)]&0x40) ) {
+ }
+ else {zzFAIL(1,zzerr40,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+ rr=(RuleRefNode *) ((Junction *)zzaRet.left)->p1;
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ char *a;
+ if ( (LA(1)==105) ) {
+ zzmatch(105); zzCONSUME;
+ zzmatch(PassAction);
+
+ a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(a!=NULL, "rule element: cannot allocate assignment");
+ strcpy(a, LATEXT(1));
+ rr->assign = a;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd7[LA(1)]&0x80) ) {
+ }
+ else {zzFAIL(1,zzerr41,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+
+ if ( label!=NULL ) {
+ rr->el_label = label->str;
+ label->elem = (Node *)rr;
+ }
+ if ( first_on_line ) {
+ CurAltStart = (Junction *)zzaRet.left;
+ altAdd(CurAltStart); /* MR7 */
+ ((RuleRefNode *)((Junction *)zzaRet.left)->p1)->altstart = CurAltStart;
+ }
+ _retv = (Node *)rr;
+ }
+ else {zzFAIL(1,zzerr42,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ }
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ }
+ else {
+ if ( (LA(1)==Action) ) {
+ if ( old_not ) warn("~ ACTION is an undefined operation");
+ zzmatch(Action);
+ zzaArg(zztasp1,0) = buildAction(LATEXT(1),action_file,action_line, 0);
+ zzCONSUME;
+
+ if ( first_on_line ) { /* MR7 */
+ CurAltStart = (Junction *)zzaArg(zztasp1,0 ).left; /* MR7 */
+ altAdd(CurAltStart); /* MR7 */
+ };
+ _retv = (Node *) ((Junction *)zzaArg(zztasp1,0 ).left)->p1;
+ }
+ else {
+ if ( (LA(1)==Pred) ) {
+ if ( old_not ) warn("~ SEMANTIC-PREDICATE is an undefined operation");
+ zzmatch(Pred);
+ zzaArg(zztasp1,0) = buildAction(LATEXT(1),action_file,action_line, 1);
+ zzCONSUME;
+
+ act = (ActionNode *) ((Junction *)zzaArg(zztasp1,0 ).left)->p1;
+ if (numericActionLabel) { /* MR10 */
+ list_add(&NumericPredLabels,act); /* MR10 */
+ numericActionLabel=0; /* MR10 */
+ }; /* MR10 */
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ char *a;
+ if ( (LA(1)==PassAction) ) {
+ zzmatch(PassAction);
+
+ a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(a!=NULL, "rule element: cannot allocate predicate fail action");
+ strcpy(a, LATEXT(1));
+ act->pred_fail = a;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd8[LA(1)]&0x1) ) {
+ }
+ else {zzFAIL(1,zzerr43,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ if ( first_on_line ) { /* MR7 */
+ CurAltStart = (Junction *)zzaArg(zztasp1,0 ).left; /* MR7 */
+ altAdd(CurAltStart); /* MR7 */
+ };
+ _retv = (Node *)act;
+ }
+ else {
+ if ( (setwd8[LA(1)]&0x2) ) {
+ if ( old_not ) warn("~ BLOCK is an undefined operation");
+ BlkLevel++;
+ if (BlkLevel >= MAX_BLK_LEVEL) fatal("Blocks nested too deeply");
+ /* MR23 */ CurBlockID_array[BlkLevel] = CurBlockID;
+ /* MR23 */ CurAltNum_array[BlkLevel] = CurAltNum;
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==Pragma) ) {
+ zzmatch(Pragma); zzCONSUME;
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ if ( (LA(1)==126) ) {
+ zzmatch(126);
+ approx=LL_k;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==127) ) {
+ zzmatch(127);
+ approx = 1;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==128) ) {
+ zzmatch(128);
+ approx = 2;
+ zzCONSUME;
+
+ }
+ else {zzFAIL(1,zzerr44,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+ }
+ else {
+ if ( (setwd8[LA(1)]&0x4) ) {
+ }
+ else {zzFAIL(1,zzerr45,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==FirstSetSymbol) ) {
+ zzmatch(FirstSetSymbol); zzCONSUME;
+ zzmatch(114); zzCONSUME;
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ if ( (LA(1)==NonTerminal) ) {
+ zzmatch(NonTerminal);
+
+ /* MR21 */ pFirstSetSymbol = (char *) calloc(strlen(LATEXT(1))+1,
+ /* MR21 */ sizeof(char));
+ /* MR21 */ require(pFirstSetSymbol!=NULL,
+ /* MR21 */ "cannot allocate first set name");
+ /* MR21 */ strcpy(pFirstSetSymbol, LATEXT(1));
+ /* MR21 */
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==TokenTerm) ) {
+ zzmatch(TokenTerm);
+
+ /* MR21 */ pFirstSetSymbol = (char *) calloc(strlen(LATEXT(1))+1,
+ /* MR21 */ sizeof(char));
+ /* MR21 */ require(pFirstSetSymbol!=NULL,
+ /* MR21 */ "cannot allocate first set name");
+ /* MR21 */ strcpy(pFirstSetSymbol, LATEXT(1));
+ /* MR21 */
+ zzCONSUME;
+
+ }
+ else {zzFAIL(1,zzerr46,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+ zzmatch(115); zzCONSUME;
+ }
+ else {
+ if ( (setwd8[LA(1)]&0x8) ) {
+ }
+ else {zzFAIL(1,zzerr47,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==114) ) {
+ zzmatch(114); zzCONSUME;
+ block( &toksrefd,&rulesrefd );
+ zzmatch(115);
+ blk = zzaRet = zzaArg(zztasp2,2);
+ /* MR23 */ CurBlockID_array[BlkLevel] = (-1);
+ /* MR23 */ CurAltNum_array[BlkLevel] = (-1);
+ --BlkLevel;
+ zzCONSUME;
+
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ if ( (LA(1)==129) ) {
+ zzmatch(129);
+ zzaRet = makeLoop(zzaRet,approx,pFirstSetSymbol);
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==130) ) {
+ zzmatch(130);
+ zzaRet = makePlus(zzaRet,approx,pFirstSetSymbol);
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==131) ) {
+ zzmatch(131); zzCONSUME;
+ {
+ zzBLOCK(zztasp4);
+ zzMake0;
+ {
+ if ( (setwd8[LA(1)]&0x10) ) {
+ {
+ zzBLOCK(zztasp5);
+ zzMake0;
+ {
+ if ( (LA(1)==132) ) {
+ zzmatch(132);
+ ampersandStyle=0;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==113) ) {
+ zzmatch(113);
+ ampersandStyle=1;
+ zzCONSUME;
+
+ }
+ else {zzFAIL(1,zzerr48,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp5);
+ }
+ }
+ zzmatch(Pred);
+ zzaRet = buildAction(LATEXT(1),action_file,action_line,1);
+ zzCONSUME;
+
+ act = (ActionNode *) ((Junction *)zzaRet.left)->p1;
+ semDepth=predicateLookaheadDepth(act);
+ if (numericActionLabel) { /* MR10 */
+ list_add(&NumericPredLabels,act); /* MR10 */
+ numericActionLabel=0; /* MR10 */
+ }; /* MR10 */
+ {
+ zzBLOCK(zztasp5);
+ zzMake0;
+ {
+ char *a;
+ if ( (LA(1)==PassAction) ) {
+ zzmatch(PassAction);
+
+ a = (char *)calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(a!=NULL, "rule element: cannot allocate predicate fail action");
+ strcpy(a, LATEXT(1));
+ act->pred_fail = a;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd8[LA(1)]&0x20) ) {
+ }
+ else {zzFAIL(1,zzerr49,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp5);
+ }
+ }
+ if ( first_on_line) { /* MR7 */
+ CurAltStart=(Junction *)zzaRet.left; /* MR7 */
+ altAdd(CurAltStart); /* MR7 */
+ };
+ _retv = (Node *)act;
+
+ pred = computePredFromContextGuard(blk,&predMsgDone); /* MR10 */
+ if ( pred==NULL) { /* MR10 */
+ if ( !predMsgDone) err("invalid or missing context guard"); /* MR10 */
+ predMsgDone=1; /* MR10 */
+ } else { /* MR10 */
+ act->guardNodes=(Junction *)blk.left; /* MR11 */
+ pred->expr = act->action;
+ pred->source = act;
+ /* MR10 */ pred->ampersandStyle = ampersandStyle; /* 0 means (g)? => ... 1 means (g)? && ... */
+ /* MR13 */ if (pred->tcontext != NULL) {
+ /* MR13 */ height=MR_max_height_of_tree(pred->tcontext);
+ /* MR13 */ equal_height=MR_all_leaves_same_height(pred->tcontext,height);
+ /* MR13 */ if (! equal_height) {
+ /* MR13 */ errFL("in guarded predicates all tokens in the guard must be at the same height",
+ /* MR13 */ FileStr[act->file],act->line);
+ /* MR13 */ };
+ /* MR13 */ }
+ /* MR10 */ if (ampersandStyle) {
+ /* MR10 */ act->ampersandPred = pred;
+ /* MR11 */ if (! HoistPredicateContext) {
+ /* MR11 */ errFL("without \"-prc on\" (guard)? && <<pred>>? ... doesn't make sense",
+ /* MR11 */ FileStr[act->file],act->line);
+ /* MR11 */ };
+ /* MR10 */ } else {
+ /* MR10 */ act->guardpred = pred;
+ /* MR10 */ };
+ /* MR10 */ if (pred->k != semDepth) {
+ /* MR10 */ warn(eMsgd2("length of guard (%d) does not match the length of semantic predicate (%d)",
+ /* MR10 */ pred->k,semDepth));
+ /* MR10 */ };
+ }
+ }
+ else {
+ if ( (setwd8[LA(1)]&0x40) ) {
+ zzaRet = makeBlk(zzaRet,approx,pFirstSetSymbol);
+ FoundGuessBlk = 1;
+ ((Junction *) ((Junction *)zzaRet.left)->p1)->guess=1;
+ if ( ! first_on_line ) {
+ err("(...)? predicate must be first element of production");
+ }
+ }
+ else {zzFAIL(1,zzerr50,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp4);
+ }
+ }
+ }
+ else {
+ if ( (setwd8[LA(1)]&0x80) ) {
+ zzaRet = makeBlk(zzaRet,approx,pFirstSetSymbol);
+ }
+ else {zzFAIL(1,zzerr51,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ }
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+
+ if ( pred==NULL && !predMsgDone) { /* MR10 */
+ ((Junction *)((Junction *)zzaRet.left)->p1)->blockid = CurBlockID;
+ ((Junction *)((Junction *)zzaRet.left)->p1)->tokrefs = toksrefd;
+ ((Junction *)((Junction *)zzaRet.left)->p1)->rulerefs = rulesrefd;
+ if ( first_on_line ) { /* MR7 */
+ CurAltStart = (Junction *)((Junction *)((Junction *)zzaRet.left)->p1); /* MR7 */
+ altAdd(CurAltStart); /* MR7 */
+ }; /* MR7 */
+ _retv = (Node *) ((Junction *)zzaRet.left)->p1;
+ }
+ }
+ else {
+ if ( (LA(1)==102) ) {
+ zzmatch(102); zzCONSUME;
+ block( &toksrefd,&rulesrefd );
+ zzaRet = makeOpt(zzaArg(zztasp2,2),approx,pFirstSetSymbol);
+ /* MR23 */ CurBlockID_array[BlkLevel] = (-1);
+ /* MR23 */ CurAltNum_array[BlkLevel] = (-1);
+ --BlkLevel;
+ zzmatch(98);
+
+ ((Junction *)((Junction *)zzaRet.left)->p1)->blockid = CurBlockID;
+ ((Junction *)((Junction *)zzaRet.left)->p1)->tokrefs = toksrefd;
+ ((Junction *)((Junction *)zzaRet.left)->p1)->rulerefs = rulesrefd;
+ zzCONSUME;
+
+ if ( first_on_line ) { /* MR7 */
+ CurAltStart = (Junction *) ((Junction *)((Junction *)zzaRet.left)->p1); /* MR7 */
+ altAdd(CurAltStart); /* MR7 */
+ };
+ _retv = (Node *) ((Junction *)zzaRet.left)->p1;
+ }
+ else {zzFAIL(1,zzerr52,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ }
+ else {
+ if ( (LA(1)==129) ) {
+ zzmatch(129);
+ warn("don't you want a ')' with that '*'?"); CannotContinue=TRUE;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==130) ) {
+ zzmatch(130);
+ warn("don't you want a ')' with that '+'?"); CannotContinue=TRUE;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==105) ) {
+ zzmatch(105);
+ warn("'>' can only appear after a nonterminal"); CannotContinue=TRUE;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==PassAction) ) {
+ zzmatch(PassAction);
+ warn("[...] out of context 'rule > [...]'");
+ CannotContinue=TRUE;
+ zzCONSUME;
+
+ }
+ else {zzFAIL(1,zzerr53,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ zzEXIT(zztasp1);
+ return _retv;
+fail:
+ zzEXIT(zztasp1);
+ CannotContinue=TRUE;
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd9, 0x1);
+ return _retv;
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+default_exception_handler(void)
+#else
+default_exception_handler()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ DefaultExGroup = exception_group();
+
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd9, 0x2);
+ }
+}
+
+ExceptionGroup *
+#ifdef __USE_PROTOS
+exception_group(void)
+#else
+exception_group()
+#endif
+{
+ ExceptionGroup * _retv;
+ zzRULE;
+ zzBLOCK(zztasp1);
+ PCCTS_PURIFY(_retv,sizeof(ExceptionGroup * ))
+ zzMake0;
+ {
+ ExceptionHandler *h; LabelEntry *label=NULL; /* MR6 */
+ FoundException = 1; FoundExceptionGroup = 1;
+ zzmatch(133);
+ _retv = (ExceptionGroup *)calloc(1, sizeof(ExceptionGroup));
+ zzCONSUME;
+
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ char *p;
+ if ( (LA(1)==PassAction) ) {
+ zzmatch(PassAction);
+
+ p = LATEXT(1)+1;
+ p[strlen(p)-1] = '\0'; /* kill trailing space */
+ label = (LabelEntry *) hash_get(Elabel, LATEXT(1)+1);
+ if ( label==NULL )
+ {
+ err(eMsg1("unknown label in exception handler: '%s'", LATEXT(1)+1));
+ }
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd9[LA(1)]&0x4) ) {
+ }
+ else {zzFAIL(1,zzerr54,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ while ( (LA(1)==135) ) {
+ h = exception_handler();
+
+ list_add(&(_retv->handlers), (void *)h);
+ zzLOOP(zztasp2);
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==134) ) {
+ zzmatch(134); zzCONSUME;
+ zzmatch(106); zzCONSUME;
+ zzmatch(Action);
+ {
+ ExceptionHandler *eh = (ExceptionHandler *)
+ calloc(1, sizeof(ExceptionHandler));
+ char *a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(eh!=NULL, "exception: cannot allocate handler");
+ require(a!=NULL, "exception: cannot allocate action");
+ strcpy(a, LATEXT(1));
+ eh->action = a;
+ eh->signalname = (char *) calloc(strlen("default")+1, sizeof(char));
+ require(eh->signalname!=NULL, "exception: cannot allocate sig name");
+ strcpy(eh->signalname, "default");
+ list_add(&(_retv->handlers), (void *)eh);
+ }
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd9[LA(1)]&0x8) ) {
+ }
+ else {zzFAIL(1,zzerr55,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+
+ if ( label!=NULL ) {
+ /* Record ex group in sym tab for this label */
+ if ( label->ex_group!=NULL ) {
+ err(eMsg1("duplicate exception handler for label '%s'",label->str));
+ } else {
+ label->ex_group = _retv;
+ /* Label the exception group itself */
+ _retv->label = label->str;
+ /* Make the labelled element pt to the exception also */
+ /* MR6 */ if (label->elem == NULL) {
+ /* MR6 */ err(eMsg1("reference in exception handler to undefined label '%s'",label->str));
+ /* MR6 */ } else {
+ switch ( label->elem->ntype ) {
+ case nRuleRef :
+ {
+ RuleRefNode *r = (RuleRefNode *)label->elem;
+ r->ex_group = _retv;
+ break;
+ }
+ case nToken :
+ {
+ TokNode *t = (TokNode *)label->elem;
+ t->ex_group = _retv;
+ break;
+ }
+ } /* end switch */
+ /* MR6 */ }; /* end test on label->elem */
+ } /* end test on label->ex_group */
+
+ } /* end test on exception label */
+
+/* MR7 */
+ /* MR7 */ if (BlkLevel == 1 && label == NULL) {
+ /* MR7 */ _retv->forRule=1;
+ /* MR7 */ } else if (label == NULL) {
+ /* MR7 */ _retv->altID = makeAltID(CurBlockID_array[BlkLevel], CurAltNum_array[BlkLevel]);
+ /* MR7 */ egAdd(_retv);
+ /* MR7 */ } else {
+ /* MR7 */ _retv->labelEntry=label;
+ /* MR7 */ };
+ /* MR7 */
+ /* MR7 */ /* You may want to remove this exc from the rule list */
+ /* MR7 */ /* and handle at the labeled element site. */
+ /* MR7 */
+ /* MR7 */ if (label != NULL) {
+ /* MR7 */ _retv = NULL;
+ /* MR7 */ };
+ zzEXIT(zztasp1);
+ return _retv;
+fail:
+ zzEXIT(zztasp1);
+ CannotContinue=TRUE;
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd9, 0x10);
+ return _retv;
+ }
+}
+
+ExceptionHandler *
+#ifdef __USE_PROTOS
+exception_handler(void)
+#else
+exception_handler()
+#endif
+{
+ ExceptionHandler * _retv;
+ zzRULE;
+ zzBLOCK(zztasp1);
+ PCCTS_PURIFY(_retv,sizeof(ExceptionHandler * ))
+ zzMake0;
+ {
+ ;
+ zzmatch(135);
+
+ _retv = (ExceptionHandler *)calloc(1, sizeof(ExceptionHandler));
+ require(_retv!=NULL, "exception: cannot allocate handler");
+ zzCONSUME;
+
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==NonTerminal) ) {
+ zzmatch(NonTerminal);
+
+ _retv->signalname = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(_retv->signalname!=NULL, "exception: cannot allocate sig name");
+ strcpy(_retv->signalname, LATEXT(1));
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==TokenTerm) ) {
+ zzmatch(TokenTerm);
+
+ _retv->signalname = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(_retv->signalname!=NULL, "exception: cannot allocate sig name");
+ strcpy(_retv->signalname, LATEXT(1));
+ zzCONSUME;
+
+ }
+ else {zzFAIL(1,zzerr56,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ zzmatch(106); zzCONSUME;
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ _retv->action = NULL;
+ if ( (LA(1)==Action) ) {
+ zzmatch(Action);
+
+ _retv->action = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(_retv->action!=NULL, "exception: cannot allocate action");
+ strcpy(_retv->action, LATEXT(1));
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd9[LA(1)]&0x20) ) {
+ }
+ else {zzFAIL(1,zzerr57,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ zzEXIT(zztasp1);
+ return _retv;
+fail:
+ zzEXIT(zztasp1);
+ CannotContinue=TRUE;
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd9, 0x40);
+ return _retv;
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+enum_file(char * fname)
+#else
+enum_file(fname)
+ char *fname ;
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ if ( (setwd9[LA(1)]&0x80) ) {
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==143) ) {
+ zzmatch(143); zzCONSUME;
+ zzmatch(ID); zzCONSUME;
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ if ( (LA(1)==149) ) {
+ zzmatch(149); zzCONSUME;
+ zzmatch(ID); zzCONSUME;
+ }
+ else {
+ if ( (setwd10[LA(1)]&0x1) ) {
+ }
+ else {zzFAIL(1,zzerr58,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+ }
+ else {
+ if ( (setwd10[LA(1)]&0x2) ) {
+ }
+ else {zzFAIL(1,zzerr59,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==151) ) {
+ {
+ zzBLOCK(zztasp3);
+ int zzcnt=1;
+ zzMake0;
+ {
+ do {
+ enum_def( fname );
+ zzLOOP(zztasp3);
+ } while ( (LA(1)==151) );
+ zzEXIT(zztasp3);
+ }
+ }
+ }
+ else {
+ if ( (LA(1)==149) ) {
+ defines( fname );
+ }
+ else {zzFAIL(1,zzerr60,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ }
+ else {
+ if ( (LA(1)==Eof) ) {
+ }
+ else {zzFAIL(1,zzerr61,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd10, 0x4);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+defines(char * fname)
+#else
+defines(fname)
+ char *fname ;
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ int v; int maxt=(-1); char *t;
+ {
+ zzBLOCK(zztasp2);
+ int zzcnt=1;
+ zzMake0;
+ {
+ do {
+ zzmatch(149); zzCONSUME;
+ zzmatch(ID);
+ t = mystrdup(LATEXT(1));
+ zzCONSUME;
+
+ zzmatch(INT);
+
+ v = atoi(LATEXT(1));
+ /* fprintf(stderr, "#token %s=%d\n", t, v);*/
+
+ /* MR2 Andreas Magnusson (Andreas.Magnusson@mailbox.swipnet.se) */
+ /* MR2 Fix to bug introduced by 1.33MR1 for #tokdefs */
+ /* MR2 Don't let #tokdefs be confused by */
+ /* MR2 DLGminToken and DLGmaxToken */
+
+ if ( ! isDLGmaxToken(t)) { /* MR2 */
+ TokenNum = v;
+ if ( v>maxt ) maxt=v;
+ if ( Tnum( t ) == 0 ) {
+ addForcedTname( t, v );
+ } else {
+ warnFL(eMsg1("redefinition of token %s; ignored",t), fname,zzline);
+ };
+};
+ zzCONSUME;
+
+ zzLOOP(zztasp2);
+ } while ( (LA(1)==149) );
+ zzEXIT(zztasp2);
+ }
+ }
+ TokenNum = maxt + 1;
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd10, 0x8);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+enum_def(char * fname)
+#else
+enum_def(fname)
+ char *fname ;
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ int v= 0; int maxt=(-1); char *t;
+ zzmatch(151); zzCONSUME;
+ zzmatch(ID); zzCONSUME;
+ zzmatch(152); zzCONSUME;
+ zzmatch(ID);
+ t = mystrdup(LATEXT(1));
+ zzCONSUME;
+
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==153) ) {
+ zzmatch(153); zzCONSUME;
+ zzmatch(INT);
+ v=atoi(LATEXT(1));
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd10[LA(1)]&0x10) ) {
+ v++;
+ }
+ else {zzFAIL(1,zzerr62,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+
+ /* fprintf(stderr, "#token %s=%d\n", t, v);*/
+ TokenNum = v;
+ if ( v>maxt ) maxt=v; /* MR3 */
+ if ( Tnum( t ) == 0 ) addForcedTname( t, v );
+ else {
+ warnFL(eMsg1("redefinition of token %s; ignored",t), fname,zzline);
+ }
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ while ( (LA(1)==154) ) {
+ zzmatch(154); zzCONSUME;
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ if ( (LA(1)==ID)&&(isDLGmaxToken(LATEXT(1))) ) {
+ if (!(isDLGmaxToken(LATEXT(1))) ) {zzfailed_pred(" isDLGmaxToken(LATEXT(1))",0 /* report */, { 0; /* no user action */ } );}
+ zzmatch(ID); zzCONSUME;
+ {
+ zzBLOCK(zztasp4);
+ zzMake0;
+ {
+ if ( (LA(1)==153) ) {
+ zzmatch(153); zzCONSUME;
+ zzmatch(INT); zzCONSUME;
+ }
+ else {
+ if ( (setwd10[LA(1)]&0x20) ) {
+ }
+ else {zzFAIL(1,zzerr63,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp4);
+ }
+ }
+ }
+ else {
+ if ( (LA(1)==ID) ) {
+ zzmatch(ID);
+ t = mystrdup(LATEXT(1));
+ zzCONSUME;
+
+ {
+ zzBLOCK(zztasp4);
+ zzMake0;
+ {
+ if ( (LA(1)==153) ) {
+ zzmatch(153); zzCONSUME;
+ zzmatch(INT);
+ v=atoi(LATEXT(1));
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd10[LA(1)]&0x40) ) {
+ v++;
+ }
+ else {zzFAIL(1,zzerr64,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp4);
+ }
+ }
+
+ /* fprintf(stderr, "#token %s=%d\n", t, v);*/
+ TokenNum = v;
+ if ( v>maxt ) maxt=v; /* MR3 */
+ if ( Tnum( t ) == 0 ) addForcedTname( t, v );
+ else {
+ warnFL(eMsg1("redefinition of token %s; ignored",t), fname,zzline);
+ }
+ }
+ else {
+ if ( (setwd10[LA(1)]&0x80) ) {
+ }
+ else {zzFAIL(1,zzerr65,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+ zzLOOP(zztasp2);
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ zzmatch(155); zzCONSUME;
+ zzmatch(156);
+ TokenNum = maxt + 1;
+ zzCONSUME;
+
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd11, 0x1);
+ }
+}
+
+
+/* MR2 Andreas Magnusson (Andreas.Magnusson@mailbox.swipnet.se) */
+/* MR2 Fix to bug introduced by 1.33MR1 for #tokdefs */
+/* MR2 Don't let #tokdefs be confused by */
+/* MR2 DLGminToken and DLGmaxToken */
+
+/* semantic check on DLGminToken and DLGmaxmaxToken in #tokdefs */
+
+#ifdef __USE_PROTOS
+static int isDLGmaxToken(char *Token)
+#else
+static int isDLGmaxToken(Token)
+char * Token;
+#endif
+{
+static char checkStr1[] = "DLGmaxToken";
+static char checkStr2[] = "DLGminToken";
+
+ if (strcmp(Token, checkStr1) == 0)
+return 1;
+else if (strcmp(Token, checkStr2) == 0)
+return 1;
+else
+return 0;
+}
+
+/* semantics of #token */
+static void
+#ifdef __USE_PROTOS
+chkToken(char *t, char *e, char *a, int tnum)
+#else
+chkToken(t,e,a,tnum)
+char *t, *e, *a;
+int tnum;
+#endif
+{
+TermEntry *p;
+
+ /* check to see that they don't try to redefine a token as a token class */
+if ( t!=NULL ) {
+p = (TermEntry *) hash_get(Tname, t);
+if ( p!=NULL && p->classname ) {
+ err(eMsg1("redefinition of #tokclass '%s' to #token not allowed; ignored",t));
+ if ( a!=NULL ) free((char *)a);
+ return;
+}
+}
+
+ if ( t==NULL && e==NULL ) { /* none found */
+err("#token requires at least token name or rexpr");
+}
+else if ( t!=NULL && e!=NULL ) { /* both found */
+if ( UserDefdTokens ) { /* if #tokdefs, must not define new */
+ p = (TermEntry *) hash_get(Tname, t);
+ if ( p == NULL) {
+ err(eMsg1("new token definition '%s' not allowed - only #token with name already defined by #tokdefs file allowed",t));
+ return;
+ };
+}
+Tklink(t, e);
+if ( a!=NULL ) {
+ if ( hasAction(e) ) {
+ err(eMsg1("redefinition of action for %s; ignored",e));
+ }
+ else setHasAction(e, a);
+}
+}
+else if ( t!=NULL ) { /* only one found */
+if ( UserDefdTokens ) {
+ p = (TermEntry *) hash_get(Tname, t);
+ if (p == NULL) {
+ err(eMsg1("new token definition '%s' not allowed - only #token with name already defined by #tokdefs file allowed",t));
+ };
+ return;
+}
+if ( Tnum( t ) == 0 ) addTname( t );
+else {
+ err(eMsg1("redefinition of token %s; ignored",t));
+}
+if ( a!=NULL ) {
+ err(eMsg1("action cannot be attached to a token name (%s); ignored",t));
+ free((char *)a);
+}
+}
+else if ( e!=NULL ) {
+if ( Tnum( e ) == 0 ) addTexpr( e );
+else {
+ if ( hasAction(e) ) {
+ err(eMsg1("redefinition of action for expr %s; ignored",e));
+ }
+ else if ( a==NULL ) {
+ err(eMsg1("redefinition of expr %s; ignored",e));
+ }
+}
+if ( a!=NULL ) setHasAction(e, a);
+}
+
+ /* if a token type number was specified, then add the token ID and 'tnum'
+* pair to the ForcedTokens list. (only applies if an id was given)
+*/
+if ( t!=NULL && tnum>0 )
+{
+if ( set_el(tnum, reserved_positions) )
+{
+ err(eMsgd("a token has already been forced to token number %d; ignored", tnum));
+}
+else
+{
+ list_add(&ForcedTokens, newForcedToken(t,tnum));
+ set_orel(tnum, &reserved_positions);
+}
+}
+}
+
+static int
+#ifdef __USE_PROTOS
+match_token(char *s, char **nxt)
+#else
+match_token(s,nxt)
+char *s;
+char **nxt;
+#endif
+{
+ if ( !(*s>='A' && *s<='Z') ) return 0;
+ s++;
+ while ( (*s>='a' && *s<='z') ||
+ (*s>='A' && *s<='Z') ||
+ (*s>='0' && *s<='9') ||
+ *s=='_' )
+ {
+ s++;
+ }
+ if ( *s!=' ' && *s!='}' ) return 0;
+ *nxt = s;
+ return 1;
+}
+
+static int
+#ifdef __USE_PROTOS
+match_rexpr(char *s, char **nxt)
+#else
+match_rexpr(s,nxt)
+char *s;
+char **nxt;
+#endif
+{
+ if ( *s!='"' ) return 0;
+ s++;
+ while ( *s!='"' )
+ {
+ if ( *s=='\n' || *s=='\r' ) /* MR13 */
+ warn("eoln found in regular expression");
+ if ( *s=='\\' ) s++;
+ s++;
+ }
+ *nxt = s+1;
+ return 1;
+}
+
+/*
+* Walk a string "{ A .. Z }" where A..Z is a space separated list
+* of token references (either labels or reg exprs). Return a
+* string "inlineX_set" for some unique integer X. Basically,
+* we pretend as if we had seen "#tokclass inlineX { A .. Z }"
+* on the input stream outside of an action.
+*/
+char *
+#ifdef __USE_PROTOS
+inline_set(char *s)
+#else
+inline_set(s)
+char *s;
+#endif
+{
+ char *nxt;
+ fprintf(stderr, "found consumeUntil( {...} )\n");
+ while ( *s==' ' || *s=='\t' || *s=='\n' || *s=='\r' ) {s++;}
+ if ( *s!='{' )
+ {
+ err("malformed consumeUntil( {...} ); missing '{'");
+ return "bad_set";
+ }
+ s++;
+ while ( *s==' ' || *s=='\t' || *s=='\n' || *s=='\r' ) {s++;}
+ while ( *s!='}' )
+ {
+ if ( match_token(s,&nxt) ) fprintf(stderr, "found token %s\n", s);
+ else if ( match_rexpr(s,&nxt) ) fprintf(stderr, "found rexpr %s\n", s);
+ else {
+ err("invalid element in consumeUntil( {...} )");
+ return "bad_set";
+ }
+ s = nxt;
+ while ( *s==' ' || *s=='\t' || *s=='\n' || *s=='\r' ) {s++;}
+ }
+ return "inlineX_set";
+}
+
+/* ANTLR-specific syntax error message generator
+* (define USER_ZZSYN when compiling so don't get 2 definitions)
+*/
+void
+#ifdef __USE_PROTOS
+zzsyn(char *text, int tok, char *egroup, SetWordType *eset, int etok,
+int k, char *bad_text)
+#else
+zzsyn(text, tok, egroup, eset, etok, k, bad_text)
+char *text, *egroup, *bad_text;
+int tok;
+int etok;
+int k;
+SetWordType *eset;
+#endif
+{
+fprintf(stderr, ErrHdr, FileStr[CurFile]!=NULL?FileStr[CurFile]:"stdin", zzline);
+fprintf(stderr, " syntax error at \"%s\"", (tok==zzEOF_TOKEN)?"EOF":text);
+if ( !etok && !eset ) {fprintf(stderr, "\n"); return;}
+if ( k==1 ) fprintf(stderr, " missing");
+else
+{
+fprintf(stderr, "; \"%s\" not", bad_text);
+if ( zzset_deg(eset)>1 ) fprintf(stderr, " in");
+}
+if ( zzset_deg(eset)>0 ) zzedecode(eset);
+else fprintf(stderr, " %s", zztokens[etok]);
+if ( strlen(egroup) > (size_t)0 ) fprintf(stderr, " in %s", egroup);
+fprintf(stderr, "\n");
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.g b/BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.g new file mode 100644 index 0000000000..e6eda6010c --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.g @@ -0,0 +1,2586 @@ +/*
+ * antlr.g -- PCCTS Version 1.xx ANTLR
+ *
+ * Parse an antlr input grammar and build a syntax-diagram.
+ *
+ * Written in itself (needs at least 1.06 to work)
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-1995
+ */
+
+/* MR1 */
+/* MR1 10-Apr-97 MR1 Replace #if logic with #include "pcctscfg.h" */
+/* MR1 */
+
+#header <<
+ #include "pcctscfg.h"
+ #include "set.h"
+ #include <ctype.h>
+ #include "syn.h"
+ #include "hash.h"
+ #include "generic.h"
+ #define zzcr_attr(attr,tok,t)
+ >>
+
+<<
+
+/* MR20 G. Hobbelt For Borland C++ 4.x & 5.x compiling with ALL warnings enabled */
+#if defined(__TURBOC__)
+#pragma warn -aus /* unused assignment of 'xxx' */
+#endif
+
+
+#ifdef __USE_PROTOS
+static void chkToken(char *, char *, char *, int);
+#else
+static void chkToken();
+#endif
+
+#ifdef __USE_PROTOS
+static int isDLGmaxToken(char *Token); /* MR3 */
+#else
+static int isDLGmaxToken(); /* MR3 */
+#endif
+
+static int class_nest_level = 0;
+
+/* MR20 G. Hobbelt extern definitions moved to antlr.h */
+
+>>
+
+#lexaction <<
+/* maintained, but not used for now */
+set AST_nodes_refd_in_actions = set_init;
+int inAlt = 0;
+set attribsRefdFromAction = set_init; /* MR20 */
+int UsedOldStyleAttrib = 0;
+int UsedNewStyleLabel = 0;
+#ifdef __USE_PROTOS
+char *inline_set(char *);
+#else
+char *inline_set();
+#endif
+
+/* MR1 10-Apr-97 MR1 Previously unable to put right shift operator */
+/* MR1 in DLG action */
+
+int tokenActionActive=0; /* MR1 */
+
+>>
+
+#lexclass STRINGS
+#token QuotedTerm "\"" << zzmode(START); >>
+#token "\n|\r|\r\n" <<
+ zzline++;
+ warn("eoln found in string");
+ zzskip();
+ >>
+#token "\\(\n|\r|\r\n)" << zzline++; zzmore(); >>
+#token "\\~[]" << zzmore(); >>
+#token "~[\n\r\"\\]+" << zzmore(); >>
+
+#lexclass ACTION_STRINGS
+#token "\"" << zzmode(ACTIONS); zzmore(); >>
+#token "\n|\r|\r\n" <<
+ zzline++;
+ warn("eoln found in string (in user action)");
+ zzskip();
+ >>
+#token "\\(\n|\r|\r\n)" << zzline++; zzmore(); >>
+#token "\\~[]" << zzmore(); >>
+#token "~[\n\r\"\\]+" << zzmore(); >>
+
+#lexclass ACTION_CHARS
+#token "'" << zzmode(ACTIONS); zzmore(); >>
+#token "\n|\r|\r\n" <<
+ zzline++;
+ warn("eoln found in char literal (in user action)");
+ zzskip();
+ >>
+#token "\\~[]" << zzmore(); >>
+#token "~[\n\r'\\]+" << zzmore(); >>
+
+#lexclass ACTION_COMMENTS
+#token "\*/" << zzmode(ACTIONS); zzmore(); >>
+#token "\*" << zzmore(); >>
+#token "\n|\r|\r\n" << zzline++; zzmore(); DAWDLE; >>
+#token "~[\n\r\*]+" << zzmore(); >>
+
+#lexclass TOK_DEF_COMMENTS
+#token "\*/" << zzmode(PARSE_ENUM_FILE);
+ zzmore(); >>
+#token "\*" << zzmore(); >>
+#token "\n|\r|\r\n" << zzline++; zzmore(); DAWDLE; >>
+#token "~[\n\r\*]+" << zzmore(); >>
+
+#lexclass TOK_DEF_CPP_COMMENTS
+#token "\n|\r|\r\n" << zzline++; zzmode(PARSE_ENUM_FILE); zzskip(); DAWDLE; >>
+#token "~[\n\r]+" << zzskip(); >>
+
+#lexclass ACTION_CPP_COMMENTS
+#token "\n|\r|\r\n" << zzline++; zzmode(ACTIONS); zzmore(); DAWDLE; >>
+#token "~[\n\r]+" << zzmore(); >>
+
+#lexclass CPP_COMMENTS
+#token "\n|\r|\r\n" << zzline++; zzmode(START); zzskip(); DAWDLE; >>
+#token "~[\n\r]+" << zzskip(); >>
+
+#lexclass COMMENTS
+#token "\*/" << zzmode(START); zzskip(); >>
+#token "\*" << zzskip(); >>
+#token "\n|\r|\r\n" << zzline++; zzskip(); DAWDLE; >>
+#token "~[\n\r\*]+" << zzskip(); >>
+
+/*
+ * This lexical class accepts actions of type [..] and <<..>>
+ *
+ * It translates the following special items for C:
+ *
+ * $j --> "zzaArg(current zztasp, j)"
+ * $i.j --> "zzaArg(zztaspi, j)"
+ * $i.nondigit> "zzaArg(current zztasp, i).nondigit"
+ * $$ --> "zzaRet"
+ * $alnum --> "alnum" (used to ref parameters)
+ * $rule --> "zzaRet"
+ * $retval --> "_retv.retval" if > 1 return values else "_retv"
+ * $[token, text] --> "zzconstr_attr(token, text)"
+ * $[] --> "zzempty_attr()"
+ *
+ * It translates the following special items for C++:
+ * (attributes are now stored with 'Token' and $i's are only
+ * pointers to the Tokens. Rules don't have attributes now.)
+ *
+ * $j --> "_tbj" where b is the block level
+ * $i.j --> "_tij"
+ * $j->nondigit> "_tbj->nondigit"
+ * $$ --> "$$"
+ * $alnum --> "alnum" (used to ref parameters)
+ * $rule --> "$rule"
+ * $retval --> "_retv.retval" if > 1 return values else "_retv"
+ * $[token, text] --> invalid
+ * $[] --> invalid
+ *
+ * And, for trees:
+ *
+ * #0 --> "(*_root)"
+ * #i --> "zzastArg(i)"
+ * #[args] --> "zzmk_ast(zzastnew(), args)"
+ * #[] --> "zzastnew()"
+ * #( root, child1, ..., childn )
+ * --> "zztmake(root, child1, ...., childn, NULL)"
+ * #() --> "NULL"
+ *
+ * For C++, ...
+ *
+ * #0 --> "(*_root)"
+ * #i --> "_astbi" where b is the block level
+ * #alnum --> "alnum_ast" (used to ref #label)
+ * #[args] --> "new AST(args)"
+ * #[] --> "new AST"
+ * #( root, child1, ..., childn )
+ * --> "AST::tmake(root, child1, ...., childn, NULL)"
+ * #() --> "NULL"
+ *
+ * To escape,
+ *
+ * \] --> ]
+ * \) --> )
+ * \$ --> $
+ * \# --> #
+ *
+ * A stack is used to nest action terminators because they can be nested
+ * like crazy: << #[$[..],..] >>
+ */
+#lexclass ACTIONS
+#token Action "\>\>" << /* these do not nest */
+ zzmode(START);
+ NLATEXT[0] = ' ';
+ NLATEXT[1] = ' ';
+ zzbegexpr[0] = ' ';
+ zzbegexpr[1] = ' ';
+ if ( zzbufovf ) {
+ err( eMsgd("action buffer overflow; size %d",ZZLEXBUFSIZE));
+ }
+
+/* MR1 10-Apr-97 MR1 Previously unable to put right shift operator */
+/* MR1 in DLG action */
+/* MR1 Doesn't matter what kind of action it is - reset*/
+
+ tokenActionActive=0; /* MR1 */
+ >>
+#token Pred "\>\>?" << /* these do not nest */
+ zzmode(START);
+ NLATEXT[0] = ' ';
+ NLATEXT[1] = ' ';
+ zzbegexpr[0] = '\0';
+ if ( zzbufovf ) {
+ err( eMsgd("predicate buffer overflow; size %d",ZZLEXBUFSIZE));
+ };
+#ifdef __cplusplus__
+/* MR10 */ list_apply(CurActionLabels, (void (*)(void *))mark_label_used_in_sem_pred);
+#else
+#ifdef __STDC__
+/* MR10 */ list_apply(CurActionLabels, (void (*)(void *))mark_label_used_in_sem_pred);
+#else
+#ifdef __USE_PROTOS
+/* MRxx */ list_apply(CurActionLabels, (void (*)(void *))mark_label_used_in_sem_pred);
+#else
+/* MR10 */ list_apply(CurActionLabels,mark_label_used_in_sem_pred);
+#endif
+#endif
+#endif
+ >>
+#token PassAction "\]" << if ( topint() == ']' ) {
+ popint();
+ if ( istackempty() ) /* terminate action */
+ {
+ zzmode(START);
+ NLATEXT[0] = ' ';
+ zzbegexpr[0] = ' ';
+ if ( zzbufovf ) {
+ err( eMsgd("parameter buffer overflow; size %d",ZZLEXBUFSIZE));
+ }
+ }
+ else {
+ /* terminate $[..] and #[..] */
+ if ( GenCC ) zzreplstr("))");
+ else zzreplstr(")");
+ zzmore();
+ }
+ }
+ else if ( topint() == '|' ) { /* end of simple [...] */
+ popint();
+ zzmore();
+ }
+ else zzmore();
+ >>
+#token "consumeUntil\( [\ \t]* \{~[\}]+\} [\ \t]* \)"
+ <<
+ zzmore();
+ zzreplstr(inline_set(zzbegexpr+
+ strlen("consumeUntil(")));
+ >>
+#token "consumeUntil\( ~[\)]+ \)"
+ << zzmore(); >>
+#token "\n|\r|\r\n" << zzline++; zzmore(); DAWDLE; >>
+#token "\>" << zzmore(); >>
+#token "$" << zzmore(); >>
+#token "$$" << if ( !GenCC ) {zzreplstr("zzaRet"); zzmore();}
+ else err("$$ use invalid in C++ mode"); >>
+
+#token "$\[\]" << if ( !GenCC ) {zzreplstr("zzempty_attr"); zzmore();}
+ else err("$[] use invalid in C++ mode"); >>
+#token "$\[" <<
+ pushint(']');
+ if ( !GenCC ) zzreplstr("zzconstr_attr(");
+ else err("$[..] use invalid in C++ mode");
+ zzmore();
+ >>
+#token "$[0-9]+" <<{
+ static char buf[100];
+ numericActionLabel=1; /* MR10 */
+ if ( strlen(zzbegexpr)>(size_t)85 )
+ fatal("$i attrib ref too big");
+ set_orel(atoi(zzbegexpr+1), &attribsRefdFromAction);
+ if ( !GenCC ) sprintf(buf,"zzaArg(zztasp%d,%s)",
+ BlkLevel-1,zzbegexpr+1);
+ else sprintf(buf,"_t%d%s",
+ BlkLevel-1,zzbegexpr+1);
+ zzreplstr(buf);
+ zzmore();
+ UsedOldStyleAttrib = 1;
+ if ( UsedNewStyleLabel )
+ err("cannot mix old-style $i with new-style labels");
+ }
+ >>
+#token "$[0-9]+." <<{
+ static char buf[100];
+ numericActionLabel=1; /* MR10 */
+ if ( strlen(zzbegexpr)>(size_t)85 )
+ fatal("$i.field attrib ref too big");
+ zzbegexpr[strlen(zzbegexpr)-1] = ' ';
+ set_orel(atoi(zzbegexpr+1), &attribsRefdFromAction);
+ if ( !GenCC ) sprintf(buf,"zzaArg(zztasp%d,%s).",
+ BlkLevel-1,zzbegexpr+1);
+ else sprintf(buf,"_t%d%s.",
+ BlkLevel-1,zzbegexpr+1);
+ zzreplstr(buf);
+ zzmore();
+ UsedOldStyleAttrib = 1;
+ if ( UsedNewStyleLabel )
+ err("cannot mix old-style $i with new-style labels");
+ }
+ >>
+#token "$[0-9]+.[0-9]+" <<{
+ static char buf[100];
+ static char i[20], j[20];
+ char *p,*q;
+ numericActionLabel=1; /* MR10 */
+ if (strlen(zzbegexpr)>(size_t)85) fatal("$i.j attrib ref too big");
+ for (p=zzbegexpr+1,q= &i[0]; *p!='.'; p++) {
+ if ( q == &i[20] )
+ fatalFL("i of $i.j attrib ref too big",
+ FileStr[CurFile], zzline );
+ *q++ = *p;
+ }
+ *q = '\0';
+ for (p++, q= &j[0]; *p!='\0'; p++) {
+ if ( q == &j[20] )
+ fatalFL("j of $i.j attrib ref too big",
+ FileStr[CurFile], zzline );
+ *q++ = *p;
+ }
+ *q = '\0';
+ if ( !GenCC ) sprintf(buf,"zzaArg(zztasp%s,%s)",i,j);
+ else sprintf(buf,"_t%s%s",i,j);
+ zzreplstr(buf);
+ zzmore();
+ UsedOldStyleAttrib = 1;
+ if ( UsedNewStyleLabel )
+ err("cannot mix old-style $i with new-style labels");
+ }
+ >>
+#token "$[_a-zA-Z][_a-zA-Z0-9]*"
+ <<{ static char buf[300]; LabelEntry *el;
+ zzbegexpr[0] = ' ';
+ if ( CurRule != NULL &&
+ strcmp(CurRule, &zzbegexpr[1])==0 ) {
+ if ( !GenCC ) zzreplstr("zzaRet");
+ }
+ else if ( CurRetDef != NULL &&
+ strmember(CurRetDef, &zzbegexpr[1])) {
+ if ( hasMultipleOperands( CurRetDef ) ) {
+ require (strlen(zzbegexpr)<=(size_t)285,
+ "$retval attrib ref too big");
+ sprintf(buf,"_retv.%s",&zzbegexpr[1]);
+ zzreplstr(buf);
+ }
+ else zzreplstr("_retv");
+ }
+ else if ( CurParmDef != NULL &&
+ strmember(CurParmDef, &zzbegexpr[1])) {
+ ;
+ }
+ else if ( Elabel==NULL ) {
+ { err("$-variables in actions outside of rules are not allowed"); }
+ } else if ( (el=(LabelEntry *)hash_get(Elabel, &zzbegexpr[1]))!=NULL ) {
+/* MR10 */
+/* MR10 */ /* element labels might exist without an elem when */
+/* MR10 */ /* it is a forward reference (to a rule) */
+/* MR10 */
+/* MR10 */ if ( GenCC && (el->elem == NULL || el->elem->ntype==nRuleRef) )
+/* MR10 */ { err(eMsg1("There are no token ptrs for rule references: '$%s'",&zzbegexpr[1])); }
+/* MR10 */
+/* MR10 */ if ( !GenCC && (el->elem == NULL || el->elem->ntype==nRuleRef) && GenAST) {
+/* MR10 */ err("You can no longer use attributes returned by rules when also using ASTs");
+/* MR10 */ err(" Use upward inheritance (\"rule >[Attrib a] : ... <<$a=...\>\>\")");
+/* MR10 */ };
+/* MR10 */
+/* MR10 */ /* keep track of <<... $label ...>> for semantic predicates in guess mode */
+/* MR10 */ /* element labels contain pointer to the owners node */
+/* MR10 */
+/* MR10 */ if (el->elem != NULL && el->elem->ntype == nToken) {
+/* MR10 */ list_add(&CurActionLabels,el);
+/* MR10 */ };
+ }
+ else
+ warn(eMsg1("$%s not parameter, return value, (defined) element label",&zzbegexpr[1]));
+ }
+ zzmore();
+ >>
+#token "#0" << zzreplstr("(*_root)"); zzmore(); chkGTFlag(); >>
+#token "#\[\]" << if ( GenCC ) {
+ if (NewAST) zzreplstr("(newAST)");
+ else zzreplstr("(new AST)");}
+ else {zzreplstr("zzastnew()");} zzmore();
+ chkGTFlag();
+ >>
+#token "#\(\)" << zzreplstr("NULL"); zzmore(); chkGTFlag(); >>
+#token "#[0-9]+" <<{
+ static char buf[100];
+ if ( strlen(zzbegexpr)>(size_t)85 )
+ fatal("#i AST ref too big");
+ if ( GenCC ) sprintf(buf,"_ast%d%s",BlkLevel-1,zzbegexpr+1);
+ else sprintf(buf,"zzastArg(%s)",zzbegexpr+1);
+ zzreplstr(buf);
+ zzmore();
+ set_orel(atoi(zzbegexpr+1), &AST_nodes_refd_in_actions);
+ chkGTFlag();
+ }
+ >>
+
+/* MR14 Arpad Beszedes 26-May-98
+ Add support for #line directives when antlr source is pre-processed
+ #lexclass ACTIONS
+*/
+
+#token "#line[\ \t]* [0-9]+ {[\ \t]* \"~[\"]+\" ([\ \t]* [0-9]*)* } (\n|\r|\r\n)"
+ <<
+ zzline = atoi(zzbegexpr+5) - 1; zzline++; zzmore();
+ getFileNameFromTheLineInfo(FileStr[CurFile], zzbegexpr);
+ >>
+
+#token "#line ~[\n\r]* (\n|\r|\r\n)"
+ <<
+ zzline++; zzmore();
+ >>
+
+/* MR14 end of a block to support #line in antlr source code */
+
+#token "#[_a-zA-Z][_a-zA-Z0-9]*"
+ <<
+ if ( !(strcmp(zzbegexpr, "#ifdef")==0 ||
+ strcmp(zzbegexpr, "#if")==0 ||
+ strcmp(zzbegexpr, "#else")==0 ||
+ strcmp(zzbegexpr, "#endif")==0 ||
+ strcmp(zzbegexpr, "#ifndef")==0 ||
+ strcmp(zzbegexpr, "#define")==0 ||
+ strcmp(zzbegexpr, "#pragma")==0 ||
+ strcmp(zzbegexpr, "#undef")==0 ||
+ strcmp(zzbegexpr, "#import")==0 ||
+ strcmp(zzbegexpr, "#line")==0 ||
+ strcmp(zzbegexpr, "#include")==0 ||
+ strcmp(zzbegexpr, "#error")==0) )
+ {
+ static char buf[100];
+ sprintf(buf, "%s_ast", zzbegexpr+1);
+/* MR27 */ list_add(&CurAstLabelsInActions, mystrdup(zzbegexpr+1));
+ zzreplstr(buf);
+ chkGTFlag();
+ }
+ zzmore();
+ >>
+#token "#\[" <<
+ pushint(']');
+ if ( GenCC ) {
+ if (NewAST) zzreplstr("(newAST(");
+ else zzreplstr("(new AST("); }
+ else zzreplstr("zzmk_ast(zzastnew(),");
+ zzmore();
+ chkGTFlag();
+ >>
+#token "#\(" <<
+ pushint('}');
+ if ( GenCC ) {
+ if (tmakeInParser) {
+ zzreplstr("tmake(");
+ }
+ else {
+ zzreplstr("ASTBase::tmake(");
+ }
+ }
+ else {
+ zzreplstr("zztmake(");
+ }
+ zzmore();
+ chkGTFlag();
+ >>
+#token "#" << zzmore(); >>
+#token "\)" <<
+ if ( istackempty() )
+ zzmore();
+ else if ( topint()==')' ) {
+ popint();
+ }
+ else if ( topint()=='}' ) {
+ popint();
+ /* terminate #(..) */
+ zzreplstr(", NULL)");
+ }
+ zzmore();
+ >>
+#token "\[" <<
+ pushint('|'); /* look for '|' to terminate simple [...] */
+ zzmore();
+ >>
+#token "\(" <<
+ pushint(')');
+ zzmore();
+ >>
+
+#token "\\\]" << zzreplstr("]"); zzmore(); >>
+#token "\\\)" << zzreplstr(")"); zzmore(); >>
+
+/* MR1 10-Apr-97 MR1 Previously unable to put right shift operator */
+/* MR1 in DLG action */
+
+#token "\\>" << if (! tokenActionActive) zzreplstr(">"); /* MR1 */
+ zzmore(); /* MR1 */
+ >> /* MR1 */
+
+
+#token "'" << zzmode(ACTION_CHARS); zzmore();>>
+#token "\"" << zzmode(ACTION_STRINGS); zzmore();>>
+#token "\\$" << zzreplstr("$"); zzmore(); >>
+#token "\\#" << zzreplstr("#"); zzmore(); >>
+#token "\\(\n|\r|\r\n)" << zzline++; zzmore(); >>
+#token "\\~[\]\)>$#]" << zzmore(); >> /* escaped char, always ignore */
+#token "/" << zzmore(); >>
+#token "/\*" << zzmode(ACTION_COMMENTS); zzmore(); >>
+#token "\*/" << warn("Missing /*; found dangling */ in action"); zzmore(); >>
+#token "//" << zzmode(ACTION_CPP_COMMENTS); zzmore(); >>
+#token "~[\n\r\)\(\\$#\>\]\[\"'/]+" << zzmore(); >>
+
+#lexclass START
+#token "[\t\ ]+" << zzskip(); >> /* Ignore White */
+#token "\n|\r|\r\n" << zzline++; zzskip(); >> /* Track Line # */
+#token "\[" << zzmode(ACTIONS); zzmore();
+ istackreset();
+ pushint(']'); >>
+#token "\<\<" << action_file=CurFile; action_line=zzline;
+ zzmode(ACTIONS); zzmore();
+ list_free(&CurActionLabels,0); /* MR10 */
+ numericActionLabel=0; /* MR10 */
+ istackreset();
+ pushint('>'); >>
+#token "\"" << zzmode(STRINGS); zzmore(); >>
+#token "/\*" << zzmode(COMMENTS); zzskip(); >>
+#token "\*/" << warn("Missing /*; found dangling */"); zzskip(); >>
+#token "//" << zzmode(CPP_COMMENTS); zzskip(); >>
+
+/* MR14 Arpad Beszedes 26-May-98
+ Add support for #line directives when antlr source is pre-processed
+ #lexclass START
+*/
+
+#token "#line[\ \t]* [0-9]+ {[\ \t]* \"~[\"]+\" ([\ \t]* [0-9]*)* } (\n|\r|\r\n)"
+ <<
+ zzline = atoi(zzbegexpr+5) - 1; zzline++; zzmore();
+ getFileNameFromTheLineInfo(FileStr[CurFile], zzbegexpr);
+ >>
+
+#token "#line ~[\n\r]* (\n|\r|\r\n)"
+ <<
+ zzline++; zzmore();
+ >>
+
+/* MR14 end of a block to support #line in antlr source code */
+
+/* */
+/* 8-Apr-97 Regularize escape sequence for ">>" */
+/* appearing in string literals */
+/* */
+
+#token "\>\>" << warn("Missing <<; found dangling \>\>"); zzskip(); >> /* MR1 */
+#token WildCard "."
+#token "\@" <<FoundException = 1; /* MR6 */
+ FoundAtOperator = 1;>> /* MR6 */
+#token Eof "@"
+ << /* L o o k F o r A n o t h e r F i l e */
+ {
+ FILE *new_input;
+ new_input = NextFile();
+ if ( new_input == NULL ) { NLA=Eof; return; }
+ fclose( input );
+ input = new_input;
+ zzrdstream( input );
+ zzskip(); /* Skip the Eof (@) char i.e continue */
+ }
+ >>
+
+#token LABEL
+
+#errclass "grammar-element" { element }
+#errclass "meta-symbol" { "\}" "!" ";" "\|" "\~" "^" "\)" }
+
+#token Pragma "{\\}#pragma" /* MR21 */
+#token FirstSetSymbol "{\\}#FirstSetSymbol" /* MR21 */
+/*
+ * Get a grammar -- Build a list of rules like:
+ *
+ * o-->Rule1--o
+ * |
+ * o-->Rule2--o
+ * |
+ * ...
+ * |
+ * o-->RuleN--o
+ */
+
+/* rule grammar */
+
+grammar : <<Graph g;>>
+ ( "{\\}#header" Action /* MR13 */
+ <<
+ if ( HdrAction==NULL ) {
+ HdrAction = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(HdrAction!=NULL, "rule grammar: cannot allocate header action");
+ strcpy(HdrAction, LATEXT(1));
+ }
+ else warn("additional #header statement ignored");
+ >>
+ | "{\\}#first" Action
+ <<
+ if ( FirstAction==NULL ) {
+ FirstAction = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(FirstAction!=NULL, "rule grammar: cannot allocate #first action");
+ strcpy(FirstAction, LATEXT(1));
+ } else {
+ warn("additional #first statement ignored");
+ };
+ >>
+
+ | "{\\}#parser" QuotedTerm
+ <<
+ if ( GenCC ) {
+ warn("#parser meta-op incompatible with -CC; ignored");
+ }
+ else {
+ if ( strcmp(ParserName,"zzparser")==0 ) {
+ ParserName=StripQuotes(mystrdup(LATEXT(1)));
+ if ( RulePrefix[0]!='\0' )
+ {
+ warn("#parser meta-op incompatible with '-gp prefix'; '-gp' ignored");
+ RulePrefix[0]='\0';
+ }
+ }
+ else warn("additional #parser statement ignored");
+ }
+ >>
+ | "{\\}#tokdefs" QuotedTerm
+ <<{
+ char *fname;
+ zzantlr_state st; FILE *f; struct zzdlg_state dst;
+ UserTokenDefsFile = mystrdup(LATEXT(1));
+ zzsave_antlr_state(&st);
+ zzsave_dlg_state(&dst);
+ fname = mystrdup(LATEXT(1));
+ f = fopen(StripQuotes(fname), "r");
+ if ( f==NULL ) {warn(eMsg1("cannot open token defs file '%s'", fname+1));}
+ else {
+ ANTLRm(enum_file(fname+1), f, PARSE_ENUM_FILE);
+ UserDefdTokens = 1;
+ }
+ zzrestore_antlr_state(&st);
+ zzrestore_dlg_state(&dst);
+ }>>
+ )*
+ ( Action
+ <<{
+ UserAction *ua = newUserAction(LATEXT(1));
+ ua->file = action_file; ua->line = action_line;
+ if ( class_nest_level>0 ) list_add(&class_before_actions, ua);
+ else list_add(&BeforeActions, ua);
+ }>>
+ | laction
+ | lmember /* MR1 */
+ | lprefix /* MR1 */
+ | aLexclass
+ | token
+ | error
+ | tclass
+ | aPred /* MR11 */
+ | default_exception_handler
+ | class_def
+ | "\}"
+ <<
+ if ( class_nest_level==0 )
+ warn("missing class definition for trailing '}'");
+ class_nest_level--;
+ >>
+ )*
+
+ rule <<g=$3; SynDiag = (Junction *) $3.left;>>
+ ( rule
+
+ <<if ( $1.left!=NULL ) {
+ g.right = NULL;
+
+/* MR21a */ /* Avoid use of a malformed graph when CannotContinue */
+/* MR21a */ /* is already set */
+/* MR21a */
+/* MR21a */ if (! (CannotContinue && g.left == NULL)) {
+/* MR21a */ g = Or(g, $1);
+/* MR21a */ }
+/* MR21a */ }
+ >>
+
+ | aLexclass
+ | token
+ | error
+ | tclass
+ | aPred /* MR11 */
+ | class_def
+ | "\}"
+ <<
+ if ( class_nest_level==0 )
+ warn("missing class definition for trailing '}'");
+ class_nest_level--;
+ >>
+ )*
+ ( Action
+ <<{
+ UserAction *ua = newUserAction(LATEXT(1));
+ ua->file = action_file; ua->line = action_line;
+ if ( class_nest_level>0 ) list_add(&class_after_actions, ua);
+ else list_add(&AfterActions, ua);
+ }>>
+ | laction
+ | lmember /* MR1 */
+ | lprefix /* MR1 */
+ | error
+ | tclass
+ | class_def
+ | aPred /* MR11 */
+ | "\}"
+ <<
+ if ( class_nest_level==0 )
+ warn("missing class definition for trailing '}'");
+ class_nest_level--;
+ >>
+ )*
+ Eof
+ ;
+ <<CannotContinue=TRUE;>>
+
+/* rule class_def */
+
+class_def
+ : <<int go=1; char name[MaxRuleName+1];>>
+ "class"
+ ( NonTerminal <<if(go) strncpy(name,LATEXT(1),MaxRuleName);>>
+ | TokenTerm <<if(go) strncpy(name,LATEXT(1),MaxRuleName);>>
+ )
+ <<
+ if ( CurrentClassName[0]!='\0' && strcmp(CurrentClassName,name)!=0
+ && GenCC ) {
+ err("only one grammar class allowed in this release");
+ go = 0;
+ }
+ else strcpy(CurrentClassName, name);
+ >>
+ <<if ( !GenCC ) { err("class meta-op used without C++ option"); }>>
+
+/* MR10 */ (~ "\{"
+/* MR10 */ <<if (ClassDeclStuff == NULL) {
+/* MR10 */ ClassDeclStuff=(char *)calloc(MaxClassDeclStuff+1,sizeof(char));
+/* MR10 */ };
+/* MR10 */ strncat(ClassDeclStuff," ",MaxClassDeclStuff);
+/* MR10 */ strncat(ClassDeclStuff,LATEXT(1),MaxClassDeclStuff);
+/* MR22 */ do {
+/* MR22 */ if (0 == strcmp(LATEXT(1),"public")) break;
+/* MR22 */ if (0 == strcmp(LATEXT(1),"private")) break;
+/* MR22 */ if (0 == strcmp(LATEXT(1),"protected")) break;
+/* MR22 */ if (0 == strcmp(LATEXT(1),"virtual")) break;
+/* MR22 */ if (0 == strcmp(LATEXT(1),",")) break;
+/* MR22 */ if (0 == strcmp(LATEXT(1),":")) break;
+/* MR22 */ if (BaseClassName != NULL) break;
+/* MR22 */ BaseClassName=(char *)calloc(strlen(LATEXT(1))+1,sizeof(char));
+/* MR22 */ require(BaseClassName!=NULL, "rule grammar: cannot allocate base class name");
+/* MR22 */ strcpy(BaseClassName,LATEXT(1));
+/* MR22 */ } while (0);
+/* MR10 */ >>
+/* MR10 */ )*
+
+ "\{"
+ <<
+ no_classes_found = 0;
+ if ( class_nest_level>=1 ) {warn("cannot have nested classes");}
+ else class_nest_level++;
+ >>
+ ;
+ <<CannotContinue=TRUE;>>
+
+/*
+ * Build -o-->o-R-o-->o- where -o-R-o- is the block from rule 'block'.
+ * Construct the RuleBlk front and EndRule node on the end of the
+ * block. This is used to add FOLLOW pointers to the rule end. Add the
+ * new rule name to the Rname hash table and sets its rulenum.
+ * Store the parameter definitions if any are found.
+ *
+ * Note that locks are required on the RuleBlk and EndRule nodes to thwart
+ * infinite recursion.
+ *
+ * Return the left graph pointer == NULL to indicate error/dupl rule def.
+ */
+
+/* rule rule */
+
+rule : <<
+
+ ExceptionGroup *eg;
+ RuleEntry *q; Junction *p; Graph r; int f, l; ECnode *e;
+ set toksrefd, rulesrefd;
+ char *pdecl=NULL, *ret=NULL, *a; CurRetDef = CurParmDef = NULL;
+ CurExGroups = NULL;
+ CurElementLabels = NULL;
+ CurAstLabelsInActions = NULL; /* MR27 */
+ /* We want a new element label hash table for each rule */
+ if ( Elabel!=NULL ) killHashTable(Elabel);
+ Elabel = newHashTable();
+ attribsRefdFromAction = empty;
+ >>
+ NonTerminal
+ <<q=NULL;
+ if ( hash_get(Rname, LATEXT(1))!=NULL ) {
+ err(eMsg1("duplicate rule definition: '%s'",LATEXT(1)));
+ CannotContinue=TRUE;
+ }
+ else
+ {
+ q = (RuleEntry *)hash_add(Rname,
+ LATEXT(1),
+ (Entry *)newRuleEntry(LATEXT(1)));
+ CurRule = q->str;
+ }
+ CurRuleNode = q;
+ f = CurFile; l = zzline;
+ NumRules++;
+ >>
+ { "!" <<if ( q!=NULL ) q->noAST = TRUE;>> }
+ { <<;>>
+ {"\<"}
+ PassAction
+ << pdecl = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(pdecl!=NULL, "rule rule: cannot allocate param decl");
+ strcpy(pdecl, LATEXT(1));
+ CurParmDef = pdecl;
+ >>
+ }
+ { "\>"
+ PassAction
+ << ret = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(ret!=NULL, "rule rule: cannot allocate ret type");
+ strcpy(ret, LATEXT(1));
+ CurRetDef = ret;
+ >>
+ }
+ { QuotedTerm <<if ( q!=NULL ) q->egroup=mystrdup(LATEXT(1));>> }
+ <<
+ if ( GenEClasseForRules && q!=NULL ) {
+ e = newECnode;
+ require(e!=NULL, "cannot allocate error class node");
+ if ( q->egroup == NULL ) {a = q->str; a[0] = (char)toupper(a[0]);}
+ else a = q->egroup;
+ if ( Tnum( a ) == 0 )
+ {
+ e->tok = addTname( a );
+ list_add(&eclasses, (char *)e);
+ if ( q->egroup == NULL ) a[0] = (char)tolower(a[0]);
+ /* refers to itself */
+ list_add(&(e->elist), mystrdup(q->str));
+ }
+ else {
+ warn(eMsg1("default errclass for '%s' would conflict with token/errclass/tokclass",a));
+ if ( q->egroup == NULL ) a[0] = (char)tolower(a[0]);
+ free((char *)e);
+ }
+ }
+ >>
+ <<BlkLevel++;
+ if (BlkLevel >= MAX_BLK_LEVEL) fatal("Blocks nested too deeply");
+/* MR23 */ CurBlockID_array[BlkLevel] = CurBlockID;
+/* MR23 */ CurAltNum_array[BlkLevel] = CurAltNum;
+ >>
+
+ ":" <<inAlt=1;>>
+ block[&toksrefd, &rulesrefd]
+ <<r = makeBlk($7,0, NULL /* pFirstSetSymbol */ );
+ CurRuleBlk = (Junction *)r.left;
+ CurRuleBlk->blockid = CurBlockID;
+ CurRuleBlk->jtype = RuleBlk;
+ if ( q!=NULL ) CurRuleBlk->rname = q->str;
+ CurRuleBlk->file = f;
+ CurRuleBlk->line = l;
+ CurRuleBlk->pdecl = pdecl;
+ CurRuleBlk->ret = ret;
+ CurRuleBlk->lock = makelocks();
+ CurRuleBlk->pred_lock = makelocks();
+ CurRuleBlk->tokrefs = toksrefd;
+ CurRuleBlk->rulerefs = rulesrefd;
+ p = newJunction(); /* add EndRule Node */
+ ((Junction *)r.right)->p1 = (Node *)p;
+ r.right = (Node *) p;
+ p->jtype = EndRule;
+ p->lock = makelocks();
+ p->pred_lock = makelocks();
+ CurRuleBlk->end = p;
+ if ( q!=NULL ) q->rulenum = NumRules;
+ $7 = r;
+ >>
+ <<
+ /* MR23 */ CurBlockID_array[BlkLevel] = (-1);
+ /* MR23 */ CurAltNum_array[BlkLevel] = (-1);
+ --BlkLevel;
+ >>
+ <<altFixup();leFixup();egFixup();>> /* MR7 */
+ ";" <<inAlt=0;>>
+ { Action
+ << a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(a!=NULL, "rule rule: cannot allocate error action");
+ strcpy(a, LATEXT(1));
+ CurRuleBlk->erraction = a;
+ >>
+ }
+ ( exception_group > [eg]
+ <<if ( eg!=NULL ) {
+ list_add(&CurExGroups, (void *)eg);
+ if (eg->label == NULL || *eg->label=='\0' ) q->has_rule_exception = 1;
+ }
+ >>
+ )*
+ <<if ( q==NULL ) $0.left = NULL; else $0 = $7;>>
+ <<CurRuleBlk->exceptions = CurExGroups;>>
+ <<CurRuleBlk->el_labels = CurElementLabels;>>
+ <<CurRuleNode->ast_labels_in_actions = CurAstLabelsInActions;>> /* MR27 */
+ <<CurRuleNode = NULL;>> /* MR27 Moved */
+ ;
+ <<CannotContinue=TRUE;>>
+
+/*
+ * pragma : "{\\}#pragma" "dup\-labeled\-tokens"
+ * <<Pragma_DupLabeledTokens=1;>>
+ * ;
+ */
+
+/* rule laction */
+
+laction : <<char *a;>>
+
+ "{\\}#lexaction"
+ Action
+ <<
+ a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(a!=NULL, "rule laction: cannot allocate action");
+ strcpy(a, LATEXT(1));
+ list_add(&LexActions, a);
+ >>
+ ;
+ <<CannotContinue=TRUE;>>
+
+/* MR1 */
+/* MR1 11-Apr-97 Provide mechanism for inserting code into DLG class */
+/* MR1 via #lexmember <<....>> & #lexprefix <<...>> */
+/* MR1 */
+
+/* rule lmember */
+
+lmember: <<char *a;>> /* MR1 */
+
+/* MR1 */ "{\\}#lexmember"
+/* MR1 */ Action
+/* MR1 */ <<
+/* MR1 */ if (! GenCC) {
+/* MR1 */ err("Use #lexmember only in C++ mode (to insert code in DLG class header");
+/* MR1 */ } else {
+/* MR1 */ a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+/* MR1 */ require(a!=NULL, "rule lmember: cannot allocate action");
+/* MR1 */ strcpy(a, LATEXT(1));
+/* MR1 */ list_add(&LexMemberActions, a);
+/* MR1 */ };
+/* MR1 */ >>
+/* MR1 */ ;
+/* MR1 */ <<CannotContinue=TRUE;>>
+
+/* rule lprefix */
+
+lprefix: <<char *a;>> /* MR1 */
+
+/* MR1 */ "{\\}#lexprefix"
+/* MR1 */ Action
+/* MR1 */ <<
+/* MR1 */ if (! GenCC) {
+/* MR1 */ err("Use #lexprefix only in C++ mode (to insert code in DLG class header");
+/* MR1 */ } else {
+/* MR1 */ a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+/* MR1 */ require(a!=NULL, "rule lprefix: cannot allocate action");
+/* MR1 */ strcpy(a, LATEXT(1));
+/* MR1 */ list_add(&LexPrefixActions, a);
+/* MR1 */ };
+/* MR1 */ >>
+/* MR1 */ ;
+/* MR1 */ <<CannotContinue=TRUE;>>
+
+/*
+ * #pred upper <<isupper()>>? predicate literal
+ * #pred lower <<islower()>>? predicate literal
+ * #pred up_or_low upper || lower predicate expression
+ * concealed interdependence
+ * #pred up_or_low_2 <<isletter()>>? A || B predicate literal equals predicate expr
+ * analyze using lower||upper
+ * generate using isLetter()
+ */
+
+/* rule aPref */
+
+aPred: <<PredEntry *predEntry=NULL;
+ char *name=NULL;
+ Predicate *predExpr=NULL;
+ char *predLiteral=NULL;
+ int save_file;
+ int save_line;
+ int predExprPresent=0;
+ >>
+
+ "{\\}#pred"
+
+ <<
+ MR_usingPredNames=1; /* will need to use -mrhoist version of genPredTree */
+ >>
+
+ /* used to allow NonTerminal but it caused problems
+ when a rule name immediately followed a #pred statement */
+
+ TokenTerm <<name=mystrdup(LATEXT(1));>>
+
+ <<
+ /* don't free - referenced in predicates */
+
+ CurPredName=(char *)calloc(1,strlen(name) + 10);
+ strcat(CurPredName,"#pred ");
+ strcat(CurPredName,name);
+
+ predEntry=(PredEntry *) hash_get(Pname,name);
+ if (predEntry != NULL) {
+ warnFL(eMsg1("#pred %s previously defined - ignored",name),
+ FileStr[action_file],action_line);
+ name=NULL;
+ };
+ >>
+
+ (
+
+ Pred <<predLiteral=mystrdup(LATEXT(1));
+ save_line=action_line;
+ save_file=action_file;
+ >>
+
+ {
+ predOrExpr>[predExpr] <<predExprPresent=1;>>
+ }
+
+ <<if (predLiteral != NULL && name != NULL) {
+
+ /*
+ * predExpr may be NULL due to syntax errors
+ * or simply omitted by the user
+ */
+
+ predEntry=newPredEntry(name);
+ predEntry->file=save_file;
+ predEntry->line=save_line;
+ predExpr=MR_predFlatten(predExpr);
+ predEntry->predLiteral=predLiteral;
+ if (! predExprPresent || predExpr == NULL) {
+ predExpr=new_pred();
+ predExpr->expr=predLiteral;
+ predExpr->source=newActionNode();
+ predExpr->source->action=predExpr->expr;
+ predExpr->source->rname=CurPredName;
+ predExpr->source->line=action_line;
+ predExpr->source->file=action_file;
+ predExpr->source->is_predicate=1;
+ predExpr->k=predicateLookaheadDepth(predExpr->source);
+ };
+ predEntry->pred=predExpr;
+ hash_add(Pname,name,(Entry *)predEntry);
+ predExpr=NULL;
+ };
+ predicate_free(predExpr);
+ >>
+
+ |
+ <<save_line=zzline; save_file=CurFile;>>
+
+ predOrExpr>[predExpr]
+
+ <<if (predExpr != NULL && name != NULL) {
+ predEntry=newPredEntry(name);
+ predEntry->file=CurFile;
+ predEntry->line=zzline;
+ predExpr=MR_predFlatten(predExpr);
+ predEntry->pred=predExpr;
+ hash_add(Pname,name,(Entry *)predEntry);
+ predExpr=NULL;
+ };
+ predicate_free(predExpr);
+ >>
+ )
+ {";"}
+;
+
+/* fail */
+
+<<predicate_free(predExpr);
+>>
+
+/* rule predOrExpr */
+
+predOrExpr>[Predicate *result] :
+ <<Predicate *ORnode;
+ Predicate *predExpr;
+ Predicate **tail=NULL;
+ >>
+ predAndExpr>[predExpr]
+ <<
+ ORnode=new_pred();
+ ORnode->expr=PRED_OR_LIST;
+ if (predExpr != NULL) {
+ ORnode->down=predExpr;
+ tail=&predExpr->right;
+ };
+ >>
+ ( "\|\|" predAndExpr>[predExpr]
+ <<
+ if (predExpr != NULL) {
+ *tail=predExpr;
+ tail=&predExpr->right;
+ };
+ >>
+ )*
+ <<
+ $result=ORnode;
+ ORnode=NULL;
+ >>
+;
+
+/* fail */
+
+<<predicate_free(ORnode);>>
+
+/* rule predAndExpr */
+
+predAndExpr>[Predicate *result] :
+ <<Predicate *ANDnode;
+ Predicate *predExpr;
+ Predicate **tail=NULL;
+ >>
+ predPrimary>[predExpr]
+ <<
+ ANDnode=new_pred();
+ ANDnode->expr=PRED_AND_LIST;
+ if (predExpr != NULL) {
+ ANDnode->down=predExpr;
+ tail=&predExpr->right;
+ };
+ >>
+ ( "&&" predPrimary>[predExpr]
+ <<
+ if (predExpr != NULL) {
+ *tail=predExpr;
+ tail=&predExpr->right;
+ };
+ >>
+ )*
+ <<
+ $result=ANDnode;
+ ANDnode=NULL;
+ >>
+;
+
+/* fail */
+
+<<predicate_free(ANDnode);>>
+
+
+/* rule predPrimary */
+
+predPrimary>[Predicate *result] :
+ <<
+ char *name=NULL;
+ PredEntry *predEntry=NULL;
+ Predicate *predExpr=NULL;
+ >>
+
+ TokenTerm <<name=mystrdup(LATEXT(1));>>
+
+ <<
+ predEntry=(PredEntry *) hash_get(Pname,name);
+ if (predEntry == NULL) {
+ warnFL(eMsg1("no previously defined #pred with name \"%s\"",name),
+ FileStr[CurFile],zzline);
+ name=NULL;
+ $result=NULL;
+ } else {
+ predExpr=predicate_dup(predEntry->pred);
+ predExpr->predEntry=predEntry;
+ $result=predExpr;
+ };
+ >>
+
+ | "\(" predOrExpr>[predExpr] "\)"
+ <<
+ $result=predExpr;
+ >>
+
+ | "!" predPrimary>[predExpr]
+ <<
+ predExpr->inverted=!predExpr->inverted;
+ $result=predExpr;
+ >>
+;
+
+/* fail */ <<
+ predicate_free(predExpr);
+ >>
+
+/* rule aLexclass */
+
+aLexclass: "{\\}#lexclass" TokenTerm <<lexclass(mystrdup(LATEXT(1)));>>
+ ;
+ <<CannotContinue=TRUE;>>
+
+/* rule error */
+
+error : <<char *t=NULL; ECnode *e; int go=1; TermEntry *p;>>
+ "{\\}#errclass"
+ (<<;>> TokenTerm <<t=mystrdup(LATEXT(1));>>
+ | QuotedTerm <<t=mystrdup(LATEXT(1));>>
+ )
+ <<e = newECnode;
+ require(e!=NULL, "cannot allocate error class node");
+ e->lexclass = CurrentLexClass;
+ if ( Tnum( (t=StripQuotes(t)) ) == 0 )
+ {
+ if ( hash_get(Texpr, t) != NULL )
+ warn(eMsg1("errclass name conflicts with regular expression '%s'",t));
+ e->tok = addTname( t );
+ set_orel(e->tok, &imag_tokens);
+ require((p=(TermEntry *)hash_get(Tname, t)) != NULL,
+ "hash table mechanism is broken");
+ p->classname = 1; /* entry is errclass name, not token */
+ list_add(&eclasses, (char *)e);
+ }
+ else
+ {
+ warn(eMsg1("redefinition of errclass or conflict w/token or tokclass '%s'; ignored",t));
+ free( (char *)e );
+ go=0;
+ }
+ >>
+ "\{"
+ ( NonTerminal <<if ( go ) t=mystrdup(LATEXT(1));>>
+ | TokenTerm <<if ( go ) t=mystrdup(LATEXT(1));>>
+ | QuotedTerm <<if ( go ) t=mystrdup(LATEXT(1));>>
+ )
+ <<if ( go ) list_add(&(e->elist), t);>>
+ (
+ ( NonTerminal <<if ( go ) t=mystrdup(LATEXT(1));>>
+ | TokenTerm <<if ( go ) t=mystrdup(LATEXT(1));>>
+ | QuotedTerm <<if ( go ) t=mystrdup(LATEXT(1));>>
+ )
+ <<if ( go ) list_add(&(e->elist), t);>>
+ )*
+ "\}"
+ ;
+ <<CannotContinue=TRUE;>>
+
+/* rule tclass */
+
+tclass : <<char *t=NULL; TCnode *e; int go=1,tok,totok; TermEntry *p, *term, *toterm;>>
+ <<char *akaString=NULL; int save_file; int save_line;>>
+ <<char *totext=NULL; >>
+ "{\\}#tokclass" TokenTerm <<t=mystrdup(LATEXT(1));>>
+ <<e = newTCnode;
+ require(e!=NULL, "cannot allocate token class node");
+ e->lexclass = CurrentLexClass;
+ if ( Tnum( t ) == 0 )
+ {
+ e->tok = addTname( t );
+ set_orel(e->tok, &imag_tokens);
+ set_orel(e->tok, &tokclasses);
+ require((p=(TermEntry *)hash_get(Tname, t)) != NULL,
+ "hash table mechanism is broken");
+ p->classname = 1; /* entry is class name, not token */
+ p->tclass = e; /* save ptr to this tclass def */
+ list_add(&tclasses, (char *)e);
+ }
+ else
+ {
+ warn(eMsg1("redefinition of tokclass or conflict w/token '%s'; ignored",t));
+ free( (char *)e );
+ go=0;
+ }
+ >>
+/* MR23 */ {
+/* MR23 */ "\("
+/* MR23 */ QuotedTerm
+/* MR23 */ <<akaString=mystrdup(StripQuotes(LATEXT(1)));
+/* MR11 */ save_file=CurFile;save_line=zzline;
+/* MR23 */ >>
+/* MR23 */ "\)"
+/* MR23 */ }
+/* MR23 */
+/* MR23 */
+/* MR23 */ <<
+/* MR23 */ if (p!= NULL && akaString != NULL) {
+/* MR23 */ if (p->akaString != NULL) {
+/* MR23 */ if (strcmp(p->akaString,akaString) != 0) {
+/* MR23 */ warnFL(eMsg2("this #tokclass statment conflicts with a previous #tokclass %s(\"%s\") statement",
+/* MR23 */ t,p->akaString),
+/* MR23 */ FileStr[save_file],save_line);
+/* MR23 */ };
+/* MR23 */ } else {
+/* MR23 */ p->akaString=akaString;
+/* MR23 */ };
+/* MR23 */ };
+/* MR23 */ >>
+
+ "\{"
+ (
+ ( TokenTerm
+ <<if ( go ) {
+ term = (TermEntry *) hash_get(Tname, LATEXT(1));
+ if ( term==NULL && UserDefdTokens ) {
+ err("implicit token definition not allowed with #tokdefs");
+ go = 0;
+ }
+ else {t=mystrdup(LATEXT(1)); tok=addTname(LATEXT(1));}
+ }>>
+
+ {
+ ".."
+ TokenTerm
+
+ <<if ( go ) {
+ toterm = (TermEntry *) hash_get(Tname, LATEXT(1));
+ if ( toterm==NULL && UserDefdTokens ) {
+ err("implicit token definition not allowed with #tokdefs");
+ go = 0;
+ } else {
+ totext=mystrdup(LATEXT(1)); totok=addTname(LATEXT(1));
+ }
+ }
+ >>
+ }
+
+ | QuotedTerm
+ <<if ( go ) {
+ term = (TermEntry *) hash_get(Texpr, LATEXT(1));
+ if ( term==NULL && UserDefdTokens ) {
+ err("implicit token definition not allowed with #tokdefs");
+ go = 0;
+ }
+ else {t=mystrdup(LATEXT(1)); tok=addTexpr(LATEXT(1));}
+ }>>
+ )
+ <<if ( go ) {
+ if (totext == NULL) {
+ list_add(&(e->tlist), t);
+ } else {
+ list_add(&(e->tlist),"..");
+ list_add(&(e->tlist),t);
+ list_add(&(e->tlist),totext);
+ }
+ totext=NULL;
+ }
+ >>
+ )+ // MR15 Manfred Kogler - forbid empty #tokclass sets (was "+")
+ "\}"
+ ;
+ <<CannotContinue=TRUE;>>
+
+/* rule token */
+
+token : <<char *t=NULL, *e=NULL, *a=NULL; int tnum=0;>>
+ <<char *akaString=NULL; TermEntry *te;int save_file=0,save_line=0;>> /* MR11 */
+ "{\\}#token"
+
+/* MR1 10-Apr-97 MR1 Allow shift right operator in DLG actions */
+/* MR1 Danger when parser feedback to lexer */
+/* MR1 */
+
+ <<tokenActionActive=1;>> /* MR1 */
+ { TokenTerm <<t=mystrdup(LATEXT(1));>>
+
+/* MR11 */ {
+/* MR11 */ "\("
+/* MR11 */ QuotedTerm
+/* MR11 */ <<akaString=mystrdup(StripQuotes(LATEXT(1)));
+/* MR11 */ save_file=CurFile;save_line=zzline;
+/* MR11 */ >>
+/* MR11 */ "\)"
+/* MR11 */ }
+
+ { "=" "[0-9]+" /* define the token type number */
+ <<tnum = atoi(LATEXT(1));>>
+ }
+ }
+ { QuotedTerm <<e=mystrdup(LATEXT(1));>> }
+ { Action
+ <<
+ a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(a!=NULL, "rule token: cannot allocate action");
+ strcpy(a, LATEXT(1));
+ >>
+ }
+
+ { ";" } /* MR11 */
+
+ <<chkToken(t, e, a, tnum);>>
+
+ <<if (t != NULL) {
+ te=(TermEntry *)hash_get(Tname,t);
+ if (te != NULL && akaString != NULL) {
+ if (te->akaString != NULL) {
+ if (strcmp(te->akaString,akaString) != 0) {
+ warnFL(eMsg2("this #token statment conflicts with a previous #token %s(\"%s\") statement",
+ t,te->akaString),
+ FileStr[save_file],save_line);
+ };
+ } else {
+ te->akaString=akaString;
+ };
+ };
+ };
+ >>
+ ;
+ <<CannotContinue=TRUE;>>
+
+/* rule block */
+
+block[set *toksrefd, set *rulesrefd]
+ : <<
+ Graph g, b;
+ set saveblah;
+ int saveinalt = inAlt;
+ ExceptionGroup *eg;
+ *$toksrefd = empty;
+ *$rulesrefd = empty;
+ set_clr(AST_nodes_refd_in_actions);
+ CurBlockID++;
+/* MR23 */ CurBlockID_array[BlkLevel] = CurBlockID;
+ CurAltNum = 1;
+/* MR23 */ CurAltNum_array[BlkLevel] = CurAltNum;
+ saveblah = attribsRefdFromAction;
+ attribsRefdFromAction = empty;
+ >>
+
+ alt[toksrefd,rulesrefd] <<b = g = $1;>>
+
+ <<
+ if ( ((Junction *)g.left)->p1->ntype == nAction )
+ {
+ ActionNode *actionNode=(ActionNode *)
+ ( ( (Junction *)g.left) ->p1);
+ if (!actionNode->is_predicate )
+ {
+ actionNode->init_action = TRUE;
+/* MR12c */ if (actionNode->noHoist) {
+/* MR12c */ errFL("<<nohoist>> appears as init-action - use <<>> <<nohoist>>",
+/* MR12c */ FileStr[actionNode->file],actionNode->line);
+/* MR12c */ };
+ }
+ }
+ ((Junction *)g.left)->blockid = CurBlockID;
+ >>
+
+ ( exception_group > [eg]
+ <<
+ if ( eg!=NULL ) {
+/* MR7 ***** eg->altID = makeAltID(CurBlockID,CurAltNum); *****/
+/* MR7 ***** CurAltStart->exception_label = eg->altID; *****/
+ list_add(&CurExGroups, (void *)eg);
+ }
+ >>
+ )*
+ <<CurAltNum++;
+/* MR23 */ CurAltNum_array[BlkLevel] = CurAltNum;
+ >>
+
+ ( "\|" <<inAlt=1;>>
+ alt[toksrefd,rulesrefd] <<g = Or(g, $2);>>
+ <<
+ ((Junction *)g.left)->blockid = CurBlockID;
+ >>
+
+ ( exception_group > [eg]
+ <<
+ if ( eg!=NULL ) {
+/* MR7 ***** eg->altID = makeAltID(CurBlockID,CurAltNum); *****/
+/* MR7 ***** CurAltStart->exception_label = eg->altID; *****/
+ list_add(&CurExGroups, (void *)eg);
+ }
+ >>
+ )*
+
+ <<CurAltNum++;
+/* MR23 */ CurAltNum_array[BlkLevel] = CurAltNum;
+ >>
+
+ )*
+ <<$0 = b;>>
+ <<attribsRefdFromAction = saveblah; inAlt = saveinalt;>>
+ ;
+ <<CannotContinue=TRUE;>>
+
+/* rule alt */
+
+alt[set *toksrefd, set *rulesrefd]
+ : <<int n=0; Graph g; int e_num=0, old_not=0; Node *node; set elems, dif;
+ int first_on_line = 1, use_def_MT_handler = 0;
+ g.left=NULL; g.right=NULL;
+
+ CurAltStart = NULL;
+ elems = empty;
+ inAlt = 1;
+ >>
+ { "\@" /* handle MismatchedToken signals with default handler */
+ <<use_def_MT_handler = 1;>>
+ }
+
+ ( <<;>> /* MR9 Removed unreferenced variable "tok" */
+ { <<old_not=0;>> "\~" <<old_not=1;>> }
+ element[old_not, first_on_line, use_def_MT_handler] > [node]
+ <<if ( node!=NULL && node->ntype!=nAction ) first_on_line = 0;>>
+ <<
+ if ( $2.left!=NULL ) {
+ g = Cat(g, $2);
+ n++;
+ if ( node!=NULL ) {
+ if ( node->ntype!=nAction ) e_num++;
+ /* record record number of all rule and token refs */
+ if ( node->ntype==nToken ) {
+ TokNode *tk = (TokNode *)((Junction *)$2.left)->p1;
+ tk->elnum = e_num;
+ set_orel(e_num, &elems);
+ }
+ else if ( node->ntype==nRuleRef ) {
+ RuleRefNode *rn = (RuleRefNode *)((Junction *)$2.left)->p1;
+ rn->elnum = e_num;
+ set_orel(e_num, $rulesrefd);
+ }
+ }
+ }
+ >>
+ )*
+ <<if ( n == 0 ) g = emptyAlt();
+ $0 = g;
+ /* We want to reduce number of LT(i) calls and the number of
+ * local attribute variables in C++ mode (for moment, later we'll
+ * do for C also). However, if trees are being built, they
+ * require most of the attrib variables to create the tree nodes
+ * with; therefore, we gen a token ptr for each token ref in C++
+ */
+ if ( GenCC && !GenAST )
+ {
+ /* This now free's the temp set -ATG 5/6/95 */
+ set temp;
+ temp = set_and(elems, attribsRefdFromAction);
+ set_orin($toksrefd, temp);
+ set_free(temp);
+ }
+ else set_orin($toksrefd, elems);
+ if ( GenCC ) {
+ dif = set_dif(attribsRefdFromAction, elems);
+ if ( set_deg(dif)>0 )
+ err("one or more $i in action(s) refer to non-token elements");
+ set_free(dif);
+ }
+ set_free(elems);
+ set_free(attribsRefdFromAction);
+ inAlt = 0;
+ >>
+ ;
+ <<CannotContinue=TRUE;>>
+
+/* rule element_label */
+
+element_label > [LabelEntry *label]
+ : <<TermEntry *t=NULL; LabelEntry *l=NULL; RuleEntry *r=NULL; char *lab;>>
+ LABEL <<lab = mystrdup(LATEXT(1));>>
+ <<
+ UsedNewStyleLabel = 1;
+ if ( UsedOldStyleAttrib ) err("cannot mix with new-style labels with old-style $i");
+ t = (TermEntry *) hash_get(Tname, lab);
+ if ( t==NULL ) t = (TermEntry *) hash_get(Texpr, lab);
+ if ( t==NULL ) r = (RuleEntry *) hash_get(Rname, lab);
+ if ( t!=NULL ) {
+ err(eMsg1("label definition clashes with token/tokclass definition: '%s'", lab));
+ $label = NULL;
+ }
+ else if ( r!=NULL ) {
+ err(eMsg1("label definition clashes with rule definition: '%s'", lab));
+ $label = NULL;
+ }
+ else {
+ /* we don't clash with anybody else */
+ l = (LabelEntry *) hash_get(Elabel, lab);
+ if ( l==NULL ) { /* ok to add new element label */
+ l = (LabelEntry *)hash_add(Elabel,
+ lab,
+ (Entry *)newLabelEntry(lab));
+ /* add to list of element labels for this rule */
+ list_add(&CurElementLabels, (void *)lab);
+/* MR7 */ leAdd(l); /* list of labels waiting for exception group definitions */
+ $label = l;
+ }
+ else {
+ err(eMsg1("label definitions must be unique per rule: '%s'", lab));
+ $label = NULL;
+ }
+ }
+ >>
+ ":"
+ ;
+
+/* rule element */
+
+element[int old_not, int first_on_line, int use_def_MT_handler] > [Node *node]
+ : <<
+ Attrib blk;
+ Predicate *pred = NULL;
+ int local_use_def_MT_handler=0;
+ ActionNode *act;
+ RuleRefNode *rr;
+ set toksrefd, rulesrefd;
+ TermEntry *term;
+ TokNode *p=NULL; RuleRefNode *q; int approx=0;
+ LabelEntry *label=NULL;
+ int predMsgDone=0;
+ int semDepth=0;
+ int ampersandStyle;
+ int height; /* MR11 */
+ int equal_height; /* MR11 */
+
+ char* pFirstSetSymbol = NULL; /* MR21 */
+
+ $node = NULL;
+ >>
+ {element_label>[label]}
+ ( TokenTerm
+ <<
+ term = (TermEntry *) hash_get(Tname, LATEXT(1));
+ if ( term==NULL && UserDefdTokens ) {
+ err("implicit token definition not allowed with #tokdefs");
+ $$.left = $$.right = NULL;
+ }
+ else {
+ $$ = buildToken(LATEXT(1));
+ p=((TokNode *)((Junction *)$$.left)->p1);
+ term = (TermEntry *) hash_get(Tname, LATEXT(1));
+ require( term!= NULL, "hash table mechanism is broken");
+ p->tclass = term->tclass;
+ p->complement = $old_not;
+ if ( label!=NULL ) {
+ p->el_label = label->str;
+ label->elem = (Node *)p;
+ }
+ }
+ >>
+ { ".."
+ ( QuotedTerm
+ <<if ( p!=NULL ) setUpperRange(p, LATEXT(1));>>
+ | TokenTerm
+ <<if ( p!=NULL ) setUpperRange(p, LATEXT(1));>>
+ )
+ }
+ <<
+ if ( p!=NULL && (p->upper_range!=0 || p->tclass || $old_not) )
+ list_add(&MetaTokenNodes, (void *)p);
+ >>
+ ( "^" <<if ( p!=NULL ) p->astnode=ASTroot;>>
+ | <<if ( p!=NULL ) p->astnode=ASTchild;>>
+ | "!" <<if ( p!=NULL ) p->astnode=ASTexclude;>>
+ )
+ { "\@" <<local_use_def_MT_handler = 1;>> }
+ <<
+ if ( p!=NULL && $first_on_line ) {
+ CurAltStart = (Junction *)$$.left;
+ altAdd(CurAltStart); /* MR7 */
+ p->altstart = CurAltStart;
+ }
+ if ( p!=NULL )
+ p->use_def_MT_handler = $use_def_MT_handler || local_use_def_MT_handler;
+ $node = (Node *)p;
+ >>
+ | QuotedTerm
+ <<
+ term = (TermEntry *) hash_get(Texpr, LATEXT(1));
+ if ( term==NULL && UserDefdTokens ) {
+ err("implicit token definition not allowed with #tokdefs");
+ $$.left = $$.right = NULL;
+ }
+ else {
+ $$ = buildToken(LATEXT(1)); p=((TokNode *)((Junction *)$$.left)->p1);
+ p->complement = $old_not;
+ if ( label!=NULL ) {
+ p->el_label = label->str;
+ label->elem = (Node *)p;
+ }
+ }
+ >>
+ { ".."
+ ( QuotedTerm
+ <<if ( p!=NULL ) setUpperRange(p, LATEXT(1));>>
+ | TokenTerm
+ <<if ( p!=NULL ) setUpperRange(p, LATEXT(1));>>
+ )
+ }
+ ( "^" <<if ( p!=NULL ) p->astnode=ASTroot;>>
+ | <<if ( p!=NULL ) p->astnode=ASTchild;>>
+ | "!" <<if ( p!=NULL ) p->astnode=ASTexclude;>>
+ )
+ { "\@" <<local_use_def_MT_handler = 1;>> }
+ <<
+ if ( p!=NULL && (p->upper_range!=0 || p->tclass || $old_not) )
+ list_add(&MetaTokenNodes, (void *)p);
+ >>
+ <<
+ if ( $first_on_line ) {
+ CurAltStart = (Junction *)$$.left;
+ altAdd(CurAltStart); /* MR7 */
+ p->altstart = CurAltStart;
+ }
+ if ( p!=NULL )
+ p->use_def_MT_handler = $use_def_MT_handler || local_use_def_MT_handler;
+ $node = (Node *)p;
+ >>
+
+ | <<if ( $old_not ) warn("~ WILDCARD is an undefined operation (implies 'nothing')");>>
+ "."
+ <<$$ = buildWildCard(LATEXT(1)); p=((TokNode *)((Junction *)$$.left)->p1);>>
+ ( "^" <<p->astnode=ASTroot;>>
+ | <<p->astnode=ASTchild;>>
+ | "!" <<p->astnode=ASTexclude;>>
+ )
+ <<list_add(&MetaTokenNodes, (void *)p);>>
+ <<
+ if ( $first_on_line ) {
+ CurAltStart = (Junction *)$$.left;
+ altAdd(CurAltStart); /* MR7 */
+ p->altstart = CurAltStart;
+ if ( label!=NULL ) {
+ p->el_label = label->str;
+ label->elem = (Node *)p;
+ }
+ }
+ $node = (Node *)p;
+ >>
+
+ | <<if ( $old_not ) warn("~ NONTERMINAL is an undefined operation");>>
+ NonTerminal
+ <<$$ = buildRuleRef(LATEXT(1));>>
+ { "!" <<q = (RuleRefNode *) ((Junction *)$$.left)->p1;
+ q->astnode=ASTexclude;>>
+ }
+ { {"\<"}
+ PassAction <<addParm(((Junction *)$$.left)->p1, LATEXT(1));>>
+ }
+ <<rr=(RuleRefNode *) ((Junction *)$$.left)->p1;>>
+ { <<char *a;>>
+ "\>"
+ PassAction
+ <<
+ a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(a!=NULL, "rule element: cannot allocate assignment");
+ strcpy(a, LATEXT(1));
+ rr->assign = a;
+ >>
+ }
+ <<
+ if ( label!=NULL ) {
+ rr->el_label = label->str;
+ label->elem = (Node *)rr;
+ }
+ if ( $first_on_line ) {
+ CurAltStart = (Junction *)$$.left;
+ altAdd(CurAltStart); /* MR7 */
+ ((RuleRefNode *)((Junction *)$$.left)->p1)->altstart = CurAltStart;
+ }
+ $node = (Node *)rr;
+ >>
+ )
+
+ | <<if ( $old_not ) warn("~ ACTION is an undefined operation");>>
+ Action <<$0 = buildAction(LATEXT(1),action_file,action_line, 0);>>
+ <<if ( $first_on_line ) { /* MR7 */
+ CurAltStart = (Junction *)$0.left; /* MR7 */
+ altAdd(CurAltStart); /* MR7 */
+ };>> /* MR7 */
+ <<$node = (Node *) ((Junction *)$0.left)->p1;>>
+
+ | <<if ( $old_not ) warn("~ SEMANTIC-PREDICATE is an undefined operation");>>
+ Pred <<$0 = buildAction(LATEXT(1),action_file,action_line, 1);>>
+ <<act = (ActionNode *) ((Junction *)$0.left)->p1;>>
+ <<if (numericActionLabel) { /* MR10 */
+ list_add(&NumericPredLabels,act); /* MR10 */
+ numericActionLabel=0; /* MR10 */
+ }; /* MR10 */
+ >>
+ { <<char *a;>>
+ PassAction
+ <<
+ a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(a!=NULL, "rule element: cannot allocate predicate fail action");
+ strcpy(a, LATEXT(1));
+ act->pred_fail = a;
+ >>
+ }
+ <<if ( $first_on_line ) { /* MR7 */
+ CurAltStart = (Junction *)$0.left; /* MR7 */
+ altAdd(CurAltStart); /* MR7 */
+ };>> /* MR7 */
+ <<$node = (Node *)act;>>
+
+ | <<if ( $old_not ) warn("~ BLOCK is an undefined operation");>>
+ <<BlkLevel++;
+ if (BlkLevel >= MAX_BLK_LEVEL) fatal("Blocks nested too deeply");
+/* MR23 */ CurBlockID_array[BlkLevel] = CurBlockID;
+/* MR23 */ CurAltNum_array[BlkLevel] = CurAltNum;
+ >>
+ { Pragma
+ ( "approx" <<approx=LL_k;>>
+ | "LL\(1\)" <<approx = 1;>> /* MR20 */
+ | "LL\(2\)" <<approx = 2;>> /* MR20 */
+ )
+ }
+
+/* MR21 */ { FirstSetSymbol
+/* MR21 */ "\("
+/* MR21 */ ( NonTerminal
+/* MR21 */ <<
+/* MR21 */ pFirstSetSymbol = (char *) calloc(strlen(LATEXT(1))+1,
+/* MR21 */ sizeof(char));
+/* MR21 */ require(pFirstSetSymbol!=NULL,
+/* MR21 */ "cannot allocate first set name");
+/* MR21 */ strcpy(pFirstSetSymbol, LATEXT(1));
+/* MR21 */ >>
+/* MR21 */ | TokenTerm
+/* MR21 */ <<
+/* MR21 */ pFirstSetSymbol = (char *) calloc(strlen(LATEXT(1))+1,
+/* MR21 */ sizeof(char));
+/* MR21 */ require(pFirstSetSymbol!=NULL,
+/* MR21 */ "cannot allocate first set name");
+/* MR21 */ strcpy(pFirstSetSymbol, LATEXT(1));
+/* MR21 */ >>
+/* MR21 */ )
+/* MR21 */ "\)"
+/* MR21 */ }
+
+ (
+
+ "\(" block[&toksrefd,&rulesrefd] "\)"
+ <<blk = $$ = $2;
+ /* MR23 */ CurBlockID_array[BlkLevel] = (-1);
+ /* MR23 */ CurAltNum_array[BlkLevel] = (-1);
+ --BlkLevel;
+ >>
+
+ ( "\*" <<$$ = makeLoop($$,approx,pFirstSetSymbol);>>
+ | "\+" <<$$ = makePlus($$,approx,pFirstSetSymbol);>>
+ | "?"
+ (
+ ( "=>" <<ampersandStyle=0;>>
+ | "&&" <<ampersandStyle=1;>> /* MR10 (g)? && <<p>>? */
+ )
+ Pred /* generalized predicate */
+ /* first make into a predicate */
+ <<$$ = buildAction(LATEXT(1),action_file,action_line,1);>>
+ <<act = (ActionNode *) ((Junction *)$$.left)->p1;>>
+ <<semDepth=predicateLookaheadDepth(act);>> /* MR10 */
+ <<if (numericActionLabel) { /* MR10 */
+ list_add(&NumericPredLabels,act); /* MR10 */
+ numericActionLabel=0; /* MR10 */
+ }; /* MR10 */
+ >>
+ { <<char *a;>>
+ PassAction
+ <<
+ a = (char *)calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(a!=NULL, "rule element: cannot allocate predicate fail action");
+ strcpy(a, LATEXT(1));
+ act->pred_fail = a;
+ >>
+ }
+ <<if ($first_on_line) { /* MR7 */
+ CurAltStart=(Junction *)$$.left; /* MR7 */
+ altAdd(CurAltStart); /* MR7 */
+ };>>
+ <<$node = (Node *)act;>>
+
+ /* for now, just snag context */
+ <<
+ pred = computePredFromContextGuard(blk,&predMsgDone); /* MR10 */
+ if ( pred==NULL) { /* MR10 */
+ if ( !predMsgDone) err("invalid or missing context guard"); /* MR10 */
+ predMsgDone=1; /* MR10 */
+ } else { /* MR10 */
+ act->guardNodes=(Junction *)blk.left; /* MR11 */
+ pred->expr = act->action;
+ pred->source = act;
+/* MR10 */ pred->ampersandStyle = ampersandStyle; /* 0 means (g)? => ... 1 means (g)? && ... */
+/* MR13 */ if (pred->tcontext != NULL) {
+/* MR13 */ height=MR_max_height_of_tree(pred->tcontext);
+/* MR13 */ equal_height=MR_all_leaves_same_height(pred->tcontext,height);
+/* MR13 */ if (! equal_height) {
+/* MR13 */ errFL("in guarded predicates all tokens in the guard must be at the same height",
+/* MR13 */ FileStr[act->file],act->line);
+/* MR13 */ };
+/* MR13 */ }
+/* MR10 */ if (ampersandStyle) {
+/* MR10 */ act->ampersandPred = pred;
+/* MR11 */ if (! HoistPredicateContext) {
+/* MR11 */ errFL("without \"-prc on\" (guard)? && <<pred>>? ... doesn't make sense",
+/* MR11 */ FileStr[act->file],act->line);
+/* MR11 */ };
+/* MR10 */ } else {
+/* MR10 */ act->guardpred = pred;
+/* MR10 */ };
+/* MR10 */ if (pred->k != semDepth) {
+/* MR10 */ warn(eMsgd2("length of guard (%d) does not match the length of semantic predicate (%d)",
+/* MR10 */ pred->k,semDepth));
+/* MR10 */ };
+ }
+ >>
+ | <<$$ = makeBlk($$,approx,pFirstSetSymbol);
+ FoundGuessBlk = 1;
+ ((Junction *) ((Junction *)$$.left)->p1)->guess=1;
+ if ( !$first_on_line ) {
+ err("(...)? predicate must be first element of production");
+ }
+ >>
+ )
+ | <<$$ = makeBlk($$,approx,pFirstSetSymbol);>>
+ )
+ <<
+ if ( pred==NULL && !predMsgDone) { /* MR10 */
+ ((Junction *)((Junction *)$$.left)->p1)->blockid = CurBlockID;
+ ((Junction *)((Junction *)$$.left)->p1)->tokrefs = toksrefd;
+ ((Junction *)((Junction *)$$.left)->p1)->rulerefs = rulesrefd;
+ if ( $first_on_line ) { /* MR7 */
+ CurAltStart = (Junction *)((Junction *)((Junction *)$$.left)->p1); /* MR7 */
+ altAdd(CurAltStart); /* MR7 */
+ }; /* MR7 */
+ $node = (Node *) ((Junction *)$$.left)->p1;
+ }
+ >>
+
+ | "\{" block[&toksrefd,&rulesrefd]
+ <<$$ = makeOpt($2,approx,pFirstSetSymbol);
+ /* MR23 */ CurBlockID_array[BlkLevel] = (-1);
+ /* MR23 */ CurAltNum_array[BlkLevel] = (-1);
+ --BlkLevel;
+ >>
+ "\}"
+ <<
+ ((Junction *)((Junction *)$$.left)->p1)->blockid = CurBlockID;
+ ((Junction *)((Junction *)$$.left)->p1)->tokrefs = toksrefd;
+ ((Junction *)((Junction *)$$.left)->p1)->rulerefs = rulesrefd;
+ >>
+ <<if ( $first_on_line ) { /* MR7 */
+ CurAltStart = (Junction *) ((Junction *)((Junction *)$$.left)->p1); /* MR7 */
+ altAdd(CurAltStart); /* MR7 */
+ };
+ >>
+ <<$node = (Node *) ((Junction *)$$.left)->p1;>>
+
+ )
+
+/* Error catching alternatives */
+ | "\*" <<warn("don't you want a ')' with that '*'?"); CannotContinue=TRUE;>>
+ | "\+" <<warn("don't you want a ')' with that '+'?"); CannotContinue=TRUE;>>
+ | "\>" <<warn("'>' can only appear after a nonterminal"); CannotContinue=TRUE;>>
+ | PassAction <<warn("[...] out of context 'rule > [...]'");
+ CannotContinue=TRUE;>>
+ ;
+ <<CannotContinue=TRUE;>>
+
+/* rule default_exception_handler */
+
+default_exception_handler
+ : exception_group > [DefaultExGroup]
+ ;
+
+/* rule exception_group */
+
+exception_group > [ExceptionGroup *eg]
+ : <<ExceptionHandler *h; LabelEntry *label=NULL; /* MR6 */
+ FoundException = 1; FoundExceptionGroup = 1;>> /* MR6 */
+
+ "exception" <<$eg = (ExceptionGroup *)calloc(1, sizeof(ExceptionGroup));>>
+ { <<char *p;>>
+ PassAction /* did they attach a label? */
+ <<
+ p = LATEXT(1)+1;
+ p[strlen(p)-1] = '\0'; /* kill trailing space */
+ label = (LabelEntry *) hash_get(Elabel, LATEXT(1)+1);
+ if ( label==NULL )
+ {
+ err(eMsg1("unknown label in exception handler: '%s'", LATEXT(1)+1));
+ }
+ >>
+ }
+ ( exception_handler > [h]
+ <<list_add(&($eg->handlers), (void *)h);>>
+ )*
+ { "default" ":" Action
+ <<{
+ ExceptionHandler *eh = (ExceptionHandler *)
+ calloc(1, sizeof(ExceptionHandler));
+ char *a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require(eh!=NULL, "exception: cannot allocate handler");
+ require(a!=NULL, "exception: cannot allocate action");
+ strcpy(a, LATEXT(1));
+ eh->action = a;
+ eh->signalname = (char *) calloc(strlen("default")+1, sizeof(char));
+ require(eh->signalname!=NULL, "exception: cannot allocate sig name");
+ strcpy(eh->signalname, "default");
+ list_add(&($eg->handlers), (void *)eh);
+ }>>
+ }
+
+ <<
+ if ( label!=NULL ) {
+ /* Record ex group in sym tab for this label */
+ if ( label->ex_group!=NULL ) {
+ err(eMsg1("duplicate exception handler for label '%s'",label->str));
+ } else {
+ label->ex_group = $eg;
+ /* Label the exception group itself */
+ $eg->label = label->str;
+ /* Make the labelled element pt to the exception also */
+/* MR6 */ if (label->elem == NULL) {
+/* MR6 */ err(eMsg1("reference in exception handler to undefined label '%s'",label->str));
+/* MR6 */ } else {
+ switch ( label->elem->ntype ) {
+ case nRuleRef :
+ {
+ RuleRefNode *r = (RuleRefNode *)label->elem;
+ r->ex_group = $eg;
+ break;
+ }
+ case nToken :
+ {
+ TokNode *t = (TokNode *)label->elem;
+ t->ex_group = $eg;
+ break;
+ }
+ } /* end switch */
+/* MR6 */ }; /* end test on label->elem */
+ } /* end test on label->ex_group */
+
+ } /* end test on exception label */
+
+/* MR7 */
+/* MR7 */ if (BlkLevel == 1 && label == NULL) {
+/* MR7 */ $eg->forRule=1;
+/* MR7 */ } else if (label == NULL) {
+/* MR7 */ $eg->altID = makeAltID(CurBlockID_array[BlkLevel], CurAltNum_array[BlkLevel]);
+/* MR7 */ egAdd($eg);
+/* MR7 */ } else {
+/* MR7 */ $eg->labelEntry=label;
+/* MR7 */ };
+/* MR7 */
+/* MR7 */ /* You may want to remove this exc from the rule list */
+/* MR7 */ /* and handle at the labeled element site. */
+/* MR7 */
+/* MR7 */ if (label != NULL) {
+/* MR7 */ $eg = NULL;
+/* MR7 */ };
+
+ >>
+ ;
+ <<CannotContinue=TRUE;>>
+
+/* rule exception_handler */
+
+exception_handler > [ExceptionHandler *eh]
+ : <<;>> /* MR9 Removed unreferenced variable "a" */
+ "catch"
+ <<
+ $eh = (ExceptionHandler *)calloc(1, sizeof(ExceptionHandler));
+ require($eh!=NULL, "exception: cannot allocate handler");
+ >>
+ ( NonTerminal
+ <<
+ $eh->signalname = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require($eh->signalname!=NULL, "exception: cannot allocate sig name");
+ strcpy($eh->signalname, LATEXT(1));
+ >>
+ | TokenTerm
+ <<
+ $eh->signalname = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require($eh->signalname!=NULL, "exception: cannot allocate sig name");
+ strcpy($eh->signalname, LATEXT(1));
+ >>
+ )
+ ":"
+ { <<$eh->action = NULL;>>
+ Action
+ <<
+ $eh->action = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ require($eh->action!=NULL, "exception: cannot allocate action");
+ strcpy($eh->action, LATEXT(1));
+ >>
+ }
+ ;
+ <<CannotContinue=TRUE;>>
+
+#token NonTerminal "[a-z] [A-Za-z0-9_]*"
+ <<
+ while ( zzchar==' ' || zzchar=='\t' ) {
+ zzadvance();
+ }
+ if ( zzchar == ':' && inAlt ) NLA = LABEL;
+ >>
+#token TokenTerm "[A-Z] [A-Za-z0-9_]*"
+ <<
+ while ( zzchar==' ' || zzchar=='\t' ) {
+ zzadvance();
+ }
+ if ( zzchar == ':' && inAlt ) NLA = LABEL;
+ >>
+#token "{\\}#[A-Za-z0-9_]*" <<warn(eMsg1("unknown meta-op: %s",LATEXT(1))); zzskip(); >>
+
+#lexclass PARSE_ENUM_FILE
+
+#token "[\t\ ]+" << zzskip(); >> /* Ignore White */
+#token "\n|\r|\r\n" << zzline++; zzskip(); >> /* Track Line # */
+#token "//" << zzmode(TOK_DEF_CPP_COMMENTS); zzmore(); >>
+#token "/\*" << zzmode(TOK_DEF_COMMENTS); zzskip(); >>
+#token "#ifdef" << zzmode(TOK_DEF_CPP_COMMENTS); zzskip(); >>
+#token "#if" << zzmode(TOK_DEF_CPP_COMMENTS); zzskip(); >>
+#token "#ifndef" << ; >>
+#token "#else" << zzmode(TOK_DEF_CPP_COMMENTS); zzskip(); >>
+#token "#endif" << zzmode(TOK_DEF_CPP_COMMENTS); zzskip(); >>
+#token "#undef" << zzmode(TOK_DEF_CPP_COMMENTS); zzskip(); >>
+#token "#import" << zzmode(TOK_DEF_CPP_COMMENTS); zzskip(); >>
+#token "@" << ; >>
+
+/* rule enum_file */
+
+enum_file[char *fname]
+ : { "#ifndef" ID
+ { "#define" ID /* ignore if it smells like a gate */
+ /* First #define after the first #ifndef (if any) is ignored */
+ }
+ }
+ ( ( enum_def[$fname] )+
+ | defines[$fname]
+ )
+ |
+ ;
+
+/* rule defines */
+
+defines[char *fname]
+ : <<int v; int maxt=(-1); char *t;>> /* MR3 */
+ (
+ "#define" ID
+ <<t = mystrdup(LATEXT(1));>>
+ INT
+ <<
+ v = atoi(LATEXT(1));
+/* fprintf(stderr, "#token %s=%d\n", t, v);*/
+
+ /* MR2 Andreas Magnusson (Andreas.Magnusson@mailbox.swipnet.se) */
+ /* MR2 Fix to bug introduced by 1.33MR1 for #tokdefs */
+ /* MR2 Don't let #tokdefs be confused by */
+ /* MR2 DLGminToken and DLGmaxToken */
+
+ if ( ! isDLGmaxToken(t)) { /* MR2 */
+ TokenNum = v;
+ if ( v>maxt ) maxt=v;
+ if ( Tnum( t ) == 0 ) {
+ addForcedTname( t, v );
+ } else {
+ warnFL(eMsg1("redefinition of token %s; ignored",t),$fname,zzline);
+ };
+ };
+ >>
+ )+
+ <<TokenNum = maxt + 1;>>
+ ;
+
+/* rule enum_def */
+
+enum_def[char *fname]
+ : <<int v= 0; int maxt=(-1); char *t;>> /* MR3 */
+ "enum" ID
+ "\{"
+ ID
+ <<t = mystrdup(LATEXT(1));>>
+ ( "=" INT <<v=atoi(LATEXT(1));>>
+ | <<v++;>>
+ )
+ <<
+/* fprintf(stderr, "#token %s=%d\n", t, v);*/
+ TokenNum = v;
+ if ( v>maxt ) maxt=v; /* MR3 */
+ if ( Tnum( t ) == 0 ) addForcedTname( t, v );
+ else {
+ warnFL(eMsg1("redefinition of token %s; ignored",t),$fname,zzline);
+ }
+ >>
+ ( ","
+
+ /* MR2 Andreas Magnusson (Andreas.Magnusson@mailbox.swipnet.se) */
+ /* MR2 Fix to bug introduced by 1.33MR1 for #tokdefs */
+ /* MR2 Don't let #tokdefs be confused by */
+ /* MR2 DLGminToken and DLGmaxToken */
+
+ {
+ <<isDLGmaxToken(LATEXT(1))>>? ID { "=" INT } /* MR2 */
+ | ID /* MR2 */
+ <<t = mystrdup(LATEXT(1));>>
+ ( "=" INT <<v=atoi(LATEXT(1));>>
+ | <<v++;>>
+ )
+ <<
+/* fprintf(stderr, "#token %s=%d\n", t, v);*/
+ TokenNum = v;
+ if ( v>maxt ) maxt=v; /* MR3 */
+ if ( Tnum( t ) == 0 ) addForcedTname( t, v );
+ else {
+ warnFL(eMsg1("redefinition of token %s; ignored",t),$fname,zzline);
+ }
+ >>
+ }
+ )*
+ "\}"
+ ";"
+ <<TokenNum = maxt + 1;>> /* MR3 */
+ ;
+
+#token INT "[0-9]+"
+#token ID "[a-zA-Z_][_a-zA-Z0-9]*"
+
+#lexclass START
+
+/* MR14 Arpad Beszedes 26-May-98
+ Add support for #line directives when antlr source is pre-processed
+*/
+
+#lexaction
+<<
+
+static char *
+#ifdef __USE_PROTOS
+getFileNameFromTheLineInfo(char *toStr, char *fromStr)
+#else
+getFileNameFromTheLineInfo(toStr, fromStr)
+char *toStr, *fromStr;
+#endif
+{
+ int i, j, k;
+
+ if (!fromStr || !toStr) return toStr;
+
+ /* find the first " */
+
+ for (i=0;
+ (i<MaxFileName) &&
+ (fromStr[i] != '\n') &&
+ (fromStr[i] != '\r') &&
+ (fromStr[i] != '\"');
+ i++) /* nothing */ ;
+
+ if ( (i == MaxFileName) ||
+ (fromStr[i] == '\n') ||
+ (fromStr[i] == '\r') ) {
+ return toStr;
+ }
+
+ /* find the second " */
+
+ for (j=i+1;
+ (j<MaxFileName) &&
+ (fromStr[j] != '\n') &&
+ (fromStr[j] != '\r') &&
+ (fromStr[j] != '\"');
+ j++) /* nothing */ ;
+
+ if ((j == MaxFileName) ||
+ (fromStr[j] == '\n') ||
+ (fromStr[j] == '\r') ) {
+ return toStr;
+ }
+
+ /* go back until the last / or \ */
+
+ for (k=j-1;
+ (fromStr[k] != '\"') &&
+ (fromStr[k] != '/') &&
+ (fromStr[k] != '\\');
+ k--) /* nothing */ ;
+
+ /* copy the string after " / or \ into toStr */
+
+ for (i=k+1; fromStr[i] != '\"'; i++) {
+ toStr[i-k-1] = fromStr[i];
+ }
+
+ toStr[i-k-1] = '\0';
+
+ return toStr;
+}
+
+/* MR14 end of a block to support #line in antlr source code */
+
+>>
+
+<<
+
+/* MR2 Andreas Magnusson (Andreas.Magnusson@mailbox.swipnet.se) */
+/* MR2 Fix to bug introduced by 1.33MR1 for #tokdefs */
+/* MR2 Don't let #tokdefs be confused by */
+/* MR2 DLGminToken and DLGmaxToken */
+
+/* semantic check on DLGminToken and DLGmaxmaxToken in #tokdefs */
+
+#ifdef __USE_PROTOS
+static int isDLGmaxToken(char *Token)
+#else
+static int isDLGmaxToken(Token)
+ char * Token;
+#endif
+{
+ static char checkStr1[] = "DLGmaxToken";
+ static char checkStr2[] = "DLGminToken";
+
+ if (strcmp(Token, checkStr1) == 0)
+ return 1;
+ else if (strcmp(Token, checkStr2) == 0)
+ return 1;
+ else
+ return 0;
+}
+
+/* semantics of #token */
+static void
+#ifdef __USE_PROTOS
+chkToken(char *t, char *e, char *a, int tnum)
+#else
+chkToken(t,e,a,tnum)
+char *t, *e, *a;
+int tnum;
+#endif
+{
+ TermEntry *p;
+
+ /* check to see that they don't try to redefine a token as a token class */
+ if ( t!=NULL ) {
+ p = (TermEntry *) hash_get(Tname, t);
+ if ( p!=NULL && p->classname ) {
+ err(eMsg1("redefinition of #tokclass '%s' to #token not allowed; ignored",t));
+ if ( a!=NULL ) free((char *)a);
+ return;
+ }
+ }
+
+ if ( t==NULL && e==NULL ) { /* none found */
+ err("#token requires at least token name or rexpr");
+ }
+ else if ( t!=NULL && e!=NULL ) { /* both found */
+ if ( UserDefdTokens ) { /* if #tokdefs, must not define new */
+ p = (TermEntry *) hash_get(Tname, t);
+ if ( p == NULL) {
+err(eMsg1("new token definition '%s' not allowed - only #token with name already defined by #tokdefs file allowed",t));
+ return;
+ };
+ }
+ Tklink(t, e);
+ if ( a!=NULL ) {
+ if ( hasAction(e) ) {
+ err(eMsg1("redefinition of action for %s; ignored",e));
+ }
+ else setHasAction(e, a);
+ }
+ }
+ else if ( t!=NULL ) { /* only one found */
+ if ( UserDefdTokens ) {
+ p = (TermEntry *) hash_get(Tname, t);
+ if (p == NULL) {
+err(eMsg1("new token definition '%s' not allowed - only #token with name already defined by #tokdefs file allowed",t));
+ };
+ return;
+ }
+ if ( Tnum( t ) == 0 ) addTname( t );
+ else {
+ err(eMsg1("redefinition of token %s; ignored",t));
+ }
+ if ( a!=NULL ) {
+ err(eMsg1("action cannot be attached to a token name (%s); ignored",t));
+ free((char *)a);
+ }
+ }
+ else if ( e!=NULL ) {
+ if ( Tnum( e ) == 0 ) addTexpr( e );
+ else {
+ if ( hasAction(e) ) {
+ err(eMsg1("redefinition of action for expr %s; ignored",e));
+ }
+ else if ( a==NULL ) {
+ err(eMsg1("redefinition of expr %s; ignored",e));
+ }
+ }
+ if ( a!=NULL ) setHasAction(e, a);
+ }
+
+ /* if a token type number was specified, then add the token ID and 'tnum'
+ * pair to the ForcedTokens list. (only applies if an id was given)
+ */
+ if ( t!=NULL && tnum>0 )
+ {
+ if ( set_el(tnum, reserved_positions) )
+ {
+ err(eMsgd("a token has already been forced to token number %d; ignored", tnum));
+ }
+ else
+ {
+ list_add(&ForcedTokens, newForcedToken(t,tnum));
+ set_orel(tnum, &reserved_positions);
+ }
+ }
+}
+>>
+
+<<
+static int
+#ifdef __USE_PROTOS
+match_token(char *s, char **nxt)
+#else
+match_token(s,nxt)
+char *s;
+char **nxt;
+#endif
+{
+ if ( !(*s>='A' && *s<='Z') ) return 0;
+ s++;
+ while ( (*s>='a' && *s<='z') ||
+ (*s>='A' && *s<='Z') ||
+ (*s>='0' && *s<='9') ||
+ *s=='_' )
+ {
+ s++;
+ }
+ if ( *s!=' ' && *s!='}' ) return 0;
+ *nxt = s;
+ return 1;
+}
+
+static int
+#ifdef __USE_PROTOS
+match_rexpr(char *s, char **nxt)
+#else
+match_rexpr(s,nxt)
+char *s;
+char **nxt;
+#endif
+{
+ if ( *s!='"' ) return 0;
+ s++;
+ while ( *s!='"' )
+ {
+ if ( *s=='\n' || *s=='\r' ) /* MR13 */
+ warn("eoln found in regular expression");
+ if ( *s=='\\' ) s++;
+ s++;
+ }
+ *nxt = s+1;
+ return 1;
+}
+
+/*
+ * Walk a string "{ A .. Z }" where A..Z is a space separated list
+ * of token references (either labels or reg exprs). Return a
+ * string "inlineX_set" for some unique integer X. Basically,
+ * we pretend as if we had seen "#tokclass inlineX { A .. Z }"
+ * on the input stream outside of an action.
+ */
+char *
+#ifdef __USE_PROTOS
+inline_set(char *s)
+#else
+inline_set(s)
+char *s;
+#endif
+{
+ char *nxt;
+ fprintf(stderr, "found consumeUntil( {...} )\n");
+ while ( *s==' ' || *s=='\t' || *s=='\n' || *s=='\r' ) {s++;}
+ if ( *s!='{' )
+ {
+ err("malformed consumeUntil( {...} ); missing '{'");
+ return "bad_set";
+ }
+ s++;
+ while ( *s==' ' || *s=='\t' || *s=='\n' || *s=='\r' ) {s++;}
+ while ( *s!='}' )
+ {
+ if ( match_token(s,&nxt) ) fprintf(stderr, "found token %s\n", s);
+ else if ( match_rexpr(s,&nxt) ) fprintf(stderr, "found rexpr %s\n", s);
+ else {
+ err("invalid element in consumeUntil( {...} )");
+ return "bad_set";
+ }
+ s = nxt;
+ while ( *s==' ' || *s=='\t' || *s=='\n' || *s=='\r' ) {s++;}
+ }
+ return "inlineX_set";
+}
+>>
+
+<<
+/* ANTLR-specific syntax error message generator
+ * (define USER_ZZSYN when compiling so don't get 2 definitions)
+ */
+void
+#ifdef __USE_PROTOS
+zzsyn(char *text, int tok, char *egroup, SetWordType *eset, int etok,
+int k, char *bad_text)
+#else
+zzsyn(text, tok, egroup, eset, etok, k, bad_text)
+char *text, *egroup, *bad_text;
+int tok;
+int etok;
+int k;
+SetWordType *eset;
+#endif
+{
+ fprintf(stderr, ErrHdr, FileStr[CurFile]!=NULL?FileStr[CurFile]:"stdin", zzline);
+ fprintf(stderr, " syntax error at \"%s\"", (tok==zzEOF_TOKEN)?"EOF":text);
+ if ( !etok && !eset ) {fprintf(stderr, "\n"); return;}
+ if ( k==1 ) fprintf(stderr, " missing");
+ else
+ {
+ fprintf(stderr, "; \"%s\" not", bad_text);
+ if ( zzset_deg(eset)>1 ) fprintf(stderr, " in");
+ }
+ if ( zzset_deg(eset)>0 ) zzedecode(eset);
+ else fprintf(stderr, " %s", zztokens[etok]);
+ if ( strlen(egroup) > (size_t)0 ) fprintf(stderr, " in %s", egroup);
+ fprintf(stderr, "\n");
+}
+>>
+
+#lexaction <<
+#ifdef __USE_PROTOS
+void mark_label_used_in_sem_pred(LabelEntry *le) /* MR10 */
+#else
+void mark_label_used_in_sem_pred(le) /* MR10 */
+ LabelEntry *le;
+#endif
+{
+ TokNode *tn;
+ require (le->elem->ntype == nToken,"mark_label_used... ntype != nToken");
+ tn=(TokNode *)le->elem;
+ require (tn->label != 0,"mark_label_used... TokNode has no label");
+ tn->label_used_in_semantic_pred=1;
+}
+>>
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.r b/BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.r new file mode 100644 index 0000000000..e3de38759f --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.r @@ -0,0 +1,787 @@ +/*
+ File: antlrMPW.r
+ Target: antlr 133MR
+ Created: Monday, June 15, 1998 4:41:11 AM
+ Author: Kenji Tanaka (kentar@osa.att.ne.jp)
+*/
+
+#include "cmdo.r"
+
+resource 'cmdo' (128, "Antlr") {
+ { /* array dialogs: 5 elements */
+ /* [1] */
+ 295,
+ "ANTLR -- Purdue Compiler Construction To"
+ "ol Set (PCCTS) LL(k) parser generator.",
+ { /* array itemArray: 12 elements */
+ /* [1] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {18, 23, 33, 223},
+ "Read grammar from stdin",
+ "-",
+ "Read grammar from stdin."
+ },
+ /* [2] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {38, 23, 53, 310},
+ "Send grammar.c/grammar.cpp to stdout",
+ "-stdout",
+ "Send grammar.c/grammar.cpp to stdout."
+ },
+ /* [3] */
+ NotDependent {
+
+ },
+ MultiFiles {
+ "Grammar File(s)É",
+ "Choose the grammar specification files y"
+ "ou wish to have ANTLR process.",
+ {79, 22, 98, 152},
+ "Grammar specification:",
+ "",
+ MultiInputFiles {
+ { /* array MultiTypesArray: 1 elements */
+ /* [1] */
+ text
+ },
+ ".g",
+ "Files ending in .g",
+ "All text files"
+ }
+ },
+ /* [4] */
+ NotDependent {
+
+ },
+ Files {
+ DirOnly,
+ OptionalFile {
+ {58, 168, 74, 298},
+ {79, 169, 98, 299},
+ "Output Directory",
+ ":",
+ "-o",
+ "",
+ "Choose the directory where ANTLR will pu"
+ "t its output.",
+ dim,
+ "Output DirectoryÉ",
+ "",
+ ""
+ },
+ NoMore {
+
+ }
+ },
+ /* [5] */
+ NotDependent {
+
+ },
+ Redirection {
+ StandardOutput,
+ {126, 27}
+ },
+ /* [6] */
+ NotDependent {
+
+ },
+ Redirection {
+ DiagnosticOutput,
+ {126, 178}
+ },
+ /* [7] */
+ NotDependent {
+
+ },
+ TextBox {
+ gray,
+ {117, 20, 167, 300},
+ "Redirection"
+ },
+ /* [8] */
+ NotDependent {
+
+ },
+ NestedDialog {
+ 5,
+ {20, 324, 40, 460},
+ "Parse OptionsÉ",
+ "Parse control options may be set with th"
+ "is button."
+ },
+ /* [9] */
+ NotDependent {
+
+ },
+ NestedDialog {
+ 2,
+ {50, 324, 70, 460},
+ "Generate OptionsÉ",
+ "Various command line options may be set "
+ "with this button."
+ },
+ /* [10] */
+ NotDependent {
+
+ },
+ NestedDialog {
+ 3,
+ {78, 324, 98, 460},
+ "More OptionsÉ",
+ "Antlr has ALOT of options. There are eve"
+ "n more to be found with this button."
+ },
+ /* [11] */
+ NotDependent {
+
+ },
+ NestedDialog {
+ 4,
+ {106, 324, 126, 460},
+ "Rename OptionsÉ",
+ "Options for renaming output files may be"
+ " set with this button."
+ },
+ /* [12] */
+ NotDependent {
+
+ },
+ VersionDialog {
+ VersionString {
+ "1.33MR"
+ },
+ "PCCTS was written by Terence Parr, Russe"
+ "ll Quong, Will Cohen, and Hank Dietz: 19"
+ "89-1998. MPW port by Scott Haney.",
+ noDialog
+ }
+ },
+ /* [2] */
+ 295,
+ "Use this dialog to specify command line "
+ "Generate Options.",
+ { /* array itemArray: 15 elements */
+ /* [1] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {18, 25, 33, 225},
+ "Generate C++ code",
+ "-CC",
+ "Generate C++ output from both ANTLR and "
+ "DLG."
+ },
+ /* [2] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {38, 25, 53, 225},
+ "Generate ASTs",
+ "-gt",
+ "Generate code for Abstract-Syntax-Trees "
+ "(ASTs)."
+ },
+ /* [3] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {58, 25, 73, 225},
+ "Generate line info",
+ "-gl",
+ "If this option is checked, ANTLR will ge"
+ "nerate line info about grammaractions, t"
+ "hereby making debugging easier since com"
+ "pile errors will point to the grammar fi"
+ "le."
+ },
+ /* [4] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {78, 25, 93, 225},
+ "Generate error classes",
+ "-ge",
+ "If this option is checked, ANTLR will ge"
+ "nerate an error class foreach non-termin"
+ "al."
+ },
+ /* [5] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {98, 25, 113, 225},
+ "Don't generate Code",
+ "-gc",
+ "If this option is checked, ANTLR will ge"
+ "nerate no code, i.e. it will only perfor"
+ "m analysis on the grammar."
+ },
+ /* [6] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {118, 25, 133, 225},
+ "Delay lookahead fetches",
+ "-gk",
+ "If this option is checked, ANTLR will ge"
+ "nerate a parser that delays lookahead fe"
+ "tches until needed."
+ },
+ /* [7] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {138, 25, 153, 225},
+ "Use newAST(...)",
+ "-newAST",
+ "In C++ mode use \"newAST(...)\" rather tha"
+ "n \"new AST(...)\""
+ },
+ /* [8] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {18, 235, 33, 435},
+ "Support parse traces",
+ "-gd",
+ "If this option is checked, ANTLR inserts"
+ " code in each parsing function to provid"
+ "e for user-defined handling of a detaile"
+ "d parse trace. The code consists of call"
+ "s to zzTRACEIN and zzTRACEOUT."
+ },
+ /* [9] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {38, 235, 53, 435},
+ "Generate cross-references",
+ "-cr",
+ "If this option is checked, ANTLR will ge"
+ "nerate a cross reference for all rules. "
+ "For each rule it will print a list of al"
+ "l other rules that refrence it."
+ },
+ /* [10] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {58, 235, 73, 435},
+ "Don't create Lexer files",
+ "-gx",
+ "If this option is checked, ANTLR will no"
+ "t generate DLG-related output files. Thi"
+ "s option should be used if one wants a c"
+ "ustom lexical analyzer or if one has mad"
+ "e changes to the grammar not affecting t"
+ "he lexical structure."
+ },
+ /* [11] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {78, 235, 93, 460},
+ "Don't generate token expr sets",
+ "-gs",
+ "If this option is checked, ANTLR will no"
+ "t generate sets for token expression set"
+ "s; instead, it will generate a || separa"
+ "ted sequence of LA(1)==token #. "
+ },
+ /* [12] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {98, 235, 113, 460},
+ "Generate ANSI-compatible",
+ "-ga",
+ "Generate ANSI-compatible code (default=F"
+ "ALSE)"
+ },
+ /* [13] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {118, 235, 133, 460},
+ "Don't generate tokens.h",
+ "-gxt",
+ "Do not generate tokens.h (default=FALSE)"
+ },
+ /* [13] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {138, 235, 153, 460},
+ "Provide \"(alpha)? beta\" info",
+ "-alpha",
+ "Provide additional information for \"(alpha)? beta\" error messages"
+ },
+ /* [14] */
+ NotDependent {
+
+ },
+ RegularEntry {
+ "Tabs(1 to 8):",
+ {162, 23, 177, 117},
+ {163, 125, 179, 196},
+ "",
+ keepCase,
+ "-tab",
+ "Width of tabs (1 to 8) for grammar.c/gra"
+ "mmar.cpp files."
+ },
+ /* [15] */
+ NotDependent {
+
+ },
+ RegularEntry {
+ "Function Prefix:",
+ {161, 236, 177, 342},
+ {162, 345, 177, 454},
+ "",
+ keepCase,
+ "-gp",
+ "Prefix all generated rule functions with"
+ " a string."
+ }
+ },
+ /* [3] */
+ 295,
+ "Use this dialog to specify still more co"
+ "mmand line options.",
+ { /* array itemArray: 12 elements */
+ /* [1] */
+ NotDependent {
+
+ },
+ RadioButtons {
+ { /* array radioArray: 3 elements */
+ /* [1] */
+ {38, 25, 53, 85}, "None", "", Set, "When this option is selected, ANTLR will"
+ " not print the grammar to stdout.",
+ /* [2] */
+ {38, 100, 53, 160}, "Yes", "-p", NotSet, "When this option is selected, ANTLR will"
+ " print the grammar, stripped of all acti"
+ "ons and comments, to stdout.",
+ /* [3] */
+ {38, 175, 53, 235}, "More", "-pa", NotSet, "When this option is selected, ANTLR will"
+ " print the grammar, stripped of all acti"
+ "ons and comments, to stdout. It will als"
+ "o annotate the output with the first set"
+ "s determined from grammar analysis."
+ }
+ },
+ /* [2] */
+ NotDependent {
+
+ },
+ TextBox {
+ gray,
+ {28, 15, 60, 250},
+ "Grammar Printing"
+ },
+ /* [3] */
+ NotDependent {
+
+ },
+ RadioButtons {
+ { /* array radioArray: 3 elements */
+ /* [1] */
+ {88, 25, 103, 85}, "Low", "", Set, "When this option is selected, ANTLR will"
+ " show ambiguities/errors in low detail.",
+ /* [2] */
+ {88, 100, 103, 160}, "Medium", "-e2", NotSet, "When this option is selected, ANTLR will"
+ " show ambiguities/errors in more detail.",
+ /* [3] */
+ {88, 175, 103, 235}, "High", "-e3", NotSet, "When this option is selected, ANTLR will"
+ " show ambiguities/errors in excruciating"
+ " detail."
+ }
+ },
+ /* [4] */
+ NotDependent {
+
+ },
+ TextBox {
+ gray,
+ {78, 15, 110, 250},
+ "Error reporting"
+ },
+ /* [5] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {130, 22, 145, 222},
+ "More warnings",
+ "-w2",
+ "If this option is checked, ANTLR will wa"
+ "rn if semantic predicates and/or (É)? bl"
+ "ocks are assumed to cover ambiguous alte"
+ "rnatives."
+ },
+ /* [6] */
+ NotDependent {
+
+ },
+ RegularEntry {
+ "Report when tnode usage exceeds:",
+ {162, 23, 180, 253},
+ {162, 255, 178, 326},
+ "",
+ keepCase,
+ "-treport",
+ "Report when tnode usage exceeds value du"
+ "ring ambiguity resolution."
+ },
+ /* [7] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {40, 292, 55, 431},
+ "Predicate",
+ "-info p",
+ "With the antlr \"-info p\" switch the user"
+ " will receive information about the pred"
+ "icate suppression in the generated file."
+ },
+ /* [8] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {60, 292, 75, 430},
+ "Tree Nodes",
+ "-info t",
+ "Using \"-info t\" gives information about "
+ "the total number of tnodes created and t"
+ "he peak number of tnodes."
+ },
+ /* [9] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {80, 292, 95, 425},
+ "First/follow",
+ "-info f",
+ "first/follow set information."
+ },
+ /* [10] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {100, 292, 115, 425},
+ "Monitor progress",
+ "-info m",
+ "prints name of each rule as it is starte"
+ "d and flushes output at start of each rule."
+ },
+ /* [11] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {120, 292, 135, 416},
+ "Orphan rules",
+ "-info o",
+ "If there is more than one rule which is "
+ "not referenced by any other rule then al"
+ "l such rules are listed."
+ },
+ /* [12] */
+ NotDependent {
+
+ },
+ TextBox {
+ gray,
+ {28, 279, 147, 451},
+ "Extra info"
+ }
+ },
+ /* [4] */
+ 295,
+ "Use this dialog to specify command line "
+ "options relating to renaming output file"
+ "s.",
+ { /* array itemArray: 7 elements */
+ /* [1] */
+ NotDependent {
+
+ },
+ RegularEntry {
+ "Errors file name:",
+ {35, 25, 50, 205},
+ {35, 205, 51, 300},
+ "err.c",
+ keepCase,
+ "-fe",
+ "This entry specifies the name ANTLR uses"
+ " for the errors file."
+ },
+ /* [2] */
+ NotDependent {
+
+ },
+ RegularEntry {
+ "Lexical output name:",
+ {60, 25, 75, 205},
+ {60, 205, 76, 300},
+ "parser.dlg",
+ keepCase,
+ "-fl",
+ "This entry specifies the name ANTLR uses"
+ " for the lexical output file."
+ },
+ /* [3] */
+ NotDependent {
+
+ },
+ RegularEntry {
+ "Lexical modes name:",
+ {85, 25, 100, 205},
+ {85, 205, 101, 300},
+ "mode.h",
+ keepCase,
+ "-fm",
+ "This entry specifies the name ANTLR uses"
+ " for the lexical mode definitions file."
+ },
+ /* [4] */
+ NotDependent {
+
+ },
+ RegularEntry {
+ "Remap file name:",
+ {110, 25, 125, 205},
+ {110, 205, 126, 300},
+ "remap.h",
+ keepCase,
+ "-fr",
+ "This entry specifies the name ANTLR uses"
+ " for the file that remaps globally visib"
+ "le symbols."
+ },
+ /* [5] */
+ NotDependent {
+
+ },
+ RegularEntry {
+ "Tokens file name:",
+ {135, 25, 150, 205},
+ {135, 205, 151, 300},
+ "tokens.h",
+ keepCase,
+ "-ft",
+ "This entry specifies the name ANTLR uses"
+ " for the tokens file."
+ },
+ /* [6] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {160, 25, 175, 175},
+ "Create std header",
+ "-gh",
+ "If this option is checked, ANTLR will cr"
+ "eate a standard header file named, by de"
+ "fault 'stdpccts.h'. This name can be alt"
+ "ered using the entry right next door."
+ },
+ /* [7] */
+ Or {
+ { /* array OrArray: 1 elements */
+ /* [1] */
+ 6
+ }
+ },
+ RegularEntry {
+ "Std header file name:",
+ {160, 175, 175, 355},
+ {160, 355, 176, 450},
+ "stdpccts.h",
+ keepCase,
+ "-fh",
+ "This entry specifies the name ANTLR uses"
+ " for the standard header file."
+ }
+ },
+ /* [5] */
+ 295,
+ "Use this dialog to specify parse options"
+ ".",
+ { /* array itemArray: 9 elements */
+ /* [1] */
+ NotDependent {
+
+ },
+ RegularEntry {
+ "Lookahead:",
+ {23, 27, 38, 152},
+ {46, 29, 62, 154},
+ "1",
+ keepCase,
+ "-k",
+ "This entry specifies the number of token"
+ "s of lookahead."
+ },
+ /* [2] */
+ NotDependent {
+
+ },
+ RegularEntry {
+ "Compr lookahead:",
+ {22, 167, 37, 292},
+ {46, 172, 62, 297},
+ "",
+ keepCase,
+ "-ck",
+ "This entry specifies the number of token"
+ "s of lookahead when using compressed (li"
+ "near approximation) lookahead. In genera"
+ "l, the compressed lookahead is much deep"
+ "er than the full lookahead."
+ },
+ /* [3] */
+ NotDependent {
+
+ },
+ RegularEntry {
+ "Max tree nodes:",
+ {22, 312, 37, 437},
+ {46, 315, 62, 445},
+ "",
+ keepCase,
+ "-rl",
+ "This entry specifies the maximum number "
+ "of tokens of tree nodes used by the gram"
+ "mar analysis."
+ },
+ /* [4] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {76, 25, 91, 350},
+ "Maintenance Release style hoisting",
+ "-mrhoist",
+ "Turn on/off k=1 Maintenance Release styl"
+ "e hoisting."
+ },
+ /* [5] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {96, 25, 111, 431},
+ "EXPERIMENTAL Maintenance Release style h"
+ "oisting",
+ "-mrhoistk",
+ "Turn on/off k>1 EXPERIMENTAL Maintenance"
+ " Release style hoisting."
+ },
+ /* [6] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {116, 25, 131, 363},
+ "Compute context for hoisted predicates",
+ "-prc on",
+ "Turn on/off computation of context for h"
+ "oisted predicates."
+ },
+ /* [7] */
+ NotDependent {
+
+ },
+ RegularEntry {
+ "Ambiguity aid:",
+ {140, 27, 155, 125},
+ {141, 135, 155, 209},
+ "",
+ keepCase,
+ "-aa",
+ "Ambiguity aid for a rule (rule name or l"
+ "ine number)."
+ },
+ /* [8] */
+ NotDependent {
+
+ },
+ RegularEntry {
+ "Limits exp growth:",
+ {140, 236, 155, 361},
+ {139, 372, 155, 452},
+ "",
+ keepCase,
+ "-aad",
+ "Limits exp growth of -aa listing - defau"
+ "lt=1 (max=ck value)."
+ },
+ /* [9] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {164, 26, 179, 366},
+ "Lookahead token may appear multiple time"
+ "s",
+ "-aam",
+ "Lookahead token may appear multiple time"
+ "s in -aa listing."
+ }
+ }
+ }
+};
+
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr1.txt b/BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr1.txt new file mode 100644 index 0000000000..4a7d22e7f2 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr1.txt @@ -0,0 +1,264 @@ +
+
+
+ANTLR(1) PCCTS Manual Pages ANTLR(1)
+
+
+
+NAME
+ antlr - ANother Tool for Language Recognition
+
+SYNTAX
+ antlr [_o_p_t_i_o_n_s] _g_r_a_m_m_a_r__f_i_l_e_s
+
+DESCRIPTION
+ _A_n_t_l_r converts an extended form of context-free grammar into
+ a set of C functions which directly implement an efficient
+ form of deterministic recursive-descent LL(k) parser.
+ Context-free grammars may be augmented with predicates to
+ allow semantics to influence parsing; this allows a form of
+ context-sensitive parsing. Selective backtracking is also
+ available to handle non-LL(k) and even non-LALR(k) con-
+ structs. _A_n_t_l_r also produces a definition of a lexer which
+ can be automatically converted into C code for a DFA-based
+ lexer by _d_l_g. Hence, _a_n_t_l_r serves a function much like that
+ of _y_a_c_c, however, it is notably more flexible and is more
+ integrated with a lexer generator (_a_n_t_l_r directly generates
+ _d_l_g code, whereas _y_a_c_c and _l_e_x are given independent
+ descriptions). Unlike _y_a_c_c which accepts LALR(1) grammars,
+ _a_n_t_l_r accepts LL(k) grammars in an extended BNF notation -
+ which eliminates the need for precedence rules.
+
+ Like _y_a_c_c grammars, _a_n_t_l_r grammars can use automatically-
+ maintained symbol attribute values referenced as dollar
+ variables. Further, because _a_n_t_l_r generates top-down
+ parsers, arbitrary values may be inherited from parent rules
+ (passed like function parameters). _A_n_t_l_r also has a mechan-
+ ism for creating and manipulating abstract-syntax-trees.
+
+ There are various other niceties in _a_n_t_l_r, including the
+ ability to spread one grammar over multiple files or even
+ multiple grammars in a single file, the ability to generate
+ a version of the grammar with actions stripped out (for
+ documentation purposes), and lots more.
+
+OPTIONS
+ -ck _n
+ Use up to _n symbols of lookahead when using compressed
+ (linear approximation) lookahead. This type of looka-
+ head is very cheap to compute and is attempted before
+ full LL(k) lookahead, which is of exponential complex-
+ ity in the worst case. In general, the compressed loo-
+ kahead can be much deeper (e.g, -ck 10) _t_h_a_n _t_h_e _f_u_l_l
+ _l_o_o_k_a_h_e_a_d (_w_h_i_c_h _u_s_u_a_l_l_y _m_u_s_t _b_e _l_e_s_s _t_h_a_n _4).
+
+ -CC Generate C++ output from both ANTLR and DLG.
+
+ -cr Generate a cross-reference for all rules. For each
+ rule, print a list of all other rules that reference
+ it.
+
+ -e1 Ambiguities/errors shown in low detail (default).
+
+ -e2 Ambiguities/errors shown in more detail.
+
+ -e3 Ambiguities/errors shown in excruciating detail.
+
+ -fe file
+ Rename err.c to file.
+
+ -fh file
+ Rename stdpccts.h header (turns on -gh) to file.
+
+ -fl file
+ Rename lexical output, parser.dlg, to file.
+
+ -fm file
+ Rename file with lexical mode definitions, mode.h, to
+ file.
+
+ -fr file
+ Rename file which remaps globally visible symbols,
+ remap.h, to file.
+
+ -ft file
+ Rename tokens.h to file.
+
+ -ga Generate ANSI-compatible code (default case). This has
+ not been rigorously tested to be ANSI XJ11 C compliant,
+ but it is close. The normal output of _a_n_t_l_r is
+ currently compilable under both K&R, ANSI C, and C++-
+ this option does nothing because _a_n_t_l_r generates a
+ bunch of #ifdef's to do the right thing depending on
+ the language.
+
+ -gc Indicates that _a_n_t_l_r should generate no C code, i.e.,
+ only perform analysis on the grammar.
+
+ -gd C code is inserted in each of the _a_n_t_l_r generated pars-
+ ing functions to provide for user-defined handling of a
+ detailed parse trace. The inserted code consists of
+ calls to the user-supplied macros or functions called
+ zzTRACEIN and zzTRACEOUT. The only argument is a _c_h_a_r
+ * pointing to a C-style string which is the grammar
+ rule recognized by the current parsing function. If no
+ definition is given for the trace functions, upon rule
+ entry and exit, a message will be printed indicating
+ that a particular rule as been entered or exited.
+
+ -ge Generate an error class for each non-terminal.
+
+ -gh Generate stdpccts.h for non-ANTLR-generated files to
+ include. This file contains all defines needed to
+ describe the type of parser generated by _a_n_t_l_r (e.g.
+ how much lookahead is used and whether or not trees are
+ constructed) and contains the header action specified
+ by the user.
+
+ -gk Generate parsers that delay lookahead fetches until
+ needed. Without this option, _a_n_t_l_r generates parsers
+ which always have _k tokens of lookahead available.
+
+ -gl Generate line info about grammar actions in C parser of
+ the form # _l_i_n_e "_f_i_l_e" which makes error messages from
+ the C/C++ compiler make more sense as they will point
+ into the grammar file not the resulting C file.
+ Debugging is easier as well, because you will step
+ through the grammar not C file.
+
+ -gs Do not generate sets for token expression lists;
+ instead generate a ||-separated sequence of
+ LA(1)==_t_o_k_e_n__n_u_m_b_e_r. The default is to generate sets.
+
+ -gt Generate code for Abstract-Syntax Trees.
+
+ -gx Do not create the lexical analyzer files (dlg-related).
+ This option should be given when the user wishes to
+ provide a customized lexical analyzer. It may also be
+ used in _m_a_k_e scripts to cause only the parser to be
+ rebuilt when a change not affecting the lexical struc-
+ ture is made to the input grammars.
+
+ -k _n Set k of LL(k) to _n; i.e. set tokens of look-ahead
+ (default==1).
+
+ -o dir
+ Directory where output files should go (default=".").
+ This is very nice for keeping the source directory
+ clear of ANTLR and DLG spawn.
+
+ -p The complete grammar, collected from all input grammar
+ files and stripped of all comments and embedded
+ actions, is listed to stdout. This is intended to aid
+ in viewing the entire grammar as a whole and to elim-
+ inate the need to keep actions concisely stated so that
+ the grammar is easier to read. Hence, it is preferable
+ to embed even complex actions directly in the grammar,
+ rather than to call them as subroutines, since the sub-
+ routine call overhead will be saved.
+
+ -pa This option is the same as -p except that the output is
+ annotated with the first sets determined from grammar
+ analysis.
+
+ -prc on
+ Turn on the computation and hoisting of predicate con-
+ text.
+
+ -prc off
+ Turn off the computation and hoisting of predicate con-
+ text. This option makes 1.10 behave like the 1.06
+ release with option -pr on. Context computation is off
+ by default.
+
+ -rl _n
+ Limit the maximum number of tree nodes used by grammar
+ analysis to _n. Occasionally, _a_n_t_l_r is unable to
+ analyze a grammar submitted by the user. This rare
+ situation can only occur when the grammar is large and
+ the amount of lookahead is greater than one. A non-
+ linear analysis algorithm is used by PCCTS to handle
+ the general case of LL(k) parsing. The average com-
+ plexity of analysis, however, is near linear due to
+ some fancy footwork in the implementation which reduces
+ the number of calls to the full LL(k) algorithm. An
+ error message will be displayed, if this limit is
+ reached, which indicates the grammar construct being
+ analyzed when _a_n_t_l_r hit a non-linearity. Use this
+ option if _a_n_t_l_r seems to go out to lunch and your disk
+ start thrashing; try _n=10000 to start. Once the
+ offending construct has been identified, try to remove
+ the ambiguity that _a_n_t_l_r was trying to overcome with
+ large lookahead analysis. The introduction of (...)?
+ backtracking blocks eliminates some of these problems -
+ _a_n_t_l_r does not analyze alternatives that begin with
+ (...)? (it simply backtracks, if necessary, at run
+ time).
+
+ -w1 Set low warning level. Do not warn if semantic
+ predicates and/or (...)? blocks are assumed to cover
+ ambiguous alternatives.
+
+ -w2 Ambiguous parsing decisions yield warnings even if
+ semantic predicates or (...)? blocks are used. Warn if
+ predicate context computed and semantic predicates
+ incompletely disambiguate alternative productions.
+
+ - Read grammar from standard input and generate stdin.c
+ as the parser file.
+
+SPECIAL CONSIDERATIONS
+ _A_n_t_l_r works... we think. There is no implicit guarantee of
+ anything. We reserve no legal rights to the software known
+ as the Purdue Compiler Construction Tool Set (PCCTS) - PCCTS
+ is in the public domain. An individual or company may do
+ whatever they wish with source code distributed with PCCTS
+ or the code generated by PCCTS, including the incorporation
+ of PCCTS, or its output, into commercial software. We
+ encourage users to develop software with PCCTS. However, we
+ do ask that credit is given to us for developing PCCTS. By
+ "credit", we mean that if you incorporate our source code
+ into one of your programs (commercial product, research pro-
+ ject, or otherwise) that you acknowledge this fact somewhere
+ in the documentation, research report, etc... If you like
+ PCCTS and have developed a nice tool with the output, please
+ mention that you developed it using PCCTS. As long as these
+ guidelines are followed, we expect to continue enhancing
+ this system and expect to make other tools available as they
+ are completed.
+
+FILES
+ *.c output C parser.
+
+ *.cpp
+ output C++ parser when C++ mode is used.
+
+ parser.dlg
+ output _d_l_g lexical analyzer.
+
+ err.c
+ token string array, error sets and error support rou-
+ tines. Not used in C++ mode.
+
+ remap.h
+ file that redefines all globally visible parser sym-
+ bols. The use of the #parser directive creates this
+ file. Not used in C++ mode.
+
+ stdpccts.h
+ list of definitions needed by C files, not generated by
+ PCCTS, that reference PCCTS objects. This is not gen-
+ erated by default. Not used in C++ mode.
+
+ tokens.h
+ output #_d_e_f_i_n_e_s for tokens used and function prototypes
+ for functions generated for rules.
+
+
+SEE ALSO
+ dlg(1), pccts(1)
+
+
+
+
+
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/bits.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/bits.c new file mode 100644 index 0000000000..ddd9bd6053 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/bits.c @@ -0,0 +1,1025 @@ +/* bits.c -- manage creation and output of bit sets used by the parser.
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2001
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <assert.h>
+#include "pcctscfg.h"
+#include "set.h"
+#include "syn.h"
+#include "hash.h"
+#include "generic.h"
+#include "dlgdef.h"
+
+/* char is only thing that is pretty much always known == 8 bits
+ * This allows output of antlr (set stuff, anyway) to be androgynous (portable)
+ */
+typedef unsigned char SetWordType;
+#define BitsPerByte 8
+#define BitsPerWord BitsPerByte*sizeof(SetWordType)
+
+static SetWordType *setwd = NULL;
+int setnum = -1;
+int wordnum = 0;
+
+int esetnum = 0;
+
+/* Used to convert native wordsize, which ANTLR uses (via set.c) to manipulate sets,
+ to bytes that are most portable size-wise.
+ */
+void
+#ifdef __USE_PROTOS
+DumpIntAsChars( FILE *f, char *format, unsigned wd )
+#else
+DumpIntAsChars( f, format, wd )
+FILE *f;
+char *format;
+unsigned wd;
+#endif
+{
+ int i;
+ /* uses max of 32 bit unsigned integer for the moment */
+ static unsigned long byte_mask[sizeof(unsigned long)] =
+ { 0xFF, 0xFF00UL, 0xFF0000UL, 0xFF000000UL }; /* MR20 G. Hobbelt */
+/* 0xFF00000000, 0xFF0000000000, 0xFF000000000000, 0xFF00000000000000 };*/
+
+ /* for each byte in the word */
+ assert(sizeof(unsigned) <= 4); /* M20 G. Hobbelt Sanity check */
+ for (i=0; i<sizeof(unsigned); i++)
+ {
+ /* mask out the ith byte and shift down to the first 8 bits */
+ fprintf(f, format, (wd&byte_mask[i])>>(i*BitsPerByte));
+ if ( i<sizeof(unsigned)-1) fprintf(f, ",");
+ }
+}
+
+/* Create a new setwd (ignoring [Ep] token on end) */
+void
+#ifdef __USE_PROTOS
+NewSetWd( void )
+#else
+NewSetWd( )
+#endif
+{
+ SetWordType *p;
+
+ if ( setwd == NULL )
+ {
+ setwd = (SetWordType *) calloc(TokenNum, sizeof(SetWordType));
+ require(setwd!=NULL, "NewSetWd: cannot alloc set wd\n");
+ }
+ for (p = setwd; p<&(setwd[TokenNum]); p++) {*p=0;}
+ wordnum++;
+}
+
+void
+#ifdef __USE_PROTOS
+DumpSetWd( void )
+#else
+DumpSetWd( )
+#endif
+{
+ if ( GenCC ) DumpSetWdForCC();
+ else DumpSetWdForC();
+}
+
+/* Dump the current setwd to ErrFile. 0..MaxTokenVal */
+void
+#ifdef __USE_PROTOS
+DumpSetWdForC( void )
+#else
+DumpSetWdForC( )
+#endif
+{
+ int i,c=1;
+
+ if ( setwd==NULL ) return;
+ fprintf(DefFile, "extern SetWordType setwd%d[];\n", wordnum);
+ fprintf(ErrFile,
+ "SetWordType setwd%d[%d] = {", wordnum, TokenNum-1);
+ for (i=0; i<TokenNum-1; i++)
+ {
+ DAWDLE;
+ if ( i!=0 ) fprintf(ErrFile, ",");
+ if ( c == 8 ) {fprintf(ErrFile, "\n\t"); c=1;} else c++;
+ fprintf(ErrFile, "0x%x", setwd[i]);
+ }
+ fprintf(ErrFile, "};\n");
+}
+
+/* Dump the current setwd to Parser.C file. 0..MaxTokenVal;
+ * Only used if -CC on.
+ */
+void
+#ifdef __USE_PROTOS
+DumpSetWdForCC( void )
+#else
+DumpSetWdForCC( )
+#endif
+{
+ int i,c=1;
+
+ if ( setwd==NULL ) return;
+ fprintf(Parser_h, "\tstatic SetWordType setwd%d[%d];\n", wordnum, TokenNum-1);
+ fprintf(Parser_c,
+ "SetWordType %s::setwd%d[%d] = {", CurrentClassName, wordnum,
+ TokenNum-1);
+ for (i=0; i<TokenNum-1; i++)
+ {
+ DAWDLE;
+ if ( i!=0 ) fprintf(Parser_c, ",");
+ if ( c == 8 ) {fprintf(Parser_c, "\n\t"); c=1;} else c++;
+ fprintf(Parser_c, "0x%x", setwd[i]);
+ }
+ fprintf(Parser_c, "};\n");
+}
+
+/* Make a new set. Dump old setwd and create new setwd if current setwd is full */
+void
+#ifdef __USE_PROTOS
+NewSet( void )
+#else
+NewSet( )
+#endif
+{
+ setnum++;
+ if ( setnum==BitsPerWord ) /* is current setwd full? */
+ {
+ DumpSetWd(); NewSetWd(); setnum = 0;
+ }
+}
+
+/* s is a set of tokens. Turn on bit at each token position in set 'setnum' */
+void
+#ifdef __USE_PROTOS
+FillSet( set s )
+#else
+FillSet( s )
+set s;
+#endif
+{
+ SetWordType mask=(((unsigned)1)<<setnum);
+ unsigned int e;
+
+ while ( !set_nil(s) )
+ {
+ e = set_int(s);
+ set_rm(e, s);
+ setwd[e] |= mask;
+ }
+}
+
+ /* E r r o r C l a s s S t u f f */
+
+/* compute the FIRST of a rule for the error class stuff */
+static set
+#ifdef __USE_PROTOS
+Efirst( char *rule, ECnode *eclass )
+#else
+Efirst( rule, eclass )
+char *rule;
+ECnode *eclass;
+#endif
+{
+ set rk, a;
+ Junction *r;
+ RuleEntry *q = (RuleEntry *) hash_get(Rname, rule);
+
+ if ( q == NULL )
+ {
+ warnNoFL(eMsg2("undefined rule '%s' referenced in errclass '%s'; ignored",
+ rule, TokenString(eclass->tok)));
+ return empty;
+ }
+ r = RulePtr[q->rulenum];
+ r->end->halt = TRUE; /* don't let reach fall off end of rule here */
+ rk = empty;
+ REACH(r, 1, &rk, a);
+ r->end->halt = FALSE;
+ return a;
+}
+
+/*
+ * scan the list of tokens/eclasses/nonterminals filling the new eclass
+ * with the set described by the list. Note that an eclass can be
+ * quoted to allow spaces etc... However, an eclass must not conflict
+ * with a reg expr found elsewhere. The reg expr will be taken over
+ * the eclass name.
+ */
+static void
+#ifdef __USE_PROTOS
+doEclass( char *eclass )
+#else
+doEclass( eclass )
+char *eclass;
+#endif
+{
+ TermEntry *q;
+ ECnode *p;
+ TCnode *tcnode;
+ ListNode *e;
+ unsigned int t;
+ unsigned deg=0;
+ set a;
+ require(eclass!=NULL, "doEclass: NULL eset");
+
+ p = (ECnode *) eclass;
+ lexmode(p->lexclass); /* switch to lexclass where errclass is defined */
+ p->eset = empty;
+ for (e = (p->elist)->next; e!=NULL; e=e->next)
+ {
+ q = NULL; /* MR23 */
+
+ if ( islower( *((char *)e->elem) ) ) /* is it a rule ref? (alias FIRST request) */
+ {
+ a = Efirst((char *)e->elem, p);
+ set_orin(&p->eset, a);
+ deg += set_deg(a);
+ set_free( a );
+ continue;
+ }
+ else if ( *((char *)e->elem)=='"' )
+ {
+ t = 0;
+ q = (TermEntry *) hash_get(Texpr, (char *) e->elem);
+ if ( q == NULL )
+ {
+ /* if quoted and not an expr look for eclass name */
+ q = (TermEntry *) hash_get(Tname, *((char **)&(e->elem))=StripQuotes((char *)e->elem));
+ if ( q != NULL ) t = q->token;
+ }
+ else t = q->token;
+ }
+ else /* labelled token/eclass/tokclass */
+ {
+ q = (TermEntry *) hash_get(Tname, (char *)e->elem);
+ if ( q != NULL )
+ {
+ if ( strcmp((char *)e->elem, TokenString(p->tok))==0 )
+ {
+ warnNoFL(eMsg1("self-referential error class '%s'; ignored",
+ (char *)e->elem));
+ continue;
+ }
+ else
+ t = q->token;
+ }
+ else t=0;
+ }
+ if ( t!=0 )
+ {
+ if (isTermEntryTokClass(q)) { /* MR23 */
+ tcnode = q->tclass; /* MR23 */
+ set_orin(&p->eset, tcnode->tset); /* MR23 */
+ deg = set_deg(p->eset); /* MR23 */
+ } /* MR23 */
+ else {
+ set_orel(t, &p->eset);
+ deg++;
+ }
+ }
+ else warnNoFL(eMsg2("undefined token '%s' referenced in errclass '%s'; ignored",
+ (char *)e->elem, TokenString(p->tok)));
+ }
+ p->setdeg = deg;
+}
+
+void
+#ifdef __USE_PROTOS
+ComputeErrorSets( void )
+#else
+ComputeErrorSets( )
+#endif
+{
+#ifdef __cplusplus
+ list_apply(eclasses, (void (*)(void *)) doEclass);
+#else
+#ifdef __USE_PROTOS
+ list_apply(eclasses, (void (*)(void *)) doEclass);
+#else
+ list_apply(eclasses, doEclass);
+#endif
+#endif
+}
+
+void
+#ifdef __USE_PROTOS
+ComputeTokSets( void )
+#else
+ComputeTokSets( )
+#endif
+{
+ ListNode *t, *e = NULL, *e1, *e2;
+ int something_changed;
+ int i;
+ TCnode *p;
+ TermEntry *q, *q1, *q2;
+
+ if ( tclasses == NULL ) return;
+
+ /* turn lists of token/tokclass references into sets */
+ for (t = tclasses->next; t!=NULL; t=t->next)
+ {
+ p = (TCnode *) t->elem;
+
+ /* if wild card, then won't have entries in tclass, assume all_tokens */
+ if ( p->tok == WildCardToken )
+ {
+ p->tset = set_dup(all_tokens);
+ continue;
+ }
+
+ lexmode(p->lexclass); /* switch to lexclass where tokclass is defined */
+ p->tset = empty;
+
+ /* instantiate all tokens/token_classes into the tset */
+ for (e = (p->tlist)->next; e!=NULL; e=e->next)
+ {
+ char *tokstr;
+ tokstr = (char *)e->elem;
+ if ( *tokstr == '"' ) {
+ q = (TermEntry *) hash_get(Texpr, tokstr);
+ require(q!=NULL, "ComputeTokSets: no token def");
+ set_orel(q->token, &p->tset);
+ } else if (tokstr[0] == '.') {
+ e1=e->next;
+ e2=e1->next;
+ e=e2;
+ q1= (TermEntry *) hash_get(Tname, (char *)e1->elem);
+ require(q1!=NULL, "ComputeTokSets: no token def");
+ q2= (TermEntry *) hash_get(Tname, (char *)e2->elem);
+ require(q2!=NULL, "ComputeTokSets: no token def");
+
+ if (set_el(q1->token,imag_tokens)) {
+errNoFL(eMsg2("can't define #tokclass %s using #tokclass or #errclass %s",
+ TokenString(p->tok),(char *)e1->elem) );
+ }
+ if (set_el(q2->token,imag_tokens)) {
+errNoFL(eMsg2("can't define #tokclass %s using #tokclass or #errclass %s",
+ TokenString(p->tok),(char *)e2->elem) );
+ }
+ if (q1->token > q2->token) {
+errNoFL(eMsg3("for #tokclass %s %s..%s - first token number > second token number",
+ TokenString(p->tok),(char *)e1->elem,(char *)e2->elem) );
+ for (i=q2->token; i<=q1->token; i++) { set_orel(i, &p->tset); }
+ } else {
+ for (i=q1->token; i<=q2->token; i++) { set_orel(i, &p->tset); }
+ }
+ } else {
+ q = (TermEntry *) hash_get(Tname, tokstr);
+ require(q!=NULL, "ComputeTokSets: no token def");
+ set_orel(q->token, &p->tset);
+ }
+ }
+ }
+
+ /* Go thru list of tokclasses again looking for tokclasses in sets */
+again:
+ something_changed = 0;
+ for (t = tclasses->next; t!=NULL; t=t->next)
+ {
+ set tcl;
+ p = (TCnode *) t->elem;
+ tcl = set_and(p->tset, tokclasses);
+ if ( !set_nil(tcl) )
+ {
+ int tk;
+ /* replace refs to tokclasses with the associated set of tokens */
+ something_changed = 1;
+ while ( !set_nil(tcl) )
+ {
+ tk = set_int(tcl); /* grab one of the tok class refs */
+ set_rm(tk, tcl);
+ if ( p->tok != tk ) /* tokclass ref to yourself? */
+ {
+ q = (TermEntry *) hash_get(Tname, TokenString(tk));
+ require(q!=NULL, "#tokclass not in hash table");
+ set_orin(&p->tset, q->tclass->tset);
+ }
+ set_rm(tk, p->tset); /* remove ref that we replaced */
+ }
+ }
+ set_free(tcl);
+ }
+ if ( something_changed ) goto again;
+}
+
+void
+#ifdef __USE_PROTOS
+DumpRemainingTokSets(void)
+#else
+DumpRemainingTokSets()
+#endif
+{
+ TCnode *p;
+ ListNode *t;
+
+ /* Go thru tclasses (for the last time) and dump the sets not dumped
+ * during code gen; yes, this is a bogus way to do this, but ComputeTokSets()
+ * can't dump the defs as the error file and tok file has not been created
+ * yet etc...
+ */
+ if ( tclasses==NULL ) return;
+ for (t = tclasses->next; t!=NULL; t=t->next)
+ {
+ unsigned e;
+ p = (TCnode *) t->elem;
+ if ( p->dumped ) continue;
+ e = DefErrSet(&(p->tset), 0, TokenString(p->tok));
+ p->dumped = 1;
+ p->setnum = e;
+ }
+}
+
+
+/* replace a subset of an error set with an error class name if a subset is found
+ * repeat process until no replacements made
+ */
+void
+#ifdef __USE_PROTOS
+SubstErrorClass( set *f )
+#else
+SubstErrorClass( f )
+set *f;
+#endif
+{
+ int max, done = 0;
+ ListNode *p;
+ ECnode *ec, *maxclass = NULL;
+ set a;
+ require(f!=NULL, "SubstErrorClass: NULL eset");
+
+ if ( eclasses == NULL ) return;
+ while ( !done )
+ {
+ max = 0;
+ maxclass = NULL;
+ for (p=eclasses->next; p!=NULL; p=p->next) /* chk all error classes */
+ {
+ ec = (ECnode *) p->elem;
+ if ( ec->setdeg > max )
+ {
+ if ( set_sub(ec->eset, *f) || set_equ(ec->eset, *f) )
+ {maxclass = ec; max=ec->setdeg;}
+ }
+ }
+ if ( maxclass != NULL ) /* if subset found, replace with token */
+ {
+ a = set_dif(*f, maxclass->eset);
+ set_orel((unsigned)maxclass->tok, &a);
+ set_free(*f);
+ *f = a;
+ }
+ else done = 1;
+ }
+}
+
+int
+#ifdef __USE_PROTOS
+DefErrSet1(int nilOK, set *f, int subst, char *name )
+#else
+DefErrSet1(nilOK, f, subst, name )
+int nilOK;
+set *f;
+int subst; /* should be substitute error classes? */
+char *name;
+#endif
+{
+ if ( GenCC ) return DefErrSetForCC1(nilOK, f, subst, name, "_set");
+ else return DefErrSetForC1(nilOK, f, subst, name, "_set");
+}
+
+int
+#ifdef __USE_PROTOS
+DefErrSet( set *f, int subst, char *name )
+#else
+DefErrSet( f, subst, name )
+set *f;
+int subst; /* should be substitute error classes? */
+char *name;
+#endif
+{
+ return DefErrSet1(0,f,subst,name);
+}
+
+int
+#ifdef __USE_PROTOS
+DefErrSetWithSuffix(int nilOK, set *f, int subst, char *name, const char* suffix)
+#else
+DefErrSetWithSuffix(nilOK, f, subst, name, suffix )
+int nilOK;
+set *f;
+int subst; /* should be substitute error classes? */
+char *name;
+char *suffix;
+#endif
+{
+ if ( GenCC ) return DefErrSetForCC1(nilOK, f, subst, name, suffix );
+ else return DefErrSetForC1(nilOK, f, subst, name, suffix);
+}
+
+/* Define a new error set. WARNING...set-implementation dependent.
+ */
+int
+#ifdef __USE_PROTOS
+DefErrSetForC1(int nilOK, set *f, int subst, char * name, const char * suffix)
+#else
+DefErrSetForC1(nilOK, f, subst, name, suffix)
+int nilOK; /* MR13 */
+set *f;
+int subst; /* should be substitute error classes? */
+char *name;
+const char *suffix;
+#endif
+{
+ unsigned *p, *endp;
+ int e=1;
+
+ if (!nilOK) require(!set_nil(*f), "DefErrSetForC1: nil set to dump?");
+
+ if ( subst ) SubstErrorClass(f);
+ p = f->setword;
+ endp = &(f->setword[f->n]);
+ esetnum++;
+ if ( name!=NULL )
+ fprintf(DefFile, "extern SetWordType %s%s[];\n", name, suffix);
+ else
+ fprintf(DefFile, "extern SetWordType zzerr%d[];\n", esetnum);
+ if ( name!=NULL ) {
+ fprintf(ErrFile, "SetWordType %s%s[%d] = {",
+ name,
+ suffix,
+ NumWords(TokenNum-1)*sizeof(unsigned));
+ }
+ else {
+ fprintf(ErrFile, "SetWordType zzerr%d[%d] = {",
+ esetnum,
+ NumWords(TokenNum-1)*sizeof(unsigned));
+ }
+ while ( p < endp )
+ {
+ if ( e > 1 ) fprintf(ErrFile, ", ");
+ DumpIntAsChars(ErrFile, "0x%x", *p++);
+ if ( e == 3 )
+ {
+ DAWDLE;
+ if ( p < endp ) fprintf(ErrFile, ",");
+ fprintf(ErrFile, "\n\t");
+ e=1;
+ }
+ else e++;
+ }
+ fprintf(ErrFile, "};\n");
+
+ return esetnum;
+}
+
+int
+#ifdef __USE_PROTOS
+DefErrSetForC( set *f, int subst, char *name )
+#else
+DefErrSetForC( f, subst, name )
+set *f;
+int subst; /* should be substitute error classes? */
+char *name;
+#endif
+{
+ return DefErrSetForC1(0,f,subst,name, "_set");
+}
+
+/* Define a new error set. WARNING...set-implementation dependent;
+ * Only used when -CC on.
+ */
+
+int
+#ifdef __USE_PROTOS
+DefErrSetForCC1(int nilOK, set *f, int subst, char *name, const char *suffix )
+#else
+DefErrSetForCC1(nilOK, f, subst, name, suffix )
+int nilOK; /* MR13 */
+set *f;
+int subst; /* should be substitute error classes? */
+char *name;
+const char *suffix;
+#endif
+{
+ unsigned *p, *endp;
+ int e=1;
+
+ if (!nilOK) require(!set_nil(*f), "DefErrSetForCC1: nil set to dump?");
+
+ if ( subst ) SubstErrorClass(f);
+ p = f->setword;
+ endp = &(f->setword[f->n]);
+ esetnum++;
+
+ if ( name!=NULL ) {
+ fprintf(Parser_h, "\tstatic SetWordType %s%s[%d];\n", name, suffix,
+ NumWords(TokenNum-1)*sizeof(unsigned));
+ fprintf(Parser_c, "SetWordType %s::%s%s[%d] = {",
+ CurrentClassName,
+ name,
+ suffix,
+ NumWords(TokenNum-1)*sizeof(unsigned));
+ }
+ else {
+ fprintf(Parser_c, "SetWordType %s::err%d[%d] = {",
+ CurrentClassName,
+ esetnum,
+ NumWords(TokenNum-1)*sizeof(unsigned));
+ fprintf(Parser_h, "\tstatic SetWordType err%d[%d];\n", esetnum,
+ NumWords(TokenNum-1)*sizeof(unsigned));
+ }
+
+ while ( p < endp )
+ {
+ if ( e > 1 ) fprintf(Parser_c, ", ");
+ DumpIntAsChars(Parser_c, "0x%x", *p++);
+ if ( e == 3 )
+ {
+ if ( p < endp ) fprintf(Parser_c, ",");
+ fprintf(Parser_c, "\n\t");
+ e=1;
+ }
+ else e++;
+ }
+ fprintf(Parser_c, "};\n");
+
+ return esetnum;
+}
+
+int
+#ifdef __USE_PROTOS
+DefErrSetForCC( set *f, int subst, char *name )
+#else
+DefErrSetForCC( f, subst, name )
+set *f;
+int subst; /* should be substitute error classes? */
+char *name;
+#endif
+{
+ return DefErrSetForCC1(0,f,subst,name, "_set");
+}
+
+void
+#ifdef __USE_PROTOS
+GenParser_c_Hdr(void)
+#else
+GenParser_c_Hdr()
+#endif
+{
+ int i,j;
+ TermEntry *te;
+ char * hasAkaName = NULL; /* MR23 */
+
+ hasAkaName = (char *) malloc(TokenNum+1); /* MR23 */
+ require(hasAkaName!=NULL, "Cannot alloc hasAkaName\n"); /* MR23 */
+ for (i = 0; i < TokenNum; i++) hasAkaName[i]='0'; /* MR23 */
+ hasAkaName[TokenNum] = 0; /* MR23 */
+
+ fprintf(Parser_c, "/*\n");
+ fprintf(Parser_c, " * %s: P a r s e r S u p p o r t\n", CurrentClassName);
+ fprintf(Parser_c, " *\n");
+ fprintf(Parser_c, " * Generated from:");
+ for (i=0; i<NumFiles; i++) fprintf(Parser_c, " %s", FileStr[i]);
+ fprintf(Parser_c, "\n");
+ fprintf(Parser_c, " *\n");
+ fprintf(Parser_c, " * Terence Parr, Russell Quong, Will Cohen, and Hank Dietz: 1989-2001\n");
+ fprintf(Parser_c, " * Parr Research Corporation\n");
+ fprintf(Parser_c, " * with Purdue University Electrical Engineering\n");
+ fprintf(Parser_c, " * with AHPCRC, University of Minnesota\n");
+ fprintf(Parser_c, " * ANTLR Version %s\n", Version);
+ fprintf(Parser_c, " */\n\n");
+
+ if ( FirstAction != NULL ) dumpAction(FirstAction,Parser_c, 0, -1, 0, 1); /* MR11 MR15b */
+
+ fprintf(Parser_c, "#define ANTLR_VERSION %s\n", VersionDef);
+
+ fprintf(Parser_c, "#include \"pcctscfg.h\"\n");
+ fprintf(Parser_c, "#include \"pccts_stdio.h\"\n");
+ fprintf(Parser_c, "#define ANTLR_SUPPORT_CODE\n");
+ if ( UserTokenDefsFile != NULL )
+ fprintf(Parser_c, "#include %s\n", UserTokenDefsFile);
+ else
+ fprintf(Parser_c, "#include \"%s\"\n", DefFileName);
+
+ fprintf(Parser_c, "#include \"%s.h\"\n\n", CurrentClassName);
+
+ fprintf(Parser_c, "const ANTLRChar *%s::tokenName(int tok) ", /* MR1 */
+ CurrentClassName); /* MR1 */
+ fprintf(Parser_c, " { return _token_tbl[tok]; }\n"); /* MR1 */ /* MR10 */
+ /* Dump a Parser::tokens for each automaton */
+ fprintf(Parser_c, "\nconst ANTLRChar *%s::_token_tbl[]={\n",
+ CurrentClassName); /* MR20 */
+ fprintf(Parser_c, "\t/* 00 */\t\"Invalid\"");
+
+ for (i=1; i<TokenNum-1; i++)
+ {
+ DAWDLE;
+ if ( i == EpToken ) continue;
+ /* remapped to invalid token? */
+ if ( TokenInd!=NULL && TokenInd[i]>=LastTokenCounted )
+ {
+ fprintf(Parser_c, ",\n\t/* %02d */\t\"invalid\"", i);
+ continue;
+ }
+ if ( TokenString(i) != NULL ) {
+ te=(TermEntry *) hash_get(Tname,TokenString(i)); /* MR11 */
+ if (te == NULL || te->akaString == NULL) { /* MR11 */
+ fprintf(Parser_c, ",\n\t/* %02d */\t\"%s\"", i, TokenString(i));
+ } else {
+ hasAkaName[i] = '1'; /* MR23 */
+ fprintf(Parser_c, ",\n\t/* %02d */\t\"%s\"", i, te->akaString); /* MR11 */
+ }
+ }
+ else
+ {
+ /* look in all lexclasses for the reg expr */
+ for (j=0; j<NumLexClasses; j++)
+ {
+ lexmode(j);
+ if ( ExprString(i) != NULL )
+ {
+ fprintf(Parser_c, ",\n\t/* %02d */\t", i);
+ dumpExpr(Parser_c, ExprString(i));
+ break;
+ }
+ }
+ if ( j>=NumLexClasses )
+ {
+ if ( UserDefdTokens )
+ {
+ fprintf(Parser_c, ",\n\t/* %02d */\t\"\"", i);
+ }
+ else
+ fatal_internal(eMsgd("No label or expr for token %d",i));
+ }
+ }
+ }
+ fprintf(Parser_c, "\n};\n");
+
+ /* Build constructors */
+ fprintf(Parser_c, "\n%s::", CurrentClassName);
+ fprintf(Parser_c, "%s(ANTLRTokenBuffer *input) : %s(input,%d,%d,%d,%d)\n",
+ CurrentClassName,
+ (BaseClassName == NULL ? "ANTLRParser" : BaseClassName),
+ OutputLL_k,
+ FoundGuessBlk,
+ DemandLookahead,
+ NumWords(TokenNum-1)*sizeof(unsigned));
+ fprintf(Parser_c, "{\n");
+ fprintf(Parser_c, "\ttoken_tbl = _token_tbl;\n");
+ if (TraceGen) {
+ fprintf(Parser_c, "\ttraceOptionValueDefault=1;\t\t// MR10 turn trace ON\n");
+ } else {
+ fprintf(Parser_c, "\ttraceOptionValueDefault=0;\t\t// MR10 turn trace OFF\n");
+ };
+ fprintf(Parser_c, "}\n\n");
+ free ( (void *) hasAkaName);
+}
+
+void
+#ifdef __USE_PROTOS
+GenParser_h_Hdr(void)
+#else
+GenParser_h_Hdr()
+#endif
+{
+ int i;
+
+ fprintf(Parser_h, "/*\n");
+ fprintf(Parser_h, " * %s: P a r s e r H e a d e r \n", CurrentClassName);
+ fprintf(Parser_h, " *\n");
+ fprintf(Parser_h, " * Generated from:");
+ for (i=0; i<NumFiles; i++) fprintf(Parser_h, " %s", FileStr[i]);
+ fprintf(Parser_h, "\n");
+ fprintf(Parser_h, " *\n");
+ fprintf(Parser_h, " * Terence Parr, Russell Quong, Will Cohen, and Hank Dietz: 1989-2001\n");
+ fprintf(Parser_h, " * Parr Research Corporation\n");
+ fprintf(Parser_h, " * with Purdue University Electrical Engineering\n");
+ fprintf(Parser_h, " * with AHPCRC, University of Minnesota\n");
+ fprintf(Parser_h, " * ANTLR Version %s\n", Version);
+ fprintf(Parser_h, " */\n\n");
+
+ if ( FirstAction != NULL ) dumpAction( FirstAction, Parser_h, 0, -1, 0, 1); /* MR11 MR15b */
+
+ fprintf(Parser_h, "#ifndef %s_h\n", CurrentClassName);
+ fprintf(Parser_h, "#define %s_h\n\n", CurrentClassName);
+
+ fprintf(Parser_h, "#ifndef ANTLR_VERSION\n");
+ fprintf(Parser_h, "#define ANTLR_VERSION %s\n",VersionDef);
+ fprintf(Parser_h, "#endif\n\n");
+
+ if ( GenAST ) fprintf(Parser_h, "class ASTBase;\n");
+ if (TraceGen) {
+ fprintf(Parser_h,"#ifndef zzTRACE_RULES\n"); /* MR20 */
+ fprintf(Parser_h,"#define zzTRACE_RULES\n"); /* MR20 */
+ fprintf(Parser_h,"#endif\n"); /* MR22 */
+ };
+ fprintf(Parser_h, "#include \"%s\"\n\n", APARSER_H);
+
+ if ( HdrAction != NULL ) dumpAction( HdrAction, Parser_h, 0, -1, 0, 1);
+
+/* MR10 */ if (ClassDeclStuff == NULL) {
+/* MR10 */ fprintf(Parser_h, "class %s : public ANTLRParser {\n", CurrentClassName);
+/* MR10 */ } else {
+/* MR10 */ fprintf(Parser_h, "class %s %s {\n",CurrentClassName,ClassDeclStuff);
+/* MR10 */ };
+
+ fprintf(Parser_h, "public:\n"); /* MR1 */
+ fprintf(Parser_h, "\tstatic const ANTLRChar *tokenName(int tk);\n");/* MR1 */
+ fprintf(Parser_h, "\tenum { SET_SIZE = %i };\n",TokenNum-1); /* MR21 */
+ fprintf(Parser_h, "protected:\n");
+ fprintf(Parser_h, "\tstatic const ANTLRChar *_token_tbl[];\n"); /* MR20 */
+ fprintf(Parser_h, "private:\n");
+}
+
+/* Currently, this is only used in !GenCC mode */
+void
+#ifdef __USE_PROTOS
+GenErrHdr( void )
+#else
+GenErrHdr( )
+#endif
+{
+ int i, j;
+ TermEntry *te;
+
+ fprintf(ErrFile, "/*\n");
+ fprintf(ErrFile, " * A n t l r S e t s / E r r o r F i l e H e a d e r\n");
+ fprintf(ErrFile, " *\n");
+ fprintf(ErrFile, " * Generated from:");
+ for (i=0; i<NumFiles; i++) fprintf(ErrFile, " %s", FileStr[i]);
+ fprintf(ErrFile, "\n");
+ fprintf(ErrFile, " *\n");
+ fprintf(ErrFile, " * Terence Parr, Russell Quong, Will Cohen, and Hank Dietz: 1989-2001\n");
+ fprintf(ErrFile, " * Parr Research Corporation\n");
+ fprintf(ErrFile, " * with Purdue University Electrical Engineering\n");
+ fprintf(ErrFile, " * With AHPCRC, University of Minnesota\n");
+ fprintf(ErrFile, " * ANTLR Version %s\n", Version);
+ fprintf(ErrFile, " */\n\n");
+
+ if ( FirstAction != NULL ) dumpAction( FirstAction, ErrFile, 0, -1, 0, 1); /* MR11 MR15b */
+
+ fprintf(ErrFile, "#define ANTLR_VERSION %s\n", VersionDef);
+
+ fprintf(ErrFile, "#include \"pcctscfg.h\"\n");
+ fprintf(ErrFile, "#include \"pccts_stdio.h\"\n");
+ if ( strcmp(ParserName, DefaultParserName)!=0 )
+ fprintf(ErrFile, "#define %s %s\n", DefaultParserName, ParserName);
+ if ( strcmp(ParserName, DefaultParserName)!=0 )
+ fprintf(ErrFile, "#include \"%s\"\n", RemapFileName);
+ if ( HdrAction != NULL ) dumpAction( HdrAction, ErrFile, 0, -1, 0, 1 );
+ if ( FoundGuessBlk )
+ {
+ fprintf(ErrFile, "#define ZZCAN_GUESS\n");
+ fprintf(ErrFile, "#include \"pccts_setjmp.h\"\n");
+ }
+ if (TraceGen) {
+ fprintf(ErrFile,"#ifndef zzTRACE_RULES\n"); /* MR20 */
+ fprintf(ErrFile,"#define zzTRACE_RULES\n"); /* MR20 */
+ fprintf(ErrFile,"#endif\n"); /* MR22 */
+ };
+
+ if ( OutputLL_k > 1 ) fprintf(ErrFile, "#define LL_K %d\n", OutputLL_k);
+#ifdef DUM
+ if ( LexGen ) fprintf(ErrFile, "#define zzEOF_TOKEN %d\n", (TokenInd!=NULL?TokenInd[EofToken]:EofToken));
+#endif
+ fprintf(ErrFile, "#define zzSET_SIZE %d\n", NumWords(TokenNum-1)*sizeof(unsigned));
+ if ( DemandLookahead ) fprintf(ErrFile, "#define DEMAND_LOOK\n");
+ fprintf(ErrFile, "#include \"antlr.h\"\n");
+ if ( GenAST ) fprintf(ErrFile, "#include \"ast.h\"\n");
+
+ if ( UserDefdTokens ) fprintf(ErrFile, "#include %s\n", UserTokenDefsFile);
+ /* still need this one as it has the func prototypes */
+ fprintf(ErrFile, "#include \"%s\"\n", DefFileName);
+ fprintf(ErrFile, "#include \"dlgdef.h\"\n");
+ fprintf(ErrFile, "#include \"err.h\"\n\n");
+
+ /* Dump a zztokens for each automaton */
+ if ( strcmp(ParserName, DefaultParserName)!=0 )
+ {
+ fprintf(ErrFile, "ANTLRChar *%s_zztokens[%d]={\n", ParserName, TokenNum-1);
+ }
+ else
+ {
+ fprintf(ErrFile, "ANTLRChar *zztokens[%d]={\n", TokenNum-1);
+ }
+ fprintf(ErrFile, "\t/* 00 */\t\"Invalid\"");
+ for (i=1; i<TokenNum-1; i++)
+ {
+ DAWDLE;
+ if ( i == EpToken ) continue;
+ /* remapped to invalid token? */
+ if ( TokenInd!=NULL && TokenInd[i]>=LastTokenCounted )
+ {
+ fprintf(ErrFile, ",\n\t/* %02d */\t\"invalid\"", i);
+ continue;
+ }
+ if ( TokenString(i) != NULL ) {
+ te=(TermEntry *) hash_get(Tname,TokenString(i)); /* MR11 */
+ if (te == NULL || te->akaString == NULL) { /* MR11 */
+ fprintf(ErrFile, ",\n\t/* %02d */\t\"%s\"", i, TokenString(i));
+ } else {
+ fprintf(ErrFile, ",\n\t/* %02d */\t\"%s\"", i, te->akaString); /* MR11 */
+ }
+ }
+ else
+ {
+ /* look in all lexclasses for the reg expr */
+ for (j=0; j<NumLexClasses; j++)
+ {
+ lexmode(j);
+ if ( ExprString(i) != NULL )
+ {
+ fprintf(ErrFile, ",\n\t/* %02d */\t", i);
+ dumpExpr(ErrFile, ExprString(i));
+ break;
+ }
+ }
+ if ( j>=NumLexClasses )
+ {
+ if ( UserDefdTokens )
+ {
+ fprintf(ErrFile, ",\n\t/* %02d */\t\"\"", i);
+ }
+ else
+ fatal_internal(eMsgd("No label or expr for token %d",i));
+ }
+ }
+ }
+ fprintf(ErrFile, "\n};\n");
+}
+
+void
+#ifdef __USE_PROTOS
+dumpExpr( FILE *f, char *e )
+#else
+dumpExpr( f, e )
+FILE *f;
+char *e;
+#endif
+{
+ while ( *e!='\0' )
+ {
+ if ( *e=='\\' && *(e+1)=='\\' )
+ {putc('\\', f); putc('\\', f); e+=2;}
+ else if ( *e=='\\' && *(e+1)=='"' )
+ {putc('\\', f); putc('"', f); e+=2;}
+ else if ( *e=='\\' ) {putc('\\', f); putc('\\', f); e++;}
+ else {putc(*e, f); e++;}
+ }
+}
+
+int
+#ifdef __USE_PROTOS
+isTermEntryTokClass(TermEntry *te)
+#else
+isTermEntryTokClass(te)
+TermEntry *te;
+#endif
+{
+ ListNode *t;
+ TCnode *p;
+ TermEntry *q;
+ char *tokstr;
+
+ if (tclasses == NULL) return 0;
+
+ for (t = tclasses->next; t!=NULL; t=t->next)
+ {
+ p = (TCnode *) t->elem;
+ tokstr = TokenString(p->tok);
+ lexmode(p->lexclass); /* switch to lexclass where tokclass is defined */
+ q = (TermEntry *) hash_get(Tname, tokstr);
+ if (q == te) return 1;
+ }
+ return 0;
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/build.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/build.c new file mode 100644 index 0000000000..4eb3b02af1 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/build.c @@ -0,0 +1,813 @@ +/*
+ * build.c -- functions associated with building syntax diagrams.
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2001
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include "pcctscfg.h"
+#include "set.h"
+#include "syn.h"
+#include "hash.h"
+#include "generic.h"
+#include "dlgdef.h"
+
+#define SetBlk(g, t, approx, first_set_symbol) { \
+ ((Junction *)g.left)->jtype = t; \
+ ((Junction *)g.left)->approx = approx; \
+ ((Junction *)g.left)->pFirstSetSymbol = first_set_symbol; \
+ ((Junction *)g.left)->end = (Junction *) g.right; \
+ ((Junction *)g.right)->jtype = EndBlk;}
+
+/* Add the parameter string 'parm' to the parms field of a block-type junction
+ * g.left points to the sentinel node on a block. i.e. g.left->p1 points to
+ * the actual junction with its jtype == some block-type.
+ */
+void
+#ifdef __USE_PROTOS
+addParm( Node *p, char *parm )
+#else
+addParm( p, parm )
+Node *p;
+char *parm;
+#endif
+{
+ char *q = (char *) malloc( strlen(parm) + 1 );
+ require(p!=NULL, "addParm: NULL object\n");
+ require(q!=NULL, "addParm: unable to alloc parameter\n");
+
+ strcpy(q, parm);
+ if ( p->ntype == nRuleRef )
+ {
+ ((RuleRefNode *)p)->parms = q;
+ }
+ else if ( p->ntype == nJunction )
+ {
+ ((Junction *)p)->parm = q; /* only one parameter allowed on subrules */
+ }
+ else fatal_internal("addParm: invalid node for adding parm");
+}
+
+/*
+ * Build an action node for the syntax diagram
+ *
+ * buildAction(ACTION) ::= --o-->ACTION-->o--
+ *
+ * Where o is a junction node.
+ */
+Graph
+#ifdef __USE_PROTOS
+buildAction( char *action, int file, int line, int is_predicate )
+#else
+buildAction( action, file, line, is_predicate )
+char *action;
+int file;
+int line;
+int is_predicate;
+#endif
+{
+ Junction *j1, *j2;
+ Graph g;
+ ActionNode *a;
+ require(action!=NULL, "buildAction: invalid action");
+
+ j1 = newJunction();
+ j2 = newJunction();
+ a = newActionNode();
+ a->action = (char *) malloc( strlen(action)+1 );
+ require(a->action!=NULL, "buildAction: cannot alloc space for action\n");
+ strcpy(a->action, action);
+ j1->p1 = (Node *) a;
+ a->next = (Node *) j2;
+ a->is_predicate = is_predicate;
+
+ if (is_predicate) {
+ PredEntry *predEntry;
+ char *t;
+ char *key;
+ char *u;
+ int inverted=0;
+
+ t=key=(char *)calloc(1,strlen(a->action)+1);
+
+ for (u=a->action; *u != '\0' ; u++) {
+ if (*u != ' ') {
+ if (t==key && *u=='!') {
+ inverted=!inverted;
+ } else {
+ *t++=*u;
+ };
+ };
+ };
+
+ *t='\0';
+
+
+ predEntry=(PredEntry *)hash_get(Pname,key);
+ a->predEntry=predEntry;
+ if (predEntry != NULL) a->inverted=inverted;
+ } else {
+/* MR12c */ char *strStart=a->action;
+/* MR12c */ char *strEnd;
+/* MR12c */ strEnd=strStart+strlen(strStart)-1;
+/* MR12c */ for ( ; strEnd >= strStart && isspace(*strEnd); strEnd--) *strEnd=0;
+/* MR12c */ while (*strStart != '\0' && isspace(*strStart)) strStart++;
+/* MR12c */ if (ci_strequ(strStart,"nohoist")) {
+/* MR12c */ a->noHoist=1;
+/* MR12c */ }
+ }
+
+ g.left = (Node *) j1; g.right = (Node *) j2;
+ a->file = file;
+ a->line = line;
+ a->rname = CurRule; /* MR10 */
+ return g;
+}
+
+/*
+ * Build a token node for the syntax diagram
+ *
+ * buildToken(TOKEN) ::= --o-->TOKEN-->o--
+ *
+ * Where o is a junction node.
+ */
+Graph
+#ifdef __USE_PROTOS
+buildToken( char *text )
+#else
+buildToken( text )
+char *text;
+#endif
+{
+ Junction *j1, *j2;
+ Graph g;
+ TokNode *t;
+ require(text!=NULL, "buildToken: invalid token name");
+
+ j1 = newJunction();
+ j2 = newJunction();
+ t = newTokNode();
+ t->altstart = CurAltStart;
+ if ( *text == '"' ) {t->label=FALSE; t->token = addTexpr( text );}
+ else {t->label=TRUE; t->token = addTname( text );}
+ j1->p1 = (Node *) t;
+ t->next = (Node *) j2;
+ g.left = (Node *) j1; g.right = (Node *) j2;
+ return g;
+}
+
+/*
+ * Build a wild-card node for the syntax diagram
+ *
+ * buildToken(TOKEN) ::= --o-->'.'-->o--
+ *
+ * Where o is a junction node.
+ */
+Graph
+#ifdef __USE_PROTOS
+buildWildCard( char *text )
+#else
+buildWildCard( text )
+char *text;
+#endif
+{
+ Junction *j1, *j2;
+ Graph g;
+ TokNode *t;
+ TCnode *w;
+ TermEntry *p;
+ require(text!=NULL, "buildWildCard: invalid token name");
+
+ j1 = newJunction();
+ j2 = newJunction();
+ t = newTokNode();
+
+ /* If the ref a wild card, make a token class for it */
+ if ( Tnum(WildCardString) == 0 )
+ {
+ w = newTCnode;
+ w->tok = addTname( WildCardString );
+ set_orel(w->tok, &imag_tokens);
+ set_orel(w->tok, &tokclasses);
+ WildCardToken = w->tok;
+ require((p=(TermEntry *)hash_get(Tname, WildCardString)) != NULL,
+ "hash table mechanism is broken");
+ p->classname = 1; /* entry is class name, not token */
+ p->tclass = w; /* save ptr to this tclass def */
+ list_add(&tclasses, (char *)w);
+ }
+ else {
+ p=(TermEntry *)hash_get(Tname, WildCardString);
+ require( p!= NULL, "hash table mechanism is broken");
+ w = p->tclass;
+ }
+
+ t->token = w->tok;
+ t->wild_card = 1;
+ t->tclass = w;
+
+ t->altstart = CurAltStart;
+ j1->p1 = (Node *) t;
+ t->next = (Node *) j2;
+ g.left = (Node *) j1; g.right = (Node *) j2;
+ return g;
+}
+
+void
+#ifdef __USE_PROTOS
+setUpperRange(TokNode *t, char *text)
+#else
+setUpperRange(t, text)
+TokNode *t;
+char *text;
+#endif
+{
+ require(t!=NULL, "setUpperRange: NULL token node");
+ require(text!=NULL, "setUpperRange: NULL token string");
+
+ if ( *text == '"' ) {t->upper_range = addTexpr( text );}
+ else {t->upper_range = addTname( text );}
+}
+
+/*
+ * Build a rule reference node of the syntax diagram
+ *
+ * buildRuleRef(RULE) ::= --o-->RULE-->o--
+ *
+ * Where o is a junction node.
+ *
+ * If rule 'text' has been defined already, don't alloc new space to store string.
+ * Set r->text to point to old copy in string table.
+ */
+Graph
+#ifdef __USE_PROTOS
+buildRuleRef( char *text )
+#else
+buildRuleRef( text )
+char *text;
+#endif
+{
+ Junction *j1, *j2;
+ Graph g;
+ RuleRefNode *r;
+ RuleEntry *p;
+ require(text!=NULL, "buildRuleRef: invalid rule name");
+
+ j1 = newJunction();
+ j2 = newJunction();
+ r = newRNode();
+ r->altstart = CurAltStart;
+ r->assign = NULL;
+ if ( (p=(RuleEntry *)hash_get(Rname, text)) != NULL ) r->text = p->str;
+ else r->text = mystrdup( text );
+ j1->p1 = (Node *) r;
+ r->next = (Node *) j2;
+ g.left = (Node *) j1; g.right = (Node *) j2;
+ return g;
+}
+
+/*
+ * Or two subgraphs into one graph via:
+ *
+ * Or(G1, G2) ::= --o-G1-o--
+ * | ^
+ * v |
+ * o-G2-o
+ *
+ * Set the altnum of junction starting G2 to 1 + altnum of junction starting G1.
+ * If, however, the G1 altnum is 0, make it 1 and then
+ * make G2 altnum = G1 altnum + 1.
+ */
+Graph
+#ifdef __USE_PROTOS
+Or( Graph g1, Graph g2 )
+#else
+Or( g1, g2 )
+Graph g1;
+Graph g2;
+#endif
+{
+ Graph g;
+ require(g1.left != NULL, "Or: invalid graph");
+ require(g2.left != NULL && g2.right != NULL, "Or: invalid graph");
+
+ ((Junction *)g1.left)->p2 = g2.left;
+ ((Junction *)g2.right)->p1 = g1.right;
+ /* set altnums */
+ if ( ((Junction *)g1.left)->altnum == 0 ) ((Junction *)g1.left)->altnum = 1;
+ ((Junction *)g2.left)->altnum = ((Junction *)g1.left)->altnum + 1;
+ g.left = g2.left;
+ g.right = g1.right;
+ return g;
+}
+
+/*
+ * Catenate two subgraphs
+ *
+ * Cat(G1, G2) ::= --o-G1-o-->o-G2-o--
+ * Cat(NULL,G2)::= --o-G2-o--
+ * Cat(G1,NULL)::= --o-G1-o--
+ */
+Graph
+#ifdef __USE_PROTOS
+Cat( Graph g1, Graph g2 )
+#else
+Cat( g1, g2 )
+Graph g1;
+Graph g2;
+#endif
+{
+ Graph g;
+
+ if ( g1.left == NULL && g1.right == NULL ) return g2;
+ if ( g2.left == NULL && g2.right == NULL ) return g1;
+ ((Junction *)g1.right)->p1 = g2.left;
+ g.left = g1.left;
+ g.right = g2.right;
+ return g;
+}
+
+/*
+ * Make a subgraph an optional block
+ *
+ * makeOpt(G) ::= --o-->o-G-o-->o--
+ * | ^
+ * v |
+ * o-------o
+ *
+ * Note that this constructs {A|B|...|Z} as if (A|B|...|Z|) was found.
+ *
+ * The node on the far right is added so that every block owns its own
+ * EndBlk node.
+ */
+Graph
+#ifdef __USE_PROTOS
+makeOpt( Graph g1, int approx, char * pFirstSetSymbol )
+#else
+makeOpt( g1, approx, pFirstSetSymbol )
+Graph g1;
+int approx;
+char * pFirstSetSymbol;
+#endif
+{
+ Junction *j1,*j2,*p;
+ Graph g;
+ require(g1.left != NULL && g1.right != NULL, "makeOpt: invalid graph");
+
+ j1 = newJunction();
+ j2 = newJunction();
+ ((Junction *)g1.right)->p1 = (Node *) j2; /* add node to G at end */
+
+ /* MR21
+ *
+ * There is code in genBlk which recognizes the node created
+ * by emptyAlt() as a special case and bypasses it. We don't
+ * want this to happen for the optBlk.
+ */
+
+ g = emptyAlt3(); /* MR21 */
+ if ( ((Junction *)g1.left)->altnum == 0 ) ((Junction *)g1.left)->altnum = 1;
+ ((Junction *)g.left)->altnum = ((Junction *)g1.left)->altnum + 1;
+ for(p=(Junction *)g1.left; p->p2!=NULL; p=(Junction *)p->p2)
+ {;} /* find last alt */
+ p->p2 = g.left; /* add optional alternative */
+ ((Junction *)g.right)->p1 = (Node *)j2; /* opt alt points to EndBlk */
+ g1.right = (Node *)j2;
+ SetBlk(g1, aOptBlk, approx, pFirstSetSymbol);
+ j1->p1 = g1.left; /* add generic node in front */
+ g.left = (Node *) j1;
+ g.right = g1.right;
+ return g;
+}
+
+/*
+ * Make a graph into subblock
+ *
+ * makeBlk(G) ::= --o-->o-G-o-->o--
+ *
+ * The node on the far right is added so that every block owns its own
+ * EndBlk node.
+ */
+Graph
+#ifdef __USE_PROTOS
+makeBlk( Graph g1, int approx, char * pFirstSetSymbol )
+#else
+makeBlk( g1, approx, pFirstSetSymbol )
+Graph g1;
+int approx;
+char * pFirstSetSymbol;
+#endif
+{
+ Junction *j,*j2;
+ Graph g;
+ require(g1.left != NULL && g1.right != NULL, "makeBlk: invalid graph");
+
+ j = newJunction();
+ j2 = newJunction();
+ ((Junction *)g1.right)->p1 = (Node *) j2; /* add node to G at end */
+ g1.right = (Node *)j2;
+ SetBlk(g1, aSubBlk, approx, pFirstSetSymbol);
+ j->p1 = g1.left; /* add node in front */
+ g.left = (Node *) j;
+ g.right = g1.right;
+
+ return g;
+}
+
+/*
+ * Make a subgraph into a loop (closure) block -- (...)*
+ *
+ * makeLoop(G) ::= |---|
+ * v |
+ * --o-->o-->o-G-o-->o--
+ * | ^
+ * v |
+ * o-----------o
+ *
+ * After making loop, always place generic node out front. It becomes
+ * the start of enclosing block. The aLoopBlk is the target of the loop.
+ *
+ * Loop blks have TWO EndBlk nodes--the far right and the node that loops back
+ * to the aLoopBlk node. Node with which we can branch past loop == aLoopBegin and
+ * one which is loop target == aLoopBlk.
+ * The branch-past (initial) aLoopBegin node has end
+ * pointing to the last EndBlk node. The loop-target node has end==NULL.
+ *
+ * Loop blocks have a set of locks (from 1..CLL_k) on the aLoopBlk node.
+ */
+Graph
+#ifdef __USE_PROTOS
+makeLoop( Graph g1, int approx, char * pFirstSetSymbol )
+#else
+makeLoop( g1, approx, pFirstSetSymbol)
+Graph g1;
+int approx;
+char * pFirstSetSymbol;
+#endif
+{
+ Junction *back, *front, *begin;
+ Graph g;
+ require(g1.left != NULL && g1.right != NULL, "makeLoop: invalid graph");
+
+ back = newJunction();
+ front = newJunction();
+ begin = newJunction();
+ g = emptyAlt3();
+ ((Junction *)g1.right)->p2 = g1.left; /* add loop branch to G */
+ ((Junction *)g1.right)->p1 = (Node *) back; /* add node to G at end */
+ ((Junction *)g1.right)->jtype = EndBlk; /* mark 1st EndBlk node */
+ ((Junction *)g1.left)->jtype = aLoopBlk; /* mark 2nd aLoopBlk node */
+ ((Junction *)g1.left)->end = (Junction *) g1.right;
+ ((Junction *)g1.left)->lock = makelocks();
+ ((Junction *)g1.left)->pred_lock = makelocks();
+ g1.right = (Node *) back;
+ begin->p1 = (Node *) g1.left;
+ g1.left = (Node *) begin;
+ begin->p2 = (Node *) g.left; /* make bypass arc */
+ ((Junction *)g.right)->p1 = (Node *) back;
+ SetBlk(g1, aLoopBegin, approx, pFirstSetSymbol);
+ front->p1 = g1.left; /* add node to front */
+ g1.left = (Node *) front;
+
+ return g1;
+}
+
+/*
+ * Make a subgraph into a plus block -- (...)+ -- 1 or more times
+ *
+ * makePlus(G) ::= |---|
+ * v |
+ * --o-->o-G-o-->o--
+ *
+ * After making loop, always place generic node out front. It becomes
+ * the start of enclosing block. The aPlusBlk is the target of the loop.
+ *
+ * Plus blks have TWO EndBlk nodes--the far right and the node that loops back
+ * to the aPlusBlk node.
+ *
+ * Plus blocks have a set of locks (from 1..CLL_k) on the aPlusBlk node.
+ */
+Graph
+#ifdef __USE_PROTOS
+makePlus( Graph g1, int approx, char * pFirstSetSymbol)
+#else
+makePlus( g1, approx, pFirstSetSymbol)
+Graph g1;
+int approx;
+char * pFirstSetSymbol;
+#endif
+{
+ int has_empty_alt_already = 0;
+ Graph g;
+ Junction *j2, *j3, *first_alt;
+ Junction *last_alt=NULL, *p;
+ require(g1.left != NULL && g1.right != NULL, "makePlus: invalid graph");
+
+ first_alt = (Junction *)g1.left;
+ j2 = newJunction();
+ j3 = newJunction();
+ if ( ((Junction *)g1.left)->altnum == 0 ) ((Junction *)g1.left)->altnum = 1;
+ ((Junction *)g1.right)->p2 = g1.left; /* add loop branch to G */
+ ((Junction *)g1.right)->p1 = (Node *) j2; /* add node to G at end */
+ ((Junction *)g1.right)->jtype = EndBlk; /* mark 1st EndBlk node */
+ g1.right = (Node *) j2;
+ SetBlk(g1, aPlusBlk, approx, pFirstSetSymbol);
+ ((Junction *)g1.left)->lock = makelocks();
+ ((Junction *)g1.left)->pred_lock = makelocks();
+ j3->p1 = g1.left; /* add node to front */
+ g1.left = (Node *) j3;
+
+ /* add an optional branch which is the "exit" branch of loop */
+ /* FIRST, check to ensure that there does not already exist
+ * an optional path.
+ */
+ /* find last alt */
+ for(p=first_alt; p!=NULL; p=(Junction *)p->p2)
+ {
+ if ( p->p1->ntype == nJunction &&
+ p->p1!=NULL &&
+ ((Junction *)p->p1)->jtype==Generic &&
+ ((Junction *)p->p1)->p1!=NULL &&
+ ((Junction *)((Junction *)p->p1)->p1)->jtype==EndBlk )
+ {
+ has_empty_alt_already = 1;
+ }
+ last_alt = p;
+ }
+ if ( !has_empty_alt_already )
+ {
+ require(last_alt!=NULL, "last_alt==NULL; bad (..)+");
+ g = emptyAlt();
+ last_alt->p2 = g.left;
+ ((Junction *)g.right)->p1 = (Node *) j2;
+
+ /* make sure lookahead computation ignores this alt for
+ * FIRST("(..)+"); but it's still used for computing the FIRST
+ * of each alternative.
+ */
+ ((Junction *)g.left)->ignore = 1;
+ }
+
+ return g1;
+}
+
+/*
+ * Return an optional path: --o-->o--
+ */
+
+Graph
+#ifdef __USE_PROTOS
+emptyAlt( void )
+#else
+emptyAlt( )
+#endif
+{
+ Junction *j1, *j2;
+ Graph g;
+
+ j1 = newJunction();
+ j2 = newJunction();
+ j1->p1 = (Node *) j2;
+ g.left = (Node *) j1;
+ g.right = (Node *) j2;
+
+ return g;
+}
+
+/* MR21
+ *
+ * There is code in genBlk which recognizes the node created
+ * by emptyAlt() as a special case and bypasses it. We don't
+ * want this to happen for the optBlk.
+ */
+
+Graph
+#ifdef __USE_PROTOS
+emptyAlt3( void )
+#else
+emptyAlt3( )
+#endif
+{
+ Junction *j1, *j2, *j3;
+ Graph g;
+
+ j1 = newJunction();
+ j2 = newJunction();
+ j3 = newJunction();
+ j1->p1 = (Node *) j2;
+ j2->p1 = (Node *) j3;
+ g.left = (Node *) j1;
+ g.right = (Node *) j3;
+
+ return g;
+}
+
+/* N o d e A l l o c a t i o n */
+
+TokNode *
+#ifdef __USE_PROTOS
+newTokNode( void )
+#else
+newTokNode( )
+#endif
+{
+ static TokNode *FreeList = NULL;
+ TokNode *p, *newblk;
+
+ if ( FreeList == NULL )
+ {
+ newblk = (TokNode *)calloc(TokenBlockAllocSize, sizeof(TokNode));
+ if ( newblk == NULL )
+ fatal_internal(eMsg1("out of memory while building rule '%s'",CurRule));
+ for (p=newblk; p<&(newblk[TokenBlockAllocSize]); p++)
+ {
+ p->next = (Node *)FreeList; /* add all new token nodes to FreeList */
+ FreeList = p;
+ }
+ }
+ p = FreeList;
+ FreeList = (TokNode *)FreeList->next;/* remove a TokNode node */
+ p->next = NULL; /* NULL the ptr we used */
+ memset( (char *) p, 0, sizeof(TokNode)); /* MR10 */
+ p->ntype = nToken;
+ p->rname = CurRule;
+ p->file = CurFile;
+ p->line = zzline;
+ p->altstart = NULL;
+
+ return p;
+}
+
+RuleRefNode *
+#ifdef __USE_PROTOS
+newRNode( void )
+#else
+newRNode( )
+#endif
+{
+ static RuleRefNode *FreeList = NULL;
+ RuleRefNode *p, *newblk;
+
+ if ( FreeList == NULL )
+ {
+ newblk = (RuleRefNode *)calloc(RRefBlockAllocSize, sizeof(RuleRefNode));
+ if ( newblk == NULL )
+ fatal_internal(eMsg1("out of memory while building rule '%s'",CurRule));
+ for (p=newblk; p<&(newblk[RRefBlockAllocSize]); p++)
+ {
+ p->next = (Node *)FreeList; /* add all new rref nodes to FreeList */
+ FreeList = p;
+ }
+ }
+ p = FreeList;
+ FreeList = (RuleRefNode *)FreeList->next;/* remove a Junction node */
+ p->next = NULL; /* NULL the ptr we used */
+ memset( (char *) p, 0, sizeof(RuleRefNode)); /* MR10 */
+ p->ntype = nRuleRef;
+ p->rname = CurRule;
+ p->file = CurFile;
+ p->line = zzline;
+ p->astnode = ASTinclude;
+ p->altstart = NULL;
+
+ return p;
+}
+
+static int junctionSeqNumber=0; /* MR10 */
+
+Junction *
+#ifdef __USE_PROTOS
+newJunction( void )
+#else
+newJunction( )
+#endif
+{
+ static Junction *FreeList = NULL;
+ Junction *p, *newblk;
+
+ if ( FreeList == NULL )
+ {
+ newblk = (Junction *)calloc(JunctionBlockAllocSize, sizeof(Junction));
+ if ( newblk == NULL )
+ fatal_internal(eMsg1("out of memory while building rule '%s'",CurRule));
+ for (p=newblk; p<&(newblk[JunctionBlockAllocSize]); p++)
+ {
+ p->p1 = (Node *)FreeList; /* add all new Junction nodes to FreeList */
+ FreeList = p;
+ }
+ }
+ p = FreeList;
+ FreeList = (Junction *)FreeList->p1;/* remove a Junction node */
+ p->p1 = NULL; /* NULL the ptr we used */
+ memset( (char *) p, 0, sizeof(Junction)); /* MR10 */
+ p->ntype = nJunction;
+ p->visited = 0;
+ p->jtype = Generic;
+ p->rname = CurRule;
+ p->file = CurFile;
+ p->line = zzline;
+ p->exception_label = NULL;
+ p->fset = (set *) calloc(CLL_k+1, sizeof(set));
+ require(p->fset!=NULL, "cannot allocate fset in newJunction");
+ p->seq=++junctionSeqNumber; /* MR10 */
+
+ return p;
+}
+
+ActionNode *
+#ifdef __USE_PROTOS
+newActionNode( void )
+#else
+newActionNode( )
+#endif
+{
+ static ActionNode *FreeList = NULL;
+ ActionNode *p, *newblk;
+
+ if ( FreeList == NULL )
+ {
+ newblk = (ActionNode *)calloc(ActionBlockAllocSize, sizeof(ActionNode));
+ if ( newblk == NULL )
+ fatal_internal(eMsg1("out of memory while building rule '%s'",CurRule));
+ for (p=newblk; p<&(newblk[ActionBlockAllocSize]); p++)
+ {
+ p->next = (Node *)FreeList; /* add all new Action nodes to FreeList */
+ FreeList = p;
+ }
+ }
+ p = FreeList;
+ FreeList = (ActionNode *)FreeList->next;/* remove an Action node */
+ memset( (char *) p, 0, sizeof(ActionNode)); /* MR10 */
+ p->ntype = nAction;
+ p->next = NULL; /* NULL the ptr we used */
+ p->done = 0;
+ p->pred_fail = NULL;
+ p->guardpred = NULL;
+ p->ampersandPred = NULL;
+ return p;
+}
+
+/*
+ * allocate the array of locks (1..CLL_k) used to inhibit infinite recursion.
+ * Infinite recursion can occur in (..)* blocks, FIRST calcs and FOLLOW calcs.
+ * Therefore, we need locks on aLoopBlk, RuleBlk, EndRule nodes.
+ *
+ * if ( lock[k]==TRUE ) then we have been here before looking for k tokens
+ * of lookahead.
+ */
+char *
+#ifdef __USE_PROTOS
+makelocks( void )
+#else
+makelocks( )
+#endif
+{
+ char *p = (char *) calloc(CLL_k+1, sizeof(char));
+ require(p!=NULL, "cannot allocate lock array");
+
+ return p;
+}
+
+#if 0
+** #ifdef __USE_PROTOS
+** void my_memset(char *p,char value,int count)
+** #else
+** void my_memset(p,value,count)
+** char *p;
+** char value;
+** int count;
+** #endif
+** {
+** int i;
+**
+** for (i=0; i<count; i++) {
+** p[i]=value;
+** };
+** }
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/dumpcycles.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/dumpcycles.c new file mode 100644 index 0000000000..8156159f71 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/dumpcycles.c @@ -0,0 +1,67 @@ +#include <stdio.h>
+#include <ctype.h>
+
+#include "set.h"
+#include "syn.h"
+#include "hash.h"
+#include "generic.h"
+
+void
+#ifdef __USE_PROTOS
+dumpcycles(void)
+#else
+dumpcycles()
+#endif
+{
+ Cycle *c;
+ CacheEntry *f;
+ ListNode *p;
+ int i=0;
+ int k;
+ int degree;
+
+ for (k=1; k <= CLL_k; k++) {
+ if (Cycles[k] == NULL) continue;
+
+ for (p = Cycles[k]->next; p!=NULL; p=p->next) {
+ c = (Cycle *) p->elem;
+ degree=set_deg(c->cyclicDep);
+ fprintf(stderr,"Cycle %d: (degree %d) %s -->\n", i++, degree, RulePtr[c->croot]->rname);
+ fprintf(stderr," *self*\n");
+ MR_dumpRuleSet(c->cyclicDep);
+ fprintf(stderr,"\n");
+ f = (CacheEntry *)
+ hash_get(Fcache,Fkey(RulePtr[c->croot]->rname,'o',k));
+ if (f == NULL) {
+ fprintf(stderr," *** FOLLOW(%s) must be in cache but isn't ***\n",
+ RulePtr[c->croot]->rname);
+ };
+ };
+ };
+}
+
+void
+#ifdef __USE_PROTOS
+dumpfostack(int k)
+#else
+dumpfostack(k)
+int k;
+#endif
+{
+ int i=0;
+ int *pi;
+
+ fprintf(stderr,"\n");
+ if (FoStack[k] == NULL) {
+ fprintf(stderr,"FoStack[%d] is null\n",k);
+ };
+ if (FoTOS[k] == NULL) {
+ fprintf(stderr,"FoTOS[%d] is null\n",k);
+ }
+ if (FoTOS[k] != NULL && FoStack[k] != NULL) {
+ for (pi=FoStack[k]; pi <= FoTOS[k]; pi++) {
+ i++;
+ fprintf(stderr,"#%d rule %d %s\n",i,*pi,RulePtr[*pi]->rname);
+ }
+ }
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/dumpnode.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/dumpnode.c new file mode 100644 index 0000000000..2a34c6fcd5 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/dumpnode.c @@ -0,0 +1,423 @@ +#include <stdio.h>
+#include <ctype.h>
+
+#include "set.h"
+#include "syn.h"
+#include "hash.h"
+#include "generic.h"
+
+#ifdef __USE_PROTOS
+void dumpset1(set s)
+#else
+void dumpset1(s)
+ set s;
+#endif
+{
+ if (set_nil(s)) {
+ fprintf(stderr,"{}");
+ } else {
+ s_fprT(stderr,s);
+ };
+}
+
+#ifdef __USE_PROTOS
+void dumpset(set s)
+#else
+void dumpset(s)
+ set s;
+#endif
+{
+ dumpset1(s);
+ fprintf(stderr,"\n");
+}
+
+#ifdef __USE_PROTOS
+int isEndRule(Node * p)
+#else
+int isEndRule(p)
+ Node * p;
+#endif
+{
+ int result=0;
+ if ( p->ntype == nJunction &&
+ ( (Junction *) p)->jtype == EndRule) {
+ result=1;
+ };
+ return result;
+}
+
+#ifdef __USE_PROTOS
+void dumppred1(int depth,Predicate *p)
+#else
+void dumppred1(depth,p)
+ int depth;
+ Predicate *p;
+#endif
+{
+ int i;
+ int k;
+
+ for (i=0; i<depth ; i++) {
+ fprintf(stderr," ");
+ };
+ if (p->expr == PRED_AND_LIST ||
+ p->expr == PRED_OR_LIST) {
+ fprintf(stderr," %s", (p->expr == NULL ? "null expr" : p->expr));
+ if (p->inverted) fprintf(stderr," predicate inverted !");
+ if (p->redundant) {
+ fprintf(stderr," Redundant!");
+ };
+ if (p->isConst) fprintf(stderr," const %d !",p->constValue);
+ fprintf(stderr,"\n");
+ } else {
+ fprintf(stderr,"predicate k=%d",p->k);
+ k=set_int(p->completionSet);
+ if (k >= 0) {
+ fprintf(stderr," Incomplete Set=%d !",k);
+ };
+ k=set_int(p->completionTree);
+ if (k >= 0) {
+ fprintf(stderr," Incomplete Tree=%d !",k);
+ };
+ if (p->redundant) {
+ fprintf(stderr," Redundant!");
+ };
+ fprintf(stderr," \"%s\" (%x)", (p->expr == NULL ? "null expr" : p->expr) ,p);
+ if (p->source != NULL) {
+ fprintf(stderr,"line %d",p->source->line);
+ };
+ if (p->inverted) fprintf(stderr," predicate inverted !");
+ fprintf(stderr,"\n");
+ for (i=0; i<depth ; i++) {
+ fprintf(stderr," ");
+ };
+ fprintf(stderr,"scontext: ");
+ dumpset(p->scontext[1]);
+ for (i=0; i<depth ; i++) {
+ fprintf(stderr," ");
+ };
+ fprintf(stderr,"tcontext: ");
+ preorder(p->tcontext);
+ fprintf(stderr,"\n");
+ };
+ fprintf(stderr,"\n");
+ if (p->down != NULL) {
+ dumppred1(depth+1,p->down);
+ };
+ if (p->right != NULL) {
+ dumppred1(depth,p->right);
+ };
+}
+
+#ifdef __USE_PROTOS
+void dumppred(Predicate *p)
+#else
+void dumppred(p)
+ Predicate *p;
+#endif
+{
+ fprintf(stderr,"---------------------------------\n");
+ dumppred1(0,p);
+ fprintf(stderr,"\n");
+}
+
+#ifdef __USE_PROTOS
+void dumppredtree(Predicate *p)
+#else
+void dumppredtree(p)
+ Predicate *p;
+#endif
+{
+ fprintf(stderr,"predicate k=%d \"%s\" line %d\n",p->k,p->expr,p->source->line);
+ dumpset(p->scontext[1]);
+}
+
+#ifdef __USE_PROTOS
+void dumppredexpr(Predicate *p)
+#else
+void dumppredexpr(p)
+ Predicate *p;
+#endif
+{
+ fprintf(stderr," pred expr \"%s\"\n",p->expr);
+}
+
+#ifdef __USE_PROTOS
+void dt(Tree *t)
+#else
+void dt(t)
+ Tree *t;
+#endif
+{
+ MR_dumpTreeF(stderr,0,t,5);
+}
+
+#ifdef __USE_PROTOS
+void d(Node * p)
+#else
+void d(p)
+ Node * p;
+#endif
+{
+
+ Junction *j;
+ RuleRefNode *r;
+ TokNode *t;
+ ActionNode *a;
+
+ if (p==NULL) {
+ fprintf(stderr,"dumpNode: Node is NULL");
+ return;
+ };
+
+ switch (p->ntype) {
+ case nJunction :
+ j = (Junction *) p;
+ fprintf(stderr, "Junction (#%d in rule %s line %d) ",j->seq,j->rname,j->line);
+ if (j->guess) fprintf(stderr,"guess block ");
+ switch (j->jtype ) {
+ case aSubBlk :
+ fprintf(stderr,"aSubBlk");
+ break;
+ case aOptBlk :
+ fprintf(stderr,"aOptBlk");
+ break;
+ case aLoopBegin :
+ fprintf(stderr,"aLoopBeginBlk");
+ break;
+ case aLoopBlk :
+ fprintf(stderr,"aLoopBlk");
+ break;
+ case aPlusBlk :
+ fprintf(stderr,"aPlusBlk");
+ break;
+ case EndBlk :
+ fprintf(stderr,"EndBlk");
+ break;
+ case RuleBlk :
+ fprintf(stderr,"RuleBlk");
+ break;
+ case Generic :
+ fprintf(stderr,"Generic");
+ break;
+ case EndRule :
+ fprintf(stderr,"EndRule");
+ break;
+ };
+ if (j->halt) fprintf(stderr," halt!");
+ if (j->p1) fprintf(stderr," p1 valid");
+ if (j->p2) {
+ if (j->p2->ntype == nJunction) {
+ fprintf(stderr," (p2=#%d)",( (Junction *) j->p2)->seq);
+ } else {
+ fprintf(stderr," (p2 valid)");
+ };
+ };
+ if (j->ignore) fprintf(stderr, " ignore/plus-block-bypass");
+ if (j->fset != NULL && set_deg(*j->fset) != 0) {
+ fprintf(stderr,"\nfset:\n");
+ dumpset(*j->fset);
+ };
+ if (j->ftree != NULL) {
+ fprintf(stderr,"\nftree:\n");
+ preorder(j->ftree);
+ };
+ fprintf(stderr,"\n");
+ break;
+ case nRuleRef :
+ r = (RuleRefNode *) p;
+ fprintf(stderr, "RuleRefNode (in rule %s line %d) to rule %s\n", r->rname,r->line,r->text);
+ break;
+ case nToken :
+ t = (TokNode *) p;
+ fprintf(stderr, "TokNode (in rule %s line %d) token %s\n",t->rname,t->line,TerminalString(t->token));
+ break;
+ case nAction :
+ a =(ActionNode *) p;
+ if (a->is_predicate) {
+ fprintf(stderr, "Predicate (in rule %s line %d) %s",a->rname,a->line,a->action);
+ if (a->inverted) fprintf(stderr," action inverted !");
+ if (a->guardpred != NULL) {
+ fprintf(stderr," guarded");
+ dumppredexpr(a->guardpred);
+ if (a->ampersandPred) {
+ fprintf(stderr," \"&&\" style");
+ } else {
+ fprintf(stderr," \"=>\" style");
+ };
+ };
+ if (a->predEntry != NULL) fprintf(stderr," predEntry \"%s\" ",a->predEntry->str);
+ fprintf(stderr,"\n");
+ } else if (a->init_action) {
+ fprintf(stderr, "Init-Action (in rule %s line %d) %s\n",a->rname,a->line,a->action);
+ } else {
+ fprintf(stderr, "Action (in rule %s line %d) %s\n",a->rname,a->line,a->action);
+ };
+ break;
+ };
+}
+
+#ifdef __USE_PROTOS
+Node * dp1(Node * p)
+#else
+Node * dp1(p)
+ Node * p;
+#endif
+{
+ Node *result=NULL;
+
+ if (p->ntype == nJunction) {
+ result=( (Junction *) p )->p1;
+ d(result);
+ } else {
+ fprintf(stderr,"dp1: Not a Junction node");
+ };
+ return result;
+}
+
+#ifdef __USE_PROTOS
+Node * dp2(Node * p)
+#else
+Node * dp2(p)
+ Node * p;
+#endif
+{
+ Node *result=NULL;
+
+ if (p->ntype == nJunction) {
+ result=( (Junction *) p )->p2;
+ d(result);
+ } else {
+ fprintf(stderr,"dp2: Not a Junction node");
+ };
+ return result;
+}
+
+#ifdef __USE_PROTOS
+Node * dn(Node * p)
+#else
+Node * dn(p)
+ Node * p;
+#endif
+
+{
+ Node *result=NULL;
+
+ if (p->ntype == nRuleRef) {
+ result=( (RuleRefNode *)p )->next;
+ } else if (p->ntype == nAction) {
+ result=( (ActionNode *)p )->next;
+ } else if (p->ntype == nToken) {
+ result=( (TokNode *)p )->next;
+ } else {
+ fprintf(stderr,"No next field: Neither a RuleRefNode, ActionNode, nor TokNode");
+ };
+ if (result != NULL) d(result);
+ return result;
+}
+
+#ifdef __USE_PROTOS
+void df(Node * p)
+#else
+void df(p)
+ Node * p;
+#endif
+{
+ int count=0;
+ Node *next;
+
+ fprintf(stderr,"\n#%d ",++count);
+ d(p);
+
+ for (next=p; next != NULL && !isEndRule(next) ; ) {
+ fprintf(stderr,"#%d ",++count);
+ if (next->ntype == nJunction) {
+ next=dp1(next);
+ } else {
+ next=dn(next);
+ };
+ };
+}
+
+#ifdef __USE_PROTOS
+Node * dfn(Node * p,int target)
+#else
+Node * dfn(p,target)
+ Node * p;
+ int target;
+#endif
+{
+ Node *result=NULL;
+ int count=0;
+ Node *next;
+
+ fprintf(stderr,"#%d ",++count);
+ d(p);
+
+ for (next=p; next != NULL && !isEndRule(next) ; ) {
+ fprintf(stderr,"#%d ",++count);
+ if (next->ntype == nJunction) {
+ next=dp1(next);
+ } else {
+ next=dn(next);
+ };
+ if (count == target) {
+ result=next;
+ break;
+ };
+ };
+ return result;
+}
+
+
+static int findnodeMatch;
+
+#ifdef __USE_PROTOS
+Junction *findnode1(Node *n)
+#else
+Junction *findnode1(n)
+ Node *n;
+#endif
+{
+ Node *next;
+ Junction *j;
+ Junction *match;
+
+ if (n == NULL) return NULL;
+ if (n->ntype == nJunction) {
+ j=(Junction *) n;
+ if (j->seq == findnodeMatch) return j;
+ if (j->jtype == EndRule) return NULL;
+ if (j->jtype != RuleBlk && j->jtype != EndBlk) {
+ if (j->p2 != NULL && !j->ignore) {
+ match=findnode1(j->p2);
+ if (match != NULL) return match;
+ };
+ };
+ };
+ next=MR_advance(n);
+ return findnode1(next);
+}
+
+#ifdef __USE_PROTOS
+Junction *findnode(int match)
+#else
+Junction *findnode(match)
+ int match;
+#endif
+{
+ Junction *j;
+ Junction *result=NULL;
+
+ findnodeMatch=match;
+
+ for (j=SynDiag; j != NULL; j=(Junction *)j->p2) {
+ require (j->ntype == nJunction && j->jtype == RuleBlk,"Not a rule block");
+ result=findnode1( (Node *) j);
+ if (result != NULL) break;
+ };
+ if (result != NULL) {
+ d( (Node *) result);
+ };
+ return result;
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/egman.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/egman.c new file mode 100644 index 0000000000..c8a633fc06 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/egman.c @@ -0,0 +1,328 @@ +/*
+ * egman.c
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33MR10
+ * 2001
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "set.h"
+#include "syn.h"
+#include "hash.h"
+#include "generic.h"
+#include "proto.h"
+
+static ExceptionGroup **egArray=NULL; /* ExceptionGroup by BlkLevel */
+static LabelEntry **leArray=NULL; /* LabelEntry by BlkLevel */
+static Junction **altArray=NULL; /* start of alternates */
+static int arraySize=0;
+static int highWater=0;
+static ExceptionGroup *lastEG=NULL; /* used in altFixup() */
+static int lastBlkLevel=0; /* used in altFixup() */
+
+#ifdef __USE_PROTOS
+static void arrayCheck(void);
+#else
+static void arrayCheck();
+#endif
+
+/* Called to add an exception group for an alternative EG */
+
+#ifdef __USE_PROTOS
+void egAdd(ExceptionGroup * eg)
+#else
+void egAdd(eg)
+ExceptionGroup *eg;
+#endif
+{
+ int i;
+
+ ExceptionGroup *nextEG;
+ ExceptionGroup *innerEG;
+
+ LabelEntry *nextLE;
+ LabelEntry *innerLE;
+
+ Junction *nextAlt;
+ Junction *innerAlt;
+
+ lastEG=eg;
+ lastBlkLevel=BlkLevel;
+
+ arrayCheck();
+ eg->pendingLink=egArray[BlkLevel];
+ egArray[BlkLevel]=eg;
+
+ /* EG for alternates already have their altID filled in */
+
+ for (i=BlkLevel+1; i<=highWater ; i++) {
+ for (innerEG=egArray[i]; innerEG != NULL ; innerEG=nextEG) {
+ nextEG=innerEG->pendingLink;
+ innerEG->pendingLink=NULL;
+ innerEG->outerEG=eg;
+ };
+ egArray[i]=NULL;
+ };
+
+ /*
+ * for patching up the LabelEntry you might use an EG for the
+ * current alternative - unlike patching up an alternative EG
+ * i.e. start the loop at BlkLevel rather than (BlkLevel+1)
+ * fill it in only if the EG and the LE are for the very
+ * same alternative if they're at the same BlkLevel
+ * it's easier to leave the LE on this list (filled in) rather than
+ * trying to selectively remove it. It will eventually be
+ * removed anyway when the BlkLevel gets small enough.
+ */
+
+ for (i=BlkLevel; i<=highWater ; i++) {
+ for (innerLE=leArray[i]; innerLE != NULL ; innerLE=nextLE) {
+ nextLE=innerLE->pendingLink;
+ if (BlkLevel != i ||
+ innerLE->curAltNum == CurAltNum_array[BlkLevel]) {
+ if (innerLE->outerEG == NULL) {
+ innerLE->outerEG=eg;
+ };
+ };
+ };
+ if (BlkLevel != i) leArray[i]=NULL;
+ };
+
+/*
+ * For the start of alternatives it is necessary to make a
+ * distinction between the exception group for the current
+ * alternative and the "fallback" EG for the block which
+ * contains the alternative
+ *
+ * The fallback outerEG is used to handle the case where
+ * no alternative of a block matches. In that case the
+ * signal is "NoViableAlt" (or "NoSemViableAlt" and the
+ * generator needs the EG of the block CONTAINING the
+ * current one.
+ *
+ * rule: ( ( ( a
+ * | b
+ * )
+ * | c
+ * )
+ * | d
+ * );
+ */
+
+ for (i=BlkLevel; i <= highWater ; i++) {
+ for (innerAlt=altArray[i]; innerAlt != NULL ; innerAlt=nextAlt) {
+ nextAlt=innerAlt->pendingLink;
+
+ /* first fill in the EG for the current alternative */
+ /* but leave it on the list in order to get the fallback EG */
+ /* if the EG is at the same LEVEL as the alternative then */
+ /* fill it in only if in the very same alternative */
+ /* */
+ /* rule: ( a */
+ /* | b */
+ /* | c exception ... */
+ /* ) */
+ /* */
+ /* if the EG is outside the alternative (e.g. BlkLevel < i) */
+ /* then it doesn't matter about the alternative */
+ /* */
+ /* rule: ( a */
+ /* | b */
+ /* | c */
+ /* ) exception ... */
+ /* */
+
+#if 0
+ printf("BlkLevel=%d i=%d altnum=%d CurAltNum=%d altID=%s\n",
+ BlkLevel,i,innerAlt->curAltNum,CurAltNum_array[BlkLevel],eg->altID);
+#endif
+ if (BlkLevel != i ||
+ innerAlt->curAltNum == CurAltNum_array[BlkLevel]) {
+ if (innerAlt->exception_label == NULL) {
+ innerAlt->exception_label=eg->altID;
+ };
+ };
+
+ /* ocurs at a later pass then for the exception_label */
+ /* if an outerEG has been found then fill in the outer EG */
+ /* remove if from the list when the BlkLevel gets smaller */
+
+ if (BlkLevel != i) {
+ if (innerAlt->outerEG == NULL) {
+ innerAlt->outerEG=eg;
+ };
+ };
+ };
+ if (BlkLevel != i) altArray[i]=NULL;
+ };
+}
+
+#ifdef __USE_PROTOS
+void leAdd(LabelEntry * le)
+#else
+void leAdd(le)
+LabelEntry *le;
+#endif
+
+{
+ arrayCheck();
+ le->pendingLink=leArray[BlkLevel];
+ le->curAltNum=CurAltNum_array[BlkLevel];
+ leArray[BlkLevel]=le;
+}
+
+#ifdef __USE_PROTOS
+void altAdd(Junction *alt)
+#else
+void altAdd(alt)
+Junction *alt;
+#endif
+
+{
+ arrayCheck();
+#if 0
+ printf("BlkLevel=%d CurAltNum=%d\n",
+ BlkLevel,CurAltNum_array[BlkLevel]);
+#endif
+ alt->curAltNum=CurAltNum_array[BlkLevel];
+ alt->pendingLink=altArray[BlkLevel];
+ altArray[BlkLevel]=alt;
+}
+
+static void
+#ifdef __USE_PROTOS
+arrayCheck(void)
+#else
+arrayCheck()
+#endif
+{
+ ExceptionGroup **egArrayNew;
+ LabelEntry **leArrayNew;
+ Junction **altArrayNew;
+ int arraySizeNew;
+ int i;
+
+ if (BlkLevel > highWater) highWater=BlkLevel;
+
+ if (BlkLevel >= arraySize) {
+ arraySizeNew=BlkLevel+5; /* MR20 */
+ egArrayNew=(ExceptionGroup **)
+ calloc(arraySizeNew,sizeof(ExceptionGroup *));
+ leArrayNew=(LabelEntry **)
+ calloc(arraySizeNew,sizeof(LabelEntry *));
+ altArrayNew=(Junction **)
+ calloc(arraySizeNew,sizeof(Junction *));
+ for (i=0; i<arraySize ; i++) {
+ egArrayNew[i]=egArray[i];
+ leArrayNew[i]=leArray[i];
+ altArrayNew[i]=altArray[i];
+ };
+ arraySize=arraySizeNew;
+ if (egArray != NULL) free( (char *) egArray);
+ if (leArray != NULL) free( (char *) leArray);
+ if (altArray != NULL) free( (char *) altArray);
+ egArray=egArrayNew;
+ leArray=leArrayNew;
+ altArray=altArrayNew;
+ };
+}
+
+/* always call leFixup() BEFORE egFixup() */
+
+void
+#ifdef __USE_PROTOS
+egFixup(void)
+#else
+egFixup()
+#endif
+{
+ int i;
+ ExceptionGroup *nextEG;
+ ExceptionGroup *innerEG;
+
+ for (i=1; i<=highWater ; i++) {
+ for (innerEG=egArray[i]; innerEG != NULL ; innerEG=nextEG) {
+ nextEG=innerEG->pendingLink;
+ innerEG->pendingLink=NULL;
+ };
+ egArray[i]=NULL;
+ };
+ lastEG=NULL;
+ lastBlkLevel=0;
+}
+
+/* always call leFixup() BEFORE egFixup() */
+
+#ifdef __USE_PROTOS
+void leFixup(void)
+#else
+void leFixup()
+#endif
+{
+
+ int i;
+ LabelEntry *nextLE;
+ LabelEntry *innerLE;
+
+ for (i=BlkLevel; i<=highWater ; i++) {
+ for (innerLE=leArray[i]; innerLE != NULL ; innerLE=nextLE) {
+ nextLE=innerLE->pendingLink;
+ innerLE->pendingLink=NULL;
+ };
+ leArray[i]=NULL;
+ };
+}
+
+/* always call altFixup() BEFORE egFixup() */
+
+#ifdef __USE_PROTOS
+void altFixup(void)
+#else
+void altFixup()
+#endif
+{
+
+ int i;
+ Junction *nextAlt;
+ Junction *innerAlt;
+
+ for (i=BlkLevel; i<=highWater ; i++) {
+ for (innerAlt=altArray[i]; innerAlt != NULL ; innerAlt=nextAlt) {
+
+ /* if an outerEG has been found then fill in the outer EG */
+
+ if (lastBlkLevel <= i) {
+ if (innerAlt->outerEG == NULL) {
+ innerAlt->outerEG=lastEG;
+ };
+ };
+ nextAlt=innerAlt->pendingLink;
+ innerAlt->pendingLink=NULL;
+ };
+ altArray[i]=NULL;
+ };
+}
+
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/err.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/err.c new file mode 100644 index 0000000000..ca239398cf --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/err.c @@ -0,0 +1,538 @@ +/*
+ * A n t l r S e t s / E r r o r F i l e H e a d e r
+ *
+ * Generated from: antlr.g
+ *
+ * Terence Parr, Russell Quong, Will Cohen, and Hank Dietz: 1989-2001
+ * Parr Research Corporation
+ * with Purdue University Electrical Engineering
+ * With AHPCRC, University of Minnesota
+ * ANTLR Version 1.33MR33
+ */
+
+#define ANTLR_VERSION 13333
+#include "pcctscfg.h"
+#include "pccts_stdio.h"
+
+#include "pcctscfg.h"
+#include "set.h"
+#include <ctype.h>
+#include "syn.h"
+#include "hash.h"
+#include "generic.h"
+#define zzcr_attr(attr,tok,t)
+#define zzSET_SIZE 20
+#include "antlr.h"
+#include "tokens.h"
+#include "dlgdef.h"
+#include "err.h"
+
+ANTLRChar *zztokens[157]={
+ /* 00 */ "Invalid",
+ /* 01 */ "Eof",
+ /* 02 */ "QuotedTerm",
+ /* 03 */ "\\n|\\r|\\r\\n",
+ /* 04 */ "\\(\\n|\\r|\\r\\n)",
+ /* 05 */ "\\~[]",
+ /* 06 */ "~[\\n\\r\"\\]+",
+ /* 07 */ "\"",
+ /* 08 */ "\\n|\\r|\\r\\n",
+ /* 09 */ "\\(\\n|\\r|\\r\\n)",
+ /* 10 */ "\\~[]",
+ /* 11 */ "~[\\n\\r\"\\]+",
+ /* 12 */ "'",
+ /* 13 */ "\\n|\\r|\\r\\n",
+ /* 14 */ "\\~[]",
+ /* 15 */ "~[\\n\\r'\\]+",
+ /* 16 */ "\\*/",
+ /* 17 */ "\\*",
+ /* 18 */ "\\n|\\r|\\r\\n",
+ /* 19 */ "~[\\n\\r\\*]+",
+ /* 20 */ "\\*/",
+ /* 21 */ "\\*",
+ /* 22 */ "\\n|\\r|\\r\\n",
+ /* 23 */ "~[\\n\\r\\*]+",
+ /* 24 */ "\\n|\\r|\\r\\n",
+ /* 25 */ "~[\\n\\r]+",
+ /* 26 */ "\\n|\\r|\\r\\n",
+ /* 27 */ "~[\\n\\r]+",
+ /* 28 */ "\\n|\\r|\\r\\n",
+ /* 29 */ "~[\\n\\r]+",
+ /* 30 */ "\\*/",
+ /* 31 */ "\\*",
+ /* 32 */ "\\n|\\r|\\r\\n",
+ /* 33 */ "~[\\n\\r\\*]+",
+ /* 34 */ "Action",
+ /* 35 */ "Pred",
+ /* 36 */ "PassAction",
+ /* 37 */ "consumeUntil\\( [\\ \\t]* \\{~[\\}]+\\} [\\ \\t]* \\)",
+ /* 38 */ "consumeUntil\\( ~[\\)]+ \\)",
+ /* 39 */ "\\n|\\r|\\r\\n",
+ /* 40 */ "\\>",
+ /* 41 */ "$",
+ /* 42 */ "$$",
+ /* 43 */ "$\\[\\]",
+ /* 44 */ "$\\[",
+ /* 45 */ "$[0-9]+",
+ /* 46 */ "$[0-9]+.",
+ /* 47 */ "$[0-9]+.[0-9]+",
+ /* 48 */ "$[_a-zA-Z][_a-zA-Z0-9]*",
+ /* 49 */ "#0",
+ /* 50 */ "#\\[\\]",
+ /* 51 */ "#\\(\\)",
+ /* 52 */ "#[0-9]+",
+ /* 53 */ "#line[\\ \\t]* [0-9]+ {[\\ \\t]* \"~[\"]+\" ([\\ \\t]* [0-9]*)* } (\\n|\\r|\\r\\n)",
+ /* 54 */ "#line ~[\\n\\r]* (\\n|\\r|\\r\\n)",
+ /* 55 */ "#[_a-zA-Z][_a-zA-Z0-9]*",
+ /* 56 */ "#\\[",
+ /* 57 */ "#\\(",
+ /* 58 */ "#",
+ /* 59 */ "\\)",
+ /* 60 */ "\\[",
+ /* 61 */ "\\(",
+ /* 62 */ "\\\\]",
+ /* 63 */ "\\\\)",
+ /* 64 */ "\\>",
+ /* 65 */ "'",
+ /* 66 */ "\"",
+ /* 67 */ "\\$",
+ /* 68 */ "\\#",
+ /* 69 */ "\\(\\n|\\r|\\r\\n)",
+ /* 70 */ "\\~[\\]\\)>$#]",
+ /* 71 */ "/",
+ /* 72 */ "/\\*",
+ /* 73 */ "\\*/",
+ /* 74 */ "//",
+ /* 75 */ "~[\\n\\r\\)\\(\\$#\\>\\]\\[\"'/]+",
+ /* 76 */ "[\\t\\ ]+",
+ /* 77 */ "\\n|\\r|\\r\\n",
+ /* 78 */ "\\[",
+ /* 79 */ "\\<\\<",
+ /* 80 */ "\"",
+ /* 81 */ "/\\*",
+ /* 82 */ "\\*/",
+ /* 83 */ "//",
+ /* 84 */ "#line[\\ \\t]* [0-9]+ {[\\ \\t]* \"~[\"]+\" ([\\ \\t]* [0-9]*)* } (\\n|\\r|\\r\\n)",
+ /* 85 */ "#line ~[\\n\\r]* (\\n|\\r|\\r\\n)",
+ /* 86 */ "\\>\\>",
+ /* 87 */ "WildCard",
+ /* 88 */ "\\@",
+ /* 89 */ "LABEL",
+ /* 90 */ "grammar-element",
+ /* 91 */ "meta-symbol",
+ /* 92 */ "Pragma",
+ /* 93 */ "FirstSetSymbol",
+ /* 94 */ "{\\}#header",
+ /* 95 */ "{\\}#first",
+ /* 96 */ "{\\}#parser",
+ /* 97 */ "{\\}#tokdefs",
+ /* 98 */ "\\}",
+ /* 99 */ "class",
+ /* 100 */ "NonTerminal",
+ /* 101 */ "TokenTerm",
+ /* 102 */ "\\{",
+ /* 103 */ "!",
+ /* 104 */ "\\<",
+ /* 105 */ "\\>",
+ /* 106 */ ":",
+ /* 107 */ ";",
+ /* 108 */ "{\\}#lexaction",
+ /* 109 */ "{\\}#lexmember",
+ /* 110 */ "{\\}#lexprefix",
+ /* 111 */ "{\\}#pred",
+ /* 112 */ "\\|\\|",
+ /* 113 */ "&&",
+ /* 114 */ "\\(",
+ /* 115 */ "\\)",
+ /* 116 */ "{\\}#lexclass",
+ /* 117 */ "{\\}#errclass",
+ /* 118 */ "{\\}#tokclass",
+ /* 119 */ "..",
+ /* 120 */ "{\\}#token",
+ /* 121 */ "=",
+ /* 122 */ "[0-9]+",
+ /* 123 */ "\\|",
+ /* 124 */ "\\~",
+ /* 125 */ "^",
+ /* 126 */ "approx",
+ /* 127 */ "LL\\(1\\)",
+ /* 128 */ "LL\\(2\\)",
+ /* 129 */ "\\*",
+ /* 130 */ "\\+",
+ /* 131 */ "?",
+ /* 132 */ "=>",
+ /* 133 */ "exception",
+ /* 134 */ "default",
+ /* 135 */ "catch",
+ /* 136 */ "{\\}#[A-Za-z0-9_]*",
+ /* 137 */ "[\\t\\ ]+",
+ /* 138 */ "\\n|\\r|\\r\\n",
+ /* 139 */ "//",
+ /* 140 */ "/\\*",
+ /* 141 */ "#ifdef",
+ /* 142 */ "#if",
+ /* 143 */ "#ifndef",
+ /* 144 */ "#else",
+ /* 145 */ "#endif",
+ /* 146 */ "#undef",
+ /* 147 */ "#import",
+ /* 148 */ "ID",
+ /* 149 */ "#define",
+ /* 150 */ "INT",
+ /* 151 */ "enum",
+ /* 152 */ "\\{",
+ /* 153 */ "=",
+ /* 154 */ ",",
+ /* 155 */ "\\}",
+ /* 156 */ ";"
+};
+SetWordType zzerr1[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x30,0x0,0x0,0x0, 0x0,0x0,0x0,0x0};
+SetWordType zzerr2[20] = {0xfc,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xf3,
+ 0xbf,0xff,0xff,0xff, 0xff,0xff,0xff,0x1f};
+SetWordType zzerr3[20] = {0xfc,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xfb,
+ 0x3b,0xf7,0xf7,0xc7, 0xff,0xff,0xff,0x1f};
+SetWordType zzerr4[20] = {0x4,0x0,0x0,0x0, 0x10,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x80,0x7,0x0,0x0, 0x0,0x0,0x0,0x0};
+SetWordType setwd1[157] = {0x0,0x50,0xa0,0x20,0x20,0x20,0x20,
+ 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
+ 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
+ 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
+ 0x20,0x20,0x20,0x6a,0x20,0xa0,0x20,0x20,
+ 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
+ 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
+ 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
+ 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
+ 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
+ 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
+ 0x20,0x20,0x20,0x0,0x0,0x20,0x20,0x21,
+ 0x21,0x21,0x21,0x6e,0x6e,0x64,0x20,0x0,
+ 0x20,0xa0,0xa0,0xa0,0x20,0x6a,0x6a,0x6a,
+ 0x6e,0x20,0x20,0x20,0x20,0x66,0x6e,0x6e,
+ 0x20,0x66,0x20,0x20,0x20,0x20,0x20,0x20,
+ 0x20,0x20,0x20,0x20,0x20,0x20,0x62,0x20,
+ 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
+ 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
+ 0x20,0x20,0x20,0x20,0x20,0x20};
+SetWordType zzerr5[20] = {0x0,0x0,0x0,0x0, 0x10,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x0,0x1,0x0,0x0, 0x0,0x0,0x0,0x0};
+SetWordType zzerr6[20] = {0x4,0x0,0x0,0x0, 0x10,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x0,0x7,0x0,0x0, 0x0,0x0,0x0,0x0};
+SetWordType zzerr7[20] = {0x4,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x0,0x6,0x0,0x0, 0x0,0x0,0x0,0x0};
+SetWordType zzerr8[20] = {0x4,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x0,0x4,0x0,0x0, 0x0,0x0,0x0,0x0};
+SetWordType zzerr9[20] = {0x2,0x0,0x0,0x0, 0x4,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x1c,0xf0,0x70,0x1, 0x20,0x0,0x0,0x0};
+SetWordType setwd2[157] = {0x0,0xf8,0x6,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0xf8,0x0,0x1,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0xf8,0xf8,0xf8,0x0,0x0,
+ 0x0,0x1,0x2,0x6,0x0,0xf8,0xf8,0xf8,
+ 0xf8,0x0,0x0,0x0,0x0,0xf8,0xf8,0xf8,
+ 0x0,0xf8,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0xe8,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0};
+SetWordType zzerr10[20] = {0x2,0x0,0x0,0x0, 0x4,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0xbc,0xf8,0x74,0x1, 0x20,0x0,0x0,0x0};
+SetWordType zzerr11[20] = {0x0,0x0,0x0,0x0, 0x8,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0xa0,0x0,0x4,0x0, 0x0,0x0,0x0,0x0};
+SetWordType zzerr12[20] = {0x2,0x0,0x0,0x0, 0x4,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x1c,0xf8,0x70,0x1, 0x20,0x0,0x0,0x0};
+SetWordType zzerr13[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0xa0,0x0,0x4,0x0, 0x0,0x0,0x0,0x0};
+SetWordType setwd3[157] = {0x0,0xfa,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0xfa,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0xfa,0xfa,0xfa,0x5,0x0,
+ 0x5,0x0,0x0,0x0,0xe2,0xfa,0xfa,0xfa,
+ 0xfa,0xc0,0x80,0x5,0xe0,0xfa,0xfa,0xfa,
+ 0x0,0xfa,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0xfa,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0};
+SetWordType zzerr14[20] = {0x4,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x20,0x0,0x0,0x0, 0x0,0x0,0x0,0x0};
+SetWordType zzerr15[20] = {0x4,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x30,0x0,0x0,0x0, 0x0,0x0,0x0,0x0};
+SetWordType zzerr16[20] = {0x4,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x30,0x0,0x0,0x0, 0x0,0x0,0x0,0x0};
+SetWordType zzerr17[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x40,0x0,0x4,0x0, 0x0,0x0,0x0,0x0};
+SetWordType zzerr18[20] = {0x4,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x24,0x0,0x80,0x0, 0x0,0x0,0x0,0x0};
+SetWordType zzerr19[20] = {0x4,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x20,0x0,0x0,0x0, 0x0,0x0,0x0,0x0};
+SetWordType zzerr20[20] = {0x6,0x0,0x0,0x0, 0x4,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x1c,0xf8,0x74,0x3, 0x20,0x0,0x0,0x0};
+SetWordType zzerr21[20] = {0x6,0x0,0x0,0x0, 0x4,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x1c,0xf8,0x70,0x3, 0x20,0x0,0x0,0x0};
+SetWordType setwd4[157] = {0x0,0xe5,0xda,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0xe5,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0xed,0xe5,0xe7,0x1a,0x0,
+ 0x0,0x0,0x0,0x0,0xc0,0xe5,0xe5,0xe5,
+ 0xe5,0x0,0x0,0x0,0x0,0xe5,0xe5,0xe5,
+ 0x0,0xe5,0x40,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0xe5,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0};
+SetWordType zzerr22[20] = {0x6,0x0,0x0,0x0, 0x4,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x3c,0xf8,0x70,0x1, 0x20,0x0,0x0,0x0};
+SetWordType zzerr23[20] = {0x6,0x0,0x0,0x0, 0x4,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x1c,0xf8,0x70,0x1, 0x20,0x0,0x0,0x0};
+SetWordType zzerr24[20] = {0x2,0x0,0x0,0x0, 0x4,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x1c,0xf8,0x70,0x1, 0x20,0x0,0x0,0x0};
+SetWordType zzerr25[20] = {0x2,0x0,0x0,0x0, 0x4,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x1c,0xf8,0x70,0x1, 0x20,0x0,0x0,0x0};
+SetWordType zzerr26[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x5,
+ 0x4,0x8,0x8,0x18, 0x20,0x0,0x0,0x0};
+SetWordType setwd5[157] = {0x0,0x1f,0xc1,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0xdf,0xc0,0xc0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0xc0,0x0,0xc0,0x0,0x0,0xc0,0xc0,0x0,
+ 0x0,0x0,0x0,0x7f,0x1f,0xdf,0xc0,0xc0,
+ 0x0,0x0,0xc0,0x0,0x67,0x1f,0x1f,0x1f,
+ 0x1f,0x0,0x0,0xc0,0x60,0x1f,0x1f,0x1f,
+ 0x0,0x1f,0x0,0x0,0x40,0xc0,0x0,0x0,
+ 0x0,0x0,0xc0,0xc0,0x0,0x0,0x5f,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0};
+SetWordType zzerr27[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x4,
+ 0x0,0x0,0x0,0x10, 0x0,0x0,0x0,0x0};
+SetWordType zzerr28[20] = {0x4,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x80,0x2,
+ 0x30,0x0,0x0,0x0, 0x0,0x0,0x0,0x0};
+SetWordType zzerr29[20] = {0x4,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x20,0x0,0x0,0x0, 0x0,0x0,0x0,0x0};
+SetWordType zzerr30[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0xd,
+ 0x0,0x0,0x80,0x0, 0x20,0x0,0x0,0x0};
+SetWordType zzerr31[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0xd,
+ 0x0,0x0,0x0,0x0, 0x20,0x0,0x0,0x0};
+SetWordType zzerr32[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x5,
+ 0x4,0x8,0x8,0x18, 0x20,0x0,0x0,0x0};
+SetWordType zzerr33[20] = {0x4,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x20,0x0,0x0,0x0, 0x0,0x0,0x0,0x0};
+SetWordType setwd6[157] = {0x0,0x0,0xfd,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0xe1,0xe1,0xe1,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0xfd,0x60,0xe9,0x0,0x0,0xe1,0xe1,0x0,
+ 0x0,0x0,0x0,0xe2,0x0,0xfd,0xfd,0xe1,
+ 0x20,0x0,0xe1,0x0,0xe2,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0xe1,0xe2,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0xe2,0xe0,0x20,0x0,
+ 0x0,0x0,0xe1,0xe1,0x0,0x0,0xe2,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0};
+SetWordType zzerr34[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0xd,
+ 0x0,0x0,0x80,0x0, 0x20,0x0,0x0,0x0};
+SetWordType zzerr35[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0xd,
+ 0x0,0x0,0x0,0x0, 0x20,0x0,0x0,0x0};
+SetWordType zzerr36[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x5,
+ 0x4,0x8,0x8,0x18, 0x20,0x0,0x0,0x0};
+SetWordType zzerr37[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0xc,
+ 0x0,0x0,0x0,0x0, 0x20,0x0,0x0,0x0};
+SetWordType zzerr38[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x4,
+ 0x84,0x9,0x8,0x18, 0x20,0x0,0x0,0x0};
+SetWordType zzerr39[20] = {0x0,0x0,0x0,0x0, 0x10,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x0,0x1,0x0,0x0, 0x0,0x0,0x0,0x0};
+SetWordType zzerr40[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x4,
+ 0x4,0x9,0x8,0x18, 0x20,0x0,0x0,0x0};
+SetWordType zzerr41[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x4,
+ 0x4,0x8,0x8,0x18, 0x20,0x0,0x0,0x0};
+SetWordType zzerr42[20] = {0x4,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x80,0x0,
+ 0x30,0x0,0x0,0x0, 0x0,0x0,0x0,0x0};
+SetWordType setwd7[157] = {0x0,0x0,0xdf,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0xdf,0xdf,0xff,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0xdf,0x3,0xdf,0x0,0x0,0xdf,0xdf,0x0,
+ 0x0,0x0,0x0,0xdf,0x0,0xdf,0xdf,0xdf,
+ 0x1,0x30,0xdf,0x0,0xdf,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0xdf,0xdf,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0xdf,0xdf,0x1,0x0,
+ 0x0,0x0,0xdf,0xdf,0x0,0x0,0xdf,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0};
+SetWordType zzerr43[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x4,
+ 0x4,0x8,0x8,0x18, 0x20,0x0,0x0,0x0};
+SetWordType zzerr44[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0xc0, 0x1,0x0,0x0,0x0};
+SetWordType zzerr45[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x30,
+ 0x40,0x0,0x4,0x0, 0x0,0x0,0x0,0x0};
+SetWordType zzerr46[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x30,0x0,0x0,0x0, 0x0,0x0,0x0,0x0};
+SetWordType zzerr47[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x20,
+ 0x40,0x0,0x4,0x0, 0x0,0x0,0x0,0x0};
+SetWordType zzerr48[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x2,0x0, 0x10,0x0,0x0,0x0};
+SetWordType zzerr49[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x4,
+ 0x4,0x8,0x8,0x18, 0x20,0x0,0x0,0x0};
+SetWordType zzerr50[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x4,
+ 0x4,0x8,0xa,0x18, 0x30,0x0,0x0,0x0};
+SetWordType zzerr51[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x4,
+ 0x4,0x8,0x8,0x18, 0x28,0x0,0x0,0x0};
+SetWordType zzerr52[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x40,0x0,0x4,0x0, 0x0,0x0,0x0,0x0};
+SetWordType zzerr53[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x4,
+ 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0};
+SetWordType setwd8[157] = {0x0,0x0,0xe1,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0xe1,0xe1,0xe1,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0xe1,0x0,0xe1,0x0,0x0,0xe3,0xe7,0x0,
+ 0x0,0x0,0x0,0xe1,0x0,0xe1,0xe1,0xef,
+ 0x0,0x0,0xe1,0x0,0xe1,0x0,0x0,0x0,
+ 0x0,0x0,0x10,0xef,0xe1,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0xe1,0xe1,0x0,0x0,
+ 0x0,0x0,0xe1,0xe1,0x0,0x10,0xe1,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0};
+SetWordType zzerr54[20] = {0x2,0x0,0x0,0x0, 0x14,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x1c,0xf8,0x78,0x9, 0xe0,0x0,0x0,0x0};
+SetWordType zzerr55[20] = {0x2,0x0,0x0,0x0, 0x4,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x1c,0xf8,0x78,0x9, 0x60,0x0,0x0,0x0};
+SetWordType zzerr56[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x30,0x0,0x0,0x0, 0x0,0x0,0x0,0x0};
+SetWordType zzerr57[20] = {0x2,0x0,0x0,0x0, 0x4,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x1c,0xf8,0x78,0x9, 0xe0,0x0,0x0,0x0};
+SetWordType setwd9[157] = {0x0,0x7c,0x1,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x7f,0x1,0x1,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x1,0x0,0x1,0x0,0x0,0x1,0x1,0x0,
+ 0x0,0x0,0x0,0x7f,0x7e,0x7f,0x1,0x1,
+ 0x0,0x0,0x1,0x0,0x7d,0x7e,0x7e,0x7e,
+ 0x7e,0x0,0x0,0x1,0x7d,0x7e,0x7e,0x7e,
+ 0x0,0x7e,0x0,0x0,0x7d,0x1,0x0,0x0,
+ 0x0,0x0,0x1,0x1,0x0,0x0,0x7f,0x64,
+ 0x64,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x80,0x0,0x0,0x0,0x0,0x0,0x80,0x0,
+ 0x80,0x0,0x0,0x0,0x0,0x0};
+SetWordType zzerr58[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0, 0x0,0x0,0xa0,0x0};
+SetWordType zzerr59[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0, 0x0,0x80,0xa0,0x0};
+SetWordType zzerr60[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0, 0x0,0x0,0xa0,0x0};
+SetWordType zzerr61[20] = {0x2,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0, 0x0,0x80,0xa0,0x0};
+SetWordType zzerr62[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0xe};
+SetWordType zzerr63[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0xe};
+SetWordType zzerr64[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0xe};
+SetWordType zzerr65[20] = {0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0, 0x0,0x0,0x10,0xc};
+SetWordType setwd10[157] = {0x0,0xc,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x0,
+ 0x3,0x0,0x0,0xf0,0xf0,0x0};
+SetWordType setwd11[157] = {0x0,0x1,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
+ 0x1,0x0,0x0,0x0,0x0,0x0};
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/fcache.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/fcache.c new file mode 100644 index 0000000000..ff7dcdfdd5 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/fcache.c @@ -0,0 +1,123 @@ +/*
+ * fcache.c
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33MR10
+ *
+ */
+
+#include <stdio.h>
+#include <ctype.h>
+
+#include "pcctscfg.h"
+
+#include "set.h"
+#include "syn.h"
+#include "hash.h"
+#include "generic.h"
+
+#ifdef __USE_PROTOS
+CacheEntry *dumpFcache1(char *prev)
+#else
+CacheEntry *dumpFcache1(prev)
+ char *prev;
+#endif
+{
+ Entry **table=Fcache;
+
+ int low=0;
+ int hi=0;
+
+ CacheEntry *least=NULL;
+
+ Entry **p;
+
+ for (p=table; p<&(table[HashTableSize]); p++) {
+
+ CacheEntry *q =(CacheEntry *) *p;
+
+ if ( q != NULL && low==0 ) low = p-table;
+ while ( q != NULL ) {
+ if (strcmp(q->str,prev) > 0) {
+ if (least == NULL) {
+ least=q;
+ } else {
+ if (strcmp(q->str,least->str) < 0) {
+ least=q;
+ };
+ };
+ };
+ q = q->next;
+ };
+
+ if ( *p != NULL ) hi = p-table;
+ }
+ return least;
+}
+
+#ifdef __USE_PROTOS
+void reportFcache(CacheEntry *q)
+#else
+void reportFcache(q)
+ CacheEntry *q;
+#endif
+{
+ char *qstr;
+
+ fprintf(stdout,"\nrule ");
+ for (qstr=q->str; *qstr != '*' ; qstr++) {
+ fprintf(stdout,"%c",*qstr);
+ };
+
+ qstr++;
+ if (*qstr == 'i') fprintf(stdout," First[");
+ if (*qstr == 'o') fprintf(stdout," Follow[");
+ qstr++;
+ fprintf(stdout,"%s]",qstr);
+ if (q->incomplete) fprintf(stdout," *** incomplete ***");
+ fprintf(stdout,"\n");
+ MR_dumpTokenSet(stdout,1,q->fset);
+}
+
+void
+#ifdef __USE_PROTOS
+DumpFcache(void)
+#else
+DumpFcache()
+#endif
+{
+
+ char *prev="";
+ int n=0;
+ CacheEntry *next;
+
+ fprintf(stdout,"\n\nDump of First/Follow Cache\n");
+
+ for(;;) {
+ next=dumpFcache1(prev);
+ if (next == NULL) break;
+ reportFcache(next);
+ ++n;
+ prev=next->str;
+ };
+ fprintf(stdout,"\nEnd dump of First/Follow Cache\n");
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/fset.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/fset.c new file mode 100644 index 0000000000..e1a76ec620 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/fset.c @@ -0,0 +1,1555 @@ +/*
+ * fset.c
+ *
+ * Compute FIRST and FOLLOW sets.
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2001
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "pcctscfg.h"
+
+#include "set.h"
+#include "syn.h"
+#include "hash.h"
+#include "generic.h"
+#include "dlgdef.h"
+#include "limits.h"
+
+#ifdef __USE_PROTOS
+static void ensure_predicates_cover_ambiguous_lookahead_sequences
+ (Junction *, Junction *, char *, Tree *);
+#else
+static void ensure_predicates_cover_ambiguous_lookahead_sequences();
+#endif
+
+/*
+ * What tokens are k tokens away from junction q?
+ *
+ * Follow both p1 and p2 paths (unless RuleBlk) to collect the tokens k away from this
+ * node.
+ * We lock the junction according to k--the lookahead. If we have been at this
+ * junction before looking for the same, k, number of lookahead tokens, we will
+ * do it again and again...until we blow up the stack. Locks are only used on aLoopBlk,
+ * RuleBlk, aPlusBlk and EndRule junctions to remove/detect infinite recursion from
+ * FIRST and FOLLOW calcs.
+ *
+ * If p->jtype == EndRule we are going to attempt a FOLLOW. (FOLLOWs are really defined
+ * in terms of FIRST's, however). To proceed with the FOLLOW, p->halt cannot be
+ * set. p->halt is set to indicate that a reference to the current rule is in progress
+ * and the FOLLOW is not desirable.
+ *
+ * If we attempt a FOLLOW and find that there is no FOLLOW or REACHing beyond the EndRule
+ * junction yields an empty set, replace the empty set with EOF. No FOLLOW means that
+ * only EOF can follow the current rule. This normally occurs only on the start symbol
+ * since all other rules are referenced by another rule somewhere.
+ *
+ * Normally, both p1 and p2 are followed. However, checking p2 on a RuleBlk node is
+ * the same as checking the next rule which is clearly incorrect.
+ *
+ * Cycles in the FOLLOW sense are possible. e.g. Fo(c) requires Fo(b) which requires
+ * Fo(c). Both Fo(b) and Fo(c) are defined to be Fo(b) union Fo(c). Let's say
+ * Fo(c) is attempted first. It finds all of the FOLLOW symbols and then attempts
+ * to do Fo(b) which finds of its FOLLOW symbols. So, we have:
+ *
+ * Fo(c)
+ * / \
+ * a set Fo(b)
+ * / \
+ * a set Fo(c) .....Hmmmm..... Infinite recursion!
+ *
+ * The 2nd Fo(c) is not attempted and Fo(b) is left deficient, but Fo(c) is now
+ * correctly Fo(c) union Fo(b). We wish to pick up where we left off, so the fact
+ * that Fo(b) terminated early means that we lack Fo(c) in the Fo(b) set already
+ * laying around. SOOOOoooo, we track FOLLOW cycles. All FOLLOW computations are
+ * cached in a hash table. After the sequence of FOLLOWs finish, we reconcile all
+ * cycles --> correct all Fo(rule) sets in the cache.
+ *
+ * Confused? Good! Read my MS thesis [Purdue Technical Report TR90-30].
+ * TJP 8/93 -- can now read PhD thesis from Purdue.
+ *
+ * Also, FIRST sets are cached in the hash table. Keys are (rulename,Fi/Fo,k).
+ * Only FIRST sets, for which the FOLLOW is not included, are stored.
+ *
+ * SPECIAL CASE of (...)+ blocks:
+ * I added an optional alt so that the alts could see what
+ * was behind the (...)+ block--thus using enough lookahead
+ * to branch out rather than just enough to distinguish
+ * between alts in the (...)+. However, when the FIRST("(...)+") is
+ * is needed, must not use this last "optional" alt. This routine
+ * turns off this path by setting a new 'ignore' flag for
+ * the alt and then resetting it afterwards.
+ */
+
+set
+#ifdef __USE_PROTOS
+rJunc( Junction *p, int k, set *rk )
+#else
+rJunc( p, k, rk )
+Junction *p;
+int k;
+set *rk;
+#endif
+{
+ set a, b;
+
+ require(p!=NULL, "rJunc: NULL node");
+ require(p->ntype==nJunction, "rJunc: not junction");
+
+#ifdef DBG_LL1
+ if ( p->jtype == RuleBlk ) fprintf(stderr, "FIRST(%s,%d) \n",((Junction *)p)->rname,k);
+ else fprintf(stderr, "rJunc: %s in rule %s\n",
+ decodeJType[p->jtype], ((Junction *)p)->rname);
+#endif
+ /* if this is one of the added optional alts for (...)+ then return */
+
+ /* no need to pop backtrace - hasn't been pushed */
+
+ if ( p->ignore ) return empty;
+
+ if (MR_MaintainBackTrace) MR_pointerStackPush(&MR_BackTraceStack,p);
+
+/* MR14 */ if (AlphaBetaTrace && p->alpha_beta_guess_end) {
+/* MR14 */ warnFL(
+/* MR14 */ "not possible to compute follow set for alpha in an \"(alpha)? beta\" block. ",
+/* MR14 */ FileStr[p->file],p->line);
+/* MR14 */ MR_alphaBetaTraceReport();
+/* MR14 */ };
+
+/* MR14 */ if (p->alpha_beta_guess_end) {
+/* MR14 */ if (MR_MaintainBackTrace) MR_pointerStackPop(&MR_BackTraceStack);
+/* MR14 */ return empty;
+/* MR14 */ }
+
+ /* locks are valid for aLoopBlk,aPlusBlk,RuleBlk,EndRule junctions only */
+ if ( p->jtype==aLoopBlk || p->jtype==RuleBlk ||
+ p->jtype==aPlusBlk || p->jtype==EndRule )
+ {
+ require(p->lock!=NULL, "rJunc: lock array is NULL");
+ if ( p->lock[k] )
+ {
+ if ( p->jtype == EndRule ) /* FOLLOW cycle? */
+ {
+#ifdef DBG_LL1
+ fprintf(stderr, "FOLLOW cycle to %s: panic!\n", p->rname);
+#endif
+ if (! MR_AmbSourceSearch) RegisterCycle(p->rname, k);
+ }
+ if (MR_MaintainBackTrace) MR_pointerStackPop(&MR_BackTraceStack);
+ return empty;
+ }
+ if ( p->jtype == RuleBlk &&
+ p->end->halt &&
+ ! MR_AmbSourceSearch) /* check for FIRST cache */
+ {
+ CacheEntry *q = (CacheEntry *) hash_get(Fcache, Fkey(p->rname,'i',k));
+ if ( q != NULL )
+ {
+ set_orin(rk, q->rk);
+ if (MR_MaintainBackTrace) MR_pointerStackPop(&MR_BackTraceStack);
+ return set_dup( q->fset );
+ }
+ }
+ if ( p->jtype == EndRule &&
+ !p->halt && /* MR11 was using cache even when halt set */
+ ! MR_AmbSourceSearch) /* FOLLOW set cached already? */
+ {
+ CacheEntry *q = (CacheEntry *) hash_get(Fcache, Fkey(p->rname,'o',k));
+ if ( q != NULL )
+ {
+#ifdef DBG_LL1
+ fprintf(stderr, "cache for FOLLOW(%s,%d):", p->rname,k);
+ s_fprT(stderr, q->fset);
+ if ( q->incomplete ) fprintf(stderr, " (incomplete)");
+ fprintf(stderr, "\n");
+#endif
+ if ( !q->incomplete )
+ {
+ if (MR_MaintainBackTrace) MR_pointerStackPop(&MR_BackTraceStack);
+ return set_dup( q->fset );
+ }
+ }
+ }
+ p->lock[k] = TRUE; /* This rule is busy */
+ }
+
+ a = b = empty;
+
+ if ( p->jtype == EndRule )
+ {
+ if (p->halt ) /* don't want FOLLOW here? */ /* unless MR10 hoisting */
+ {
+ p->lock[k] = FALSE;
+ set_orel(k, rk); /* indicate this k value needed */
+ if (MR_MaintainBackTrace) MR_pointerStackPop(&MR_BackTraceStack);
+ return empty;
+ }
+ if (! MR_AmbSourceSearch) FoPush(p->rname, k); /* Attempting FOLLOW */
+ if ( p->p1 == NULL ) set_orel((TokenInd!=NULL?TokenInd[EofToken]:EofToken), &a);/* if no FOLLOW assume EOF */
+#ifdef DBG_LL1
+ fprintf(stderr, "-->FOLLOW(%s,%d)\n", p->rname,k);
+#endif
+ }
+
+ if ( p->p1 != NULL ) {
+/* MR14 */ if (p->guess) {
+/* MR14 */ if (p->guess_analysis_point == NULL) {
+/* MR14 */ Node * guess_point;
+/* MR14 */ guess_point=(Node *)analysis_point(p);
+/* MR14 */ if (guess_point == (Node *)p) {
+/* MR14 */ guess_point=p->p1;
+/* MR14 */ }
+/* MR14 */ p->guess_analysis_point=guess_point;
+/* MR14 */ }
+/* MR14 */ REACH(p->guess_analysis_point, k, rk, a);
+ } else {
+ REACH(p->p1, k, rk, a);
+ }
+ }
+
+ /* C a c h e R e s u l t s */
+
+ if ( p->jtype == RuleBlk && p->end->halt && ! MR_AmbSourceSearch) /* can save FIRST set? */
+ {
+ CacheEntry *q = newCacheEntry( Fkey(p->rname,'i',k) );
+ /*fprintf(stderr, "Caching %s FIRST %d\n", p->rname, k);*/
+ hash_add(Fcache, Fkey(p->rname,'i',k), (Entry *)q);
+ q->fset = set_dup( a );
+ q->rk = set_dup( *rk );
+ }
+
+ if ( p->jtype == EndRule &&
+ !p->halt && /* MR11 was using cache even with halt set */
+ ! MR_AmbSourceSearch) /* just completed FOLLOW? */
+ {
+ /* Cache Follow set */
+ CacheEntry *q = (CacheEntry *) hash_get(Fcache, Fkey(p->rname,'o',k));
+ if ( q==NULL )
+ {
+ q = newCacheEntry( Fkey(p->rname,'o',k) );
+ hash_add(Fcache, Fkey(p->rname,'o',k), (Entry *)q);
+ }
+ /*fprintf(stderr, "Caching %s FOLLOW %d\n", p->rname, k);*/
+ if ( set_nil(a) && !q->incomplete )
+ {
+ /* Don't ever save a nil set as complete.
+ * Turn it into an eof set.
+ */
+ set_orel(EofToken, &a);
+ }
+ set_orin(&(q->fset), a);
+ FoPop( k );
+ if ( FoTOS[k] == NULL && Cycles[k] != NULL ) ResolveFoCycles(k);
+#ifdef DBG_LL1
+ fprintf(stderr, "saving FOLLOW(%s,%d):", p->rname, k);
+ s_fprT(stderr, q->fset);
+ if ( q->incomplete ) fprintf(stderr, " (incomplete)");
+ fprintf(stderr, "\n");
+#endif
+ }
+
+ if (p->jtype != RuleBlk && p->p2 != NULL && /* MR14 */ ! p->guess) {
+ REACH(p->p2, k, rk, b);
+ }
+
+ if ( p->jtype==aLoopBlk || p->jtype==RuleBlk ||
+ p->jtype==aPlusBlk || p->jtype==EndRule )
+ p->lock[k] = FALSE; /* unlock node */
+
+ set_orin(&a, b);
+ set_free(b);
+ if (MR_MaintainBackTrace) MR_pointerStackPop(&MR_BackTraceStack);
+ return a;
+}
+
+set
+#ifdef __USE_PROTOS
+rRuleRef( RuleRefNode *p, int k, set *rk_out )
+#else
+rRuleRef( p, k, rk_out )
+RuleRefNode *p;
+int k;
+set *rk_out;
+#endif
+{
+ set rk;
+ Junction *r;
+ int k2;
+ set a, rk2, b;
+ int save_halt;
+ RuleEntry *q = (RuleEntry *) hash_get(Rname, p->text);
+ require(p!=NULL, "rRuleRef: NULL node");
+ require(p->ntype==nRuleRef, "rRuleRef: not rule ref");
+
+#ifdef DBG_LL1
+ fprintf(stderr, "rRuleRef: %s\n", p->text);
+#endif
+
+ if (MR_MaintainBackTrace) MR_pointerStackPush(&MR_BackTraceStack,p);
+
+ if ( q == NULL )
+ {
+ warnFL( eMsg1("rule %s not defined",p->text), FileStr[p->file], p->line );
+ REACH(p->next, k, rk_out, a);
+ if (MR_MaintainBackTrace) MR_pointerStackPop(&MR_BackTraceStack);
+ return a;
+ }
+ rk2 = empty;
+
+/* MR9 Problems with rule references in guarded predicates */
+/* MR9 Perhaps can use hash table to find rule ? */
+
+/* MR9 */ if (RulePtr == NULL) {
+/* MR9 */ fatalFL(eMsg2("Rule %s uses rule %s via RulePtr before it has been initialized",
+/* MR9 */ p->rname,q->str),FileStr[p->file],p->line);
+/* MR9 */ };
+
+ r = RulePtr[q->rulenum];
+ if ( r->lock[k] )
+ {
+ errNoFL( eMsg2("infinite left-recursion to rule %s from rule %s",
+ r->rname, p->rname) );
+
+ if (MR_MaintainBackTrace) MR_pointerStackPop(&MR_BackTraceStack);
+
+ return empty;
+ }
+
+ save_halt = r->end->halt;
+ r->end->halt = TRUE; /* don't let reach fall off end of rule here */
+ rk = empty;
+ REACH(r, k, &rk, a);
+ r->end->halt = save_halt;
+ while ( !set_nil(rk) ) {
+ k2 = set_int(rk); /* MR11 this messes up the ambiguity search routine */
+ set_rm(k2, rk);
+ REACH(p->next, k2, &rk2, b); /* MR11 by changing the value of k */
+ set_orin(&a, b);
+ set_free(b);
+ }
+ set_free(rk); /* this has no members, but free it's memory */
+ set_orin(rk_out, rk2); /* remember what we couldn't do */
+ set_free(rk2);
+ if (MR_MaintainBackTrace) MR_pointerStackPop(&MR_BackTraceStack);
+ return a;
+}
+
+/*
+ * Return FIRST sub k ( token_node )
+ *
+ * TJP 10/11/93 modified this so that token nodes that are actually
+ * ranges (T1..T2) work.
+ */
+set
+#ifdef __USE_PROTOS
+rToken( TokNode *p, int k, set *rk )
+#else
+rToken( p, k, rk )
+TokNode *p;
+int k;
+set *rk;
+#endif
+{
+ set a;
+
+ require(p!=NULL, "rToken: NULL node");
+ require(p->ntype==nToken, "rToken: not token node");
+
+#ifdef DBG_LL1
+ fprintf(stderr, "rToken: %s\n", (TokenString(p->token)!=NULL)?TokenString(p->token):
+ ExprString(p->token));
+#endif
+
+
+ if (MR_MaintainBackTrace) MR_pointerStackPush(&MR_BackTraceStack,p);
+
+ if (MR_AmbSourceSearch && (k-1) == 0) {
+
+ set localConstrain;
+ set intersection;
+
+ localConstrain=fset[maxk-k+1];
+
+ if (! set_nil(p->tset)) {
+ intersection=set_and(localConstrain,p->tset);
+ if (! set_nil(intersection)) {
+ MR_backTraceReport();
+ };
+ set_free(intersection);
+ } else {
+ if (set_el( (unsigned) p->token,localConstrain)) {
+ MR_backTraceReport();
+ }
+ };
+ };
+
+ if ( k-1 == 0 ) {
+
+ if (MR_MaintainBackTrace) MR_pointerStackPop(&MR_BackTraceStack);
+
+ if ( !set_nil(p->tset) ) {
+ return set_dup(p->tset);
+ } else {
+ return set_of(p->token);
+ };
+ }
+
+ REACH(p->next, k-1, rk, a);
+
+ if (MR_MaintainBackTrace) MR_pointerStackPop(&MR_BackTraceStack);
+
+ return a;
+}
+
+set
+#ifdef __USE_PROTOS
+rAction( ActionNode *p, int k, set *rk )
+#else
+rAction( p, k, rk )
+ActionNode *p;
+int k;
+set *rk;
+#endif
+{
+ set a;
+
+ require(p!=NULL, "rJunc: NULL node");
+ require(p->ntype==nAction, "rJunc: not action");
+
+/* MR11 */ if (p->is_predicate && p->ampersandPred != NULL) {
+/* MR11 */ Predicate *pred=p->ampersandPred;
+/* MR11 */ if (k <= pred->k) {
+/* MR11 */ REACH(p->guardNodes,k,rk,a);
+/* MR11 */ return a;
+/* MR11 */ };
+/* MR11 */ };
+
+ /* it might be a good idea when doing an MR_AmbSourceSearch
+ to *not* look behind predicates under some circumstances
+ we'll look into that later
+ */
+
+ REACH(p->next, k, rk, a); /* ignore actions */
+ return a;
+}
+
+ /* A m b i g u i t y R e s o l u t i o n */
+
+
+void
+#ifdef __USE_PROTOS
+dumpAmbigMsg( set *fset, FILE *f, int want_nls )
+#else
+dumpAmbigMsg( fset, f, want_nls )
+set *fset;
+FILE *f;
+int want_nls;
+#endif
+{
+ int i;
+
+ set copy; /* MR11 */
+
+ if ( want_nls ) fprintf(f, "\n\t");
+ else fprintf(f, " ");
+
+ for (i=1; i<=CLL_k; i++)
+ {
+ copy=set_dup(fset[i]); /* MR11 */
+
+ if ( i>1 )
+ {
+ if ( !want_nls ) fprintf(f, ", ");
+ }
+ if ( set_deg(copy) > 3 && elevel == 1 )
+ {
+ int e,m;
+ fprintf(f, "{");
+ for (m=1; m<=3; m++)
+ {
+ e=set_int(copy);
+ fprintf(f, " %s", TerminalString(e));
+ set_rm(e, copy);
+ }
+ fprintf(f, " ... }");
+ }
+ else s_fprT(f, copy);
+ if ( want_nls ) fprintf(f, "\n\t");
+ set_free(copy);
+ }
+ fprintf(f, "\n");
+
+}
+
+static void
+#ifdef __USE_PROTOS
+verify_context(Predicate *predicate)
+#else
+verify_context(predicate)
+Predicate *predicate;
+#endif
+{
+ if ( predicate == NULL ) return;
+
+ if ( predicate->expr == PRED_OR_LIST ||
+ predicate->expr == PRED_AND_LIST )
+ {
+ verify_context(predicate->down);
+ verify_context(predicate->right); /* MR10 */
+ return;
+ }
+
+ if ( !predicate->source->ctxwarned && predicate->source->guardpred==NULL &&
+ ((predicate->k > 1 &&
+ !is_single_tuple(predicate->tcontext)) ||
+ ( predicate->k == 1 &&
+ set_deg(predicate->scontext[1])>1 )) )
+ {
+
+/* MR9 Suppress annoying messages caused by our own clever(?) fix */
+
+ fprintf(stderr, ErrHdr, FileStr[predicate->source->file],
+ predicate->source->line);
+ fprintf(stderr, " warning: predicate applied for >1 lookahead %d-sequences\n", predicate->k);
+ fprintf(stderr, ErrHdr, FileStr[predicate->source->file],
+ predicate->source->line);
+ fprintf(stderr, " predicate text: \"%s\"\n",
+ (predicate->expr == NULL ? "(null)" : predicate->expr) );
+ fprintf(stderr, ErrHdr, FileStr[predicate->source->file],
+ predicate->source->line);
+ fprintf(stderr, " You may only want one lookahead %d-sequence to apply\n", predicate->k);
+ fprintf(stderr, ErrHdr, FileStr[predicate->source->file],
+ predicate->source->line);
+ fprintf(stderr, " Try using a context guard '(...)? =>'\n");
+ predicate->source->ctxwarned = 1;
+ }
+ verify_context(predicate->right); /* MR10 */
+}
+
+/*
+ * If delta is the set of ambiguous lookahead sequences, then make sure that
+ * the predicate(s) for productions alt1,alt2 cover the sequences in delta.
+ *
+ * For example,
+ * a : <<PRED1>>? (A B|A C)
+ * | b
+ * ;
+ * b : <<PRED2>>? A B
+ * | A C
+ * ;
+ *
+ * This should give a warning that (A C) predicts both productions and alt2
+ * does not have a predicate in the production that generates (A C).
+ *
+ * The warning detection is simple. Let delta = LOOK(alt1) intersection LOOK(alt2).
+ * Now, if ( delta set-difference context(predicates-for-alt1) != empty then
+ * alt1 does not "cover" all ambiguous sequences.
+ *
+ * If ambig is nonempty, then ambig in LL(k) sense -> use tree info; else use fset
+ * info. Actually, sets are used only if k=1 for this grammar.
+ */
+static void
+#ifdef __USE_PROTOS
+ensure_predicates_cover_ambiguous_lookahead_sequences
+ ( Junction *alt1, Junction *alt2, char *sub, Tree *ambig )
+#else
+ensure_predicates_cover_ambiguous_lookahead_sequences( alt1, alt2, sub, ambig )
+Junction *alt1;
+Junction *alt2;
+char *sub;
+Tree *ambig;
+#endif
+{
+ if ( !ParseWithPredicates ) return;
+
+ if ( ambig!=NULL )
+ {
+ Tree *non_covered = NULL;
+ if ( alt1->predicate!=NULL )
+ non_covered = tdif(ambig, alt1->predicate, alt1->fset, alt2->fset);
+ if ( (non_covered!=NULL || alt1->predicate==NULL) && WarningLevel>1 )
+ {
+ fprintf(stderr, ErrHdr, FileStr[alt1->file], alt1->line);
+ fprintf(stderr, " warning: alt %d %shas no predicate to resolve ambiguity",
+ alt1->altnum, sub);
+ if ( alt1->predicate!=NULL && non_covered!=NULL )
+ {
+ fprintf(stderr, " upon");
+ preorder(non_covered);
+ }
+ else if ( alt1->predicate==NULL )
+ {
+ fprintf(stderr, " upon");
+ preorder(ambig->down);
+ }
+ fprintf(stderr, "\n");
+ }
+ Tfree(non_covered);
+ non_covered = NULL;
+ if ( alt2->predicate!=NULL )
+ non_covered = tdif(ambig, alt2->predicate, alt1->fset, alt2->fset);
+ if ( (non_covered!=NULL || alt2->predicate==NULL) && WarningLevel>1 )
+ {
+ fprintf(stderr, ErrHdr, FileStr[alt2->file], alt2->line);
+ fprintf(stderr, " warning: alt %d %shas no predicate to resolve ambiguity",
+ alt2->altnum, sub);
+ if ( alt2->predicate!=NULL && non_covered!=NULL )
+ {
+ fprintf(stderr, " upon");
+ preorder(non_covered);
+ }
+ else if ( alt2->predicate==NULL )
+ {
+ fprintf(stderr, " upon");
+ preorder(ambig->down);
+ }
+ fprintf(stderr, "\n");
+ }
+ Tfree(non_covered);
+ }
+ else if ( !set_nil(alt1->fset[1]) )
+ {
+ set delta, non_covered;
+ delta = set_and(alt1->fset[1], alt2->fset[1]);
+ non_covered = set_dif(delta, covered_set(alt1->predicate));
+ if ( set_deg(non_covered)>0 && WarningLevel>1 )
+ {
+ fprintf(stderr, ErrHdr, FileStr[alt1->file], alt1->line);
+ fprintf(stderr, " warning: alt %d %shas no predicate to resolve ambiguity",
+ alt1->altnum, sub);
+ if ( alt1->predicate!=NULL )
+ {
+ fprintf(stderr, " upon ");
+ s_fprT(stderr, non_covered);
+ }
+ fprintf(stderr, "\n");
+ }
+ set_free( non_covered );
+ non_covered = set_dif(delta, covered_set(alt2->predicate));
+ if ( set_deg(non_covered)>0 && WarningLevel>1 )
+ {
+ fprintf(stderr, ErrHdr, FileStr[alt2->file], alt2->line);
+ fprintf(stderr, " warning: alt %d %shas no predicate to resolve ambiguity",
+ alt2->altnum, sub);
+ if ( alt2->predicate!=NULL )
+ {
+ fprintf(stderr, " upon ");
+ s_fprT(stderr, non_covered);
+ }
+ fprintf(stderr, "\n");
+ }
+ set_free( non_covered );
+ set_free( delta );
+ }
+ else fatal_internal("productions have no lookahead in predicate checking routine");
+}
+
+#ifdef __USE_PROTOS
+void MR_doPredicatesHelp(int inGuessBlock,Junction *alt1,Junction *alt2,int jtype,char *sub)
+#else
+void MR_doPredicatesHelp(inGuessBlock,alt1,alt2,jtype,sub)
+ int inGuessBlock;
+ Junction *alt1;
+ Junction *alt2;
+ int jtype;
+ char *sub;
+#endif
+{
+ Predicate *p1;
+ Predicate *p2;
+
+ Junction *parentRule=MR_nameToRuleBlk(alt1->rname);
+
+ if (inGuessBlock && WarningLevel <= 1) return;
+
+ /* let antlr give the usual error message */
+
+ if (alt1->predicate == NULL && alt2->predicate == NULL) return;
+
+ if ( (jtype == RuleBlk || jtype == aSubBlk)
+ && (alt1->predicate == NULL && alt2->predicate != NULL)) {
+ fprintf(stderr, ErrHdr, FileStr[parentRule->file],parentRule->line);
+ fprintf(stderr," warning: alt %d line %d and alt %d line %d of %s\n%s%s%s",
+ alt1->altnum,
+ alt1->line,
+ alt2->altnum,
+ alt2->line,
+ sub,
+ " These alts have ambig lookahead sequences resolved by a predicate for\n",
+ " the second choice. The second choice may not be reachable.\n",
+ " You may want to use a complementary predicate or rearrange the alts\n"
+ );
+ return;
+ };
+
+ /* first do the easy comparison. then do the hard one */
+
+ if (MR_comparePredicates(alt1->predicate,alt2->predicate)) {
+
+ if (jtype == aLoopBegin || jtype == aPlusBlk ) {
+
+ /* I'm not sure this code is reachable.
+ Predicates following a (...)+ or (...)* block are probably
+ considered validation predicates and therefore not
+ participate in the predication expression
+ */
+
+ fprintf(stderr, ErrHdr,FileStr[parentRule->file],parentRule->line);
+ fprintf(stderr," warning: %s of %s in rule %s\n (file %s alt %d line %d and alt %d line %d)\n%s",
+ "the predicates used to disambiguate optional/exit paths of ",
+ sub,
+ CurRule,
+ FileStr[alt1->file],
+ alt1->altnum,
+ alt1->line,
+ alt2->altnum,
+ alt2->line,
+ " are identical and have no resolving power\n");
+ } else {
+ fprintf(stderr, ErrHdr, FileStr[parentRule->file], parentRule->line);
+ fprintf(stderr," warning: %s rule %s\n (file %s alt %d line %d and alt %d line %d)\n%s",
+ "the predicates used to disambiguate",
+ CurRule,
+ FileStr[alt1->file],
+ alt1->altnum,
+ alt1->line,
+ alt2->altnum,
+ alt2->line,
+ " are identical and have no resolving power\n");
+ };
+ } else {
+ p1=predicate_dup_without_context(alt1->predicate);
+ p1=MR_unfold(p1);
+ MR_clearPredEntry(p1);
+ MR_simplifyInverted(p1,0);
+ p1=MR_predSimplifyALL(p1);
+ p2=predicate_dup_without_context(alt2->predicate);
+ p2=MR_unfold(p2);
+ MR_clearPredEntry(p2);
+ MR_simplifyInverted(p2,0);
+ p2=MR_predSimplifyALL(p2);
+ if (MR_comparePredicates(p1,p2)) {
+ if (jtype == aLoopBegin || jtype == aPlusBlk ) {
+ fprintf(stderr, ErrHdr, FileStr[parentRule->file], parentRule->line);
+ fprintf(stderr," warning: %s of %s in rule %s\n (file %s alt %d line %d and alt %d line %d)\n%s%s",
+ "the predicates used to disambiguate optional/exit paths of ",
+ sub,
+ CurRule,
+ FileStr[alt1->file],
+ alt1->altnum,
+ alt1->line,
+ alt2->altnum,
+ alt2->line,
+ " are identical when compared without context and may have no\n",
+ " resolving power for some lookahead sequences.\n");
+ } else {
+ fprintf(stderr, ErrHdr, FileStr[parentRule->file], parentRule->line);
+ fprintf(stderr," warning: %s rule %s\n (file %s alt %d line %d and alt %d line %d)\n%s%s",
+ "the predicates used to disambiguate",
+ CurRule,
+ FileStr[alt1->file],
+ alt1->altnum,
+ alt1->line,
+ alt2->altnum,
+ alt2->line,
+ " are identical when compared without context and may have no\n",
+ " resolving power for some lookahead sequences.\n");
+ };
+ if (InfoP) {
+ fprintf(output,"\n#if 0\n\n");
+ fprintf(output,"The following predicates are identical when compared without\n");
+ fprintf(output," lookahead context information. For some ambiguous lookahead\n");
+ fprintf(output," sequences they may not have any power to resolve the ambiguity.\n");
+ fprintf(output,"\n");
+
+ fprintf(output,"Choice 1: %s alt %d line %d file %s\n\n",
+ MR_ruleNamePlusOffset( (Node *) alt1),
+ alt1->altnum,
+ alt1->line,
+ FileStr[alt1->file]);
+ fprintf(output," The original predicate for choice 1 with available context information:\n\n");
+ MR_dumpPred1(2,alt1->predicate,1);
+ fprintf(output," The predicate for choice 1 after expansion (but without context information):\n\n");
+ MR_dumpPred1(2,p1,0);
+ if (p1 == NULL) {
+ Predicate *phelp;
+ fprintf(output," The predicate for choice 1 after expansion (but before simplification)\n\n");
+ phelp=predicate_dup_without_context(alt1->predicate);
+ phelp=MR_unfold(phelp);
+ MR_clearPredEntry(phelp);
+ MR_simplifyInverted(phelp,0);
+ phelp=MR_predSimplifyALLX(phelp,1);
+ MR_dumpPred1(2,phelp,0);
+ predicate_free(phelp);
+ };
+ fprintf(output,"\n");
+
+ fprintf(output,"Choice 2: %s alt %d line %d file %s\n\n",
+ MR_ruleNamePlusOffset( (Node *) alt2),
+ alt2->altnum,
+ alt2->line,
+ FileStr[alt2->file]);
+ fprintf(output," The original predicate for choice 2 with available context information:\n\n");
+ MR_dumpPred1(1,alt2->predicate,1);
+ fprintf(output," The predicate for choice 2 after expansion (but without context information):\n\n");
+ MR_dumpPred1(1,p2,0);
+ if (p2 == NULL) {
+ Predicate *phelp;
+ fprintf(output," The predicate for choice 2 after expansion (but before simplification)\n\n");
+ phelp=predicate_dup_without_context(alt2->predicate);
+ phelp=MR_unfold(phelp);
+ MR_clearPredEntry(phelp);
+ MR_simplifyInverted(phelp,0);
+ phelp=MR_predSimplifyALLX(phelp,1);
+ MR_dumpPred1(2,phelp,0);
+ predicate_free(phelp);
+ };
+ fprintf(output,"\n#endif\n");
+ };
+ } else if (MR_secondPredicateUnreachable(p1,p2)) {
+ if (jtype == aLoopBegin || jtype == aPlusBlk ) {
+ fprintf(stderr, ErrHdr, FileStr[parentRule->file], parentRule->line);
+ fprintf(stderr," warning: %s of %s in rule %s\n (file %s alt %d line %d and alt %d line %d)\n%s%s",
+ "the predicate used to disambiguate the first choice of the optional/exit paths of ",
+ sub,
+ CurRule,
+ FileStr[alt1->file],
+ alt1->altnum,
+ alt1->line,
+ alt2->altnum,
+ alt2->line,
+ " appears to \"cover\" the second predicate when compared without context.\n",
+ " The second predicate may have no resolving power for some lookahead sequences.\n");
+ } else {
+ fprintf(stderr, ErrHdr, FileStr[parentRule->file], parentRule->line);
+ fprintf(stderr," warning: %s rule %s\n (file %s alt %d line %d and alt %d line %d)\n%s%s",
+ "the predicate used to disambiguate the first choice of",
+ CurRule,
+ FileStr[alt1->file],
+ alt1->altnum,
+ alt1->line,
+ alt2->altnum,
+ alt2->line,
+ " appears to \"cover\" the second predicate when compared without context.\n",
+ " The second predicate may have no resolving power for some lookahead sequences.\n");
+ };
+ if (InfoP) {
+ fprintf(output,"\n#if 0\n\n");
+ fprintf(output,"The first predicate appears to \"cover\" the second predicate when they\n");
+ fprintf(output," are compared without lookahead context information. For some ambiguous\n");
+ fprintf(output," lookahead sequences the second predicate may not have any power to\n");
+ fprintf(output," resolve the ambiguity.\n");
+ fprintf(output,"\n");
+ fprintf(output,"Choice 1: %s alt %d line %d file %s\n\n",
+ MR_ruleNamePlusOffset( (Node *) alt1),
+ alt1->altnum,
+ alt1->line,
+ FileStr[alt1->file]);
+ fprintf(output," The original predicate for choice 1 with available context information:\n\n");
+ MR_dumpPred1(2,alt1->predicate,1);
+ fprintf(output," The predicate for choice 1 after expansion (but without context information):\n\n");
+ MR_dumpPred1(2,p1,0);
+ if (p1 == NULL) {
+ Predicate *phelp;
+ fprintf(output," The predicate for choice 1 after expansion (but before simplification)\n\n");
+ phelp=predicate_dup_without_context(alt1->predicate);
+ phelp=MR_unfold(phelp);
+ MR_clearPredEntry(phelp);
+ MR_simplifyInverted(phelp,0);
+ phelp=MR_predSimplifyALLX(phelp,1);
+ MR_dumpPred1(2,phelp,0);
+ predicate_free(phelp);
+ };
+ fprintf(output,"\n");
+
+ fprintf(output,"Choice 2: %s alt %d line %d file %s\n\n",
+ MR_ruleNamePlusOffset( (Node *) alt2),
+ alt2->altnum,
+ alt2->line,
+ FileStr[alt2->file]);
+ fprintf(output," The original predicate for choice 2 with available context information:\n\n");
+ MR_dumpPred1(1,alt2->predicate,1);
+ fprintf(output," The predicate for choice 2 after expansion (but without context information):\n\n");
+ MR_dumpPred1(1,p2,0);
+ if (p2 == NULL) {
+ Predicate *phelp;
+ fprintf(output," The predicate for choice 2 after expansion (but before simplification)\n\n");
+ phelp=predicate_dup_without_context(alt2->predicate);
+ phelp=MR_unfold(phelp);
+ MR_clearPredEntry(phelp);
+ MR_simplifyInverted(phelp,0);
+ phelp=MR_predSimplifyALLX(phelp,1);
+ MR_dumpPred1(2,phelp,0);
+ predicate_free(phelp);
+ };
+ fprintf(output,"\n#endif\n");
+ };
+ };
+ predicate_free(p1);
+ predicate_free(p2);
+ };
+}
+
+static int totalOverflow=0; /* MR9 */
+
+void
+#ifdef __USE_PROTOS
+HandleAmbiguity( Junction *block, Junction *alt1, Junction *alt2, int jtype )
+#else
+HandleAmbiguity( block, alt1, alt2, jtype )
+Junction *block;
+Junction *alt1;
+Junction *alt2;
+int jtype;
+#endif
+{
+ unsigned **ftbl;
+ set *fset, b;
+ int i, numAmbig,n2;
+ Tree *ambig=NULL, *t, *u;
+ char *sub = "";
+ long n;
+ int thisOverflow=0; /* MR9 */
+ long set_deg_value; /* MR10 */
+ long threshhold; /* MR10 */
+
+ require(block!=NULL, "NULL block");
+ require(block->ntype==nJunction, "invalid block");
+
+ /* These sets are used to constrain LL_k set, but are made CLL_k long anyway */
+ fset = (set *) calloc(CLL_k+1, sizeof(set));
+ require(fset!=NULL, "cannot allocate fset");
+ ftbl = (unsigned **) calloc(CLL_k+1, sizeof(unsigned *));
+ require(ftbl!=NULL, "cannot allocate ftbl");
+
+ /* create constraint table and count number of possible ambiguities (use<=LL_k) */
+ for (n=1,i=1; i<=CLL_k; i++)
+ {
+ b = set_and(alt1->fset[i], alt2->fset[i]);
+/* MR9 */ set_deg_value = set_deg(b);
+/* MR10 */ if (n > 0) {
+/* MR10 */ threshhold = LONG_MAX / n;
+/* MR10 */ if (set_deg_value <= threshhold) {
+/* MR10 */ n *= set_deg_value;
+/* MR10 */ } else {
+/* MR10 */ n=LONG_MAX;
+/* MR9 */ if (totalOverflow == 0) {
+#if 0
+ /* MR10 comment this out because it just makes users worry */
+
+/* MR9 */ warnNoFL("Overflow in computing number of possible ambiguities in HandleAmbiguity\n");
+#endif
+/* MR9 */ };
+/* MR9 */ thisOverflow++;
+/* MR9 */ totalOverflow++;
+/* MR9 */ };
+/* MR10 */ } else {
+/* MR10 */ n *= set_deg_value;
+/* MR9 */ };
+ fset[i] = set_dup(b);
+ ftbl[i] = set_pdq(b);
+ set_free(b);
+ }
+
+ switch ( jtype )
+ {
+ case aSubBlk: sub = "of (..) "; break;
+ case aOptBlk: sub = "of {..} "; break;
+ case aLoopBegin: sub = "of (..)* "; break;
+ case aLoopBlk: sub = "of (..)* "; break;
+ case aPlusBlk: sub = "of (..)+ "; break;
+ case RuleBlk: sub = "of the rule itself "; break;
+ default : sub = ""; break;
+ }
+
+ /* If the block is marked as a compressed lookahead only block, then
+ * simply return; ambiguity warning is given only at warning level 2.
+ */
+ if ( block->approx>0 )
+ {
+ if ( ParseWithPredicates )
+ {
+ if (alt1->predicate != NULL) predicate_free(alt1->predicate); /* MR12 */
+ if (alt2->predicate != NULL) predicate_free(alt2->predicate); /* MR12 */
+
+ require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
+ alt1->predicate = MR_find_predicates_and_supp((Node *)alt1->p1);
+ require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
+ require (MR_predicate_context_completed(alt1->predicate),"predicate alt 1 not completed");
+ alt1->predicate=MR_predSimplifyALL(alt1->predicate);
+
+ require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
+ alt2->predicate = MR_find_predicates_and_supp((Node *)alt2->p1);
+ require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
+ require (MR_predicate_context_completed(alt2->predicate),"predicate alt 2 not completed");
+ alt2->predicate=MR_predSimplifyALL(alt2->predicate);
+
+ MR_doPredicatesHelp(0,alt1,alt2,jtype,sub);
+
+ if ( HoistPredicateContext
+ && (alt1->predicate!=NULL||alt2->predicate!=NULL) )
+ {
+ verify_context(alt1->predicate);
+ verify_context(alt2->predicate);
+ }
+
+ if ( HoistPredicateContext
+ && (alt1->predicate!=NULL||alt2->predicate!=NULL)
+ && WarningLevel>1 )
+ ensure_predicates_cover_ambiguous_lookahead_sequences(alt1, alt2, sub, ambig);
+ }
+
+ if ( WarningLevel>1 )
+ {
+ fprintf(stderr, ErrHdr, FileStr[alt1->file], alt1->line);
+ if ( jtype == aLoopBegin || jtype == aPlusBlk )
+ fprintf(stderr, " warning: optional/exit path and alt(s) %sambiguous upon", sub);
+ else
+ fprintf(stderr, " warning(approx): alts %d and %d %sambiguous upon",
+ alt1->altnum, alt2->altnum, sub);
+ dumpAmbigMsg(fset, stderr, 0);
+ MR_traceAmbSource(fset,alt1,alt2);
+ }
+ for (i=1; i<=CLL_k; i++) set_free( fset[i] );
+ free((char *)fset);
+ for (i=1; i<=CLL_k; i++) free( (char *)ftbl[i] );
+ free((char *)ftbl);
+ return;
+ }
+
+ /* if all sets have degree 1 for k<LL_k, then must be ambig upon >=1 permutation;
+ * don't bother doing full LL(k) analysis.
+ * (This "if" block handles the LL(1) case)
+ */
+
+ n2 = 0;
+ for (i=1; i<LL_k; i++) n2 += set_deg(alt1->fset[i])+set_deg(alt2->fset[i]);
+
+ /* here STARTS the special case in which the lookahead sets for alt1 and alt2
+ all have degree 1 for k<LL_k (including LL_k=1)
+ */
+
+ if ( n2==2*(LL_k-1) )
+ {
+
+ /* TJP: added to fix the case where LL(1) and syntactic predicates didn't
+ * work. It now recognizes syntactic predicates, but does not like combo:
+ * LL(1)/syn/sem predicates. (10/24/93)
+ */
+
+ if ( first_item_is_guess_block_extra((Junction *)alt1->p1)!=NULL )
+ {
+ if ( WarningLevel==1 )
+ {
+ for (i=1; i<=CLL_k; i++) set_free( fset[i] );
+ free((char *)fset);
+ for (i=1; i<=CLL_k; i++) free( (char *)ftbl[i] );
+ free((char *)ftbl);
+ return;
+ }
+
+ fprintf(stderr, ErrHdr, FileStr[alt1->file], alt1->line);
+ if ( jtype == aLoopBegin || jtype == aPlusBlk )
+ fprintf(stderr, " warning: optional/exit path and alt(s) %sambiguous upon", sub);
+ else
+ fprintf(stderr, " warning: alts %d and %d %sambiguous upon",
+ alt1->altnum, alt2->altnum, sub);
+ dumpAmbigMsg(fset, stderr, 0);
+ MR_traceAmbSource(fset,alt1,alt2);
+ }
+
+ ambig = NULL;
+ if ( LL_k>1 ) ambig = make_tree_from_sets(alt1->fset, alt2->fset);
+ if ( ParseWithPredicates )
+ {
+ if (alt1->predicate != NULL) predicate_free(alt1->predicate); /* MR12 */
+ if (alt2->predicate != NULL) predicate_free(alt2->predicate); /* MR12 */
+
+ require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
+ alt1->predicate = MR_find_predicates_and_supp((Node *)alt1->p1);
+ require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
+ require (MR_predicate_context_completed(alt1->predicate),"predicate alt 1 not completed");
+ alt1->predicate=MR_predSimplifyALL(alt1->predicate);
+
+ require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
+ alt2->predicate = MR_find_predicates_and_supp((Node *)alt2->p1);
+ require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
+ require (MR_predicate_context_completed(alt2->predicate),"predicate alt 2 not completed");
+ alt2->predicate=MR_predSimplifyALL(alt2->predicate);
+
+ MR_doPredicatesHelp(0,alt1,alt2,jtype,sub);
+
+ if ( HoistPredicateContext && (alt1->predicate!=NULL||alt2->predicate!=NULL) )
+ {
+ verify_context(alt1->predicate);
+ verify_context(alt2->predicate);
+ }
+ if (HoistPredicateContext&&(alt1->predicate!=NULL||alt2->predicate!=NULL) && WarningLevel>1)
+ ensure_predicates_cover_ambiguous_lookahead_sequences(alt1, alt2, sub, ambig);
+ if ( WarningLevel == 1 &&
+ (alt1->predicate!=NULL||alt2->predicate!=NULL))
+ {
+ for (i=1; i<=CLL_k; i++) set_free( fset[i] );
+ free((char *)fset);
+ for (i=1; i<=CLL_k; i++) free( (char *)ftbl[i] );
+ free((char *)ftbl);
+ Tfree(ambig);
+ return;
+ }
+ }
+/* end TJP (10/24/93) */
+
+ fprintf(stderr, ErrHdr, FileStr[alt1->file], alt1->line);
+ if ( jtype == aLoopBegin || jtype == aPlusBlk )
+ fprintf(stderr, " warning: optional/exit path and alt(s) %sambiguous upon", sub);
+ else
+ fprintf(stderr, " warning: alts %d and %d %sambiguous upon",
+ alt1->altnum, alt2->altnum, sub);
+ if ( elevel == 3 && LL_k>1 )
+ {
+ preorder(ambig);
+ fprintf(stderr, "\n");
+ for (i=1; i<=CLL_k; i++) set_free( fset[i] );
+ free((char *)fset);
+ for (i=1; i<=CLL_k; i++) free( (char *)ftbl[i] );
+ free((char *)ftbl);
+ Tfree(ambig);
+ return;
+ };
+
+ Tfree(ambig);
+ dumpAmbigMsg(fset, stderr, 0);
+
+ /* because this is a special case in which both alt1 and alt2 have
+ lookahead sets of degree 1 for k<LL_k (including k=1) the linear
+ lookahead style search is adequate
+ */
+
+ MR_traceAmbSource(fset,alt1,alt2);
+
+ for (i=1; i<=CLL_k; i++) set_free( fset[i] );
+ free((char *)fset);
+ for (i=1; i<=CLL_k; i++) free( (char *)ftbl[i] );
+ free((char *)ftbl);
+ return;
+ }
+
+ /* here ENDS the special case in which the lookahead sets for alt1 and alt2
+ all have degree 1 for k<LL_k (including LL_k=1)
+ */
+
+ /* in case tree construction runs out of memory, set info to make good err msg */
+
+ CurAmbigAlt1 = alt1->altnum;
+ CurAmbigAlt2 = alt2->altnum;
+ CurAmbigbtype = sub;
+ CurAmbigfile = alt1->file;
+ CurAmbigline = alt1->line;
+
+ /* Don't do full LL(n) analysis if (...)? block because the block,
+ by definition, defies LL(n) analysis.
+ If guess (...)? block and ambiguous then don't remove anything from
+ 2nd alt to resolve ambig.
+ Want to predict with LL sup 1 ( n ) decision not LL(n) if guess block
+ since it is much cheaper than LL(n). LL sup 1 ( n ) "covers" the LL(n)
+ lookahead information.
+
+ Note: LL(n) context cannot be computed for semantic predicates when
+ followed by (..)?.
+
+ If (..)? then we scream "AAAHHHH! No LL(n) analysis will help"
+
+ Is 'ambig' always defined if we enter this if? I hope so
+ because the 'ensure...()' func references it. TJP Nov 1993.
+ */
+
+ /* THM MR30: Instead of using first_item_is_guss_block we use
+ first_item_is_guess_block_extra which will look inside a
+ loop block for a guess block. In other words ( (...)? )*.
+ It there is an ambiguity in this circumstance then we suppress
+ the normal methods of resolving ambiguities.
+ */
+
+ if ( first_item_is_guess_block_extra((Junction *)alt1->p1)!=NULL )
+ {
+ if ( ParseWithPredicates )
+ {
+ if (alt1->predicate != NULL) predicate_free(alt1->predicate); /* MR12 */
+ if (alt2->predicate != NULL) predicate_free(alt2->predicate); /* MR12 */
+ require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
+ alt1->predicate = MR_find_predicates_and_supp((Node *)alt1->p1);
+ require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
+ require (MR_predicate_context_completed(alt1->predicate),"predicate alt 1 not completed");
+ alt1->predicate=MR_predSimplifyALL(alt1->predicate);
+
+ require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
+ alt2->predicate = MR_find_predicates_and_supp((Node *)alt2->p1);
+ require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
+ require (MR_predicate_context_completed(alt2->predicate),"predicate alt 2 not completed");
+ alt2->predicate=MR_predSimplifyALL(alt2->predicate);
+
+ MR_doPredicatesHelp(1,alt1,alt2,jtype,sub);
+
+ if ( HoistPredicateContext && (alt1->predicate!=NULL||alt2->predicate!=NULL) )
+ {
+ verify_context(alt1->predicate);
+ verify_context(alt2->predicate);
+ }
+ if ( HoistPredicateContext && (alt1->predicate!=NULL||alt2->predicate!=NULL) && WarningLevel>1 )
+ ensure_predicates_cover_ambiguous_lookahead_sequences(alt1, alt2, sub, ambig);
+ if ( WarningLevel==1 &&
+ (alt1->predicate!=NULL||alt2->predicate!=NULL))
+ {
+ for (i=1; i<=CLL_k; i++) set_free( fset[i] );
+ free((char *)fset);
+ for (i=1; i<=CLL_k; i++) free( (char *)ftbl[i] );
+ free((char *)ftbl);
+ return;
+ }
+ }
+
+ if ( WarningLevel>1 )
+ {
+ fprintf(stderr, ErrHdr, FileStr[alt1->file], alt1->line);
+ if ( jtype == aLoopBegin || jtype == aPlusBlk )
+ fprintf(stderr, " warning: optional/exit path and alt(s) %sambiguous upon", sub);
+ else
+ fprintf(stderr, " warning: alts %d and %d %sambiguous upon",
+ alt1->altnum, alt2->altnum, sub);
+ dumpAmbigMsg(fset, stderr, 0);
+ MR_traceAmbSource(fset,alt1,alt2);
+ }
+
+ for (i=1; i<=CLL_k; i++) set_free( fset[i] );
+ free((char *)fset);
+ for (i=1; i<=CLL_k; i++) free( (char *)ftbl[i] );
+ free((char *)ftbl);
+ return;
+ }
+
+ /* Not resolved with (..)? block. Do full LL(n) analysis */
+
+ /* ambig is the set of k-tuples truly in common between alt 1 and alt 2 */
+ /* MR11 VerifyAmbig once used fset destructively */
+
+ ambig = VerifyAmbig(alt1, alt2, ftbl, fset, &t, &u, &numAmbig);
+
+ /* are all things in intersection really ambigs? */
+
+ if (thisOverflow || numAmbig < n ) /* MR9 */
+ {
+ Tree *v;
+
+ /* remove ambig permutation from 2nd alternative to resolve ambig;
+ * We want to compute the set of artificial tuples, arising from
+ * LL sup 1 (n) compression, that collide with real tuples from the
+ * 2nd alternative. This is the set of "special case" tuples that
+ * the LL sup 1 (n) decision template maps incorrectly.
+ */
+
+ /* when generating code in genExpr() it does
+ *
+ * if ( genExprSets(j->fset) && !genExprTree(j->ftree)) {...
+ *
+ * Sooooo the j->ftree is the tree of alt2
+ * after removal of conflicts, not alt1 !
+ */
+
+ if ( ambig!=NULL )
+ {
+ /* at the top of ambig is an ALT node */
+
+ for (v=ambig->down; v!=NULL; v=v->right)
+ {
+ u = trm_perm(u, v); /* remove v FROM u */
+ }
+/* fprintf(stderr, "after rm alt2:"); preorder(u); fprintf(stderr, "\n");*/
+ }
+ Tfree( t );
+ alt1->ftree = tappend(alt1->ftree, u);
+ alt1->ftree = tleft_factor(alt1->ftree);
+ }
+
+ if ( ambig==NULL )
+ {
+ for (i=1; i<=CLL_k; i++) set_free( fset[i] );
+ free((char *)fset);
+ for (i=1; i<=CLL_k; i++) free( (char *)ftbl[i] );
+ free((char *)ftbl);
+ return;
+ }
+
+ ambig = tleft_factor(ambig);
+
+/* TJP:
+ * At this point, we surely have an LL(k) ambiguity. Check for predicates
+ */
+ if ( ParseWithPredicates )
+ {
+ if (alt1->predicate != NULL) predicate_free(alt1->predicate); /* MR12 */
+ if (alt2->predicate != NULL) predicate_free(alt2->predicate); /* MR12 */
+ require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
+ alt1->predicate = MR_find_predicates_and_supp((Node *)alt1->p1);
+ require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
+ require (MR_predicate_context_completed(alt1->predicate),"predicate alt 1 not completed");
+ alt1->predicate=MR_predSimplifyALL(alt1->predicate);
+
+ require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
+ alt2->predicate = MR_find_predicates_and_supp((Node *)alt2->p1);
+ require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
+ require (MR_predicate_context_completed(alt2->predicate),"predicate alt 2 not completed");
+ alt2->predicate=MR_predSimplifyALL(alt2->predicate);
+
+ MR_doPredicatesHelp(0,alt1,alt2,jtype,sub);
+
+ if ( HoistPredicateContext && (alt1->predicate!=NULL||alt2->predicate!=NULL) )
+ {
+ verify_context(alt1->predicate);
+ verify_context(alt2->predicate);
+ }
+ if ( HoistPredicateContext && (alt1->predicate!=NULL||alt2->predicate!=NULL) && WarningLevel>1 )
+ ensure_predicates_cover_ambiguous_lookahead_sequences(alt1, alt2, sub, ambig);
+ if ( WarningLevel==1 &&
+ (alt1->predicate!=NULL||alt2->predicate!=NULL))
+ {
+
+ /* We found at least one pred for at least one of the alts;
+ * If warnings are low, just return.
+ */
+
+ Tfree(ambig);
+ for (i=1; i<=CLL_k; i++) set_free( fset[i] );
+ free((char *)fset);
+ for (i=1; i<=CLL_k; i++) free( (char *)ftbl[i] );
+ free((char *)ftbl);
+ return;
+ }
+ /* else we're gonna give a warning */
+ }
+/* end TJP addition */
+
+ fprintf(stderr, ErrHdr, FileStr[alt1->file], alt1->line);
+ if ( jtype == aLoopBegin || jtype == aPlusBlk )
+ fprintf(stderr, " warning: optional/exit path and alt(s) %sambiguous upon", sub);
+ else
+ fprintf(stderr, " warning: alts %d and %d %sambiguous upon",
+ alt1->altnum, alt2->altnum, sub);
+ if ( elevel == 3 )
+ {
+ preorder(ambig->down); /* <===== k>1 ambiguity message data */
+ fprintf(stderr, "\n");
+ } else {
+ MR_skipped_e3_report=1;
+ dumpAmbigMsg(fset, stderr, 0);
+ };
+
+ MR_traceAmbSourceK(ambig,alt1,alt2); /* <====== k>1 ambiguity aid */
+
+ Tfree(ambig);
+
+ for (i=1; i<=CLL_k; i++) set_free( fset[i] );
+ free((char *)fset);
+ for (i=1; i<=CLL_k; i++) free( (char *)ftbl[i] );
+ free((char *)ftbl);
+}
+
+/* Don't analyze alpha block of (alpha)?beta; if (alpha)? then analyze
+ * Return the 1st node of the beta block if present else return j.
+ */
+Junction *
+#ifdef __USE_PROTOS
+analysis_point( Junction *j )
+#else
+analysis_point( j )
+Junction *j;
+#endif
+{
+ Junction *gblock;
+
+ /* MR13b When there was an action/predicate preceding a guess block
+ the guess block became invisible at the analysis_point.
+
+ first_item_is_guess_block accepts any kind of node,
+ despite the fact that the formal is a junction. But
+ I don't want to have to change it all over the place
+ until I know it works.
+ */
+
+ if ( j->ntype != nJunction && j->ntype != nAction) return j;
+
+ gblock = first_item_is_guess_block((Junction *)j);
+
+ if ( gblock!=NULL )
+ {
+ Junction *past = gblock->end;
+ Junction *p;
+ require(past!=NULL, "analysis_point: no end block on (...)? block");
+
+ for (p=(Junction *)past->p1; p!=NULL; )
+ {
+ if ( p->ntype==nAction )
+ {
+ p=(Junction *)((ActionNode *)p)->next;
+ continue;
+ }
+ if ( p->ntype!=nJunction )
+ {
+ past->alpha_beta_guess_end=1; /* MR14 */
+ return (Junction *)past->p1;
+ }
+ if ( p->jtype==EndBlk || p->jtype==EndRule )
+ {
+ return j;
+ }
+/* MR6 */
+/* MR6 A guess block is of the form "(alpha)? beta" or "(alpha)?". */
+/* MR6 When beta is omitted (second form) this means "(alpha)? alpha". */
+/* MR6 The program does not store another copy of alpha in this case. */
+/* MR6 During analysis when the program needs to know what follows the */
+/* MR6 guess clause. It calls this routine. */
+/* MR6 */
+/* MR6 If it is of the form "(alpha)? beta" it returns a pointer to beta.*/
+/* MR6 */
+/* MR6 If it is of the form "(alpha)?" it returns a pointer to the guess */
+/* MR6 block itself thereby reusing the junction tree. */
+/* MR6 */
+/* MR6 It works by searching the "next in sequence" chain (skipping actions) */
+/* MR6 searching for a RuleRef or Token node. (Those are the only 4 kinds */
+/* MR6 of nodes: Junctions, RuleRef, Token, and Action.) */
+/* MR6 */
+/* MR6 This won't work for the special case "(alpha)? ()" because it has no */
+/* MR6 rule references or token nodes. It eventually encounters a */
+/* MR6 junction of type EndBlk or EndRule and says to its caller: nothing */
+/* MR6 more here to analyze - must be of the form "(alpha)?". */
+/* MR6 */
+/* MR6 In the case of "(alpha)? ()" it should return a pointer to "()" */
+/* MR6 */
+/* MR6 I think. */
+/* MR6 */
+ if ( p->jtype!=Generic) { /* MR6 */
+ past->alpha_beta_guess_end=1; /* MR14 */
+ return (Junction *)past->p1; /* MR6 */
+ }; /* MR6 */
+ p=(Junction *)p->p1;
+ }
+ }
+ return j;
+}
+
+set
+#ifdef __USE_PROTOS
+First( Junction *j, int k, int jtype, int *max_k )
+#else
+First( j, k, jtype, max_k )
+Junction *j;
+int k;
+int jtype;
+int *max_k;
+#endif
+{
+ Junction *alt1, *alt2;
+ set a, rk, fCurBlk;
+ int savek;
+ int p1, p2;
+
+ int save_maintainBackTrace;
+
+ require(j->ntype==nJunction, "First: non junction passed");
+
+ /* C o m p u t e F I R S T s e t w i t h k l o o k a h e a d */
+ fCurBlk = rk = empty;
+ for (alt1=j; alt1!=NULL; alt1 = (Junction *)alt1->p2 )
+ {
+ Junction * p = NULL;
+ Junction * p1junction = NULL;
+ p = analysis_point((Junction *)alt1->p1);
+ p1junction = (Junction *) (alt1->p1);
+#if 0
+ if (p != p1junction) {
+ fprintf(stdout,"Analysis point for #%d is #%d", p1junction->seq, p->seq); /* debug */
+ }
+#endif
+ REACH(p, k, &rk, alt1->fset[k]);
+ require(set_nil(rk), "rk != nil");
+ set_free(rk);
+ set_orin(&fCurBlk, alt1->fset[k]);
+ }
+
+ /* D e t e c t A m b i g u i t i e s */
+ *max_k = 1;
+ for (p1=1,alt1=j; alt1!=NULL; alt1 = (Junction *)alt1->p2, p1++)
+ {
+ for (p2=1,alt2=(Junction *)alt1->p2; alt2!=NULL; alt2 = (Junction *)alt2->p2, p2++)
+ {
+ savek = k;
+ a = set_and(alt1->fset[k], alt2->fset[k]);
+ while ( !set_nil(a) )
+ {
+ /* if we have hit the max k requested, just give warning */
+ if ( j->approx==k ) {
+ }
+
+ if ( k==CLL_k )
+ {
+#ifdef NOT_USED
+*** int save_LL_k = LL_k;
+*** int save_CLL_k = CLL_k;
+*** /* Get new LL_k from interactive feature if enabled */
+*** if ( AImode )
+*** AmbiguityDialog(j, jtype, alt1, alt2, &CLL_k, &LL_k);
+#endif
+ *max_k = CLL_k;
+ save_maintainBackTrace=MR_MaintainBackTrace;
+ if (AlphaBetaTrace) MR_MaintainBackTrace=0;
+ HandleAmbiguity(j, alt1, alt2, jtype);
+ MR_MaintainBackTrace=save_maintainBackTrace;
+ break;
+ }
+ else
+ {
+ Junction *p = analysis_point((Junction *)alt1->p1);
+ Junction *q = analysis_point((Junction *)alt2->p1);
+ k++; /* attempt ambig alts again with more lookahead */
+
+ REACH(p, k, &rk, alt1->fset[k]);
+ require(set_nil(rk), "rk != nil");
+ REACH(q, k, &rk, alt2->fset[k]);
+ require(set_nil(rk), "rk != nil");
+ set_free(a);
+ a = set_and(alt1->fset[k], alt2->fset[k]);
+ if ( k > *max_k ) *max_k = k;
+ }
+ }
+ set_free(a);
+ k = savek;
+ }
+ }
+
+ return fCurBlk;
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/fset2.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/fset2.c new file mode 100644 index 0000000000..7f686a53d5 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/fset2.c @@ -0,0 +1,2250 @@ +/*
+ * fset2.c
+ *
+ * Compute FIRST sets for full LL(k)
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2001
+ */
+
+#include <stdio.h>
+#include "pcctscfg.h"
+#include <stdlib.h>
+
+#ifdef PCCTS_USE_STDARG
+#include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
+
+#include "set.h"
+#include "syn.h"
+#include "hash.h"
+#include "generic.h"
+#include "dlgdef.h"
+
+/* ick! globals. Used by permute() to track which elements of a set have been used */
+
+static int *findex;
+set *fset; /* MR11 make global */
+static unsigned **ftbl;
+static set *constrain; /* pts into fset. constrains tToken() to 'constrain' */
+int ConstrainSearch;
+int maxk; /* set to initial k upon tree construction request */
+ /* MR11 make global */
+static Tree *FreeList = NULL;
+
+#ifdef __USE_PROTOS
+static int tmember_of_context(Tree *, Predicate *);
+#else
+static int tmember_of_context();
+#endif
+
+#if TREE_DEBUG
+set set_of_tnodes_in_use;
+int stop_on_tnode_seq_number=(-1); /* (-1) to disable */
+#endif
+
+/* Do root
+ * Then each sibling
+ */
+
+void
+#ifdef __USE_PROTOS
+preorder( Tree *tree )
+#else
+preorder( tree )
+Tree *tree;
+#endif
+{
+ if ( tree == NULL ) return;
+ if ( tree->down != NULL ) fprintf(stderr, " (");
+ if ( tree->token == ALT ) fprintf(stderr, " ALT");
+ else fprintf(stderr, " %s", TerminalString(tree->token));
+ if ( tree->token==EpToken ) fprintf(stderr, "(%d)", tree->v.rk);
+ preorder(tree->down);
+ if ( tree->down != NULL ) fprintf(stderr, " )");
+ preorder(tree->right);
+}
+
+#ifdef __USE_PROTOS
+int MR_tree_matches_constraints(int k,set * constrain,Tree *t)
+#else
+int MR_tree_matches_constraints(k,constrain,t)
+ int k;
+ set * constrain;
+ Tree * t;
+#endif
+{
+ int i;
+ Tree *u;
+
+ if (k == 0) return 1;
+
+ /* for testing guard predicates: if the guard tree is shorter
+ than the constraint then it is a match. The reason is that
+ a guard of (A B) should be equivalent to a guard of (A B . . .)
+ where "." matches every token. Thus a match which runs out
+ of tree before constraint is a match.
+ */
+
+ if (t == NULL) return 1;
+ require (set_deg(constrain[0]) == 1,
+ "MR_tree_matches_constraints: set_deg != 1");
+ i=set_int(constrain[0]);
+ if (t->token != i) return 0;
+ if (k-1 == 0) return 1;
+ for (u=t->down; u != NULL; u=u->right) {
+ if (MR_tree_matches_constraints(k-1,&constrain[1],u)) {
+ return 1;
+ };
+ };
+ return 0;
+}
+
+/* check the depth of each primary sibling to see that it is exactly
+ * k deep. e.g.;
+ *
+ * ALT
+ * |
+ * A ------- B
+ * | |
+ * C -- D E
+ *
+ * Remove all branches <= k deep.
+ *
+ * Added by TJP 9-23-92 to make the LL(k) constraint mechanism to work.
+ */
+
+static int pruneCount=0;
+static int prunePeak=200;
+
+Tree *
+#ifdef __USE_PROTOS
+prune( Tree *t, int k )
+#else
+prune( t, k )
+Tree *t;
+int k;
+#endif
+{
+ pruneCount++;
+ if (pruneCount > prunePeak+100) {
+ prunePeak=pruneCount;
+#if 0
+*** fprintf(stderr,"pruneCount=%d\n",pruneCount);
+/*** preorder(t); ***/
+*** fprintf(stderr,"\n",pruneCount);
+#endif
+ };
+ if ( t == NULL ) {
+ pruneCount--;
+ return NULL;
+ };
+ if ( t->token == ALT ) fatal_internal("prune: ALT node in FIRST tree");
+ if ( t->right!=NULL ) t->right = prune(t->right, k);
+ if ( k>1 )
+ {
+ if ( t->down!=NULL ) t->down = prune(t->down, k-1);
+ if ( t->down == NULL )
+ {
+ Tree *r = t->right;
+ t->right = NULL;
+ Tfree(t);
+ pruneCount--;
+ return r;
+ }
+ }
+ pruneCount--;
+ return t;
+}
+
+/* build a tree (root child1 child2 ... NULL) */
+#ifdef PCCTS_USE_STDARG
+Tree *tmake(Tree *root, ...)
+#else
+Tree *tmake(va_alist)
+va_dcl
+#endif
+{
+ Tree *w;
+ va_list ap;
+ Tree *child, *sibling=NULL, *tail=NULL;
+#ifndef PCCTS_USE_STDARG
+ Tree *root;
+#endif
+
+#ifdef PCCTS_USE_STDARG
+ va_start(ap, root);
+#else
+ va_start(ap);
+ root = va_arg(ap, Tree *);
+#endif
+ child = va_arg(ap, Tree *);
+ while ( child != NULL )
+ {
+#ifdef DUM
+ /* added "find end of child" thing TJP March 1994 */
+ for (w=child; w->right!=NULL; w=w->right) {;} /* find end of child */
+#else
+ w = child;
+#endif
+
+ if ( sibling == NULL ) {sibling = child; tail = w;}
+ else {tail->right = child; tail = w;}
+ child = va_arg(ap, Tree *);
+ }
+
+ /* was "root->down = sibling;" */
+ if ( root==NULL ) root = sibling;
+ else root->down = sibling;
+
+ va_end(ap);
+ return root;
+}
+
+Tree *
+#ifdef __USE_PROTOS
+tnode( int tok )
+#else
+tnode( tok )
+int tok;
+#endif
+{
+ Tree *p, *newblk;
+ static int n=0;
+
+ if ( FreeList == NULL )
+ {
+ /*fprintf(stderr, "tnode: %d more nodes\n", TreeBlockAllocSize);*/
+ if ( TreeResourceLimit > 0 )
+ {
+ if ( (n+TreeBlockAllocSize) >= TreeResourceLimit )
+ {
+ fprintf(stderr, ErrHdr, FileStr[CurAmbigfile], CurAmbigline);
+ fprintf(stderr, " hit analysis resource limit while analyzing alts %d and %d %s\n",
+ CurAmbigAlt1,
+ CurAmbigAlt2,
+ CurAmbigbtype);
+ exit(PCCTS_EXIT_FAILURE);
+ }
+ }
+ newblk = (Tree *)calloc(TreeBlockAllocSize, sizeof(Tree));
+ if ( newblk == NULL )
+ {
+ fprintf(stderr, ErrHdr, FileStr[CurAmbigfile], CurAmbigline);
+ fprintf(stderr, " out of memory while analyzing alts %d and %d %s\n",
+ CurAmbigAlt1,
+ CurAmbigAlt2,
+ CurAmbigbtype);
+ exit(PCCTS_EXIT_FAILURE);
+ }
+ n += TreeBlockAllocSize;
+ for (p=newblk; p<&(newblk[TreeBlockAllocSize]); p++)
+ {
+ p->right = FreeList; /* add all new Tree nodes to Free List */
+ FreeList = p;
+ }
+ }
+ p = FreeList;
+ FreeList = FreeList->right; /* remove a tree node */
+ p->right = NULL; /* zero out ptrs */
+ p->down = NULL;
+ p->token = tok;
+
+ TnodesAllocated++; /* MR10 */
+ TnodesInUse++; /* MR10 */
+ if (TnodesInUse > TnodesPeak) TnodesPeak=TnodesInUse; /* MR10 */
+
+#ifdef TREE_DEBUG
+ require(!p->in_use, "tnode: node in use!");
+ p->in_use = 1;
+ p->seq=TnodesAllocated;
+ set_orel( (unsigned) TnodesAllocated,&set_of_tnodes_in_use);
+ if (stop_on_tnode_seq_number == p->seq) {
+ fprintf(stderr,"\n*** just allocated tnode #%d ***\n",
+ stop_on_tnode_seq_number);
+ };
+#endif
+ return p;
+}
+
+static Tree *
+#ifdef __USE_PROTOS
+eofnode( int k )
+#else
+eofnode( k )
+int k;
+#endif
+{
+ Tree *t=NULL;
+ int i;
+
+ for (i=1; i<=k; i++)
+ {
+ t = tmake(tnode((TokenInd!=NULL?TokenInd[EofToken]:EofToken)), t, NULL);
+ }
+ return t;
+}
+
+
+
+void
+#ifdef __USE_PROTOS
+_Tfree( Tree *t )
+#else
+_Tfree( t )
+Tree *t;
+#endif
+{
+ if ( t!=NULL )
+ {
+#ifdef TREE_DEBUG
+ if (t->seq == stop_on_tnode_seq_number) {
+ fprintf(stderr,"\n*** just freed tnode #%d ***\n",t->seq);
+ };
+ require(t->in_use, "_Tfree: node not in use!");
+ t->in_use = 0;
+ set_rm( (unsigned) t->seq,set_of_tnodes_in_use);
+#endif
+ t->right = FreeList;
+ FreeList = t;
+ TnodesInUse--; /* MR10 */
+ }
+}
+
+/* tree duplicate */
+Tree *
+#ifdef __USE_PROTOS
+tdup( Tree *t )
+#else
+tdup( t )
+Tree *t;
+#endif
+{
+ Tree *u;
+
+ if ( t == NULL ) return NULL;
+ u = tnode(t->token);
+ u->v.rk = t->v.rk;
+ u->right = tdup(t->right);
+ u->down = tdup(t->down);
+ return u;
+}
+
+/* tree duplicate (assume tree is a chain downwards) */
+Tree *
+#ifdef __USE_PROTOS
+tdup_chain( Tree *t )
+#else
+tdup_chain( t )
+Tree *t;
+#endif
+{
+ Tree *u;
+
+ if ( t == NULL ) return NULL;
+ u = tnode(t->token);
+ u->v.rk = t->v.rk;
+ u->down = tdup(t->down);
+ return u;
+}
+
+Tree *
+#ifdef __USE_PROTOS
+tappend( Tree *t, Tree *u )
+#else
+tappend( t, u )
+Tree *t;
+Tree *u;
+#endif
+{
+ Tree *w;
+
+/*** fprintf(stderr, "tappend(");
+ *** preorder(t); fprintf(stderr, ",");
+ *** preorder(u); fprintf(stderr, " )\n");
+*/
+ if ( t == NULL ) return u;
+ if ( t->token == ALT && t->right == NULL ) return tappend(t->down, u);
+ for (w=t; w->right!=NULL; w=w->right) {;}
+ w->right = u;
+ return t;
+}
+
+/* dealloc all nodes in a tree */
+void
+#ifdef __USE_PROTOS
+Tfree( Tree *t )
+#else
+Tfree( t )
+Tree *t;
+#endif
+{
+ if ( t == NULL ) return;
+ Tfree( t->down );
+ Tfree( t->right );
+ _Tfree( t );
+}
+
+/* find all children (alts) of t that require remaining_k nodes to be LL_k
+ * tokens long.
+ *
+ * t-->o
+ * |
+ * a1--a2--...--an <-- LL(1) tokens
+ * | | |
+ * b1 b2 ... bn <-- LL(2) tokens
+ * | | |
+ * . . .
+ * . . .
+ * z1 z2 ... zn <-- LL(LL_k) tokens
+ *
+ * We look for all [Ep] needing remaining_k nodes and replace with u.
+ * u is not destroyed or actually used by the tree (a copy is made).
+ */
+Tree *
+#ifdef __USE_PROTOS
+tlink( Tree *t, Tree *u, int remaining_k )
+#else
+tlink( t, u, remaining_k )
+Tree *t;
+Tree *u;
+int remaining_k;
+#endif
+{
+ Tree *p;
+ require(remaining_k!=0, "tlink: bad tree");
+
+ if ( t==NULL ) return NULL;
+ /*fprintf(stderr, "tlink: u is:"); preorder(u); fprintf(stderr, "\n");*/
+ if ( t->token == EpToken && t->v.rk == remaining_k )
+ {
+ require(t->down==NULL, "tlink: invalid tree");
+ if ( u == NULL ) {
+/* MR10 */ Tree *tt=t->right;
+/* MR10 */ _Tfree(t);
+/* MR10 */ return tt;
+ };
+ p = tdup( u );
+ p->right = t->right;
+ _Tfree( t );
+ return p;
+ }
+ t->down = tlink(t->down, u, remaining_k);
+ t->right = tlink(t->right, u, remaining_k);
+ return t;
+}
+
+/* remove as many ALT nodes as possible while still maintaining semantics */
+Tree *
+#ifdef __USE_PROTOS
+tshrink( Tree *t )
+#else
+tshrink( t )
+Tree *t;
+#endif
+{
+ if ( t == NULL ) return NULL;
+ t->down = tshrink( t->down );
+ t->right = tshrink( t->right );
+ if ( t->down == NULL )
+ {
+ if ( t->token == ALT )
+ {
+ Tree *u = t->right;
+ _Tfree(t);
+ return u; /* remove useless alts */
+ }
+ return t;
+ }
+
+ /* (? (ALT (? ...)) s) ==> (? (? ...) s) where s = sibling, ? = match any */
+ if ( t->token == ALT && t->down->right == NULL)
+ {
+ Tree *u = t->down;
+ u->right = t->right;
+ _Tfree( t );
+ return u;
+ }
+ /* (? (A (ALT t)) s) ==> (? (A t) s) where A is a token; s,t siblings */
+ if ( t->token != ALT && t->down->token == ALT && t->down->right == NULL )
+ {
+ Tree *u = t->down->down;
+ _Tfree( t->down );
+ t->down = u;
+ return t;
+ }
+ return t;
+}
+
+Tree *
+#ifdef __USE_PROTOS
+tflatten( Tree *t )
+#else
+tflatten( t )
+Tree *t;
+#endif
+{
+ if ( t == NULL ) return NULL;
+ t->down = tflatten( t->down );
+ t->right = tflatten( t->right );
+ if ( t->down == NULL ) return t;
+
+ if ( t->token == ALT )
+ {
+ Tree *u;
+ /* find tail of children */
+ for (u=t->down; u->right!=NULL; u=u->right) {;}
+ u->right = t->right;
+ u = t->down;
+ _Tfree( t );
+ return u;
+ }
+ return t;
+}
+
+Tree *
+#ifdef __USE_PROTOS
+tJunc( Junction *p, int k, set *rk )
+#else
+tJunc( p, k, rk )
+Junction *p;
+int k;
+set *rk;
+#endif
+{
+ Tree *t=NULL, *u=NULL;
+ Junction *alt;
+ Tree *tail=NULL, *r;
+
+#ifdef DBG_TRAV
+ fprintf(stderr, "tJunc(%d): %s in rule %s\n", k,
+ decodeJType[p->jtype], ((Junction *)p)->rname);
+#endif
+
+/* MR14 */ if (AlphaBetaTrace && p->alpha_beta_guess_end) {
+/* MR14 */ warnFL(
+/* MR14 */ "not possible to compute follow set for alpha in an \"(alpha)? beta\" block. ",
+/* MR14 */ FileStr[p->file],p->line);
+/* MR14 */ MR_alphaBetaTraceReport();
+/* MR14 */ };
+
+/* MR14 */ if (p->alpha_beta_guess_end) {
+/* MR14 */ return NULL;
+/* MR14 */ }
+
+ if ( p->jtype==aLoopBlk || p->jtype==RuleBlk ||
+ p->jtype==aPlusBlk || p->jtype==aSubBlk || p->jtype==aOptBlk )
+ {
+ if ( p->jtype!=aSubBlk && p->jtype!=aOptBlk ) {
+ require(p->lock!=NULL, "rJunc: lock array is NULL");
+ if ( p->lock[k] ) return NULL;
+ p->lock[k] = TRUE;
+ }
+
+/* MR10 */ if (MR_MaintainBackTrace) {
+/* MR10 */ if (p->jtype != Generic) MR_pointerStackPush(&MR_BackTraceStack,p);
+/* MR10 */ };
+
+ TRAV(p->p1, k, rk, tail);
+
+/* MR10 */ if (MR_MaintainBackTrace) {
+/* MR10 */ if (p->jtype != Generic) MR_pointerStackPop(&MR_BackTraceStack);
+/* MR10 */ };
+
+ if ( p->jtype==RuleBlk ) {p->lock[k] = FALSE; return tail;}
+ r = tmake(tnode(ALT), tail, NULL);
+ for (alt=(Junction *)p->p2; alt!=NULL; alt = (Junction *)alt->p2)
+ {
+ /* if this is one of the added optional alts for (...)+ then break */
+ if ( alt->ignore ) break;
+
+ if ( tail==NULL ) {TRAV(alt->p1, k, rk, tail); r->down = tail;}
+ else
+ {
+/* MR10 */ if (MR_MaintainBackTrace) {
+/* MR10 */ if (p->jtype != Generic) MR_pointerStackPush(&MR_BackTraceStack,p);
+/* MR10 */ };
+
+ TRAV(alt->p1, k, rk, tail->right);
+
+/* MR10 */ if (MR_MaintainBackTrace) {
+/* MR10 */ if (p->jtype != Generic) MR_pointerStackPop(&MR_BackTraceStack);
+/* MR10 */ };
+ if ( tail->right != NULL ) tail = tail->right;
+ }
+ }
+ if ( p->jtype!=aSubBlk && p->jtype!=aOptBlk ) p->lock[k] = FALSE;
+#ifdef DBG_TREES
+ fprintf(stderr, "blk(%s) returns:",((Junction *)p)->rname); preorder(r); fprintf(stderr, "\n");
+#endif
+ if ( r->down == NULL ) {_Tfree(r); return NULL;}
+ return r;
+ }
+
+ if ( p->jtype==EndRule )
+ {
+ if ( p->halt ) /* don't want FOLLOW here? */
+ {
+/**** if ( ContextGuardTRAV ) return NULL; ****/
+ set_orel( (unsigned) k, rk); /* indicate this k value needed */ /* MR10 cast */
+ t = tnode(EpToken);
+ t->v.rk = k;
+ return t;
+ }
+ require(p->lock!=NULL, "rJunc: lock array is NULL");
+ if ( p->lock[k] ) return NULL;
+ /* if no FOLLOW assume k EOF's */
+ if ( p->p1 == NULL ) return eofnode(k);
+ p->lock[k] = TRUE;
+ }
+
+/* MR14 */ if (p->p1 != NULL && p->guess && p->guess_analysis_point == NULL) {
+/* MR14 */ Node * guess_point;
+/* MR14 */ guess_point=(Node *)analysis_point(p);
+/* MR14 */ if (guess_point == (Node *)p) {
+/* MR14 */ guess_point=p->p1;
+/* MR14 */ }
+/* MR14 */ p->guess_analysis_point=guess_point;
+/* MR14 */ }
+
+ if ( p->p2 == NULL )
+ {
+
+/* MR10 */ if (MR_MaintainBackTrace) {
+/* MR10 */ if (p->jtype != Generic) MR_pointerStackPush(&MR_BackTraceStack,p);
+/* MR10 */ };
+
+/* M14 */ if (p->guess_analysis_point != NULL) {
+/* M14 */ TRAV(p->guess_analysis_point, k, rk,t);
+/* M14 */ } else {
+ TRAV(p->p1, k, rk,t);
+/* M14 */ }
+
+/* MR10 */ if (MR_MaintainBackTrace) {
+/* MR10 */ if (p->jtype != Generic) MR_pointerStackPop(&MR_BackTraceStack);
+/* MR10 */ };
+
+ if ( p->jtype==EndRule ) p->lock[k]=FALSE;
+ return t;
+ }
+
+/* MR10 */ if (MR_MaintainBackTrace) {
+/* MR10 */ if (p->jtype != Generic) MR_pointerStackPush(&MR_BackTraceStack,p);
+/* MR10 */ };
+
+/* M14 */ if (p->guess_analysis_point != NULL) {
+/* M14 */ TRAV(p->guess_analysis_point, k, rk,t);
+/* M14 */ } else {
+ TRAV(p->p1, k, rk,t);
+/* M14 */ }
+
+/* MR10 */ if (MR_MaintainBackTrace) {
+/* MR10 */ if (p->jtype != Generic) MR_pointerStackPop(&MR_BackTraceStack);
+/* MR10 */ };
+
+ if ( p->jtype!=RuleBlk && /* MR14 */ !p->guess) TRAV(p->p2, k, rk, u);
+
+ if ( p->jtype==EndRule ) p->lock[k] = FALSE;/* unlock node */
+
+ if ( t==NULL ) return tmake(tnode(ALT), u, NULL);
+ return tmake(tnode(ALT), t, u, NULL);
+}
+
+Tree *
+#ifdef __USE_PROTOS
+tRuleRef( RuleRefNode *p, int k, set *rk_out )
+#else
+tRuleRef( p, k, rk_out )
+RuleRefNode *p;
+int k;
+set *rk_out;
+#endif
+{
+ int k2;
+ Tree *t=NULL, *u=NULL;
+ Junction *r;
+ set rk, rk2;
+ int save_halt;
+ RuleEntry *q = (RuleEntry *) hash_get(Rname, p->text);
+
+#ifdef DBG_TRAV
+ fprintf(stderr, "tRuleRef: %s\n", p->text);
+#endif
+ if ( q == NULL )
+ {
+ TRAV(p->next, k, rk_out, t);/* ignore undefined rules */
+ return t;
+ }
+ rk = rk2 = empty;
+ if (RulePtr == NULL) fatal("RulePtr==NULL");
+ r = RulePtr[q->rulenum];
+ if ( r->lock[k] ) return NULL;
+ save_halt = r->end->halt;
+ r->end->halt = TRUE; /* don't let reach fall off end of rule here */
+
+/* MR10 */ if (MR_MaintainBackTrace) {
+/* MR10 */ MR_pointerStackPush(&MR_BackTraceStack,p);
+/* MR10 */ };
+
+ TRAV(r, k, &rk, t);
+
+/* MR10 */ if (MR_MaintainBackTrace) {
+/* MR10 */ MR_pointerStackPop(&MR_BackTraceStack);
+/* MR10 */ };
+
+ r->end->halt = save_halt;
+#ifdef DBG_TREES
+ fprintf(stderr, "after ruleref, t is:"); preorder(t); fprintf(stderr, "\n");
+#endif
+ t = tshrink( t );
+ while ( !set_nil(rk) ) { /* any k left to do? if so, link onto tree */
+ k2 = set_int(rk);
+ set_rm(k2, rk);
+
+/* MR10 */ if (MR_MaintainBackTrace) {
+/* MR10 */ MR_pointerStackPush(&MR_BackTraceStack,p);
+/* MR10 */ };
+
+ TRAV(p->next, k2, &rk2, u);
+
+/* MR10 */ if (MR_MaintainBackTrace) {
+/* MR10 */ MR_pointerStackPop(&MR_BackTraceStack);
+/* MR10 */ };
+
+ t = tlink(t, u, k2); /* any alts missing k2 toks, add u onto end */
+ Tfree(u); /* MR10 */
+ }
+ set_free(rk); /* rk is empty, but free it's memory */
+ set_orin(rk_out, rk2); /* remember what we couldn't do */
+ set_free(rk2);
+ return t;
+}
+
+Tree *
+#ifdef __USE_PROTOS
+tToken( TokNode *p, int k, set *rk )
+#else
+tToken( p, k, rk )
+TokNode *p;
+int k;
+set *rk;
+#endif
+{
+ Tree *t=NULL, *tset=NULL, *u;
+
+ if (ConstrainSearch) {
+ if (MR_AmbSourceSearch) {
+ require(constrain>=fset&&constrain<=&(fset[CLL_k]),"tToken: constrain is not a valid set");
+ } else {
+ require(constrain>=fset&&constrain<=&(fset[LL_k]),"tToken: constrain is not a valid set");
+ };
+ constrain = &fset[maxk-k+1];
+ }
+
+#ifdef DBG_TRAV
+ fprintf(stderr, "tToken(%d): %s\n", k, TerminalString(p->token));
+ if ( ConstrainSearch ) {
+ fprintf(stderr, "constrain is:"); s_fprT(stderr, *constrain); fprintf(stderr, "\n");
+ }
+#endif
+
+ /* is it a meta token (set of tokens)? */
+
+ if ( !set_nil(p->tset) )
+ {
+ unsigned e=0;
+ set a;
+ Tree *n, *tail = NULL;
+
+ if ( ConstrainSearch ) {
+ a = set_and(p->tset, *constrain);
+ if (set_nil(a)) { /* MR10 */
+ set_free(a); /* MR11 */
+ return NULL; /* MR10 */
+ }; /* MR10 */
+ } else {
+ a = set_dup(p->tset);
+ };
+
+ for (; !set_nil(a); set_rm(e, a))
+ {
+ e = set_int(a);
+ n = tnode(e);
+ if ( tset==NULL ) { tset = n; tail = n; }
+ else { tail->right = n; tail = n; }
+ }
+ set_free( a );
+ }
+ else if ( ConstrainSearch && !set_el(p->token, *constrain) )
+ {
+/* fprintf(stderr, "ignoring token %s(%d)\n", TerminalString(p->token),
+ k);*/
+ return NULL;
+ }
+ else {
+ tset = tnode( p->token );
+ };
+
+/* MR10 */ if (MR_MaintainBackTrace) {
+/* MR10 */ if (k == 1) {
+/* MR10 */ MR_pointerStackPush(&MR_BackTraceStack,p);
+/* MR13 */ if (MR_SuppressSearch) {
+/* MR13 */ MR_suppressSearchReport();
+/* MR13 */ } else {
+/* MR10 */ MR_backTraceReport();
+/* MR13 */ };
+/* MR10 */ MR_pointerStackPop(&MR_BackTraceStack);
+/* MR11 */ Tfree(tset);
+/* MR11 */ return NULL;
+/* MR10 */ };
+/* MR10 */ };
+
+ if ( k == 1 ) return tset;
+
+ if (MR_MaintainBackTrace) {
+ MR_pointerStackPush(&MR_BackTraceStack,p);
+ };
+
+ TRAV(p->next, k-1, rk, t);
+
+ if (MR_MaintainBackTrace) {
+ Tfree(t);
+ Tfree(tset);
+ MR_pointerStackPop(&MR_BackTraceStack);
+ return NULL;
+ };
+
+ /* here, we are positive that, at least, this tree will not contribute
+ * to the LL(2) tree since it will be too shallow, IF t==NULL.
+ * If doing a context guard walk, then don't prune.
+ */
+ if ( t == NULL && !ContextGuardTRAV ) /* tree will be too shallow */
+ {
+ if ( tset!=NULL ) Tfree( tset );
+ return NULL;
+ }
+#ifdef DBG_TREES
+ fprintf(stderr, "tToken(%d)->next:",k); preorder(t); fprintf(stderr, "\n");
+#endif
+
+ /* if single token root, then just make new tree and return */
+ /* MR10 - set_nil(p->tset) isn't a good test because of ConstraintSearch */
+
+ if (tset->right == NULL) return tmake(tset, t, NULL); /* MR10 */
+
+ /* here we must make a copy of t as a child of each element of the tset;
+ * e.g., "T1..T3 A" would yield ( nil ( T1 A ) ( T2 A ) ( T3 A ) )
+ */
+ for (u=tset; u!=NULL; u=u->right)
+ {
+ /* make a copy of t and hook it onto bottom of u */
+ u->down = tdup(t);
+ }
+ Tfree( t );
+#ifdef DBG_TREES
+ fprintf(stderr, "range is:"); preorder(tset); fprintf(stderr, "\n");
+#endif
+ return tset;
+}
+
+Tree *
+#ifdef __USE_PROTOS
+tAction( ActionNode *p, int k, set *rk )
+#else
+tAction( p, k, rk )
+ActionNode *p;
+int k;
+set *rk;
+#endif
+{
+ Tree *t=NULL;
+ set *save_fset=NULL;
+ int i;
+
+ /* fprintf(stderr, "tAction\n"); */
+
+/* An MR_SuppressSearch is looking for things that can be
+ reached even when the predicate is false.
+
+ There are three kinds of predicates:
+ plain: r1: <<p>>? r2
+ guarded: r1: (A)? => <<p>>? r2
+ ampersand style: r1: (A)? && <<p>>? r2
+
+ Of the three kinds of predicates, only a guard predicate
+ has things which are reachable even when the predicate
+ is false. To be reachable the constraint must *not*
+ match the guard.
+
+*/
+
+ if (p->is_predicate && MR_SuppressSearch) {
+
+ Predicate *pred=p->guardpred;
+
+ if (pred == NULL) {
+ t=NULL;
+ goto EXIT;
+ };
+ constrain = &fset[maxk-k+1];
+ if (pred->k == 1) {
+ set dif;
+ dif=set_dif(*constrain,pred->scontext[1]);
+ if (set_nil(dif)) {
+ set_free(dif);
+ t=NULL;
+ goto EXIT;
+ };
+ set_free(dif);
+ } else {
+ if (MR_tree_matches_constraints(k,constrain,pred->tcontext)) {
+ t=NULL;
+ goto EXIT;
+ };
+ }
+ };
+
+ /* The ampersand predicate differs from the
+ other predicates because its first set
+ is a subset of the first set behind the predicate
+
+ r1: (A)? && <<p>>? r2 ;
+ r2: A | B;
+
+ In this case first[1] of r1 is A, even
+ though first[1] of r2 is {A B}.
+ */
+
+ if (p->is_predicate && p->ampersandPred != NULL) {
+
+ Predicate *pred=p->ampersandPred;
+ Tree *tAND;
+ Tree *tset;
+
+ if (k <= pred->k) {
+ if (MR_MaintainBackTrace) MR_pointerStackPush(&MR_BackTraceStack,p);
+ TRAV(p->guardNodes,k,rk,t);
+ if (MR_MaintainBackTrace) MR_pointerStackPop(&MR_BackTraceStack);
+ return t;
+ } else {
+ require (k>1,"tAction for ampersandpred: k <= 1");
+ if (ConstrainSearch) {
+ if (MR_AmbSourceSearch) {
+ require(constrain>=fset&&constrain<=&(fset[CLL_k]),
+ "tToken: constrain is not a valid set");
+ } else {
+ require(constrain>=fset&&constrain<=&(fset[LL_k]),
+ "tToken: constrain is not a valid set");
+ };
+ save_fset=(set *) calloc (CLL_k+1,sizeof(set));
+ require (save_fset != NULL,"tAction save_fset alloc");
+ for (i=1; i <= CLL_k ; i++) {
+ save_fset[i]=set_dup(fset[i]);
+ };
+ if (pred->k == 1) {
+ constrain = &fset[maxk-k+1];
+ set_andin(constrain,pred->scontext[1]);
+ if (set_nil(*constrain)) {
+ t=NULL;
+ goto EXIT;
+ };
+ } else {
+ constrain = &fset[maxk-k+1];
+ if (! MR_tree_matches_constraints(pred->k,constrain,pred->tcontext)) {
+ t=NULL;
+ goto EXIT;
+ }; /* end loop on i */
+ }; /* end loop on pred scontext/tcontext */
+ }; /* end if on k > pred->k */
+ }; /* end if on constrain search */
+
+ TRAV(p->next,k,rk,t);
+
+ if (t != NULL) {
+ t=tshrink(t);
+ t=tflatten(t);
+ t=tleft_factor(t);
+ if (pred->tcontext != NULL) {
+ tAND=MR_computeTreeAND(t,pred->tcontext);
+ } else {
+ tset=MR_make_tree_from_set(pred->scontext[1]);
+ tAND=MR_computeTreeAND(t,tset);
+ Tfree(tset);
+ };
+ Tfree(t);
+ t=tAND;
+ };
+ goto EXIT;
+
+ }; /* end if on ampersand predicate */
+
+ TRAV(p->next,k,rk,t);
+
+EXIT:
+ if (save_fset != NULL) {
+ for (i=1 ; i <= CLL_k ; i++) {
+ set_free(fset[i]);
+ fset[i]=save_fset[i];
+ };
+ free ( (char *) save_fset);
+ };
+ return t;
+}
+
+/* see if e exists in s as a possible input permutation (e is always a chain) */
+
+int
+#ifdef __USE_PROTOS
+tmember( Tree *e, Tree *s )
+#else
+tmember( e, s )
+Tree *e;
+Tree *s;
+#endif
+{
+ if ( e==NULL||s==NULL ) return 0;
+/** fprintf(stderr, "tmember(");
+*** preorder(e); fprintf(stderr, ",");
+*** preorder(s); fprintf(stderr, " )\n");
+*/
+ if ( s->token == ALT && s->right == NULL ) return tmember(e, s->down);
+ if ( e->token!=s->token )
+ {
+ if ( s->right==NULL ) return 0;
+ return tmember(e, s->right);
+ }
+ if ( e->down==NULL && s->down == NULL ) return 1;
+ if ( tmember(e->down, s->down) ) return 1;
+ if ( s->right==NULL ) return 0;
+ return tmember(e, s->right);
+}
+
+/* see if e exists in s as a possible input permutation (e is always a chain);
+ * Only check s to the depth of e. In other words, 'e' can be a shorter
+ * sequence than s.
+ */
+int
+#ifdef __USE_PROTOS
+tmember_constrained( Tree *e, Tree *s)
+#else
+tmember_constrained( e, s )
+Tree *e;
+Tree *s;
+#endif
+{
+ if ( e==NULL||s==NULL ) return 0;
+/** fprintf(stderr, "tmember_constrained(");
+*** preorder(e); fprintf(stderr, ",");
+*** preorder(s); fprintf(stderr, " )\n");
+**/
+ if ( s->token == ALT && s->right == NULL )
+ return tmember_constrained(e, s->down);
+ if ( e->token!=s->token )
+ {
+ if ( s->right==NULL ) return 0;
+ return tmember_constrained(e, s->right);
+ }
+ if ( e->down == NULL ) return 1; /* if s is matched to depth of e return */
+ if ( tmember_constrained(e->down, s->down) ) return 1;
+ if ( s->right==NULL ) return 0;
+ return tmember_constrained(e, s->right);
+}
+
+/* combine (? (A t) ... (A u) ...) into (? (A t u)) */
+Tree *
+#ifdef __USE_PROTOS
+tleft_factor( Tree *t )
+#else
+tleft_factor( t )
+Tree *t;
+#endif
+{
+ Tree *u, *v, *trail, *w;
+
+ /* left-factor what is at this level */
+ if ( t == NULL ) return NULL;
+ for (u=t; u!=NULL; u=u->right)
+ {
+ trail = u;
+ v=u->right;
+ while ( v!=NULL )
+ {
+ if ( u->token == v->token )
+ {
+ if ( u->down!=NULL )
+ {
+ for (w=u->down; w->right!=NULL; w=w->right) {;}
+ w->right = v->down; /* link children together */
+ }
+ else u->down = v->down;
+ trail->right = v->right; /* unlink factored node */
+ _Tfree( v );
+ v = trail->right;
+ }
+ else {trail = v; v=v->right;}
+ }
+ }
+ /* left-factor what is below */
+ for (u=t; u!=NULL; u=u->right) u->down = tleft_factor( u->down );
+ return t;
+}
+
+/* remove the permutation p from t if present */
+Tree *
+#ifdef __USE_PROTOS
+trm_perm( Tree *t, Tree *p )
+#else
+trm_perm( t, p )
+Tree *t;
+Tree *p;
+#endif
+{
+ /*
+ fprintf(stderr, "trm_perm(");
+ preorder(t); fprintf(stderr, ",");
+ preorder(p); fprintf(stderr, " )\n");
+ */
+ if ( t == NULL || p == NULL ) return NULL;
+ if ( t->token == ALT )
+ {
+ t->down = trm_perm(t->down, p);
+ if ( t->down == NULL ) /* nothing left below, rm cur node */
+ {
+ Tree *u = t->right;
+ _Tfree( t );
+ return trm_perm(u, p);
+ }
+ t->right = trm_perm(t->right, p); /* look for more instances of p */
+ return t;
+ }
+ if ( p->token != t->token ) /* not found, try a sibling */
+ {
+ t->right = trm_perm(t->right, p);
+ return t;
+ }
+ t->down = trm_perm(t->down, p->down);
+ if ( t->down == NULL ) /* nothing left below, rm cur node */
+ {
+ Tree *u = t->right;
+ _Tfree( t );
+ return trm_perm(u, p);
+ }
+ t->right = trm_perm(t->right, p); /* look for more instances of p */
+ return t;
+}
+
+/* add the permutation 'perm' to the LL_k sets in 'fset' */
+void
+#ifdef __USE_PROTOS
+tcvt( set *fset, Tree *perm )
+#else
+tcvt( fset, perm )
+set *fset;
+Tree *perm;
+#endif
+{
+ if ( perm==NULL ) return;
+ set_orel(perm->token, fset);
+ tcvt(fset+1, perm->down);
+}
+
+/* for each element of ftbl[k], make it the root of a tree with permute(ftbl[k+1])
+ * as a child.
+ */
+Tree *
+#ifdef __USE_PROTOS
+permute( int k, int max_k )
+#else
+permute( k, max_k )
+int k, max_k;
+#endif
+{
+ Tree *t, *u;
+
+ if ( k>max_k ) return NULL;
+ if ( ftbl[k][findex[k]] == nil ) return NULL;
+ t = permute(k+1, max_k);
+ if ( t==NULL&&k<max_k ) /* no permutation left below for k+1 tokens? */
+ {
+ findex[k+1] = 0;
+ (findex[k])++; /* try next token at this k */
+ return permute(k, max_k);
+ }
+
+ u = tmake(tnode(ftbl[k][findex[k]]), t, NULL);
+ if ( k == max_k ) (findex[k])++;
+ return u;
+}
+
+/* Compute LL(k) trees for alts alt1 and alt2 of p.
+ * function result is tree of ambiguous input permutations
+ *
+ * ALGORITHM may change to look for something other than LL_k size
+ * trees ==> maxk will have to change.
+ */
+Tree *
+#ifdef __USE_PROTOS
+VerifyAmbig( Junction *alt1, Junction *alt2, unsigned **ft, set *fs, Tree **t, Tree **u, int *numAmbig )
+#else
+VerifyAmbig( alt1, alt2, ft, fs, t, u, numAmbig )
+Junction *alt1;
+Junction *alt2;
+unsigned **ft;
+set *fs;
+Tree **t;
+Tree **u;
+int *numAmbig;
+#endif
+{
+ set rk;
+ Tree *perm, *ambig=NULL;
+ Junction *p;
+ int k;
+ int tnodes_at_start=TnodesAllocated;
+ int tnodes_at_end;
+ int tnodes_used;
+ set *save_fs;
+ int j;
+
+ save_fs=(set *) calloc(CLL_k+1,sizeof(set));
+ require(save_fs != NULL,"save_fs calloc");
+
+ for (j=0; j <= CLL_k ; j++) save_fs[j]=set_dup(fs[j]);
+
+ maxk = LL_k; /* NOTE: for now, we look for LL_k */
+ ftbl = ft;
+ fset = fs;
+ constrain = &(fset[1]);
+ findex = (int *) calloc(LL_k+1, sizeof(int));
+ if ( findex == NULL )
+ {
+ fprintf(stderr, ErrHdr, FileStr[CurAmbigfile], CurAmbigline);
+ fprintf(stderr, " out of memory while analyzing alts %d and %d of %s\n",
+ CurAmbigAlt1,
+ CurAmbigAlt2,
+ CurAmbigbtype);
+ exit(PCCTS_EXIT_FAILURE);
+ }
+ for (k=1; k<=LL_k; k++) findex[k] = 0;
+
+ rk = empty;
+ ConstrainSearch = 1; /* consider only tokens in ambig sets */
+
+ p = analysis_point((Junction *)alt1->p1);
+ TRAV(p, LL_k, &rk, *t);
+ *t = tshrink( *t );
+ *t = tflatten( *t );
+ *t = tleft_factor( *t ); /* MR10 */
+ *t = prune(*t, LL_k);
+ *t = tleft_factor( *t );
+
+/*** fprintf(stderr, "after shrink&flatten&prune&left_factor:"); preorder(*t); fprintf(stderr, "\n");*/
+ if ( *t == NULL )
+ {
+/*** fprintf(stderr, "TreeIncomplete --> no LL(%d) ambiguity\n", LL_k);*/
+ Tfree( *t ); /* kill if impossible to have ambig */
+ *t = NULL;
+ }
+
+ p = analysis_point((Junction *)alt2->p1);
+
+ TRAV(p, LL_k, &rk, *u);
+ *u = tshrink( *u );
+ *u = tflatten( *u );
+ *t = tleft_factor( *t ); /* MR10 */
+ *u = prune(*u, LL_k);
+ *u = tleft_factor( *u );
+/* fprintf(stderr, "after shrink&flatten&prune&lfactor:"); preorder(*u); fprintf(stderr, "\n");*/
+ if ( *u == NULL )
+ {
+/* fprintf(stderr, "TreeIncomplete --> no LL(%d) ambiguity\n", LL_k);*/
+ Tfree( *u );
+ *u = NULL;
+ }
+
+ for (k=1; k<=LL_k; k++) set_clr( fs[k] );
+
+ ambig = tnode(ALT);
+ k = 0;
+ if ( *t!=NULL && *u!=NULL )
+ {
+ while ( (perm=permute(1,LL_k))!=NULL )
+ {
+/* fprintf(stderr, "chk perm:"); preorder(perm); fprintf(stderr, "\n");*/
+ if ( tmember(perm, *t) && tmember(perm, *u) )
+ {
+/* fprintf(stderr, "ambig upon"); preorder(perm); fprintf(stderr, "\n");*/
+
+ k++;
+ perm->right = ambig->down;
+ ambig->down = perm;
+ tcvt(&(fs[1]), perm);
+ }
+ else Tfree( perm );
+ }
+ }
+
+ for (j=0; j <= CLL_k ; j++) fs[j]=save_fs[j];
+ free( (char *) save_fs);
+
+ tnodes_at_end=TnodesAllocated;
+ tnodes_used=tnodes_at_end - tnodes_at_start;
+
+ if (TnodesReportThreshold > 0 && tnodes_used > TnodesReportThreshold) {
+ fprintf(stdout,"There were %d tuples whose ambiguity could not be resolved by full lookahead\n",k);
+ fprintf(stdout,"There were %d tnodes created to resolve ambiguity between:\n\n",tnodes_used);
+ fprintf(stdout," Choice 1: %s line %d file %s\n",
+ MR_ruleNamePlusOffset( (Node *) alt1),alt1->line,FileStr[alt1->file]);
+ fprintf(stdout," Choice 2: %s line %d file %s\n",
+ MR_ruleNamePlusOffset( (Node *) alt2),alt2->line,FileStr[alt2->file]);
+ for (j=1; j <= CLL_k ; j++) {
+ fprintf(stdout,"\n Intersection of lookahead[%d] sets:\n",j);
+ MR_dumpTokenSet(stdout,2,fs[j]);
+ };
+ fprintf(stdout,"\n");
+ };
+
+ *numAmbig = k;
+ if ( ambig->down == NULL ) {_Tfree(ambig); ambig = NULL;}
+ free( (char *)findex );
+/* fprintf(stderr, "final ambig:"); preorder(ambig); fprintf(stderr, "\n");*/
+ return ambig;
+}
+
+static Tree *
+#ifdef __USE_PROTOS
+bottom_of_chain( Tree *t )
+#else
+bottom_of_chain( t )
+Tree *t;
+#endif
+{
+ if ( t==NULL ) return NULL;
+ for (; t->down != NULL; t=t->down) {;}
+ return t;
+}
+
+/*
+ * Make a tree from k sets where the degree of the first k-1 sets is 1.
+ */
+Tree *
+#ifdef __USE_PROTOS
+make_tree_from_sets( set *fset1, set *fset2 )
+#else
+make_tree_from_sets( fset1, fset2 )
+set *fset1;
+set *fset2;
+#endif
+{
+ set inter;
+ int i;
+ Tree *t=NULL, *n, *u;
+ unsigned *p,*q;
+ require(LL_k>1, "make_tree_from_sets: LL_k must be > 1");
+
+ /* do the degree 1 sets first */
+ for (i=1; i<=LL_k-1; i++)
+ {
+ inter = set_and(fset1[i], fset2[i]);
+ require(set_deg(inter)==1, "invalid set to tree conversion");
+ n = tnode(set_int(inter));
+ if (t==NULL) t=n; else tmake(t, n, NULL);
+ set_free(inter);
+ }
+
+ /* now add the chain of tokens at depth k */
+ u = bottom_of_chain(t);
+ inter = set_and(fset1[LL_k], fset2[LL_k]);
+ if ( (q=p=set_pdq(inter)) == NULL ) fatal_internal("Can't alloc space for set_pdq");
+ /* first one is linked to bottom, then others are sibling linked */
+ n = tnode(*p++);
+ u->down = n;
+ u = u->down;
+ while ( *p != nil )
+ {
+ n = tnode(*p);
+ u->right = n;
+ u = u->right;
+ p++;
+ }
+ free((char *)q);
+
+ return t;
+}
+
+/* create and return the tree of lookahead k-sequences that are in t, but not
+ * in the context of predicates in predicate list p.
+ */
+Tree *
+#ifdef __USE_PROTOS
+tdif( Tree *ambig_tuples, Predicate *p, set *fset1, set *fset2 )
+#else
+tdif( ambig_tuples, p, fset1, fset2 )
+Tree *ambig_tuples;
+Predicate *p;
+set *fset1;
+set *fset2;
+#endif
+{
+ unsigned **ft;
+ Tree *dif=NULL;
+ Tree *perm;
+ set b;
+ int i,k;
+
+ if ( p == NULL ) return tdup(ambig_tuples);
+
+ ft = (unsigned **) calloc(CLL_k+1, sizeof(unsigned *));
+ require(ft!=NULL, "cannot allocate ft");
+ for (i=1; i<=CLL_k; i++)
+ {
+ b = set_and(fset1[i], fset2[i]);
+ ft[i] = set_pdq(b);
+ set_free(b);
+ }
+ findex = (int *) calloc(LL_k+1, sizeof(int));
+ if ( findex == NULL )
+ {
+ fatal_internal("out of memory in tdif while checking predicates");
+ }
+ for (k=1; k<=LL_k; k++) findex[k] = 0;
+
+#ifdef DBG_TRAV
+ fprintf(stderr, "tdif_%d[", p->k);
+ preorder(ambig_tuples);
+ fprintf(stderr, ",");
+ preorder(p->tcontext);
+ fprintf(stderr, "] =");
+#endif
+
+ ftbl = ft;
+ while ( (perm=permute(1,p->k))!=NULL )
+ {
+#ifdef DBG_TRAV
+ fprintf(stderr, "test perm:"); preorder(perm); fprintf(stderr, "\n");
+#endif
+ if ( tmember_constrained(perm, ambig_tuples) &&
+ !tmember_of_context(perm, p) )
+ {
+#ifdef DBG_TRAV
+ fprintf(stderr, "satisfied upon"); preorder(perm); fprintf(stderr, "\n");
+#endif
+ k++;
+ if ( dif==NULL ) dif = perm;
+ else
+ {
+ perm->right = dif;
+ dif = perm;
+ }
+ }
+ else Tfree( perm );
+ }
+
+#ifdef DBG_TRAV
+ preorder(dif);
+ fprintf(stderr, "\n");
+#endif
+
+ for (i=1; i<=CLL_k; i++) free( (char *)ft[i] );
+ free((char *)ft);
+ free((char *)findex);
+
+ return dif;
+}
+
+/* is lookahead sequence t a member of any context tree for any
+ * predicate in p?
+ */
+static int
+#ifdef __USE_PROTOS
+tmember_of_context( Tree *t, Predicate *p )
+#else
+tmember_of_context( t, p )
+Tree *t;
+Predicate *p;
+#endif
+{
+ for (; p!=NULL; p=p->right)
+ {
+ if ( p->expr==PRED_AND_LIST || p->expr==PRED_OR_LIST )
+ return tmember_of_context(t, p->down);
+ if ( tmember_constrained(t, p->tcontext) ) return 1;
+ if ( tmember_of_context(t, p->down) ) return 1;
+ }
+ return 0;
+}
+
+int
+#ifdef __USE_PROTOS
+is_single_tuple( Tree *t )
+#else
+is_single_tuple( t )
+Tree *t;
+#endif
+{
+ if ( t == NULL ) return 0;
+ if ( t->right != NULL ) return 0;
+ if ( t->down == NULL ) return 1;
+ return is_single_tuple(t->down);
+}
+
+
+/* MR10 Check that a context guard contains only allowed things */
+/* MR10 (mainly token references). */
+
+#ifdef __USE_PROTOS
+int contextGuardOK(Node *p,int h,int *hmax)
+#else
+int contextGuardOK(p,h,hmax)
+ Node *p;
+ int h;
+ int *hmax;
+#endif
+{
+ Junction *j;
+ TokNode *tn;
+
+ if (p == NULL) return 1;
+ if (p->ntype == nToken) {
+ h++;
+ if (h > *hmax) *hmax=h;
+ tn=(TokNode *)p;
+ if (tn->el_label != NULL) {
+ warnFL(eMsg1("a label (\"%s\") for a context guard element is meaningless",tn->el_label),
+ FileStr[p->file],p->line);
+ };
+ return contextGuardOK( ( (TokNode *) p)->next,h,hmax);
+ } else if (p->ntype == nAction) {
+ goto Fail;
+ } else if (p->ntype == nRuleRef) {
+ goto Fail;
+ } else {
+ require (p->ntype == nJunction,"Unexpected ntype");
+ j=(Junction *) p;
+ if (j->jtype != Generic &&
+ j->jtype != aSubBlk && /* pretty sure this one is allowed */
+/**** j->jtype != aOptBlk && ****/ /* pretty sure this one is allowed */ /* MR11 not any more ! */
+ j->jtype != EndBlk) {
+ errFL("A context guard may not contain an option block: {...} or looping block: (...)* or (...)+",
+ FileStr[p->file],p->line);
+ contextGuardOK(j->p1,h,hmax);
+ return 0;
+ };
+ /* do both p1 and p2 so use | rather than || */
+ return contextGuardOK(j->p2,h,hmax) | contextGuardOK(j->p1,h,hmax);
+ };
+Fail:
+ errFL("A context guard may contain only Token references - guard will be ignored",
+ FileStr[p->file],p->line);
+ contextGuardOK( ( (ActionNode *) p)->next,h,hmax);
+ return 0;
+}
+
+/*
+ * Look at a (...)? generalized-predicate context-guard and compute
+ * either a lookahead set (k==1) or a lookahead tree for k>1. The
+ * k level is determined by the guard itself rather than the LL_k
+ * variable. For example, ( A B )? is an LL(2) guard and ( ID )?
+ * is an LL(1) guard. For the moment, you can only have a single
+ * tuple in the guard. Physically, the block must look like this
+ * --o-->TOKEN-->o-->o-->TOKEN-->o-- ... -->o-->TOKEN-->o--
+ * An error is printed for any other type.
+ */
+Predicate *
+#ifdef __USE_PROTOS
+computePredFromContextGuard(Graph blk,int *msgDone) /* MR10 */
+#else
+computePredFromContextGuard(blk,msgDone) /* MR10 */
+ Graph blk;
+ int *msgDone; /* MR10 */
+#endif
+{
+ Junction *junc = (Junction *)blk.left, *p;
+ Tree *t=NULL;
+ Predicate *pred = NULL;
+ set scontext, rk;
+ int ok;
+ int hmax=0;
+
+ require(junc!=NULL && junc->ntype == nJunction, "bad context guard");
+
+/* MR10 Check for anything other than Tokens and generic junctions */
+
+ *msgDone=0; /* MR10 */
+ ok=contextGuardOK( (Node *)junc,0,&hmax); /* MR10 */
+ if (! ok) { /* MR10 */
+ *msgDone=1; /* MR10 */
+ return NULL; /* MR10 */
+ }; /* MR10 */
+ if (hmax == 0) {
+errFL("guard is 0 tokens long",FileStr[junc->file],junc->line); /* MR11 */
+ *msgDone=1;
+ return NULL;
+ };
+ if (hmax > CLL_k) { /* MR10 */
+errFL(eMsgd2("guard is %d tokens long - lookahead is limited to max(k,ck)==%d", /* MR10 */
+ hmax,CLL_k), /* MR10 */
+ FileStr[junc->file],junc->line); /* MR10 */
+ *msgDone=1; /* MR10 */
+ return NULL; /* MR10 */
+ }; /* MR10 */
+
+ rk = empty;
+ p = junc;
+ pred = new_pred();
+ pred->k = hmax; /* MR10 should be CLL_k, not LLK ? */
+ if (hmax > 1 ) /* MR10 was LL_k */
+ {
+ ConstrainSearch = 0;
+ ContextGuardTRAV = 1;
+ TRAV(p, hmax, &rk, t); /* MR10 was LL_k */
+ ContextGuardTRAV = 0;
+ set_free(rk);
+ t = tshrink( t );
+ t = tflatten( t );
+ t = tleft_factor( t );
+/*
+ fprintf(stderr, "ctx guard:");
+ preorder(t);
+ fprintf(stderr, "\n");
+*/
+ pred->tcontext = t;
+ }
+ else
+ {
+ REACH(p, 1, &rk, scontext);
+ require(set_nil(rk), "rk != nil");
+ set_free(rk);
+/*
+ fprintf(stderr, "LL(1) ctx guard is:");
+ s_fprT(stderr, scontext);
+ fprintf(stderr, "\n");
+*/
+ pred->scontext[1] = scontext;
+ }
+
+ list_add(&ContextGuardPredicateList,pred); /* MR13 */
+
+ return pred;
+}
+
+/* MR13
+ When the context guard is originally computed the
+ meta-tokens are not known.
+*/
+
+#ifdef __USE_PROTOS
+void recomputeContextGuard(Predicate *pred)
+#else
+void recomputeContextGuard(pred)
+ Predicate *pred;
+#endif
+{
+ Tree * t=NULL;
+ set scontext;
+ set rk;
+ ActionNode * actionNode;
+ Junction * p;
+
+ actionNode=pred->source;
+ require (actionNode != NULL,"context predicate's source == NULL");
+
+ p=actionNode->guardNodes;
+ require (p != NULL,"context predicate's guardNodes == NULL");
+
+ rk = empty;
+ if (pred->k > 1 )
+ {
+ ConstrainSearch = 0;
+ ContextGuardTRAV = 1;
+ TRAV(p, pred->k, &rk, t);
+ ContextGuardTRAV = 0;
+ set_free(rk);
+ t = tshrink( t );
+ t = tflatten( t );
+ t = tleft_factor( t );
+ Tfree(pred->tcontext);
+ pred->tcontext = t;
+ }
+ else
+ {
+ REACH(p, 1, &rk, scontext);
+ require(set_nil(rk), "rk != nil");
+ set_free(rk);
+ set_free(pred->scontext[1]);
+ pred->scontext[1] = scontext;
+ }
+}
+
+/* MR11 - had enough of flags yet ? */
+
+int MR_AmbSourceSearch=0;
+int MR_AmbSourceSearchGroup=0;
+int MR_AmbSourceSearchChoice=0;
+int MR_AmbSourceSearchLimit=0;
+int MR_matched_AmbAidRule=0;
+
+static set *matchSets[2]={NULL,NULL};
+static int *tokensInChain=NULL;
+static Junction *MR_AmbSourceSearchJ[2];
+
+void MR_traceAmbSourceKclient()
+{
+ int i;
+ set *save_fset;
+ int save_ConstrainSearch;
+ set incomplete;
+ Tree *t;
+
+ if (matchSets[0] == NULL) {
+ matchSets[0]=(set *) calloc (CLL_k+1,sizeof(set));
+ require (matchSets[0] != NULL,"matchSets[0] alloc");
+ matchSets[1]=(set *) calloc (CLL_k+1,sizeof(set));
+ require (matchSets[1] != NULL,"matchSets[1] alloc");
+ };
+
+ for (i=1 ; i <= MR_AmbSourceSearchLimit ; i++) {
+ set_clr(matchSets[0][i]);
+ set_orel( (unsigned) tokensInChain[i],
+ &matchSets[0][i]);
+ set_clr(matchSets[1][i]);
+ set_orel( (unsigned) tokensInChain[i],
+ &matchSets[1][i]);
+ };
+
+ save_fset=fset;
+ save_ConstrainSearch=ConstrainSearch;
+
+
+
+ for (i=0 ; i < 2 ; i++) {
+
+#if 0
+** fprintf(stdout," Choice:%d Depth:%d ",i+1,MR_AmbSourceSearchLimit);
+** fprintf(stdout,"(");
+** for (j=1 ; j <= MR_AmbSourceSearchLimit ; j++) {
+** if (j != 1) fprintf(stdout," ");
+** fprintf(stdout,"%s",TerminalString(tokensInChain[j]));
+** };
+** fprintf(stdout,")\n\n");
+#endif
+
+ fset=matchSets[i];
+
+ MR_AmbSourceSearch=1;
+ MR_MaintainBackTrace=1;
+ MR_AmbSourceSearchChoice=i;
+ ConstrainSearch=1;
+
+ maxk = MR_AmbSourceSearchLimit;
+
+ incomplete=empty;
+ t=NULL;
+
+ constrain = &(fset[1]);
+ MR_pointerStackReset(&MR_BackTraceStack);
+
+ TRAV(MR_AmbSourceSearchJ[i],maxk,&incomplete,t);
+
+ Tfree(t);
+
+ require (set_nil(incomplete),"MR_traceAmbSourceK TRAV incomplete");
+ require (MR_BackTraceStack.count == 0,"K: MR_BackTraceStack.count != 0");
+
+ set_free(incomplete);
+ };
+
+ ConstrainSearch=save_ConstrainSearch;
+ fset=save_fset;
+ MR_AmbSourceSearch=0;
+ MR_MaintainBackTrace=0;
+ MR_AmbSourceSearchChoice=0;
+}
+
+#ifdef __USE_PROTOS
+Tree *tTrunc(Tree *t,int depth)
+#else
+Tree *tTrunc(t,depth)
+ Tree *t;
+#endif
+{
+ Tree *u;
+
+ require ( ! (t == NULL && depth > 0),"tree too short");
+
+ if (depth == 0) return NULL;
+
+ if (t->token == ALT) {
+ u=tTrunc(t->down,depth);
+ } else {
+ u=tnode(t->token);
+ u->down=tTrunc(t->down,depth-1);
+ };
+ if (t->right != NULL) u->right=tTrunc(t->right,depth);
+ return u;
+}
+
+#ifdef __USE_PROTOS
+void MR_iterateOverTree(Tree *t,int chain[])
+#else
+void MR_iterateOverTree(t,chain)
+ Tree *t;
+ int chain[];
+#endif
+{
+ if (t == NULL) return;
+ chain[0]=t->token;
+ if (t->down != NULL) {
+ MR_iterateOverTree(t->down,&chain[1]);
+ } else {
+ MR_traceAmbSourceKclient();
+ };
+ MR_iterateOverTree(t->right,&chain[0]);
+ chain[0]=0;
+}
+
+#ifdef __USE_PROTOS
+void MR_traceAmbSourceK(Tree *t,Junction *alt1,Junction *alt2)
+#else
+void MR_traceAmbSourceK(t,alt1,alt2)
+ Tree *t;
+ Junction *alt1;
+ Junction *alt2;
+#endif
+{
+ int i;
+ int depth;
+ int maxDepth;
+ Tree *truncatedTree;
+
+ if (MR_AmbAidRule == NULL) return;
+
+ if ( ! (
+ strcmp(MR_AmbAidRule,alt1->rname) == 0 ||
+ strcmp(MR_AmbAidRule,alt2->rname) == 0 ||
+ MR_AmbAidLine==alt1->line ||
+ MR_AmbAidLine==alt2->line
+ )
+ ) return;
+
+ MR_matched_AmbAidRule++;
+
+ /* there are no token sets in trees, only in TokNodes */
+
+ MR_AmbSourceSearchJ[0]=analysis_point( (Junction *) alt1->p1);
+ MR_AmbSourceSearchJ[1]=analysis_point( (Junction *) alt2->p1);
+
+ if (tokensInChain == NULL) {
+ tokensInChain=(int *) calloc (CLL_k+1,sizeof(int));
+ require (tokensInChain != NULL,"tokensInChain alloc");
+ };
+
+ MR_AmbSourceSearchGroup=0;
+
+ fprintf(stdout,"\n");
+ fprintf(stdout," Ambiguity Aid ");
+ fprintf(stdout,
+ (MR_AmbAidDepth <= LL_k ?
+ "(-k %d -aa %s %s -aad %d)\n\n" :
+ "(-k %d -aa %s %s [-k value limits -aad %d])\n\n"),
+ LL_k,
+ MR_AmbAidRule,
+ (MR_AmbAidMultiple ? "-aam" : ""),
+ MR_AmbAidDepth);
+
+ for (i=0 ; i < 2 ; i++) {
+ fprintf(stdout," Choice %d: %-25s line %d file %s\n",
+ (i+1),
+ MR_ruleNamePlusOffset( (Node *) MR_AmbSourceSearchJ[i]),
+ MR_AmbSourceSearchJ[i]->line,
+ FileStr[MR_AmbSourceSearchJ[i]->file]);
+ };
+
+ fprintf(stdout,"\n");
+
+ if (MR_AmbAidDepth < LL_k) {
+ maxDepth=MR_AmbAidDepth;
+ } else {
+ maxDepth=LL_k;
+ };
+
+ for (depth=1 ; depth <= maxDepth; depth++) {
+ MR_AmbSourceSearchLimit=depth;
+ if (depth < LL_k) {
+ truncatedTree=tTrunc(t,depth);
+ truncatedTree=tleft_factor(truncatedTree);
+ MR_iterateOverTree(truncatedTree,&tokensInChain[1]); /* <===== */
+ Tfree(truncatedTree);
+ } else {
+ MR_iterateOverTree(t,tokensInChain); /* <===== */
+ };
+ fflush(stdout);
+ fflush(stderr);
+ };
+
+ fprintf(stdout,"\n");
+ MR_AmbSourceSearch=0;
+ MR_MaintainBackTrace=0;
+ MR_AmbSourceSearchGroup=0;
+ MR_AmbSourceSearchChoice=0;
+ MR_AmbSourceSearchLimit=0;
+
+}
+
+
+/* this if for k=1 grammars only
+
+ this is approximate only because of the limitations of linear
+ approximation lookahead. Don't want to do a k=3 search when
+ the user only specified a ck=3 grammar
+*/
+
+#ifdef __USE_PROTOS
+void MR_traceAmbSource(set *matchSets,Junction *alt1, Junction *alt2)
+#else
+void MR_traceAmbSource(matchSets,alt1,alt2)
+ set *matchSets;
+ Junction *alt1;
+ Junction *alt2;
+#endif
+{
+ set *save_fset;
+ Junction *p[2];
+ int i;
+ int j;
+ set *dup_matchSets;
+ set intersection;
+ set incomplete;
+ set tokensUsed;
+ int depth;
+
+ if (MR_AmbAidRule == NULL) return;
+ if ( ! (
+ strcmp(MR_AmbAidRule,alt1->rname) == 0 ||
+ strcmp(MR_AmbAidRule,alt2->rname) == 0 ||
+ MR_AmbAidLine==alt1->line ||
+ MR_AmbAidLine==alt2->line
+ )
+ ) return;
+
+ MR_matched_AmbAidRule++;
+
+ save_fset=fset;
+
+ dup_matchSets=(set *) calloc(CLL_k+1,sizeof(set));
+ require (dup_matchSets != NULL,"Can't allocate dup_matchSets");
+
+ p[0]=analysis_point( (Junction *) alt1->p1);
+ p[1]=analysis_point( (Junction *) alt2->p1);
+
+ fprintf(stdout,"\n");
+
+ fprintf(stdout," Ambiguity Aid ");
+ fprintf(stdout,
+ (MR_AmbAidDepth <= CLL_k ?
+ "(-ck %d -aa %s %s -aad %d)\n\n" :
+ "(-ck %d -aa %s %s [-ck value limits -aad %d])\n\n"),
+ CLL_k,
+ MR_AmbAidRule,
+ (MR_AmbAidMultiple ? "-aam" : ""),
+ MR_AmbAidDepth);
+
+ for (i=0 ; i < 2 ; i++) {
+ fprintf(stdout," Choice %d: %-25s line %d file %s\n",
+ (i+1),
+ MR_ruleNamePlusOffset( (Node *) p[i]),
+ p[i]->line,FileStr[p[i]->file]);
+ };
+
+ for (j=1; j <= CLL_k ; j++) {
+ fprintf(stdout,"\n Intersection of lookahead[%d] sets:\n",j);
+ intersection=set_and(alt1->fset[j],alt2->fset[j]);
+ MR_dumpTokenSet(stdout,2,intersection);
+ set_free(intersection);
+ };
+
+ fprintf(stdout,"\n");
+
+ require (1 <= MR_AmbAidDepth && MR_AmbAidDepth <= CLL_k,
+ "illegal MR_AmbAidDepth");
+
+ MR_AmbSourceSearchGroup=0;
+ for (depth=1; depth <= MR_AmbAidDepth; depth++) {
+ MR_AmbSourceSearchLimit=depth;
+ for (i=0 ; i < 2 ; i++) {
+
+/*** fprintf(stdout," Choice:%d Depth:%d\n\n",i+1,depth); ***/
+
+ for (j=0 ; j <= CLL_k ; j++) { dup_matchSets[j]=set_dup(matchSets[j]); };
+ fset=dup_matchSets;
+
+ fflush(output);
+ fflush(stdout);
+
+ MR_AmbSourceSearch=1;
+ MR_MaintainBackTrace=1;
+ MR_AmbSourceSearchChoice=i;
+
+ maxk = depth;
+ tokensUsed=empty;
+ incomplete=empty;
+
+ constrain = &(fset[1]);
+ MR_pointerStackReset(&MR_BackTraceStack);
+
+ REACH(p[i],depth,&incomplete,tokensUsed);
+
+ fflush(output);
+ fflush(stdout);
+
+ require (set_nil(incomplete),"MR_traceAmbSource REACH incomplete");
+ require (MR_BackTraceStack.count == 0,"1: MR_BackTraceStack.count != 0");
+
+ set_free(incomplete);
+ set_free(tokensUsed);
+
+ for (j=0 ; j <= CLL_k ; j++) { set_free(dup_matchSets[j]); };
+ };
+ };
+
+ fprintf(stdout,"\n");
+
+ MR_AmbSourceSearch=0;
+ MR_MaintainBackTrace=0;
+ MR_AmbSourceSearchGroup=0;
+ MR_AmbSourceSearchChoice=0;
+ MR_AmbSourceSearchLimit=0;
+
+ fset=save_fset;
+ free ( (char *) dup_matchSets);
+}
+
+static int itemCount;
+
+void MR_backTraceDumpItemReset() {
+ itemCount=0;
+}
+
+#ifdef __USE_PROTOS
+void MR_backTraceDumpItem(FILE *f,int skip,Node *n)
+#else
+void MR_backTraceDumpItem(f,skip,n)
+ FILE *f;
+ int skip;
+ Node *n;
+#endif
+{
+ TokNode *tn;
+ RuleRefNode *rrn;
+ Junction *j;
+ ActionNode *a;
+
+ switch (n->ntype) {
+ case nToken:
+ itemCount++; if (skip) goto EXIT;
+ tn=(TokNode *)n;
+ if (set_nil(tn->tset)) {
+ fprintf(f," %2d #token %-23s",itemCount,TerminalString(tn->token));
+ } else {
+ fprintf(f," %2d #tokclass %-20s",itemCount,TerminalString(tn->token));
+ };
+ break;
+ case nRuleRef:
+ itemCount++; if (skip) goto EXIT;
+ rrn=(RuleRefNode *)n;
+ fprintf(f," %2d to %-27s",itemCount,rrn->text);
+ break;
+ case nAction:
+ a=(ActionNode *)n;
+ goto EXIT;
+ case nJunction:
+
+ j=(Junction *)n;
+
+ switch (j->jtype) {
+ case aSubBlk:
+ if (j->guess) {
+ itemCount++; if (skip) goto EXIT;
+ fprintf(f," %2d %-30s",itemCount,"in (...)? block at");
+ break;
+ };
+/****** fprintf(f," %2d %-32s",itemCount,"in (...) block at"); *******/
+/****** break; *******/
+ goto EXIT;
+ case aOptBlk:
+ itemCount++; if (skip) goto EXIT;
+ fprintf(f," %2d %-30s",itemCount,"in {...} block");
+ break;
+ case aLoopBlk:
+ itemCount++; if (skip) goto EXIT;
+ fprintf(f," %2d %-30s",itemCount,"in (...)* block");
+ break;
+ case EndBlk:
+ if (j->alpha_beta_guess_end) {
+ itemCount++; if (skip) goto EXIT;
+ fprintf(f," %2d %-30s",itemCount,"end (...)? block at");
+ break;
+ };
+ goto EXIT;
+/****** fprintf(f," %2d %-32s",itemCount,"end of a block at"); *****/
+/****** break; *****/
+ case RuleBlk:
+ itemCount++; if (skip) goto EXIT;
+ fprintf(f," %2d %-30s",itemCount,j->rname);
+ break;
+ case Generic:
+ goto EXIT;
+ case EndRule:
+ itemCount++; if (skip) goto EXIT;
+ fprintf (f," %2d end %-26s",itemCount,j->rname);
+ break;
+ case aPlusBlk:
+ itemCount++; if (skip) goto EXIT;
+ fprintf(f," %2d %-30s",itemCount,"in (...)+ block");
+ break;
+ case aLoopBegin:
+ goto EXIT;
+ };
+ break;
+ };
+ fprintf(f," %-23s line %-4d %s\n",MR_ruleNamePlusOffset(n),n->line,FileStr[n->file]);
+EXIT:
+ return;
+}
+
+
+static PointerStack previousBackTrace={0,0,NULL};
+
+#ifdef __USE_PROTOS
+void MR_backTraceReport(void)
+#else
+void MR_backTraceReport()
+#endif
+{
+ int i;
+ int match = 0;
+ int limitMatch;
+
+ Node *p;
+ TokNode *tn;
+ set remainder;
+ int depth;
+
+ /* Even when doing a k=2 search this routine can get
+ called when there is only 1 token on the stack.
+ This is because something like rRuleRef can change
+ the search value of k from 2 to 1 temporarily.
+ It does this because the it wants to know the k=1
+ first set before it does a k=2 search
+ */
+
+ depth=0;
+ for (i=0; i < MR_BackTraceStack.count ; i++) {
+ p=(Node *) MR_BackTraceStack.data[i];
+ if (p->ntype == nToken) depth++;
+ };
+
+/* MR14 */ if (MR_AmbSourceSearch) {
+/* MR14 */ require (depth <= MR_AmbSourceSearchLimit,"depth > MR_AmbSourceSearchLimit");
+/* MR14 */ }
+
+ /* MR23 THM - Traceback report was being called at the wrong time for -alpha reports */
+ /* Reported by Arpad Beszedes (beszedes@inf.u-szeged.hu) */
+
+ if (MR_AmbSourceSearchLimit == 0 || depth < MR_AmbSourceSearchLimit) {
+ return;
+ };
+
+ MR_backTraceDumpItemReset();
+
+ limitMatch=MR_BackTraceStack.count;
+ if (limitMatch > previousBackTrace.count) {
+ limitMatch=previousBackTrace.count;
+ };
+
+ for (match=0; match < limitMatch; match++) {
+ if (MR_BackTraceStack.data[match] !=
+ previousBackTrace.data[match]) {
+ break;
+ };
+ };
+
+ /* not sure at the moment why there would be duplicates */
+
+ if (match != MR_BackTraceStack.count) {
+
+ fprintf(stdout," Choice:%d Depth:%d Group:%d",
+ (MR_AmbSourceSearchChoice+1),
+ MR_AmbSourceSearchLimit,
+ ++MR_AmbSourceSearchGroup);
+
+ depth=0;
+ fprintf(stdout," (");
+ for (i=0; i < MR_BackTraceStack.count ; i++) {
+ p=(Node *) MR_BackTraceStack.data[i];
+ if (p->ntype != nToken) continue;
+ tn=(TokNode *)p;
+ if (depth != 0) fprintf(stdout," ");
+ fprintf(stdout,TerminalString(tn->token));
+ depth++;
+ if (! MR_AmbAidMultiple) {
+ if (set_nil(tn->tset)) {
+ set_rm( (unsigned) tn->token,fset[depth]);
+ } else {
+ remainder=set_dif(fset[depth],tn->tset);
+ set_free(fset[depth]);
+ fset[depth]=remainder;
+ };
+ };
+ };
+ fprintf(stdout,")\n");
+
+ for (i=0; i < MR_BackTraceStack.count ; i++) {
+ MR_backTraceDumpItem(stdout, (i<match) ,(Node *) MR_BackTraceStack.data[i]);
+ };
+ fprintf(stdout,"\n");
+ fflush(stdout);
+
+ MR_pointerStackReset(&previousBackTrace);
+
+ for (i=0; i < MR_BackTraceStack.count ; i++) {
+ MR_pointerStackPush(&previousBackTrace,MR_BackTraceStack.data[i]);
+ };
+
+ };
+}
+
+#ifdef __USE_PROTOS
+void MR_setConstrainPointer(set * newConstrainValue)
+#else
+void MR_setConstrainPointer(newConstrainValue)
+ set * newConstrainValue;
+#endif
+{
+ constrain=newConstrainValue;
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/gen.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/gen.c new file mode 100644 index 0000000000..368a96b9ac --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/gen.c @@ -0,0 +1,4797 @@ +/*
+ * gen.c
+ *
+ * Generate C code (ANSI, K&R, C++)
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2001
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include "pcctscfg.h"
+#include "set.h"
+#include "syn.h"
+#include "hash.h"
+#include "generic.h"
+#include "dlgdef.h"
+
+#define NumExprPerLine 4
+static int on1line=0;
+static set tokensRefdInBlock;
+
+ /* T r a n s l a t i o n T a b l e s */
+
+/* C_Trans[node type] == pointer to function that knows how to translate that node. */
+#ifdef __cplusplus
+void (*C_Trans[NumNodeTypes+1])(...) = {
+ NULL,
+ NULL, /* See next table.
+Junctions have many types */
+ (void (*)(...)) genRuleRef,
+ (void (*)(...)) genToken,
+ (void (*)(...)) genAction
+ };
+#else
+void (*C_Trans[NumNodeTypes+1])() = {
+ NULL,
+ NULL, /* See next table.
+Junctions have many types */
+ genRuleRef,
+ genToken,
+ genAction
+ };
+#endif
+
+/* C_JTrans[Junction type] == pointer to function that knows how to translate that
+ * kind of junction node.
+ */
+#ifdef __cplusplus
+void (*C_JTrans[NumJuncTypes+1])(...) = {
+ NULL,
+ (void (*)(...)) genSubBlk,
+ (void (*)(...)) genOptBlk,
+ (void (*)(...)) genLoopBlk,
+ (void (*)(...)) genEndBlk,
+ (void (*)(...)) genRule,
+ (void (*)(...)) genJunction,
+ (void (*)(...)) genEndRule,
+ (void (*)(...)) genPlusBlk,
+ (void (*)(...)) genLoopBegin
+ };
+#else
+void (*C_JTrans[NumJuncTypes+1])() = {
+ NULL,
+ genSubBlk,
+ genOptBlk,
+ genLoopBlk,
+ genEndBlk,
+ genRule,
+ genJunction,
+ genEndRule,
+ genPlusBlk,
+ genLoopBegin
+ };
+#endif
+
+#define PastWhiteSpace(s) while (*(s) == ' ' || *(s) == '\t') {s++;}
+
+static int tabs = 0;
+
+/* MR6 Got tired of text running off page when using standard tab stops */
+
+#define TAB { int i; \
+ if (TabWidth==0) { \
+ for (i=0; i<tabs; i++) fputc('\t', output); \
+ } else { \
+ for (i=0; i<tabs*TabWidth; i++) fputc(' ',output); \
+ }; \
+ }
+
+static void
+#ifdef __USE_PROTOS
+tab( void )
+#else
+tab( )
+#endif
+TAB
+
+#ifdef __USE_PROTOS
+static char *tokenFollowSet(TokNode *);
+static ActionNode *findImmedAction( Node * );
+static void dumpRetValAssign(char *, char *, RuleRefNode *); /* MR30 */
+static void dumpAfterActions(FILE *output);
+static set ComputeErrorSet(Junction *, int, int);
+static void makeErrorClause(Junction *, set, int, int);
+static void DumpFuncHeader( Junction *, RuleEntry * );
+static int has_guess_block_as_first_item(Junction *);
+static int genExprSets(set *, int);
+static void genExprTree( Tree *t, int k );
+static void genExprTreeOriginal( Tree *t, int k ); /* MR10 */
+static char * findOuterHandlerLabel(ExceptionGroup *eg); /* MR7 */
+static void OutLineInfo(FILE *file,int line,char *fileName); /* MR14 */
+#else
+static char *tokenFollowSet();
+static ActionNode *findImmedAction();
+static void dumpRetValAssign();
+static void dumpAfterActions();
+static set ComputeErrorSet();
+static void makeErrorClause();
+static void DumpFuncHeader();
+static int has_guess_block_as_first_item();
+static int genExprSets();
+static void genExprTree();
+static void genExprTreeOriginal(); /* MR10 */
+static char * findOuterHandlerLabel(); /* MR7 */
+static void OutLineInfo(); /* MR14 */
+#endif
+
+#define gen(s) {tab(); fprintf(output, s);}
+#define gen1(s,a) {tab(); fprintf(output, s,a);}
+#define gen2(s,a,b) {tab(); fprintf(output, s,a,b);}
+#define gen3(s,a,b,c) {tab(); fprintf(output, s,a,b,c);}
+#define gen4(s,a,b,c,d) {tab(); fprintf(output, s,a,b,c,d);}
+#define gen5(s,a,b,c,d,e) {tab(); fprintf(output, s,a,b,c,d,e);}
+#define gen6(s,a,b,c,d,e,f) {tab(); fprintf(output, s,a,b,c,d,e,f);}
+#define gen7(s,a,b,c,d,e,f,g) {tab(); fprintf(output, s,a,b,c,d,e,f,g);}
+
+#define _gen(s) {fprintf(output, s);}
+#define _gen1(s,a) {fprintf(output, s,a);}
+#define _gen2(s,a,b) {fprintf(output, s,a,b);}
+#define _gen3(s,a,b,c) {fprintf(output, s,a,b,c);}
+#define _gen4(s,a,b,c,d){fprintf(output, s,a,b,c,d);}
+#define _gen5(s,a,b,c,d,e){fprintf(output, s,a,b,c,d,e);}
+#define _gen6(s,a,b,c,d,e,f){fprintf(output, s,a,b,c,d,e,f);}
+#define _gen7(s,a,b,c,d,e,f,g){fprintf(output, s,a,b,c,d,e,f,g);}
+
+
+/* MR11 a convenient place to set a break point */
+
+#ifdef __USE_PROTOS
+void MR_break(void)
+#else
+void MR_break()
+#endif
+{
+ return;
+}
+
+/* MR10 genTraceOut(Junction *) */
+
+#ifdef __USE_PROTOS
+static void genTraceOut(Junction *q)
+#else
+static void genTraceOut(q)
+ Junction *q;
+#endif
+{
+ if ( TraceGen ) {
+ if ( GenCC ) {gen1("zzTRACEOUT(\"%s\");\n", q->rname);}
+ else gen1("zzTRACEOUT((ANTLRChar *)\"%s\");\n", q->rname);
+ }
+}
+
+static void
+#ifdef __USE_PROTOS
+warn_about_using_gk_option(void)
+#else
+warn_about_using_gk_option()
+#endif
+{
+ static int warned_already=0;
+
+ if ( !DemandLookahead || warned_already ) return;
+ warned_already = 1;
+ warnNoFL("-gk option could cause trouble for <<...>>? predicates");
+}
+
+void
+#ifdef __USE_PROTOS
+freeBlkFsets( Junction *q )
+#else
+freeBlkFsets( q )
+Junction *q;
+#endif
+{
+ int i;
+ Junction *alt;
+ require(q!=NULL, "freeBlkFsets: invalid node");
+
+ for (alt=q; alt != NULL; alt= (Junction *) alt->p2 )
+ {
+ for (i=1; i<=CLL_k; i++) set_free(alt->fset[i]);
+ }
+}
+
+/*
+ * Generate a local variable allocation for each token references
+ * in this block.
+ */
+static void
+#ifdef __USE_PROTOS
+genTokenPointers( Junction *q )
+#else
+genTokenPointers( q )
+Junction *q;
+#endif
+{
+ /* Rule refs are counted and can be referenced, but their
+ * value is not set to anything useful ever.
+ *
+ * The ptrs are to be named _tij where i is the current level
+ * and j is the element number within an alternative.
+ */
+ int first=1, t=0;
+ set a;
+ tokensRefdInBlock = q->tokrefs;
+
+ if ( set_deg(q->tokrefs) == 0 ) return;
+ a = set_dup(q->tokrefs);
+ gen("ANTLRTokenPtr ");
+ for (; !set_nil(a); set_rm(t, a))
+ {
+ t = set_int(a);
+ if ( first ) first = 0;
+ else _gen(",");
+ if ( !DontCopyTokens ) _gen2("_tv%d%d,", BlkLevel, t);
+ _gen2("_t%d%d", BlkLevel, t);
+ if ( !DontCopyTokens ) {_gen2("= &_tv%d%d", BlkLevel, t);}
+ else _gen("=NULL");
+ }
+ _gen(";\n");
+ set_free(a);
+}
+
+static int
+#ifdef __USE_PROTOS
+hasDefaultException(ExceptionGroup *eg)
+#else
+hasDefaultException(eg)
+ExceptionGroup *eg;
+#endif
+{
+ ListNode *q;
+
+ for (q = eg->handlers->next; q!=NULL; q=q->next)
+ {
+ ExceptionHandler *eh = (ExceptionHandler *)q->elem;
+ if ( strcmp("default", eh->signalname)==0 ) {
+ return 1;
+ }
+ }
+ return 0;
+}
+static void
+#ifdef __USE_PROTOS
+dumpException(ExceptionGroup *eg, int no_default_case)
+#else
+dumpException(eg, no_default_case)
+ExceptionGroup *eg;
+int no_default_case;
+#endif
+{
+ char *outerLabel; /* MR7 */
+ int altHandler=0; /* MR7 */
+ int namedHandler=0; /* MR7 */
+
+ outerLabel=findOuterHandlerLabel(eg); /* MR7 */
+
+ if (eg->label != NULL) { /* MR7 */
+ namedHandler=1; /* MR7 */
+ } else if (eg->forRule) { /* MR7 */
+ /* nothing */ /* MR20 */
+ } else { /* MR7 */
+ altHandler=1; /* MR7 */
+ }; /* MR7 */
+
+#if 0
+** if (! eg->used) { /* MR7 */
+** warnFL("exception group never used", /* MR7 */
+** FileStr[eg->altstart->file],eg->altstart->line); /* MR7 */
+** }; /* MR7 */
+#endif
+
+ if (namedHandler) { /* MR7 */
+ gen1("switch ( _signal ) { /* [%s] */\n",eg->label); /* MR7 */
+ } else { /* MR7 */
+ gen("switch ( _signal ) {\n"); /* MR7 */
+ gen("case NoSignal: break; /* MR7 */\n"); /* MR7 */
+ }; /* MR7 */
+ {
+ ListNode *q;
+ for (q = eg->handlers->next; q!=NULL; q=q->next)
+ {
+ ExceptionHandler *eh = (ExceptionHandler *)q->elem;
+ if ( strcmp("default", eh->signalname)==0 ) {
+ gen("default :\n");
+ tabs++;
+ dumpAction(eh->action, output, tabs, -1, 1, 1);
+ gen("_signal=NoSignal; /* MR7 */\n"); /* MR7 */
+ gen("break; /* MR7 */\n"); /* MR7 */
+ tabs--;
+ gen("}\n");
+
+ /* copied from later code in dumpException */ /* MR7 */
+
+ if (namedHandler) { /* MR7 */
+ gen("if (_signal != NoSignal)"); /* MR7 */
+ _gen1(" goto %s_handler; /* MR7 */\n",outerLabel);/* MR7 */
+ } else if (altHandler) { /* MR7 */
+ gen1("goto %s_handler; /* MR7 */\n",outerLabel); /* MR7 */
+ };
+ return;
+ }
+ gen1("case %s :\n", eh->signalname);
+ tabs++;
+ if ( eh->action != NULL )
+ {
+ dumpAction(eh->action, output, tabs, -1, 1, 1);
+ gen("break; /* MR7 */\n"); /* MR7 */
+ }
+ tabs--;
+ }
+ }
+ if ( no_default_case ) return;
+
+ gen("default :\n");
+ tabs++; /* MR7 */
+ gen("break; /* MR7 */\n"); /* MR7 */
+ tabs--; /* MR7 */
+
+ tabs++;
+/***** gen("*_retsignal = _signal;\n"); *****/
+
+ tabs--;
+ gen("}\n");
+
+ if (namedHandler) { /* MR7 */
+ gen("if (_signal != NoSignal)"); /* MR7 */
+ _gen1(" goto %s_handler; /* MR7 */\n",outerLabel); /* MR7 */
+ } else if (altHandler) { /* MR7 */
+ gen1("goto %s_handler; /* MR7 */\n",outerLabel); /* MR7 */
+ };
+
+}
+
+static void
+#ifdef __USE_PROTOS
+dumpExceptions(ListNode *list)
+#else
+dumpExceptions(list)
+ListNode *list;
+#endif
+{
+ ListNode *p;
+
+ for (p = list->next; p!=NULL; p=p->next)
+ {
+ ExceptionGroup *eg = (ExceptionGroup *) p->elem;
+ _gen2("%s%s_handler:\n",
+ eg->label==NULL?"":eg->label,
+ eg->altID==NULL?"":eg->altID);
+ if ( eg->altID!=NULL ) dumpException(eg, 0);
+ else {
+ /* This must be the rule exception handler */
+ dumpException(eg, 1);
+ if ( !hasDefaultException(eg) )
+ {
+ gen("default :\n");
+ tabs++;
+ gen("zzdflthandlers(_signal,_retsignal);\n");
+ tabs--;
+ gen("}\n");
+ }
+ }
+ }
+}
+
+/* For each element label that is found in a rule, generate a unique
+ * Attribute (and AST pointer if GenAST) variable.
+ */
+void
+#ifdef __USE_PROTOS
+genElementLabels(ListNode *list)
+#else
+genElementLabels(list)
+ListNode *list;
+#endif
+{
+ int first=1;
+ ListNode *p;
+
+ if ( GenCC ) {gen("ANTLRTokenPtr");}
+ else {gen("Attrib");}
+ for (p = list->next; p!=NULL; p=p->next)
+ {
+ char *ep = (char *)p->elem;
+ if ( first ) first = 0;
+ else _gen(",");
+ if ( GenCC ) {_gen1(" %s=NULL",ep);}
+ else {_gen1(" %s",ep);}
+ }
+ _gen(";\n");
+
+ if ( !GenAST ) return;
+
+ first = 1;
+ gen("AST");
+ for (p = list->next; p!=NULL; p=p->next)
+ {
+ char *ep = (char *)p->elem;
+ if ( first ) first = 0;
+ else _gen(",");
+ _gen1(" *%s_ast=NULL",ep);
+ }
+ _gen(";\n");
+}
+
+/*
+ * Generate a local variable allocation for each token or rule reference
+ * in this block.
+ */
+static void
+#ifdef __USE_PROTOS
+genASTPointers( Junction *q )
+#else
+genASTPointers( q )
+Junction *q;
+#endif
+{
+ int first=1, t;
+ set a;
+
+ a = set_or(q->tokrefs, q->rulerefs);
+ if ( set_deg(a) > 0 )
+ {
+ gen("AST ");
+ for (; !set_nil(a); set_rm(t, a))
+ {
+ t = set_int(a);
+ if ( first ) first = 0;
+ else _gen(",");
+ _gen2("*_ast%d%d=NULL", BlkLevel, t);
+ }
+ set_free(a);
+ }
+ _gen(";\n");
+}
+
+static void
+#ifdef __USE_PROTOS
+BLOCK_Head( void )
+#else
+BLOCK_Head( )
+#endif
+{
+ gen("{\n");
+ tabs++;
+ if ( !GenCC ) gen1("zzBLOCK(zztasp%d);\n", BlkLevel);
+}
+
+static void
+#ifdef __USE_PROTOS
+BLOCK_Tail( void )
+#else
+BLOCK_Tail( )
+#endif
+{
+ if ( !GenCC ) gen1("zzEXIT(zztasp%d);\n", BlkLevel);
+ if ( !GenCC ) gen("}\n");
+ tabs--;
+ gen("}\n");
+}
+
+static void
+#ifdef __USE_PROTOS
+BLOCK_Preamble( Junction *q )
+#else
+BLOCK_Preamble( q )
+Junction *q;
+#endif
+{
+ ActionNode *a;
+ Junction *begin;
+
+ BLOCK_Head();
+ if ( GenCC ) genTokenPointers(q);
+ if ( GenCC&&GenAST ) genASTPointers(q);
+ if ( q->jtype == aPlusBlk ) gen("int zzcnt=1;\n");
+ if ( q->parm != NULL && !q->predparm ) gen1("zzaPush(%s);\n", q->parm)
+ else if ( !GenCC ) gen("zzMake0;\n");
+ if ( !GenCC ) gen("{\n");
+ if ( q->jtype == aLoopBegin ) begin = (Junction *) ((Junction *)q->p1);
+ else begin = q;
+ if ( has_guess_block_as_first_item(begin) )
+ {
+ gen("zzGUESS_BLOCK\n");
+ }
+ if ( q->jtype == aLoopBegin )
+ a = findImmedAction( ((Junction *)q->p1)->p1 ); /* look at aLoopBlk */
+ else
+ a = findImmedAction( q->p1 );
+ if ( a!=NULL && !a->is_predicate) {
+/* MR21 */ if (!a->noHoist) dumpActionPlus(a, a->action, output, tabs, a->file, a->line, 1);
+ a->done = 1; /* remove action. We have already handled it */
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+genCombinedPredTreeContextOrig( Predicate *p )
+#else
+genCombinedPredTreeContextOrig( p )
+Predicate *p;
+#endif
+{
+ static set *ctx=NULL; /* genExprSets() is destructive, make copy*/
+ require(p!=NULL, "can't make context tree for NULL pred tree");
+
+#ifdef DBG_PRED
+ fprintf(stderr, "enter genCombinedPredTreeContextOrig(%s,0x%x) with sets:\n", p->expr, p);
+ s_fprT(stderr, p->scontext[1]);
+ fprintf(stderr, "\n");
+#endif
+ if ( p->down == NULL )
+ {
+/*** if ( p->k>1 && p->tcontext!=NULL ) ***/
+ if ( p->tcontext!=NULL )
+ {
+ _gen("(");
+ genExprTree(p->tcontext, 1);
+ _gen(")");
+ }
+/*** else if ( p->k==1 && set_deg(p->scontext[1])>0 ) ***/
+ else if ( set_deg(p->scontext[1])>0 )
+ {
+ if ( ctx==NULL ) ctx = (set *)calloc(CLL_k+1, sizeof(set));
+ require(ctx!=NULL, "ctx cannot allocate");
+ ctx[0]=empty;
+ ctx[1]=set_dup(p->scontext[1]);
+ _gen("(");
+ genExprSets(&(ctx[0]), p->k);
+ _gen(")");
+ set_free(ctx[1]);
+ }
+ else if ( p->expr==PRED_AND_LIST || p->expr==PRED_OR_LIST ) {
+ fatal_internal("pred tree is orphan OR or AND list");
+ }
+ else {
+ if (! HoistPredicateContext) {
+ _gen(" 1 /* no context: prc is off */ ");
+ } else {
+ fatal_internal("pred tree context is empty");
+ };
+ }
+ return;
+ }
+
+/* MR10 - make AND just like OR */
+
+ if ( p->expr == PRED_AND_LIST )
+ {
+ Predicate *list = p->down;
+ for (; list!=NULL; list=list->right)
+ {
+ genCombinedPredTreeContextOrig(list);
+ if ( list->right!=NULL ) _gen("|| /* MR10 was wrong */ ");
+ };
+ return;
+ }
+
+ if ( p->expr == PRED_OR_LIST )
+ {
+ Predicate *list = p->down;
+ for (; list!=NULL; list=list->right)
+ {
+ genCombinedPredTreeContextOrig(list);
+ if ( list->right!=NULL ) _gen("||");
+ };
+ return;
+ };
+
+ fatal("pred tree is really wacked");
+}
+
+/* [genCombinedPredTreeContext] */
+
+void
+#ifdef __USE_PROTOS
+genCombinedPredTreeContext( Predicate *p )
+#else
+genCombinedPredTreeContext( p )
+Predicate *p;
+#endif
+{
+ Tree *t;
+ int predDepth=0;
+
+ if (0 && ! MR_usingPredNames && ! MRhoisting) {
+ genCombinedPredTreeContextOrig(p);
+ } else {
+/* MR13 */ MR_pred_depth(p,&predDepth);
+/* MR13 */ if (predDepth == 1) {
+/* MR13 */
+/* MR13 */ set scontext[2];
+/* MR13 */ scontext[0]=empty;
+/* MR13 */ scontext[1]=MR_compute_pred_set(p);
+/* MR13 */ if (set_nil(scontext[1])) {
+/* MR13 */ _gen(" 1 /* MR12 no context (-prc off) */ ");
+/* MR13 */ } else {
+/* MR13 */ _gen("(");
+/* MR13 */ genExprSets(&scontext[0], 1);
+/* MR13 */ set_free(scontext[1]);
+/* MR13 */ _gen(")");
+/* MR13 */ };
+
+ } else {
+ t=MR_compute_pred_tree_context(p);
+ if (t == NULL) {
+ _gen(" 1 /* MR12 no context (-prc off) */ ");
+ } else {
+ _gen("(");
+ genExprTree(t, 1);
+ Tfree(t); /* MR10 */
+ _gen(")");
+ };
+ };
+ };
+}
+
+/* [genPredTreeGate] */
+
+void
+#ifdef __USE_PROTOS
+genPredTreeGate( Predicate *p, int in_and_expr )
+#else
+genPredTreeGate( p, in_and_expr )
+Predicate *p;
+int in_and_expr;
+#endif
+{
+ if ( in_and_expr )
+ {
+ _gen("!(");
+ genCombinedPredTreeContext(p);
+ _gen(")||");
+ if ( p->down!=NULL ) _gen("\n");
+ }
+ else
+ {
+ _gen("(");
+ genCombinedPredTreeContext(p);
+ _gen(")&&");
+ if ( p->down!=NULL ) _gen("\n");
+ }
+}
+
+#ifdef __USE_PROTOS
+void genPredEntry(Predicate *p,int outer)
+#else
+void genPredEntry(p,outer)
+ Predicate *p;
+ int outer;
+#endif
+{
+ int inverted=0;
+ Predicate *q;
+ int localOuter=outer;
+ int needRP=0;
+
+ if (p == NULL) return;
+
+ if (p->predEntry != NULL && p->predEntry->predLiteral != NULL) {
+ if (p->inverted != p->predEntry->pred->inverted) {
+ _gen("! /* inverted pred */ (");
+ needRP=1;
+ } else {
+ if (!localOuter) _gen("(");
+ needRP=1;
+ };
+ dumpAction(p->predEntry->predLiteral,output,0,p->source->file,p->source->line,0);
+ if (needRP) _gen(")");
+ return;
+ };
+
+ inverted=p->inverted;
+
+ if (inverted) {
+ _gen(" ! /* inverted pred */ (");
+ localOuter=1;
+ };
+
+ if (p->expr == PRED_OR_LIST) {
+ if (!localOuter) _gen("(");
+ for (q=p->down; q != NULL ; q=q->right) {
+ genPredEntry(q,0);
+ if (q->right != NULL) _gen(" || ");
+ };
+ if (!localOuter) _gen(")");
+ } else if (p->expr == PRED_AND_LIST) {
+ if (!localOuter) _gen("(");
+ for (q=p->down; q != NULL ; q=q->right) {
+ genPredEntry(q,0);
+ if (q->right != NULL) _gen(" && ");
+ };
+ if (!localOuter) _gen(")");
+ } else {
+ if (!localOuter) _gen("(");
+ require (p->source != NULL,"predEntry->source == NULL");
+ require (p->source->inverted == 0,"dumpPredEntry p->source->inverted != 0");
+ dumpAction(p->source->action,output,0,p->source->file,p->source->line,0);
+ if (!localOuter) _gen(")");
+ };
+
+ if (inverted) {
+ _gen(")");
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+dumpPredAction(ActionNode *anode,
+ char *s,FILE *output,int tabs,int file,int line,int final_newline)
+#else
+dumpPredAction(anode,
+ s,output,tabs,file,line,final_newline)
+
+ ActionNode *anode;
+ char *s;
+ FILE *output;
+ int tabs;
+ int file;
+ int line;
+ int final_newline;
+#endif
+{
+ PredEntry *predEntry=anode->predEntry;
+ int inverted=anode->inverted;
+ Predicate *workPred;
+
+ if (predEntry == NULL) {
+
+ /* inline predicate literal */
+
+ require(inverted == 0,"dumpPredAction action->inverted");
+ dumpAction(s,output,tabs,file,line,final_newline);
+
+ } else {
+
+ /* a reference to a predicate - possibly with an inverted source */
+
+ if (predEntry->predLiteral != NULL) {
+ if (inverted) _gen("! /* inverted pred */ (");
+ dumpAction(predEntry->predLiteral,output,0,anode->file,anode->line,0);
+ if (inverted) _gen(")");
+ } else {
+ workPred=predicate_dup(predEntry->pred);
+ if (inverted) workPred->inverted=!workPred->inverted;
+ genPredEntry(workPred,1);
+ predicate_free(workPred);
+ };
+ };
+}
+
+/* [genPred] */
+
+void
+#ifdef __USE_PROTOS
+genPred(Predicate *p, Node *j,int suppress_sva)
+#else
+genPred(p,j,suppress_sva)
+ Predicate *p;
+ Node *j;
+ int suppress_sva;
+#endif
+{
+ if ( FoundException && !suppress_sva) {_gen("(_sva=(");} /* MR11 suppress_sva */
+ else {_gen("(");}
+ if ( GenLineInfo && j->file != -1 ) _gen("\n");
+ if (p->source != NULL && p->source->ampersandPred != NULL) {
+ if (p->source->ampersandPred->k == 1) {
+
+ set ctx[2];
+
+ ctx[0]=empty;
+ ctx[1]=set_dup(p->source->ampersandPred->scontext[1]);
+
+ _gen("(");
+ genExprSets(&(ctx[0]), p->k);
+ _gen(") && ");
+ set_free(ctx[1]);
+ } else {
+ _gen("( ");
+ genExprTree(p->source->ampersandPred->tcontext,1);
+ _gen(" ) && ");
+ };
+ };
+
+ dumpPredAction((ActionNode *)p->source,
+ p->expr, output, 0, -1 /*indicates no line info*/, j->line, 0);
+
+ if ( FoundException && !suppress_sva) /* MR11 suppress_sva */
+ {_gen("),_sva)");} /* MR10 - get red of "meant ==" messages */
+ else {_gen(")");}
+}
+
+void
+#ifdef __USE_PROTOS
+MR_distinctORcontextOpt(Predicate *p,Node *j,int in_and_expr)
+#else
+MR_distinctORcontextOpt(p,j,in_and_expr)
+ Predicate *p;
+ Node *j;
+ int in_and_expr;
+#endif
+{
+ Predicate *q;
+
+ _gen(" /* MR10 Distinct OR context optimization */ \n");
+
+ if (in_and_expr) {
+ gen("zzpf=0,\n");
+ for (q=p->down; q != NULL; q=q->right) {
+ gen("( ");
+ genCombinedPredTreeContext(q);
+ _gen(" && (zzpf=1, ");
+ genPred(q,j,0);
+ _gen(" )) ||\n");
+ };
+ gen("!zzpf)");
+ } else {
+ require (0,
+ "MR_distinctORcontextOpt: can't get here when using MR_predSimplify");
+#if 0
+** for (q=p->down; q != NULL; q=q->right) {
+** gen("( ");
+** genCombinedPredTreeContext(q);
+** _gen(" && ");
+** genPred(q,j);
+** if (q->right != NULL) {
+** _gen(" ) ||\n");
+** };
+** };
+** gen(")");
+#endif
+ };
+}
+
+void
+#ifdef __USE_PROTOS
+genPredTreeOrig( Predicate *p, Node *j, int in_and_expr )
+#else
+genPredTreeOrig( p, j, in_and_expr )
+Predicate *p;
+Node *j;
+int in_and_expr;
+#endif
+{
+
+/* MR10 */ int allHaveContext=1;
+/* MR10 */ int noneHaveContext=1;
+
+/* MR10 */ MR_predContextPresent(p,&allHaveContext,&noneHaveContext);
+
+ if ( ! noneHaveContext ) /* MR10 context guards ignored when -prc off */
+ {
+ _gen("(");
+ genPredTreeGate(p, in_and_expr);
+ }
+
+ /* if leaf node, just gen predicate */
+
+ if ( p->down==NULL )
+ {
+ genPred(p,j,0);
+ if ( ! noneHaveContext ) _gen(")"); /* MR10 context guards ignored when -prc off */
+ return;
+ }
+
+ /* if AND list, do both preds (only two possible) */
+ if ( p->expr == PRED_AND_LIST )
+ {
+#if 0
+** _gen("(");
+** genPredTreeOrig(p->down, j, 1);
+** _gen("&&");
+** genPredTreeOrig(p->down->right, j, 1);
+** _gen(")");
+** if ( ! noneHaveContext ) _gen(")"); /* MR10 context guards ignored when -prc off */
+** return;
+#endif
+ /* MR11 - make it work with AND with more than two children - like OR */
+
+ Predicate *list;
+ _gen("(");
+ list = p->down;
+ for (; list!=NULL; list=list->right)
+ {
+ genPredTreeOrig(list, j, 1);
+ if ( list->right!=NULL ) _gen("&&");
+ }
+ _gen(")");
+ if ( ! noneHaveContext ) _gen(")"); /* MR10 context guards ignored when -prc off */
+ return;
+ };
+
+ if ( p->expr == PRED_OR_LIST )
+ {
+ Predicate *list;
+ _gen("(");
+ list = p->down;
+ for (; list!=NULL; list=list->right)
+ {
+ genPredTreeOrig(list, j, 0);
+ if ( list->right!=NULL ) _gen("||");
+ }
+ _gen(")");
+ if ( ! noneHaveContext ) _gen(")"); /* MR10 context guards ignored when -prc off */
+ return;
+ }
+
+ fatal_internal("genPredTreeOrig: predicate tree is wacked");
+}
+
+#if 0
+** Predicate member dummyPredDepth is no longer used in MR10
+** but we might need it again in the future
+**
+** if (MRhoisting) {
+** if ( !noneHaveContext &&
+** ! in_and_expr &&
+** p->source != NULL &&
+** p->source->dummyPredicateDepth > 0 &&
+** p->down == NULL) {
+** _gen("(");
+** genCombinedPredTreeContext(p);
+** _gen(" )\n");
+** return;
+** };
+** };
+#endif
+
+/* [genPredTree] */
+
+/* in_and_expr
+
+ what to do if the context is wrong
+ what to do if the context is correct but the predicate is false
+
+ remember: if the context is wrong it's the same as if the
+ predicate is true as far as enabling an alternative
+
+ Consider (AND p q r)
+
+ if in an ... && ... expression then you don't want
+ the entire predicate chain to fail just because the
+ context for one component is wrong: so return true
+
+ Consider (OR p q r)
+
+ if in an ... || ... expression then you don't want
+ the entire predicate chain to succeed just because
+ the context for one component is correct when the
+ corresponding test is false: so return false when
+ the context is correct but the test is false.
+*/
+
+void
+#ifdef __USE_PROTOS
+genPredTree( Predicate *p, Node *j, int in_and_expr, int suppress_sva )
+#else
+genPredTree( p, j, in_and_expr, suppress_sva)
+ Predicate *p;
+ Node *j;
+ int in_and_expr;
+ int suppress_sva;
+#endif
+{
+
+ int allHaveContext=1;
+ int noneHaveContext=1;
+ Tree *groupTree;
+ Tree *oneTree;
+ Predicate *q;
+ int identicalORcontextOptimization=0;
+ int identicalANDcontextOptimization=0;
+
+ if (0 && !MR_usingPredNames && !MRhoisting) {
+ genPredTreeOrig(p,j,in_and_expr);
+ return;
+ };
+
+ MR_predContextPresent(p,&allHaveContext,&noneHaveContext);
+
+ if ( ! noneHaveContext ) { /* MR10 context guards ignored when -prc off */
+
+ _gen("(");
+
+ /* MR10 optimize OR predicates which are all leaves */
+
+ if (p->expr == PRED_OR_LIST && MR_allPredLeaves(p->down)) {
+ groupTree=MR_compute_pred_tree_context(p);
+ for (q=p->down ; q != NULL ; q=q->right) {
+ oneTree=MR_compute_pred_tree_context(q);
+ if (! MR_tree_equ(groupTree,oneTree)) {
+ Tfree(oneTree);
+ break;
+ };
+ Tfree(oneTree);
+ };
+ Tfree(groupTree);
+ if (q == NULL) {
+ _gen("/* MR10 individual OR gates suppressed when all predicates are leaves");
+ _gen(" with identical context */\n");
+ genPredTreeGate(p,in_and_expr); /* use the parent's in_and_expr for this gate */
+ identicalORcontextOptimization=1;
+ } else {
+ MR_distinctORcontextOpt(p,j,in_and_expr);
+ return;
+ };
+ } else if (p->expr == PRED_AND_LIST && MR_allPredLeaves(p->down)) {
+
+ /* MR12 optimize AND predicates which are all leaves */
+
+ groupTree=MR_compute_pred_tree_context(p);
+ for (q=p->down ; q != NULL ; q=q->right) {
+ oneTree=MR_compute_pred_tree_context(q);
+ if (! MR_tree_equ(groupTree,oneTree)) {
+ Tfree(oneTree);
+ break;
+ };
+ Tfree(oneTree);
+ };
+ Tfree(groupTree);
+ if (q == NULL) {
+ _gen("/* MR12 individual AND gates suppressed when all predicates are leaves");
+ _gen(" with identical context */\n");
+ genPredTreeGate(p,in_and_expr); /* use the parent's in_and_expr for this gate */
+ identicalANDcontextOptimization=1;
+ } else {
+ genPredTreeGate(p, in_and_expr);
+ };
+ } else {
+ genPredTreeGate(p, in_and_expr);
+ };
+ }
+
+ /* if leaf node, just gen predicate */
+
+ if ( p->down==NULL )
+ {
+ genPred(p,j,suppress_sva);
+ if ( ! noneHaveContext ) _gen(")"); /* MR10 context guards ignored when -prc off */
+ return;
+ }
+
+ /* if AND list, do both preds (only two possible) */
+ /* MR10 not any more ! */
+
+ if ( p->expr == PRED_AND_LIST )
+ {
+ Predicate *list;
+ _gen("(");
+ list = p->down;
+ for (; list != NULL; list=list->right) {
+ if (identicalANDcontextOptimization) {
+ genPred(list, j,suppress_sva);
+ } else {
+ genPredTree(list, j, 1, suppress_sva); /* in and context */
+ };
+ if ( list->right!=NULL ) _gen("&&");
+ };
+ _gen(")");
+ if ( ! noneHaveContext ) _gen(")"); /* MR10 context guards ignored when -prc off */
+ return;
+ }
+
+ if ( p->expr == PRED_OR_LIST )
+ {
+ Predicate *list;
+ _gen("(");
+ list = p->down;
+ for (; list!=NULL; list=list->right)
+ {
+ if (identicalORcontextOptimization) {
+ genPred(list, j,suppress_sva);
+ } else {
+ genPredTree(list, j, 0, suppress_sva);
+ };
+ if ( list->right!=NULL ) _gen("||");
+ }
+ _gen(")");
+ if ( ! noneHaveContext ) _gen(")"); /* MR10 context guards ignored when -prc off */
+ return;
+ }
+
+ fatal_internal("predicate tree is wacked");
+}
+
+/* [genPredTreeMainXX] */
+
+Predicate * /* MR10 */
+#ifdef __USE_PROTOS
+genPredTreeMainXX( Predicate *p, Node *j ,int in_and_expr)
+#else
+genPredTreeMainXX( p, j ,in_and_expr)
+ Predicate *p;
+ Node *j;
+ int in_and_expr;
+#endif
+{
+
+ int allHaveContext=1;
+ int noneHaveContext=1;
+
+#if 0
+ fprintf(stderr,"Pred before\n");
+ dumppred(p);
+ fprintf(stderr,"\n");
+ fprintf(stderr,"Pred after\n");
+ dumppred(p);
+ fprintf(stderr,"\n");
+#endif
+
+ p=MR_predSimplifyALL(p); /* MR10 */
+
+ require (MR_predicate_context_completed(p),"predicate context is not complete");
+
+ MR_cleanup_pred_trees(p); /* MR10 */
+
+ MR_predContextPresent(p,&allHaveContext,&noneHaveContext);
+ if (!noneHaveContext & !allHaveContext) {
+ warnFL("predicate contains elements both with and without context",
+ FileStr[j->file],j->line);
+ };
+
+ if (InfoP) {
+ _gen("\n#if 0\n\n");
+ MR_dumpPred(p,1);
+ _gen("#endif\n");
+ };
+ genPredTree(p,j,in_and_expr,0);
+ return p;
+}
+
+Predicate * /* MR10 */
+#ifdef __USE_PROTOS
+genPredTreeMain( Predicate *p, Node *j)
+#else
+genPredTreeMain( p, j)
+ Predicate *p;
+ Node *j;
+#endif
+{
+ return genPredTreeMainXX(p,j,1);
+}
+
+static void
+#ifdef __USE_PROTOS
+genExprTreeOriginal( Tree *t, int k )
+#else
+genExprTreeOriginal( t, k )
+Tree *t;
+int k;
+#endif
+{
+ require(t!=NULL, "genExprTreeOriginal: NULL tree");
+
+ if ( t->token == ALT )
+ {
+ _gen("("); genExprTreeOriginal(t->down, k); _gen(")");
+ if ( t->right!=NULL )
+ {
+ _gen("||");
+ on1line++;
+ if ( on1line > NumExprPerLine ) { on1line=0; _gen("\n"); }
+ _gen("("); genExprTreeOriginal(t->right, k); _gen(")");
+ }
+ return;
+ }
+ if ( t->down!=NULL ) _gen("(");
+ _gen1("LA(%d)==",k);
+ if ( TokenString(t->token) == NULL ) _gen1("%d", t->token)
+ else _gen1("%s", TokenString(t->token));
+ if ( t->down!=NULL )
+ {
+ _gen("&&");
+ on1line++;
+ if ( on1line > NumExprPerLine ) { on1line=0; _gen("\n"); }
+ _gen("("); genExprTreeOriginal(t->down, k+1); _gen(")");
+ }
+ if ( t->down!=NULL ) _gen(")");
+ if ( t->right!=NULL )
+ {
+ _gen("||");
+ on1line++;
+ if ( on1line > NumExprPerLine ) { on1line=0; _gen("\n"); }
+ _gen("("); genExprTreeOriginal(t->right, k); _gen(")");
+ }
+}
+
+#ifdef __USE_PROTOS
+static void MR_LAtokenString(int k,int token)
+#else
+static void MR_LAtokenString(k,token)
+ int k;
+ int token;
+#endif
+{
+ char *ts;
+
+ ts=TokenString(token);
+ if (ts == NULL) {
+ _gen2(" LA(%d)==%d",k,token);
+ } else {
+ _gen2(" LA(%d)==%s",k,ts);
+ };
+}
+
+
+#ifdef __USE_PROTOS
+static int MR_countLeaves(Tree *t)
+#else
+static int MR_countLeaves(t)
+ Tree *t;
+#endif
+{
+ if (t == NULL) return 0;
+ if (t->token == ALT) {
+ return MR_countLeaves(t->down)+MR_countLeaves(t->right);
+ } else {
+ return 1+MR_countLeaves(t->down)+MR_countLeaves(t->right);
+ };
+}
+
+#ifdef __USE_PROTOS
+static void MR_genOneLine(Tree *tree,int k)
+#else
+static void MR_genOneLine(tree,k)
+ Tree *tree;
+ int k;
+#endif
+{
+ if (tree == NULL) return;
+ if (tree->token == ALT) {
+ MR_genOneLine(tree->down,k);
+ } else {
+ MR_LAtokenString(k,tree->token);
+ if (tree->down != NULL &&
+ tree->down->right == NULL) {
+ _gen(" &&");
+ MR_genOneLine(tree->down,k+1);
+ } else if (tree->down != NULL) {
+ _gen(" && (");
+ MR_genOneLine(tree->down,k+1);
+ _gen(")");
+ };
+ };
+ if (tree->right != NULL) {
+ _gen(" ||");
+ MR_genOneLine(tree->right,k);
+ };
+}
+
+static int across;
+static int depth;
+static int lastkonline;
+
+#ifdef __USE_PROTOS
+static void MR_genMultiLine(Tree *tree,int k)
+#else
+static void MR_genMultiLine(tree,k)
+ Tree *tree;
+ int k;
+#endif
+{
+ int i;
+
+ if (tree == NULL) return;
+ if (tree->token == ALT) {
+ MR_genMultiLine(tree,k);
+ } else {
+ MR_LAtokenString(k,tree->token);
+ lastkonline=k;
+ across++;
+ if (tree->down != NULL && tree->down->right == NULL) {
+ if (across > 3) {
+ _gen("\n");
+ across=0;
+ lastkonline=0;
+ for (i=0 ; i < depth+k ; i++) _gen(" ");
+ _gen("&&");
+ } else {
+ _gen(" &&");
+ };
+ MR_genMultiLine(tree->down,k+1);
+ } else if (tree->down != NULL) {
+ _gen("\n");
+ lastkonline=0;
+ across=0;
+ for (i=0 ; i < depth+k ; i++) _gen(" ");
+ _gen("&& (");
+ MR_genMultiLine(tree->down,k+1);
+ _gen(")");
+ };
+ };
+ if (tree->right != NULL) {
+ if (k < lastkonline) {
+ _gen("\n");
+ across=0;
+ lastkonline=0;
+ for (i=0; i < depth+k-1 ; i++) _gen(" ");
+ _gen("||");
+ } else if (across > 3 ) {
+ _gen("\n");
+ across=0;
+ lastkonline=0;
+ for (i=0; i < depth+k ; i++) _gen(" ");
+ _gen("||");
+ } else {
+ _gen(" ||");
+ };
+ MR_genMultiLine(tree->right,k);
+ };
+}
+
+#ifdef __USE_PROTOS
+static void genExprTree(Tree *tree,int k)
+#else
+static void genExprTree(tree,k)
+ Tree *tree;
+ int k;
+#endif
+{
+ int count;
+
+#if 0
+ /* MR20 THM This was probably an error.
+ The routine should probably reference that static
+ "across" and this declaration hides it.
+ */
+
+ int across;
+#endif
+
+ require (tree != NULL,"genExprTree: tree is NULL");
+ require (k > 0,"genExprTree: k <= 0");
+
+ if (0 && !MRhoisting) { /* MR11 make new version standard */
+ genExprTreeOriginal(tree,k);
+ } else {
+ count=MR_countLeaves(tree);
+ if (count < 5) {
+ MR_genOneLine(tree,k);
+ } else {
+ _gen("\n");
+ across=0;
+ depth=0;
+ lastkonline=0;
+ MR_genMultiLine(tree,k);
+ _gen("\n");
+ };
+ };
+}
+
+
+/*
+ * Generate LL(k) type expressions of the form:
+ *
+ * (LA(1) == T1 || LA(1) == T2 || ... || LA(1) == Tn) &&
+ * (LA(2) == T1 || LA(2) == T2 || ... || LA(2) == Tn) &&
+ * .....
+ * (LA(k) == T1 || LA(k) == T2 || ... || LA(k) == Tn)
+ *
+ * If GenExprSetsOpt generate:
+ *
+ * (setwdi[LA(1)]&(1<<j)) && (setwdi[LA(2)]&(1<<j)) ...
+ *
+ * where n is set_deg(expr) and Ti is some random token and k is the last nonempty
+ * set in fset <=CLL_k.
+ * k=1..CLL_k where CLL_k >= 1.
+ *
+ * This routine is visible only to this file and cannot answer a TRANS message.
+ *
+ */
+
+/* [genExpr] */
+
+static int
+#ifdef __USE_PROTOS
+genExpr( Junction *j )
+#else
+genExpr( j )
+Junction *j;
+#endif
+{
+ int max_k;
+
+ /* if full LL(k) is sufficient, then don't use approximate (-ck) lookahead
+ * from CLL_k..LL_k
+ */
+ {
+ int limit;
+ if ( j->ftree!=NULL ) limit = LL_k;
+ else limit = CLL_k;
+ max_k = genExprSets(j->fset, limit);
+ }
+
+ /* Do tests for real tuples from other productions that conflict with
+ * artificial tuples generated by compression (using sets of tokens
+ * rather than k-trees).
+ */
+ if ( j->ftree != NULL )
+ {
+ _gen(" && !("); genExprTree(j->ftree, 1); _gen(")");
+ }
+
+ if ( ParseWithPredicates && j->predicate!=NULL )
+ {
+ Predicate *p = j->predicate;
+ warn_about_using_gk_option();
+ _gen("&&");
+ j->predicate=genPredTreeMain(p, (Node *)j); /* MR10 */
+ }
+
+ return max_k;
+}
+
+static int
+#ifdef __USE_PROTOS
+genExprSets( set *fset, int limit )
+#else
+genExprSets( fset, limit )
+set *fset;
+int limit;
+#endif
+{
+ int k = 1;
+ int max_k = 0;
+ unsigned *e, *g, firstTime=1;
+
+ if (set_nil(fset[1])) {
+ _gen(" 0 /* MR13 empty set expression - undefined rule ? infinite left recursion ? */ ");
+ MR_BadExprSets++;
+ };
+
+ if ( GenExprSetsOpt )
+ {
+ while ( k <= limit && !set_nil(fset[k]) ) /* MR11 */
+ {
+ if ( set_deg(fset[k])==1 ) /* too simple for a set? */
+ {
+ int e;
+ _gen1("(LA(%d)==",k);
+ e = set_int(fset[k]);
+ if ( TokenString(e) == NULL ) _gen1("%d)", e)
+ else _gen1("%s)", TokenString(e));
+ }
+ else
+ {
+ NewSet();
+ FillSet( fset[k] );
+ _gen3("(setwd%d[LA(%d)]&0x%x)", wordnum, k, 1<<setnum);
+ }
+ if ( k>max_k ) max_k = k;
+ if ( k == CLL_k ) break;
+ k++;
+ if ( k<=limit && !set_nil(fset[k]) ) _gen(" && "); /* MR11 */
+ on1line++;
+ if ( on1line > NumExprPerLine ) { on1line=0; _gen("\n"); }
+ }
+ return max_k;
+ }
+
+ while ( k<= limit && !set_nil(fset[k]) ) /* MR11 */
+ {
+ if ( (e=g=set_pdq(fset[k])) == NULL ) fatal_internal("genExpr: cannot allocate IF expr pdq set");
+ for (; *e!=nil; e++)
+ {
+ if ( !firstTime ) _gen(" || ") else { _gen("("); firstTime = 0; }
+ on1line++;
+ if ( on1line > NumExprPerLine ) { on1line=0; _gen("\n"); }
+ _gen1("LA(%d)==",k);
+ if ( TokenString(*e) == NULL ) _gen1("%d", *e)
+ else _gen1("%s", TokenString(*e));
+ }
+ free( (char *)g );
+ _gen(")");
+ if ( k>max_k ) max_k = k;
+ if ( k == CLL_k ) break;
+ k++;
+ if ( k <= limit && !set_nil(fset[k]) ) { firstTime=1; _gen(" && "); } /* MR11 */
+ on1line++;
+ if ( on1line > NumExprPerLine ) { on1line=0; _gen("\n"); }
+ }
+ return max_k;
+}
+
+/*
+ * Generate code for any type of block. If the last alternative in the block is
+ * empty (not even an action) don't bother doing it. This permits us to handle
+ * optional and loop blocks as well.
+ *
+ * Only do this block, return after completing the block.
+ * This routine is visible only to this file and cannot answer a TRANS message.
+ */
+static set
+#ifdef __USE_PROTOS
+genBlk( Junction *q, int jtype, int *max_k, int *need_right_curly, int * lastAltEmpty /* MR23 */)
+#else
+genBlk( q, jtype, max_k, need_right_curly, lastAltEmpty /* MR23 */)
+Junction *q;
+int jtype;
+int *max_k;
+int *need_right_curly;
+int *lastAltEmpty; /* MR23 */
+#endif
+{
+ set f;
+ Junction *alt;
+ int a_guess_in_block = 0;
+ require(q!=NULL, "genBlk: invalid node");
+ require(q->ntype == nJunction, "genBlk: not junction");
+ *need_right_curly=0;
+ *lastAltEmpty = 0; /* MR23 */
+ if ( q->p2 == NULL ) /* only one alternative? Then don't need if */
+ {
+ if (first_item_is_guess_block((Junction *)q->p1)!=NULL )
+ {
+ if (jtype != aLoopBlk && jtype != aOptBlk && jtype != aPlusBlk) {
+ warnFL("(...)? as only alternative of block is unnecessary", FileStr[q->file], q->line);
+ };
+ gen("zzGUESS\n"); /* guess anyway to make output code consistent */
+/* MR10 disable */ /**** gen("if ( !zzrv )\n"); ****/
+/* MR10 */ gen("if ( !zzrv ) {\n"); tabs++; (*need_right_curly)++;
+ };
+ TRANS(q->p1);
+ return empty; /* no decision to be made-->no error set */
+ }
+
+ f = First(q, 1, jtype, max_k);
+ for (alt=q; alt != NULL; alt= (Junction *) alt->p2 )
+ {
+ if ( alt->p2 == NULL ) /* chk for empty alt */
+ {
+ Node *p = alt->p1;
+ if ( p->ntype == nJunction )
+ {
+ /* we have empty alt */
+/* MR23
+ There is a conflict between giving good error information for non-exceptions
+ and making life easy for those using parser exception handling. Consider:
+
+ r: { A } b;
+ b: B;
+
+ with input "C"
+
+ Before MR21 the error message would be "expecting B - found C". After MR21
+ the error message would be "expcect A, B - found C". This was good, but it
+ caused problems for those using parser exceptions because the reference to
+ B was generated inside the {...} where B really wasn't part of the block.
+
+ In MR23 this has been changed for the case where exceptions are in use to
+ not generate the extra check in the tail of the {A} block.
+*/
+
+
+/* MR23 */ if (isEmptyAlt( ((Junction *)p)->p1, (Node *)q->end)) {
+/* MR23 */ *lastAltEmpty = 1;
+/* MR23 */ if (FoundException) {
+/* MR23 */ /* code to restore state if a prev alt didn't follow guess */
+/* MR23 */ if ( a_guess_in_block && jtype != aPlusBlk) {
+/* MR23 */ gen("if ( !zzrv ) zzGUESS_DONE; /* MR28 */\n");
+/* MR23 */ }
+/* MR23 */ break;
+/* MR23 */ };
+/* MR28 */ if (jtype == aPlusBlk) {
+/* MR28 */ break;
+/* MR28 */ }
+/* MR23 */ }
+ }
+ } /* end of for loop on alt */
+
+/* MR10 */ if (alt->p2 == NULL &&
+/* MR10 */ ( q->jtype == aSubBlk || q->jtype == RuleBlk) ) {
+/* MR10 */ if (first_item_is_guess_block(alt)) {
+/* MR10 */ warnFL("(...)? as last alternative of block is unnecessary",
+/* MR10 */ FileStr[alt->file],alt->line);
+/* MR10 */ };
+/* MR10 */ };
+
+ if ( alt != q ) gen("else ")
+ else
+ {
+ if ( DemandLookahead ) {
+ if ( !GenCC ) {gen1("LOOK(%d);\n", *max_k);}
+ else gen1("look(%d);\n", *max_k);
+ }
+ }
+
+ if ( alt!=q )
+ {
+ _gen("{\n");
+ tabs++;
+ (*need_right_curly)++;
+ /* code to restore state if a prev alt didn't follow guess */
+ if ( a_guess_in_block )
+ gen("if ( !zzrv ) zzGUESS_DONE;\n");
+ }
+ if ( first_item_is_guess_block((Junction *)alt->p1)!=NULL )
+ {
+ a_guess_in_block = 1;
+ gen("zzGUESS\n");
+ }
+ gen("if ( ");
+ if ( first_item_is_guess_block((Junction *)alt->p1)!=NULL ) _gen("!zzrv && ");
+ genExpr(alt);
+ _gen(" ) ");
+ _gen("{\n");
+ tabs++;
+ TRANS(alt->p1);
+ --tabs;
+ gen("}\n");
+/* MR10 */ if (alt->p2 == NULL) {
+/* MR10 */ if (first_item_is_guess_block(alt)) {
+/* MR10 */ gen("/* MR10 */ else {\n");
+/* MR10 */ tabs++;
+/* MR10 */ (*need_right_curly)++;
+/* MR10 */ /* code to restore state if a prev alt didn't follow guess */
+/* MR10 */ gen("/* MR10 */ if ( !zzrv ) zzGUESS_DONE;\n");
+/* MR10 */ gen("/* MR10 */ if (0) {} /* last alternative of block is guess block */\n");
+/* MR10 */ };
+/* MR10 */ };
+ }
+ return f;
+}
+
+static int
+#ifdef __USE_PROTOS
+has_guess_block_as_first_item( Junction *q )
+#else
+has_guess_block_as_first_item( q )
+Junction *q;
+#endif
+{
+ Junction *alt;
+
+ for (alt=q; alt != NULL; alt= (Junction *) alt->p2 )
+ {
+ if ( first_item_is_guess_block((Junction *)alt->p1)!=NULL ) return 1;
+ }
+ return 0;
+}
+
+static int
+#ifdef __USE_PROTOS
+has_guess_block_as_last_item( Junction *q )
+#else
+has_guess_block_as_last_item( q )
+Junction *q;
+#endif
+{
+ Junction *alt;
+
+ if (q == NULL) return 0;
+ for (alt=q; alt->p2 != NULL && !( (Junction *) alt->p2)->ignore; alt= (Junction *) alt->p2 ) {};
+ return first_item_is_guess_block( (Junction *) alt->p1) != NULL;
+}
+
+/* MR30 See description of first_item_is_guess_block for background */
+
+Junction *
+#ifdef __USE_PROTOS
+first_item_is_guess_block_extra(Junction *q )
+#else
+first_item_is_guess_block_extra(q)
+Junction *q;
+#endif
+{
+ while ( q!=NULL &&
+ ( ( q->ntype==nAction ) ||
+ ( q->ntype==nJunction &&
+ (q->jtype==Generic || q->jtype == aLoopBlk)
+ )
+ )
+ )
+ {
+ if ( q->ntype==nJunction ) q = (Junction *)q->p1;
+ else q = (Junction *) ((ActionNode *)q)->next;
+ }
+
+ if ( q==NULL ) return NULL;
+ if ( q->ntype!=nJunction ) return NULL;
+ if ( q->jtype!=aSubBlk ) return NULL;
+ if ( !q->guess ) return NULL;
+
+ return q;
+}
+
+/* return NULL if 1st item of alt is NOT (...)? block; else return ptr to aSubBlk node
+ * of (...)?; This function ignores actions and predicates.
+ */
+
+Junction *
+#ifdef __USE_PROTOS
+first_item_is_guess_block( Junction *q )
+#else
+first_item_is_guess_block( q )
+Junction *q;
+#endif
+{
+ Junction * qOriginal = q; /* DEBUG */
+
+ /* MR14 Couldn't find aSubBlock which was a guess block when it lay
+ behind aLoopBlk. The aLoopBlk only appear in conjunction with
+ aLoopBegin, but the routine didn't know that. I think.
+
+ MR14a Added extra parentheses to clarify precedence
+
+ MR30 This appears to have been a mistake. The First set was then
+ computed incorrectly for:
+
+ r : ( (A)? B
+ | C
+ )*
+
+ The routine analysis_point was seeing the guess block when
+ it was still analyzing the loopBegin block. As a consequence,
+ when it looked for the analysis_point it was processing the B, but
+ skipping over the C alternative altogether because it thought
+ it was looking at a guess block, not realizing there was a loop
+ block in front of the loopBegin.
+
+ loopBegin loopBlk subBlk/guess A G EB G B EB EB EB ER
+ | | | ^ ^
+ | | | |
+ | +-> G C G ----------------------+ |
+ | |
+ +--- G G G -------------------------------------+
+
+ Reported by Arpad Beszedes (beszedes@inf.u-szeged.hu).
+
+ MR30 This is still more complicated. This fix caused ambiguity messages
+ to be reported for "( (A B)? )* A B" but not for "( (A B)? )+". Why is
+ there a difference when these are outwardly identical ? It is because the
+ start of a (...)* block is represented by two nodes: a loopBegin block
+ followed by a loopBlock whereas the start of a (...)+ block is
+ represented as a single node: a plusBlock. So if first_item_is_guess_block
+ is called when the current node is a loopBegin it starts with the
+ loop block rather than the the sub block which follows the loop block.
+ However, we can't just skip past the loop block because some routines
+ depend on the old implementation. So, we provide a new implementation
+ which does skip the loopBlock. However, which should be called when ?
+ I'm not sure, but my guess is that first_item_is_guess_block_extra (the
+ new one) should only be called for the ambiguity routines.
+
+ */
+
+ while ( q!=NULL &&
+ ( ( q->ntype==nAction ) ||
+ ( q->ntype==nJunction &&
+ (q->jtype==Generic /*** || q->jtype == aLoopBlk ***/ ) /*** MR30 Undo MR14 change ***/
+ )
+ )
+ )
+ {
+ if ( q->ntype==nJunction ) q = (Junction *)q->p1;
+ else q = (Junction *) ((ActionNode *)q)->next;
+ }
+
+ if ( q==NULL ) return NULL;
+ if ( q->ntype!=nJunction ) return NULL;
+ if ( q->jtype!=aSubBlk ) return NULL;
+ if ( !q->guess ) return NULL;
+
+ return q;
+}
+
+/* MR1 */
+/* MR1 10-Apr-97 MR1 Routine to stringize failed semantic predicates msgs */
+/* MR1 */
+
+#define STRINGIZEBUFSIZE 1024
+
+static char stringizeBuf[STRINGIZEBUFSIZE];
+char *
+#ifdef __USE_PROTOS
+stringize(char * s)
+#else
+stringize(s)
+char *s;
+#endif
+
+{
+ char *p;
+ char *stop;
+
+ p=stringizeBuf;
+ stop=&stringizeBuf[1015];
+
+ if (s != 0) {
+ while (*s != 0) {
+ if (p >= stop) {
+ goto stringizeStop;
+ } else if (*s == '\n') {
+ *p++='\\';
+ *p++='n';
+ *p++='\\';
+ *p++=*s++;
+ } else if (*s == '\\') {
+ *p++=*s;
+ *p++=*s++;
+ } else if (*s == '\"') {
+ *p++='\\';
+ *p++=*s++;
+ while (*s != 0) {
+ if (p >= stop) {
+ goto stringizeStop;
+ } else if (*s == '\n') {
+ *p++='\\';
+ *p++=*s++;
+ } else if (*s == '\\') {
+ *p++=*s++;
+ *p++=*s++;
+ } else if (*s == '\"') {
+ *p++='\\';
+ *p++=*s++;
+ break;
+ } else {
+ *p++=*s++;
+ };
+ };
+ } else if (*s == '\'') {
+ *p++=*s++;
+ while (*s != 0) {
+ if (p >= stop) {
+ goto stringizeStop;
+ } else if (*s == '\'') {
+ *p++=*s++;
+ break;
+ } else if (*s == '\\') {
+ *p++=*s++;
+ *p++=*s++;
+ } else if (*s == '\"') {
+ *p++='\\';
+ *p++=*s++;
+ break;
+ } else {
+ *p++=*s++;
+ };
+ };
+ } else {
+ *p++=*s++;
+ };
+ };
+ };
+ goto stringizeExit;
+stringizeStop:
+ *p++='.';
+ *p++='.';
+ *p++='.';
+stringizeExit:
+ *p=0;
+ return stringizeBuf;
+}
+
+#ifdef __USE_PROTOS
+int isNullAction(char *s)
+#else
+int isNullAction(s)
+ char *s;
+#endif
+{
+ char *p;
+ for (p=s; *p != '\0' ; p++) {
+ if (*p != ';' && *p !=' ') return 0;
+ };
+ return 1;
+}
+/* MR1 */
+/* MR1 End of Routine to stringize code for failed predicates msgs */
+/* MR1 */
+
+/* Generate an action. Don't if action is NULL which means that it was already
+ * handled as an init action.
+ */
+void
+#ifdef __USE_PROTOS
+genAction( ActionNode *p )
+#else
+genAction( p )
+ActionNode *p;
+#endif
+{
+ require(p!=NULL, "genAction: invalid node and/or rule");
+ require(p->ntype==nAction, "genAction: not action");
+
+ if ( !p->done ) /* MR10 */ /* MR11 */
+ {
+ if ( p->is_predicate)
+ {
+ if ( p->guardpred != NULL )
+ {
+ Predicate *guardDup=predicate_dup(p->guardpred); /* MR10 */
+ gen("if (!");
+ guardDup=genPredTreeMain(guardDup, (Node *)p);
+ predicate_free(guardDup);
+ }
+/* MR10 */ else if (p->ampersandPred != NULL) {
+/* MR10 */ gen("if (!");
+/* MR10 */ p->ampersandPred=genPredTreeMain(p->ampersandPred, (Node *)p);
+/* MR10 */ }
+ else
+ {
+ gen("if (!(");
+ /* make sure that '#line n' is on front of line */
+ if ( GenLineInfo && p->file != -1 ) _gen("\n");
+ dumpPredAction(p,p->action, output, 0, p->file, p->line, 0);
+ _gen(")");
+ }
+
+/* MR23 Change failed predicate macro to have three arguments:
+
+ macro arg 1: The stringized predicate itself
+ macro arg 2: 0 => no user-defined error action
+ 1 => user-defined error action
+ macro arg 3: The user-defined error action
+
+ This gives the user more control of the error action.
+*/
+ tabs++;
+ gen3(") {zzfailed_pred(\"%s\",%s, { %s } );}\n", /* MR23 */
+ stringize(p->action), /* MR23 */
+ (p->pred_fail == NULL ? /* MR23/MR27 */
+ "0 /* report */" : "1 /* user action */"), /* MR23/MR27 */
+ (p->pred_fail == NULL ? /* MR23 */
+ "0; /* no user action */" : p->pred_fail)); /* MR23 */
+ tabs--;
+ }
+ else /* not a predicate */
+ {
+ if (! isNullAction(p->action) && !p->noHoist) {
+ if ( FoundGuessBlk ) {
+ if ( GenCC ) {
+ gen("if ( !guessing ) {\n");
+ } else {
+ gen("zzNON_GUESS_MODE {\n");
+ };
+ };
+ dumpActionPlus(p, p->action, output, tabs, p->file, p->line, 1); /* MR21 */
+ if ( FoundGuessBlk ) gen("}\n");
+ };
+ }
+ }
+ TRANS(p->next)
+}
+
+/*
+ * if invoking rule has !noAST pass zzSTR to rule ref and zzlink it in
+ * else pass addr of temp root ptr (&_ast) (don't zzlink it in).
+ *
+ * if ! modifies rule-ref, then never link it in and never pass zzSTR.
+ * Always pass address of temp root ptr.
+ */
+void
+#ifdef __USE_PROTOS
+genRuleRef( RuleRefNode *p )
+#else
+genRuleRef( p )
+RuleRefNode *p;
+#endif
+{
+ Junction *q;
+ char *handler_id = "";
+ RuleEntry *r, *r2;
+ char *parm = "", *exsig = "";
+
+ int genRuleRef_emittedGuessGuard=0; /* MR10 */
+
+ require(p!=NULL, "genRuleRef: invalid node and/or rule");
+ require(p->ntype==nRuleRef, "genRuleRef: not rule reference");
+
+ if ( p->altstart!=NULL && p->altstart->exception_label!=NULL )
+ handler_id = p->altstart->exception_label;
+
+ r = (RuleEntry *) hash_get(Rname, p->text);
+ if ( r == NULL )
+ {
+ warnFL( eMsg1("rule %s not defined",
+ p->text), FileStr[p->file], p->line );
+ return;
+ }
+
+/* MR8 5-Aug-97 Reported by S.Bochnak@microtool.com.pl */
+/* Don't do assign when no return values declared */
+/* Move definition of q up and use it to guard p->assign */
+
+ q = RulePtr[r->rulenum]; /* find definition of ref'd rule */ /* MR8 */
+
+ r2 = (RuleEntry *) hash_get(Rname, p->rname);
+ if ( r2 == NULL ) {warnNoFL("Rule hash table is screwed up beyond belief"); return;}
+
+ OutLineInfo(output,p->line,FileStr[p->file]);
+
+ if ( GenCC && GenAST ) {
+ gen("_ast = NULL;\n");
+ }
+
+ if ( FoundGuessBlk && p->assign!=NULL && q->ret != NULL ) { /* MR8 */
+ if ( GenCC ) {
+ gen("if ( !guessing ) {\n");
+ } else {
+ gen("zzNON_GUESS_MODE {\n");
+ };
+ tabs++; /* MR11 */
+ genRuleRef_emittedGuessGuard=1; /* MR11 */
+ };
+
+ if ( FoundException ) exsig = "&_signal";
+
+ tab();
+ if ( GenAST )
+ {
+ if ( GenCC ) {
+/**** if ( r2->noAST || p->astnode==ASTexclude )
+****/
+ {
+/**** _gen("_ast = NULL;\n");
+****/
+ parm = "&_ast";
+ }
+/*** we always want to set just a pointer now, then set correct
+pointer after
+
+ else {
+ _gen("_astp =
+(_tail==NULL)?(&_sibling):(&(_tail->_right));\n");
+ parm = "_astp";
+ }
+****/
+ }
+ else {
+ if ( r2->noAST || p->astnode==ASTexclude )
+ {
+ _gen("_ast = NULL; ");
+ parm = "&_ast";
+ }
+ else parm = "zzSTR";
+ }
+ if ( p->assign!=NULL && q->ret!=NULL ) /* MR8 */
+ {
+ if ( !hasMultipleOperands(p->assign) ) {_gen1("%s = ",p->assign);} /* MR23 */
+ else _gen1("{ struct _rv%d _trv; _trv = ", r->rulenum);
+ }
+ if ( FoundException ) {
+ _gen5("%s%s(%s,&_signal%s%s); ",
+ RulePrefix,
+ p->text,
+ parm,
+ (p->parms!=NULL)?",":"",
+ (p->parms!=NULL)?p->parms:"");
+ if ( p->ex_group!=NULL ) {
+ _gen("\n");
+ gen("if (_signal) {\n");
+ tabs++;
+ dumpException(p->ex_group, 0);
+ tabs--;
+ gen("}");
+ }
+ else {
+ _gen1("if (_signal) goto %s_handler;", handler_id);
+ }
+ }
+ else {
+ _gen5("%s%s(%s%s%s);",
+ RulePrefix,
+ p->text,
+ parm,
+ (p->parms!=NULL)?",":"",
+ (p->parms!=NULL)?p->parms:"");
+ }
+ if ( GenCC && (r2->noAST || p->astnode==ASTexclude) )
+ {
+ /* rule has a ! or element does */
+ /* still need to assign to #i so we can play with it */
+ _gen("\n");
+ gen2("_ast%d%d = (AST *)_ast;", BlkLevel-1, p->elnum);
+ }
+ else if ( !r2->noAST && p->astnode == ASTinclude )
+ {
+ /* rule doesn't have a ! and neither does element */
+/* MR10 */ if (FoundGuessBlk && !genRuleRef_emittedGuessGuard) {
+/* MR10 */ _gen("\n");
+/* MR10 */ if (GenCC) gen ("if (!guessing) { /* MR10 */")
+/* MR10 */ else gen ("if (!zzguessing) { /* MR10 */\n");
+/* MR10 */ tabs++;
+/* MR10 */ };
+ if ( GenCC ) {
+ _gen("\n");
+ gen("if ( _tail==NULL ) _sibling = _ast; else _tail->setRight(_ast);\n");
+ gen2("_ast%d%d = (AST *)_ast;\n", BlkLevel-1, p->elnum);
+ tab();
+ }
+ else _gen(" ");
+ if ( GenCC ) {
+ _gen("ASTBase::"); }
+ else _gen("zz");
+ _gen("link(_root, &_sibling, &_tail);");
+
+/* MR10 */ if (FoundGuessBlk && !genRuleRef_emittedGuessGuard) { /* MR10 */
+/* MR10 */ _gen("\n");
+/* MR10 */ tabs--;
+/* MR10 */ if (GenCC) gen ("}; /* MR10 */")
+/* MR10 */ else gen ("}; /* MR10 */");
+/* MR10 */ };
+ }
+ }
+ else
+ {
+ if ( p->assign!=NULL && q->ret!=NULL ) /* MR8 */
+ {
+ if ( !hasMultipleOperands(p->assign) ) {_gen1("%s = ",p->assign);} /* MR23 */
+ else _gen1("{ struct _rv%d _trv; _trv = ", r->rulenum);
+ }
+ if ( FoundException ) {
+ _gen4("%s%s(&_signal%s%s); ",
+ RulePrefix,
+ p->text,
+ (p->parms!=NULL)?",":"",
+ (p->parms!=NULL)?p->parms:"");
+ if ( p->ex_group!=NULL ) {
+ _gen("\n");
+ gen("if (_signal) {\n");
+ tabs++;
+ dumpException(p->ex_group, 0);
+ tabs--;
+ gen("}");
+ }
+ else {
+ _gen1("if (_signal) goto %s_handler;", handler_id);
+ }
+ }
+ else {
+ _gen3("%s%s(%s);",
+ RulePrefix,
+ p->text,
+ (p->parms!=NULL)?p->parms:"");
+ }
+ if ( p->assign!=NULL && q->ret!=NULL ) _gen("\n"); /* MR8 */
+ }
+
+ if ( p->assign!=NULL && q->ret!=NULL) { /* MR8 */
+ if ( hasMultipleOperands(p->assign) ) /* MR23 */
+ {
+ _gen("\n");
+ dumpRetValAssign(p->assign, q->ret, p); /* MR30 */
+ _gen("}");
+ }
+ }
+ _gen("\n");
+
+ /* Handle element labels now */
+ if ( p->el_label!=NULL )
+ {
+ if ( GenAST )
+ {
+ if ( GenCC ) {
+ gen3("%s_ast = _ast%d%d;\n", p->el_label, BlkLevel-1, p->elnum);
+ }
+ else {gen1("%s_ast = zzastCur;\n", p->el_label);}
+ }
+ else if (!GenCC ) {
+ gen1("%s = zzaCur;\n", p->el_label);
+ }
+ }
+
+ if ( FoundGuessBlk && p->assign!=NULL && q->ret!=NULL ) { /* MR8 */
+ /* in guessing mode, don't branch to handler upon error */
+ tabs--; /* MR11 */
+ gen("} else {\n");
+ tabs++; /* MR11 */
+ if ( FoundException ) {
+ gen6("%s%s(%s%s&_signal%s%s);\n",
+ RulePrefix,
+ p->text,
+ parm,
+ (*parm!='\0')?",":"",
+ (p->parms!=NULL)?",":"",
+ (p->parms!=NULL)?p->parms:"");
+ }
+ else {
+ gen5("%s%s(%s%s%s);\n",
+ RulePrefix,
+ p->text,
+ parm,
+ (p->parms!=NULL && *parm!='\0')?",":"",
+ (p->parms!=NULL)?p->parms:"");
+ }
+ tabs--; /* MR11 */
+ gen("}\n");
+ }
+ TRANS(p->next)
+}
+
+/*
+ * Generate code to match a token.
+ *
+ * Getting the next token is tricky. We want to ensure that any action
+ * following a token is executed before the next GetToken();
+ */
+void
+#ifdef __USE_PROTOS
+genToken( TokNode *p )
+#else
+genToken( p )
+TokNode *p;
+#endif
+{
+ RuleEntry *r;
+ char *handler_id = "";
+ ActionNode *a;
+ char *set_name;
+ char *set_nameErrSet;
+ int complement;
+ int ast_label_in_action = 0; /* MR27 */
+ int pushedCmodeAST = 0; /* MR27 */
+
+ require(p!=NULL, "genToken: invalid node and/or rule");
+ require(p->ntype==nToken, "genToken: not token");
+ if ( p->altstart!=NULL && p->altstart->exception_label!=NULL )
+ handler_id = p->altstart->exception_label;
+
+ r = (RuleEntry *) hash_get(Rname, p->rname);
+ if ( r == NULL ) {warnNoFL("Rule hash table is screwed up beyond belief"); return;}
+
+/*
+ * MR27 Has the element label been referenced as an AST (with the # operator) ?
+ * If so, then we'll want to build the AST even though the user has used
+ * the ! operator.
+ */
+/* MR27 */ if (GenAST && p->el_label != NULL) {
+/* MR27 */ ast_label_in_action = list_search_cstring(r->ast_labels_in_actions,
+/* MR27 */ p->el_label);
+/* MR27 */ }
+
+ OutLineInfo(output,p->line,FileStr[p->file]);
+
+ if ( !set_nil(p->tset) ) /* implies '.', ~Tok, or tokenclass */
+ {
+ unsigned e;
+ unsigned eErrSet = 0;
+ set b;
+ set bErrSet; /* MR23 */
+ b = set_dup(p->tset);
+ bErrSet = set_dup(p->tset); /* MR23 */
+ complement = p->complement; /* MR23 */
+ if ( p->tclass!=NULL && complement == 0 /* MR23 */) { /* token class not complemented*/
+ static char buf[MaxRuleName+20]; /* MR23 */
+ static char bufErrSet[MaxRuleName+20]; /* MR23 */
+ if ( p->tclass->dumped ) {
+ e = p->tclass->setnum;
+ eErrSet = p->tclass->setnumErrSet;
+ }
+ else {
+ e = DefErrSet(&b, 0, TokenString(p->token));
+ eErrSet = DefErrSetWithSuffix(0, &bErrSet, 1, TokenString(p->token), "_errset");
+ p->tclass->dumped = 1; /* indicate set has been created */
+ p->tclass->setnum = e;
+ p->tclass->setnumErrSet = eErrSet; /* MR23 */
+ }
+ sprintf(buf, "%s_set", TokenString(p->token));
+ sprintf(bufErrSet, "%s_errset", TokenString(p->token)); /* MR23 */
+ set_name = buf;
+ set_nameErrSet = bufErrSet; /* MR23 */
+ }
+
+ /* MR23 - Forgot about the case of ~TOKCLASS. */
+
+ else if ( p->tclass!=NULL && complement != 0 /* MR23 */)
+ {
+ static char buf[MaxRuleName+20]; /* MR23 */
+ static char bufErrSet[MaxRuleName+20]; /* MR23 */
+ if ( p->tclass->dumpedComplement ) {
+ e = p->tclass->setnumComplement;
+ eErrSet = p->tclass->setnumErrSetComplement;
+ }
+ else {
+ e = DefErrSetWithSuffix(0, &b, 0, TokenString(p->token), "_setbar");
+ eErrSet = DefErrSetWithSuffix(0, &bErrSet, 1, TokenString(p->token), "_errsetbar");
+ p->tclass->dumpedComplement = 1; /* indicate set has been created */
+ p->tclass->setnumComplement = e;
+ p->tclass->setnumErrSetComplement = eErrSet; /* MR23 */
+ }
+ sprintf(buf, "%s_setbar", TokenString(p->token));
+ sprintf(bufErrSet, "%s_errsetbar", TokenString(p->token)); /* MR23 */
+ set_name = buf;
+ set_nameErrSet = bufErrSet; /* MR23 */
+ }
+ else { /* wild card */
+ static char buf[sizeof("zzerr")+10];
+ static char bufErrSet[sizeof("zzerr")+10];
+ int n = DefErrSet( &b, 0, NULL );
+ int nErrSet = DefErrSetWithSuffix(0, &bErrSet, 1, NULL, "_set");
+ if ( GenCC ) sprintf(buf, "err%d", n);
+ else sprintf(buf, "zzerr%d", n);
+ if ( GenCC ) sprintf(bufErrSet, "err%d", nErrSet);
+ else sprintf(bufErrSet, "zzerr%d", nErrSet);
+ set_name = buf;
+ set_nameErrSet = bufErrSet;
+ }
+
+ if ( !FoundException ) {
+/* MR23 */ gen2("zzsetmatch(%s, %s);", set_name, set_nameErrSet);
+ }
+ else if ( p->ex_group==NULL ) {
+ if ( p->use_def_MT_handler )
+ gen3("zzsetmatch_wdfltsig(%s,(ANTLRTokenType)%d,%s);",
+ set_name,
+ p->token,
+ tokenFollowSet(p))
+ else
+ gen2("zzsetmatch_wsig(%s, %s_handler);",
+ set_name,
+ handler_id);
+ }
+ else
+ {
+ gen1("if ( !_setmatch_wsig(%s) ) {\n", set_name);
+ tabs++;
+/* MR6 */ if (FoundGuessBlk) {
+/* MR6 */ if ( GenCC ) {gen("if ( guessing ) goto fail;\n");}
+/* MR6 */ else gen("if ( zzguessing ) goto fail;\n");
+/* MR6 */ };
+ gen("_signal=MismatchedToken;\n");
+ dumpException(p->ex_group, 0);
+ tabs--;
+ gen("}\n");
+ }
+ set_free(b);
+ set_free(bErrSet);
+ }
+ else if ( TokenString(p->token)!=NULL )
+ {
+ if ( FoundException ) {
+ if ( p->use_def_MT_handler )
+ gen2("zzmatch_wdfltsig(%s,%s);",TokenString(p->token),tokenFollowSet(p))
+ else if ( p->ex_group==NULL )
+ {
+ gen2("zzmatch_wsig(%s, %s_handler);",
+ TokenString(p->token),
+ handler_id);
+ }
+ else
+ {
+/* MR6 */ if (GenCC) {
+/* MR6 */ gen1("if ( !_match_wsig(%s) ) {\n", TokenString(p->token));
+/* MR6 */ } else {
+/* MR6 */ gen1("if ( !_zzmatch_wsig(%s) ) {\n", TokenString(p->token));
+/* MR6 */ };
+ tabs++;
+/* MR6 */ if (FoundGuessBlk) {
+/* MR6 */ if ( GenCC ) {gen("if ( guessing ) goto fail;\n");}
+/* MR6 */ else gen("if ( zzguessing ) goto fail;\n");
+/* MR6 */ };
+ gen("_signal=MismatchedToken;\n");
+ dumpException(p->ex_group, 0);
+ tabs--;
+ gen("}\n");
+ }
+ }
+ else gen1("zzmatch(%s);", TokenString(p->token));
+ }
+ else {
+ if ( FoundException ) {
+ if ( p->use_def_MT_handler )
+ gen2("zzmatch_wdfltsig((ANTLRTokenType)%d,%s);",
+ p->token,tokenFollowSet(p))
+ else
+ gen2("zzmatch_wsig(%d,%s_handler);",p->token,handler_id);
+ }
+ else {gen1("zzmatch(%d);", p->token);}
+ }
+
+ a = findImmedAction( p->next );
+ /* generate the token labels */
+ if ( GenCC && p->elnum>0 )
+ {
+ /* If building trees in C++, always gen the LT() assigns */
+ if ( set_el(p->elnum, tokensRefdInBlock) || GenAST )
+ {
+/* MR10 */ if ( FoundGuessBlk ) {
+/* MR10 */ gen("\n");
+/* MR10 */ if (p->label_used_in_semantic_pred) {
+/* MR10 */ gen2(" _t%d%d = (ANTLRTokenPtr)LT(1); /* MR10 */\n", BlkLevel-1, p->elnum);
+/* MR10 */ } else {
+/* MR10 */ gen("if ( !guessing ) {\n"); tab();
+/* MR10 */ _gen2(" _t%d%d = (ANTLRTokenPtr)LT(1);\n", BlkLevel-1, p->elnum);
+/* MR10 */ gen("}\n");
+/* MR10 */ };
+/* MR10 */ } else {
+/* MR10 */ _gen2(" _t%d%d = (ANTLRTokenPtr)LT(1);", BlkLevel-1, p->elnum);
+/* MR10 */ };
+/* MR10 */
+ }
+
+/*
+ * MR23 labase is never used in the C++ runtime library.
+ * and this code is generated only in C++ mode
+ */
+
+/*** if ( LL_k>1 ) / * MR23 disabled */
+/*** if ( !DemandLookahead ) _gen(" labase++;"); / * MR23 disabled */
+/*** _gen("\n"); / * MR23 disabled */
+/*** tab(); / * MR23 disabled */
+ }
+ if ( GenAST )
+ {
+ if ( FoundGuessBlk &&
+ (ast_label_in_action || !(p->astnode == ASTexclude || r->noAST)) )
+ {
+ if ( GenCC ) {_gen("if ( !guessing ) {\n"); tab();}
+ else {_gen("zzNON_GUESS_MODE {\n"); tab();}
+ }
+
+/* MR27 addition when labels referenced when operator ! used */
+
+ pushedCmodeAST = 0; /* MR27 */
+ if (ast_label_in_action && (p->astnode == ASTexclude || r->noAST)) {
+ _gen("\n");
+ if (GenCC) {
+/* MR13 */ if (NewAST) {
+/* MR13 */ gen4("_ast%d%d = newAST(_t%d%d); /* MR27 */\n", BlkLevel-1, p->elnum, BlkLevel-1, p->elnum);
+/* MR13 */ } else {
+/* MR13 */ gen4("_ast%d%d = new AST(_t%d%d); /* MR27 */\n", BlkLevel-1, p->elnum, BlkLevel-1, p->elnum);
+/* MR13 */ }
+ }
+ else {
+ pushedCmodeAST = 1;
+ gen("zzastPush(zzmk_ast(zzastnew(),zzaCur)); /* MR27 */");
+ }
+ }
+
+/* end MR27 addition for labels referenced when operator ! used */
+
+ if (!r->noAST )
+ {
+ if (GenCC && !(p->astnode == ASTexclude) ) {
+ _gen("\n");
+/* MR13 */ if (NewAST) {
+/* MR13 */ gen4("_ast%d%d = newAST(_t%d%d);\n", BlkLevel-1, p->elnum, BlkLevel-1, p->elnum);
+/* MR13 */ } else {
+/* MR13 */ gen4("_ast%d%d = new AST(_t%d%d);\n", BlkLevel-1, p->elnum, BlkLevel-1, p->elnum);
+/* MR13 */ }
+ tab();
+ }
+ if ( GenCC && !(p->astnode == ASTexclude) )
+ {_gen2("_ast%d%d->", BlkLevel-1, p->elnum);}
+ else _gen(" ");
+ if ( p->astnode==ASTchild ) {
+ if ( !GenCC ) _gen("zz");
+ _gen("subchild(_root, &_sibling, &_tail);");
+ }
+ else if ( p->astnode==ASTroot ) {
+ if ( !GenCC ) _gen("zz");
+ _gen("subroot(_root, &_sibling, &_tail);");
+ }
+ if ( GenCC && !(p->astnode == ASTexclude) ) {
+ _gen("\n");
+ tab();
+ }
+ }
+ else if ( !GenCC ) {
+ if (! pushedCmodeAST) _gen(" zzastDPush;");
+ }
+ if ( FoundGuessBlk &&
+ (ast_label_in_action || !(p->astnode == ASTexclude || r->noAST)) )
+ {gen("}\n"); tab();}
+ }
+
+ /* Handle element labels now */
+ if ( p->el_label!=NULL )
+ {
+ int done_NON_GUESSMODE=0;
+
+ _gen("\n");
+
+/* MR10 */ /* do Attrib / Token ptr for token label used in semantic pred */
+/* MR10 */ /* for these cases do assign even in guess mode */
+/* MR10 */
+/* MR10 */ if (p->label_used_in_semantic_pred) {
+/* MR10 */ if ( GenCC ) {
+/* MR10 */ if ( set_el(p->elnum, tokensRefdInBlock) || GenAST ) {
+/* MR10 */ gen3("%s = _t%d%d;", p->el_label, BlkLevel-1, p->elnum);
+/* MR10 */ } else {
+/* MR10 */ gen1("%s = (ANTLRTokenPtr)LT(1);\n", p->el_label);
+/* MR10 */ };
+/* MR10 */ } else {
+/* MR10 */ gen1("%s = zzaCur;", p->el_label);
+/* MR10 */ };
+/* MR10 */ if (FoundGuessBlk) _gen(" /* MR10 */");
+/* MR10 */ _gen("\n");
+/* MR10 */ };
+
+ /* Do Attrib / Token ptr */
+
+/* MR10 */ if (! p->label_used_in_semantic_pred) {
+/* MR10 */
+/* MR10 */ if ( FoundGuessBlk ) {
+/* MR10 */ if (! done_NON_GUESSMODE) {
+/* MR10 */ done_NON_GUESSMODE=1;
+/* MR10 */ if ( GenCC ) {gen("if ( !guessing ) {\n"); tab();}
+/* MR10 */ else {gen("zzNON_GUESS_MODE {\n"); tab();}
+/* MR10 */ };
+/* MR10 */ };
+/* MR10 */
+/* MR10 */ if ( GenCC ) {
+/* MR10 */ if ( set_el(p->elnum, tokensRefdInBlock) || GenAST ) {
+/* MR10 */ gen3("%s = _t%d%d;\n", p->el_label, BlkLevel-1, p->elnum);
+/* MR10 */ } else {
+/* MR10 */ gen1("%s = (ANTLRTokenPtr)LT(1);\n", p->el_label);
+/* MR10 */ };
+/* MR10 */ } else {
+/* MR10 */ gen1("%s = zzaCur;\n", p->el_label);
+/* MR10 */ };
+/* MR10 */ };
+
+ /* Do AST ptr */
+
+ if (GenAST && (ast_label_in_action || !(p->astnode == ASTexclude || r->noAST) )) /* MR27 */
+ {
+
+/* MR10 */ if ( FoundGuessBlk ) {
+/* MR10 */ if (! done_NON_GUESSMODE) {
+/* MR10 */ done_NON_GUESSMODE=1;
+/* MR10 */ if ( GenCC ) {gen("if ( !guessing ) {\n"); tab();}
+/* MR10 */ else {gen("zzNON_GUESS_MODE {\n"); tab();}
+/* MR10 */ };
+/* MR10 */ };
+
+ if ( GenCC ) {
+ gen3("%s_ast = _ast%d%d;\n", p->el_label, BlkLevel-1, p->elnum);
+ }
+ else {gen1("%s_ast = zzastCur;\n", p->el_label);}
+ }
+
+/* MR10 */ if (done_NON_GUESSMODE) {
+/* MR10 */ gen("}\n"); tab();
+/* MR10 */ };
+
+ }
+
+ /* Handle any actions immediately following action */
+ if ( a != NULL ) /* MR10 */ /* MR11 */
+ {
+ /* delay next token fetch until after action */
+ _gen("\n");
+ if ( a->is_predicate)
+ {
+#if 0
+/* Disabled in MR30 ************************************************************
+ And moved into genAction
+ *****************************************************************************
+*/
+
+ gen("if (!(");
+
+ /* make sure that '#line n' is on front of line */ /* MR14 */
+ if ( GenLineInfo && p->file != -1 ) _gen("\n"); /* MR14 */
+ dumpPredAction(a,a->action, output, 0, a->file, a->line, 0);
+
+/* MR23 Change failed predicate macro to have three arguments:
+
+ macro arg 1: The stringized predicate itself
+ macro arg 2: 0 => no user-defined error action
+ 1 => user-defined error action
+ macro arg 3: The user-defined error action
+
+ This gives the user more control of the error action.
+*/
+ _gen(")) \n");
+ tabs++;
+ gen3(" {zzfailed_pred(\"%s\",%s,{ %s } );}\n", /* MR23 */
+ stringize(a->action), /* MR23 */
+ (a->pred_fail == NULL ? /* MR23/MR27 */
+ "0 /* report */" : "1 /* user action */"), /* MR23/MR27 */
+ (a->pred_fail == NULL ? /* MR23 */
+ "0; /* no user action */" : a->pred_fail)); /* MR23 */
+ tabs--;
+/* Disabled in MR30 ************************************************************
+ And moved into genAction
+ *****************************************************************************
+*/
+#endif
+ }
+ else /* MR9 a regular action - not a predicate action */
+ {
+
+/* MR23: Search an action which is not a predicate for LT(i),
+ LA(i), or LATEXT(i) in order to warn novice users that
+ it refers to the previous matched token, not the next
+ one. This is different than the case for semantic
+ predicates.
+*/
+
+/* MR23 */ if (GenCC) {
+/* MR23 */ if (strstr(a->action, "LT(") != NULL) LTinTokenAction = 1;
+/* MR23 */ }
+/* MR23 */ else {
+/* MR23 */ if (strstr(a->action, "LA(") != NULL) LTinTokenAction = 1;
+/* MR23 */ if (strstr(a->action, "LATEXT(") != NULL) LTinTokenAction = 1;
+/* MR23 */ }
+
+ if ( FoundGuessBlk ) {
+ if ( GenCC ) {gen("if ( !guessing ) {\n");}
+ else gen("zzNON_GUESS_MODE {\n");
+ }
+ dumpActionPlus(a, a->action, output, tabs, a->file, a->line, 1); /* MR21 */
+ if ( FoundGuessBlk ) gen("}\n");
+ a->done = 1; /* MR30 */
+ }
+/*** a->done = 1; MR30 Moved up into then branch for true actions, but not predicates ***/
+ if ( !DemandLookahead ) {
+ if ( GenCC ) {
+ if ( FoundException && p->use_def_MT_handler ) gen("if (!_signal)");
+ _gen(" consume();")
+ if ( FoundException && p->use_def_MT_handler )
+ _gen(" _signal=NoSignal;");
+ _gen("\n");
+ }
+ else
+ {
+ if ( FoundException && p->use_def_MT_handler ) _gen("if (!_signal)");
+ _gen(" zzCONSUME;\n");
+ if ( FoundException && p->use_def_MT_handler ) _gen(" _signal=NoSignal;");
+ _gen("\n");
+ }
+ }
+ else gen("\n");
+ if (a->done) { /* MR30 */
+ TRANS( a->next ); /* MR30 */
+ } /* MR30 */
+ else { /* MR30 */
+ TRANS( p->next ); /* MR30 */
+ } /* MR30 */
+ }
+ else
+ {
+ if ( !DemandLookahead ) {
+ if ( GenCC ) {
+ if (FoundException && p->use_def_MT_handler) _gen("if (!_signal)");
+ _gen(" consume();")
+ if (FoundException&&p->use_def_MT_handler) _gen(" _signal=NoSignal;");
+ _gen("\n");
+ }
+ else {
+ if (FoundException && p->use_def_MT_handler) _gen("if (!_signal)");
+ _gen(" zzCONSUME;");
+ if ( FoundException && p->use_def_MT_handler ) _gen(" _signal=NoSignal;");
+ _gen("\n");
+ }
+ }
+ else _gen("\n");
+ TRANS(p->next);
+ }
+}
+
+/* MR21
+ *
+ * There was a bug in the code generation for {...} which causes it
+ * to omit the optional tokens from the error messages. The easiest
+ * way to fix this was to make the opt block look like a sub block:
+ *
+ * { a | b | c }
+ *
+ * becomes (internally):
+ *
+ * ( a | b | c | )
+ *
+ * The code for genOptBlk is now identical to genSubBlk except for
+ * cosmetic changes.
+ */
+
+void
+#ifdef __USE_PROTOS
+genOptBlk( Junction *q )
+#else
+genOptBlk( q )
+Junction *q;
+#endif
+{
+ int max_k;
+ set f;
+ int need_right_curly;
+ set savetkref;
+ int lastAltEmpty; /* MR23 */
+ savetkref = tokensRefdInBlock;
+ require(q->ntype == nJunction, "genOptBlk: not junction");
+ require(q->jtype == aOptBlk, "genOptBlk: not opt block");
+
+ OutLineInfo(output,q->line,FileStr[q->file]);
+ BLOCK_Preamble(q);
+ BlkLevel++;
+ BlockPreambleOption(q,q->pFirstSetSymbol); /* MR21 */
+ f = genBlk(q, aOptBlk, &max_k, &need_right_curly, &lastAltEmpty /* MR23 */);
+/* MR23
+ Bypass error clause generation when exceptions are used in {...} block
+ See multi-line note in genBlk near call to isEmptyAlt.
+*/
+ if (! FoundException) {
+ if ( q->p2 != NULL ) {tab(); makeErrorClause(q,f,max_k,0 /* use plus block bypass ? */ );}
+ }
+ else {
+ gen("/* MR23 skip error clause for {...} when exceptions in use */\n");
+ }
+ { int i; for (i=1; i<=need_right_curly; i++) {tabs--; gen("}\n");} }
+ freeBlkFsets(q);
+ --BlkLevel;
+ BLOCK_Tail();
+
+ if ( q->guess )
+ {
+ gen("zzGUESS_DONE\n");
+ }
+
+ /* must duplicate if (alpha)?; one guesses (validates), the
+ * second pass matches */
+ if ( q->guess && analysis_point(q)==q )
+ {
+ OutLineInfo(output,q->line,FileStr[q->file]);
+ BLOCK_Preamble(q);
+ BlkLevel++;
+ f = genBlk(q, aSubBlk, &max_k, &need_right_curly, &lastAltEmpty /* MR23 */);
+ if ( q->p2 != NULL ) {tab(); makeErrorClause(q,f,max_k,0 /* use plus block bypass ? */ );}
+ { int i; for (i=1; i<=need_right_curly; i++) {tabs--; gen("}\n");} }
+ freeBlkFsets(q);
+ --BlkLevel;
+ BLOCK_Tail();
+ }
+
+ tokensRefdInBlock = savetkref;
+ if (q->end->p1 != NULL) TRANS(q->end->p1);
+}
+
+/*
+ * Generate code for a loop blk of form:
+ *
+ * |---|
+ * v |
+ * --o-G-o-->o--
+ */
+void
+#ifdef __USE_PROTOS
+genLoopBlk( Junction *begin, Junction *q, Junction *start, int max_k )
+#else
+genLoopBlk( begin, q, start, max_k )
+Junction *begin;
+Junction *q;
+Junction *start; /* where to start generating code from */
+int max_k;
+#endif
+{
+ set f;
+ int need_right_curly;
+ set savetkref;
+ Junction *guessBlock; /* MR10 */
+ int singleAlt; /* MR10 */
+ int lastAltEmpty; /* MR23 */
+
+ savetkref = tokensRefdInBlock;
+ require(q->ntype == nJunction, "genLoopBlk: not junction");
+ require(q->jtype == aLoopBlk, "genLoopBlk: not loop block");
+
+ if ( q->visited ) return;
+ q->visited = TRUE;
+
+ /* first_item_is_guess_block doesn't care what kind of node it is */
+
+ guessBlock=first_item_is_guess_block( (Junction *) q->p1); /* MR10 */
+ singleAlt=q->p2==NULL; /* MR10 */
+
+ if (singleAlt && !guessBlock) /* MR10 */ /* only one alternative? */
+ {
+ if ( DemandLookahead ) {
+ if ( !GenCC ) {gen1("LOOK(%d);\n", max_k);}
+ else gen1("look(%d);\n", max_k);
+ }
+ gen("while ( ");
+ if ( begin!=NULL ) genExpr(begin);
+ else genExpr(q);
+ /* if no predicates have been hoisted for this single alt (..)*
+ * do so now
+ */
+ require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
+ if ( ParseWithPredicates && begin->predicate==NULL )
+ {
+ Predicate *a = MR_find_predicates_and_supp((Node *)q->p1);
+ require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
+
+ if ( a!=NULL )
+ {
+ _gen("&&");
+ a=genPredTreeMain(a, (Node *)q); /* MR10 */
+ }
+/* MR10 */ if (MRhoisting) {
+/* MR10 */ predicate_free(a);
+/* MR10 */ };
+ }
+ _gen(" ) {\n");
+ tabs++;
+ TRANS(q->p1);
+ if ( !GenCC ) gen1("zzLOOP(zztasp%d);\n", BlkLevel-1);
+ if ( DemandLookahead ) {
+ if ( !GenCC ) {gen1("LOOK(%d);\n", max_k);}
+ else gen1("look(%d);\n", max_k);
+ }
+ --tabs;
+ gen("}\n");
+ freeBlkFsets(q);
+ q->visited = FALSE;
+ tokensRefdInBlock = savetkref;
+ return;
+ }
+ gen("for (;;) {\n"); /* MR20 G. Hobbelt */
+ tabs++;
+/* MR6 */
+/* MR6 "begin" can never be null when called from genLoopBegin */
+/* MR6 because q==(Junction *)begin->p1 and we know q is valid */
+/* MR6 */
+/* MR6 from genLoopBegin: */
+/* MR6 */
+/* MR6 if ( LL_k>1 && !set_nil(q->fset[2]) ) */
+/* MR6 genLoopBlk( q, (Junction *)q->p1, q, max_k ); */
+/* MR6 else genLoopBlk( q, (Junction *)q->p1, NULL, max_k ); */
+/* MR6 */
+ if ( begin!=NULL )
+ {
+ if ( DemandLookahead )
+ {
+ if ( !GenCC ) {gen1("LOOK(%d);\n", max_k);}
+ else gen1("look(%d);\n", max_k);
+ }
+ /* The bypass arc of the (...)* predicts what to do when you fail, but
+ * ONLY after having tested the loop start expression. To avoid this,
+ * we simply break out of the (...)* loop when we find something that
+ * is not in the prediction of the loop (all alts thereof).
+ */
+ gen("if ( !(");
+
+/*** TJP says: It used to use the prediction expression for the bypass arc
+ of the (...)*. HOWEVER, if a non LL^1(k) decision was found, this
+ thing would miss the ftree stored in the aLoopBegin node and generate
+ an LL^1(k) decision anyway.
+
+ *** genExpr((Junction *)begin->p2);
+ ***/
+
+ genExpr((Junction *)begin);
+ _gen(")) break;\n");
+
+ }
+
+ /* generate code for terminating loop (this is optional branch) */
+
+ f = genBlk(q, aLoopBlk, &max_k, &need_right_curly, &lastAltEmpty /* MR23 */);
+ set_free(f);
+ freeBlkFsets(q);
+
+ /* generate code for terminating loop (this is optional branch) */
+
+/* MR6 */
+/* MR6 30-May-97 Bug reported by Manuel Ornato */
+/* MR6 A definite bug involving the exit from a loop block */
+/* MR6 In 1.23 and later versions (including 1.33) Instead */
+/* MR6 exiting the block and reporting a syntax error the */
+/* MR6 code loops forever. */
+/* MR6 Looking at 1.20 which generates proper code it is not */
+/* MR6 clear which of two changes should be undone. */
+/* MR6 This is my best guess. */
+/* MR6 From earlier MR6 note we know that begin can never be */
+/* MR6 null when genLoopBlk called from genLoopBegin */
+/* MR6 */
+/* MR6 */ if ( begin==NULL) {
+/* MR6 */ /* code for exiting loop "for sure" */
+/* MR6 */ gen("/* Suppressed by MR6 */ /*** else break; ***/\n");
+/* MR6 */ };
+
+/* MR10 */if (singleAlt && guessBlock) {
+/* MR10 */ tabs--;
+/* MR6 */ gen("} else break; /* MR6 code for exiting loop \"for sure\" */\n");
+/* MR10 */ need_right_curly--;
+/* MR10 */ } else {
+/* MR6 */ gen("else break; /* MR6 code for exiting loop \"for sure\" */\n");
+/* MR10 */ };
+
+ { int i; for (i=1; i<=need_right_curly; i++) {tabs--; gen("}\n");} }
+ if ( !GenCC ) gen1("zzLOOP(zztasp%d);\n", BlkLevel-1);
+ --tabs;
+ gen("}\n");
+ q->visited = FALSE;
+ tokensRefdInBlock = savetkref;
+}
+
+/*
+ * Generate code for a loop blk of form:
+ *
+ * |---|
+ * v |
+ * --o-->o-->o-G-o-->o--
+ * | ^
+ * v |
+ * o-----------o
+ *
+ * q->end points to the last node (far right) in the blk.
+ *
+ * Note that q->end->jtype must be 'EndBlk'.
+ *
+ * Generate code roughly of the following form:
+ *
+ * do {
+ * ... code for alternatives ...
+ * } while ( First Set of aLoopBlk );
+ *
+ * OR if > 1 alternative
+ *
+ * do {
+ * ... code for alternatives ...
+ * else break;
+ * } while ( 1 );
+ */
+void
+#ifdef __USE_PROTOS
+genLoopBegin( Junction *q )
+#else
+genLoopBegin( q )
+Junction *q;
+#endif
+{
+ set f;
+ int i;
+ int max_k;
+ set savetkref;
+ savetkref = tokensRefdInBlock;
+ require(q!=NULL, "genLoopBegin: invalid node and/or rule");
+ require(q->ntype == nJunction, "genLoopBegin: not junction");
+ require(q->jtype == aLoopBegin, "genLoopBegin: not loop block");
+ require(q->p2!=NULL, "genLoopBegin: invalid Loop Graph");
+
+ OutLineInfo(output,q->line,FileStr[q->file]);
+
+ BLOCK_Preamble(q);
+ BlkLevel++;
+ BlockPreambleOption(q,q->pFirstSetSymbol); /* MR21 */
+ f = First(q, 1, aLoopBegin, &max_k);
+ /* If not simple LL(1), must specify to start at LoopBegin, not LoopBlk */
+ if ( LL_k>1 && !set_nil(q->fset[2]) )
+ genLoopBlk( q, (Junction *)q->p1, q, max_k );
+ else genLoopBlk( q, (Junction *)q->p1, NULL, max_k );
+
+ for (i=1; i<=CLL_k; i++) set_free(q->fset[i]);
+ for (i=1; i<=CLL_k; i++) set_free(((Junction *)q->p2)->fset[i]);
+ --BlkLevel;
+ BLOCK_Tail();
+ set_free(f);
+ tokensRefdInBlock = savetkref;
+/* MR21 */ if (MR_BlkErr) {
+/* MR21 */ set f, fArray[2];
+/* MR21 */ f = ComputeErrorSet(q,1,0 /* use plus block bypass ? */ );
+/* MR21 */ fArray[0]= empty;
+/* MR21 */ fArray[1]= set_dup(f);
+/* MR21 */ gen("if (");
+/* MR21 */ genExprSets(fArray,1); /* note: destroys set arguments */
+/* MR21 */ _gen(") { /* MR21 option -mrblksynerr */\n");
+/* MR21 */ tabs++;
+/* MR21 */ tab();
+/* MR21 */ _gen("/* nothing */ }\n");
+/* MR21 */ tab();
+/* MR21 */ makeErrorClause(q,f,1,0 /* use plus block bypass ? */ ); /* frees set */
+/* MR21 */ tabs--;
+/* MR21 */ };
+ if (q->end->p1 != NULL) TRANS(q->end->p1);
+}
+
+/*
+ * Generate code for a loop blk of form:
+ *
+ * |---|
+ * v |
+ * --o-G-o-->o--
+ *
+ * q->end points to the last node (far right) in the blk.
+ * Note that q->end->jtype must be 'EndBlk'.
+ *
+ * Generate code roughly of the following form:
+ *
+ * do {
+ * ... code for alternatives ...
+ * } while ( First Set of aPlusBlk );
+ *
+ * OR if > 1 alternative
+ *
+ * do {
+ * ... code for alternatives ...
+ * else if not 1st time through, break;
+ * } while ( 1 );
+ */
+void
+#ifdef __USE_PROTOS
+genPlusBlk( Junction *q )
+#else
+genPlusBlk( q )
+Junction *q;
+#endif
+{
+ int max_k;
+ set f;
+ int need_right_curly;
+ int lastAltEmpty; /* MR23 */
+ set savetkref;
+ Junction *guessBlock; /* MR10 */
+ int singleAlt; /* MR10 */
+
+ savetkref = tokensRefdInBlock;
+ require(q!=NULL, "genPlusBlk: invalid node and/or rule");
+ require(q->ntype == nJunction, "genPlusBlk: not junction");
+ require(q->jtype == aPlusBlk, "genPlusBlk: not Plus block");
+ require(q->p2 != NULL, "genPlusBlk: not a valid Plus block");
+
+ if ( q->visited ) return;
+ q->visited = TRUE;
+ OutLineInfo(output,q->line,FileStr[q->file]);
+ BLOCK_Preamble(q);
+ BlkLevel++;
+
+ BlockPreambleOption((Junction *)q, q->pFirstSetSymbol); /* MR21 */
+
+ /* first_item_is_guess_block doesn't care what kind of node it is */
+
+ guessBlock=first_item_is_guess_block( (Junction *)q->p1); /* MR10 */
+
+ /* if the ignore flag is set on the 2nd alt and that alt is empty,
+ * then it is the implied optional alternative that we added for (...)+
+ * and, hence, only 1 alt.
+ */
+
+/* MR10 Reported by Pulkkinen Esa (esap@cs.tut.fi)
+ * Outer code for guess blocks ignored when there is only one alt
+ * for a (...)+ block.
+ * Force use of regular code rather than "optimized" code for that case
+ */
+
+ singleAlt=( ( (Junction *) q->p2)->p2 == NULL) &&
+ ( ( (Junction *) q->p2)->ignore ); /* only one alternative? */
+
+ if (singleAlt && !guessBlock) /* MR10 */
+ {
+
+ Predicate *a=NULL;
+ /* if the only alt has a semantic predicate, hoist it; must test before
+ * entering loop.
+ */
+ if ( ParseWithPredicates )
+ {
+ require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
+ a = MR_find_predicates_and_supp((Node *)q);
+ require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
+
+ if ( a!=NULL ) {
+ gen("if (");
+ a=genPredTreeMain(a, (Node *)q); /* MR10 */
+ _gen(") {\n");
+ }
+ }
+ gen("do {\n");
+ tabs++;
+ TRANS(q->p1);
+ if ( !GenCC ) gen1("zzLOOP(zztasp%d);\n", BlkLevel-1);
+ f = First(q, 1, aPlusBlk, &max_k);
+ if ( DemandLookahead ) {
+ if ( !GenCC ) {gen1("LOOK(%d);\n", max_k);}
+ else gen1("look(%d);\n", max_k);
+ }
+ --tabs;
+ gen("} while ( ");
+ if ( q->parm!=NULL && q->predparm ) _gen1("(%s) && ", q->parm);
+ genExpr(q);
+ if ( ParseWithPredicates && a!=NULL )
+ {
+ if (! MR_comparePredicates(q->predicate,a)) {
+ _gen("&&");
+ a=genPredTreeMain(a, (Node *)q); /* MR10 */
+ };
+ }
+ _gen(" );\n");
+ if ( ParseWithPredicates && a!=NULL ) gen("}\n");
+ --BlkLevel;
+ BLOCK_Tail();
+ q->visited = FALSE;
+ freeBlkFsets(q);
+ set_free(f);
+ tokensRefdInBlock = savetkref;
+/* MR21 */ if (MR_BlkErr) {
+/* MR21 */ set f, fArray[2];
+/* MR21 */ f = ComputeErrorSet(q,1,1 /* use plus block bypass ? */ );
+/* MR21 */ fArray[0]= empty;
+/* MR21 */ fArray[1]= set_dup(f);
+/* MR21 */ gen("if (");
+/* MR21 */ genExprSets(fArray,1); /* note: destroys set arguments */
+/* MR21 */ _gen(") { /* MR21 option -mrblksynerr */\n");
+/* MR21 */ tabs++;
+/* MR21 */ tab();
+/* MR21 */ _gen("/* nothing */ }\n");
+/* MR21 */ tab();
+/* MR21 */ makeErrorClause(q,f,1,1 /* use plus block bypass ? */ ); /* frees set */
+/* MR21 */ tabs--;
+/* MR21 */ };
+ if (q->end->p1 != NULL) TRANS(q->end->p1);
+/* MR10 */ if (MRhoisting) {
+/* MR10 */ predicate_free(a);
+/* MR10 */ };
+ return;
+ }
+ gen("do {\n");
+ tabs++;
+ f = genBlk(q, aPlusBlk, &max_k, &need_right_curly, &lastAltEmpty /* MR23 */);
+/* MR6 */
+/* MR6 Sinan Karasu (sinan@tardis.ds.boeing.com) */
+/* MR6 Failed to turn off guess mode when leaving block */
+/* MR6 */
+/* MR6 */ if ( has_guess_block_as_last_item(q) ) {
+/* MR10 */ gen("/* MR10 ()+ */ else {\n");
+/* MR10 */ tabs++;
+/* MR10 */ need_right_curly++;
+/* MR10 */ gen("/* MR10 ()+ */ if ( !zzrv ) zzGUESS_DONE;\n");
+/* MR6 */ gen("/* MR10 ()+ */ if ( zzcnt > 1 ) break;\n");
+/* MR10 */ } else {
+/* MR10 */ gen("/* MR10 ()+ */ else {\n");
+/* MR10 */ tabs++;
+/* MR10 */ need_right_curly++;
+/* MR10 */ gen("if ( zzcnt > 1 ) break;\n");
+/* MR10 */ };
+
+/* MR21 */ if (MR_BlkErr && 1 >= max_k) {
+/* MR21 */ set f;
+/* MR21 */ f = ComputeErrorSet(q,1,0 /* use plus block bypass ? */ );
+/* MR21 */ tabs++;
+/* MR21 */ tab();
+/* MR21 */ makeErrorClause(q,f,1,0 /* use plus block bypass ? */ ); /* frees set */
+/* MR21 */ tabs--;
+/* MR21 */ }
+/* MR21 */ else {
+ tab();
+ makeErrorClause(q,f,max_k,1 /* use plus block bypass ? */);
+ /* MR21 I think this generates the wrong set ? */
+ /* MR21 because it includes the plus block bypass ? */
+ /* MR21 but I'm afraid to change it without additional checking */
+ }
+
+ { int i; for (i=1; i<=need_right_curly; i++) {tabs--; gen("}\n");} }
+ freeBlkFsets(q);
+ gen("zzcnt++;");
+ if ( !GenCC ) _gen1(" zzLOOP(zztasp%d);", BlkLevel-1);
+ _gen("\n");
+ if ( DemandLookahead ) {
+ if ( !GenCC ) {gen1("LOOK(%d);\n", max_k);}
+ else gen1("look(%d);\n", max_k);
+ }
+ --tabs;
+ if ( q->parm!=NULL && q->predparm ) {gen1("} while (%s);\n", q->parm);}
+ else gen("} while ( 1 );\n");
+ --BlkLevel;
+ BLOCK_Tail();
+ q->visited = FALSE;
+ tokensRefdInBlock = savetkref;
+/* MR21 */ if (MR_BlkErr) {
+/* MR21 */ set f, fArray[2];
+/* MR21 */ f = ComputeErrorSet(q,1,1 /* use plus block bypass ? */ );
+/* MR21 */ fArray[0]= empty;
+/* MR21 */ fArray[1]= set_dup(f);
+/* MR21 */ gen("if (");
+/* MR21 */ genExprSets(fArray,1); /* note: destroys set arguments */
+/* MR21 */ _gen(") { /* MR21 option -mrblksynerr */\n");
+/* MR21 */ tabs++;
+/* MR21 */ tab();
+/* MR21 */ _gen("/* nothing */ }\n");
+/* MR21 */ tab();
+/* MR21 */ makeErrorClause(q,f,1,1 /* use plus block bypass ? */ ); /* frees set */
+/* MR21 */ tabs--;
+/* MR21 */ };
+ if (q->end->p1 != NULL) TRANS(q->end->p1);
+}
+
+/*
+ * Generate code for a sub blk of alternatives of form:
+ *
+ * --o-G1--o--
+ * | ^
+ * v /|
+ * o-G2-o|
+ * | ^
+ * v |
+ * ..........
+ * | ^
+ * v /
+ * o-Gn-o
+ *
+ * q points to the 1st junction of blk (upper-left).
+ * q->end points to the last node (far right) in the blk.
+ * Note that q->end->jtype must be 'EndBlk'.
+ * The last node in every alt points to q->end.
+ *
+ * Generate code of the following form:
+ * if ( First(G1) ) {
+ * ...code for G1...
+ * }
+ * else if ( First(G2) ) {
+ * ...code for G2...
+ * }
+ * ...
+ * else {
+ * ...code for Gn...
+ * }
+ */
+
+void
+#ifdef __USE_PROTOS
+genSubBlk( Junction *q )
+#else
+genSubBlk( q )
+Junction *q;
+#endif
+{
+ int max_k;
+ set f;
+ int need_right_curly;
+ int lastAltEmpty; /* MR23 */
+ set savetkref;
+ savetkref = tokensRefdInBlock;
+ require(q->ntype == nJunction, "genSubBlk: not junction");
+ require(q->jtype == aSubBlk, "genSubBlk: not subblock");
+
+ OutLineInfo(output,q->line,FileStr[q->file]);
+ BLOCK_Preamble(q);
+ BlkLevel++;
+ BlockPreambleOption(q,q->pFirstSetSymbol); /* MR21 */
+ f = genBlk(q, aSubBlk, &max_k, &need_right_curly, &lastAltEmpty /* MR23 */);
+
+/* MR23
+ Bypass error clause generation when exceptions are used in a sub block
+ in which the last alternative is epsilon. Example: "(A | B | )".
+ See multi-line note in genBlk near call to isEmptyAlt.
+*/
+ if (FoundException && lastAltEmpty) {
+ gen("/* MR23 skip error clause for (...| epsilon) when exceptions in use */\n");
+ }
+ else {
+ if ( q->p2 != NULL ) {tab(); makeErrorClause(q,f,max_k,0 /* use plus block bypass ? */ );}
+ }
+
+ { int i; for (i=1; i<=need_right_curly; i++) {tabs--; gen("}\n");} }
+ freeBlkFsets(q);
+ --BlkLevel;
+ BLOCK_Tail();
+
+ if ( q->guess )
+ {
+ gen("zzGUESS_DONE\n");
+ }
+
+ /* must duplicate if (alpha)?; one guesses (validates), the
+ * second pass matches */
+ if ( q->guess && analysis_point(q)==q )
+ {
+ OutLineInfo(output,q->line,FileStr[q->file]);
+ BLOCK_Preamble(q);
+ BlkLevel++;
+ f = genBlk(q, aSubBlk, &max_k, &need_right_curly, &lastAltEmpty /* MR23 */);
+ if ( q->p2 != NULL ) {tab(); makeErrorClause(q,f,max_k,0 /* use plus block bypass ? */);}
+ { int i; for (i=1; i<=need_right_curly; i++) {tabs--; gen("}\n");} }
+ freeBlkFsets(q);
+ --BlkLevel;
+ BLOCK_Tail();
+ }
+
+ tokensRefdInBlock = savetkref;
+ if (q->end->p1 != NULL) TRANS(q->end->p1);
+}
+
+static int TnodesAllocatedPrevRule=0;
+
+/*
+ * Generate code for a rule.
+ *
+ * rule--> o-->o-Alternatives-o-->o
+ * Or,
+ * rule--> o-->o-Alternative-o-->o
+ *
+ * The 1st junction is a RuleBlk. The second can be a SubBlk or just a junction
+ * (one alternative--no block), the last is EndRule.
+ * The second to last is EndBlk if more than one alternative exists in the rule.
+ *
+ * To get to the init-action for a rule, we must bypass the RuleBlk,
+ * and possible SubBlk.
+ * Mark any init-action as generated so genBlk() does not regenerate it.
+ */
+void
+#ifdef __USE_PROTOS
+genRule( Junction *q )
+#else
+genRule( q )
+Junction *q;
+#endif
+{
+
+ const char * returnValueInitializer;
+
+do { /* MR10 Change recursion into iteration */
+
+ int max_k;
+ set follow, rk, f;
+ ActionNode *a;
+ RuleEntry *r;
+ int lastAltEmpty; /* MR23 */
+ static int file = -1;
+ int need_right_curly;
+ require(q->ntype == nJunction, "genRule: not junction");
+ require(q->jtype == RuleBlk, "genRule: not rule");
+
+/* MR14 */ require (MR_BackTraceStack.count == 0,"-alpha MR_BackTraceStack.count != 0");
+/* MR14 */ MR_pointerStackReset(&MR_BackTraceStack);
+/* MR14 */ if (AlphaBetaTrace) MR_MaintainBackTrace=1;
+
+ CurRule=q->rname; /* MR11 */
+
+ r = (RuleEntry *) hash_get(Rname, q->rname);
+ if ( r == NULL ) warnNoFL("Rule hash table is screwed up beyond belief");
+ if ( q->file != file ) /* open new output file if need to */
+ {
+/* MR6 */
+/* MR6 Simpler to debug when output goes to stdout rather than a file */
+/* MR6 */
+/* MR6 */ if (UseStdout) {
+/* MR6 */ output = stdout;
+/* MR6 */ } else {
+/* MR6 */ if ( output != NULL) fclose( output );
+/* MR6 */ output = fopen(OutMetaName(outname(FileStr[q->file])), "w");
+/* MR6 */ };
+ require(output != NULL, "genRule: can't open output file");
+
+#ifdef SPECIAL_FOPEN
+ special_fopen_actions(OutMetaName(outname(FileStr[q->file]))); /* MR1 */
+#endif
+ if ( file == -1 ) genHdr1(q->file);
+ else genHdr(q->file);
+ file = q->file;
+ }
+
+ if (InfoM) {
+ fprintf(stderr," rule %s\n",q->rname);
+ fflush(output);
+ };
+
+#if 0
+ if (strcmp(q->rname,"***debug***") == 0) {
+ fprintf(stderr,"***debug*** %s reached\n",q->rname);
+ MR_break();
+ };
+#endif
+
+ DumpFuncHeader(q,r);
+ tabs++;
+
+ /* MR23
+
+ If there is a single return value then it can be initialized in
+ the declaration using assignment syntax. If there are multiple
+ return values then antlr creates a struct and initialization takes
+ place element by element for each element of the struct. For
+ multiple elements the initialization is by assignment so we have
+ to wait until all declarations are done before emitting that code -
+ because of restrictions in C which don't exist in C++.
+
+ In the past (before MR23) the only kind of initialization was
+ the PURIFY macro which was just a memset() of 0. Now we allow
+ the user to specify an initial value. PURIFY is still used in C
+ mode because C does not have constructors. However, PURIFY is
+ not used in C++ mode because it might overwrite information created
+ by elements which have their own ctor.
+
+ */
+
+ if ( q->ret!=NULL )
+ {
+ if ( hasMultipleOperands(q->ret) ) /* MR23 */
+ {
+
+ /* Emit initialization code later. */
+
+ gen1("struct _rv%d _retv;\n",r->rulenum);
+ }
+ else
+ {
+ /* Emit initialization code now. */
+
+ tab();
+ DumpType(q->ret, output);
+ returnValueInitializer = getInitializer(q->ret);
+ if (returnValueInitializer == NULL) { /* MR23 */
+ gen(" _retv;\n"); /* MR1 MR3 */
+ } /* MR23 */
+ else { /* MR23 */
+ gen1(" _retv = %s;\n", returnValueInitializer); /* MR23 */
+ } /* MR23 */
+ }
+ }
+
+ OutLineInfo(output,q->line,FileStr[q->file]);
+
+ if (InfoM) {
+ fflush(output);
+ };
+
+ gen("zzRULE;\n");
+ if ( FoundException )
+ {
+ gen("int _sva=1;\n");
+ }
+ if ( GenCC && GenAST )
+ gen("ASTBase *_ast = NULL, *_sibling = NULL, *_tail = NULL;\n");
+ if ( GenCC ) genTokenPointers(q);
+ if ( GenCC&&GenAST ) genASTPointers(q);
+ if ( q->el_labels!=NULL ) genElementLabels(q->el_labels);
+ if ( FoundException ) gen("int _signal=NoSignal;\n");
+
+ if ( !GenCC ) gen1("zzBLOCK(zztasp%d);\n", BlkLevel);
+
+/* MR10 */ /* move zzTRACEIN to before init action */
+
+/* MR10 */ if ( TraceGen ) {
+/* MR10 */ if ( GenCC ) {gen1("zzTRACEIN(\"%s\");\n", q->rname);}
+/* MR10 */ else gen1("zzTRACEIN((ANTLRChar *)\"%s\");\n", q->rname);
+/* MR10 */ }
+
+/* MR7 Moved PURIFY() to after all local variables have been declared */
+/* MR7 so that the generated code is valid C as well as C++ */
+/* MR7 Jan Mikkelsen 10-June-1997 */
+
+
+ /*
+ MR23 Do the PURIFY macro only for C mode.
+ C++ users should use constructors or initialization expressions.
+ */
+
+ if ( q->ret != NULL ) /* MR7 */
+ { /* MR7 */
+ if (hasMultipleOperands(q->ret)) { /* MR23 */
+ if (PURIFY == TRUE) {
+ gen1("PCCTS_PURIFY(_retv,sizeof(struct _rv%d))\n",r->rulenum); /* MR23 */
+ }
+ } /* MR7 */
+ else { /* MR7 */
+
+ /* MR23
+ If there were only one return value operand and
+ it had an initializer then it would have been
+ initiailized in the declaration.
+ */
+
+ returnValueInitializer = getInitializer(q->ret); /* MR23 */
+ if (returnValueInitializer == NULL) { /* MR23 */
+ if (PURIFY == TRUE) {
+ gen("PCCTS_PURIFY(_retv,sizeof("); /* MR23 */
+ DumpType(q->ret, output); /* MR7 */
+ gen("))\n"); /* MR7 */
+ }
+ } /* MR23 */
+ } /* MR7 */
+
+ if (hasMultipleOperands(q->ret)) { /* MR23 */
+ DumpInitializers(output, r, q->ret); /* MR23 */
+ }
+
+ }
+ if ( !GenCC ) gen("zzMake0;\n");
+ if ( FoundException ) gen("*_retsignal = NoSignal;\n");
+
+ if ( !GenCC ) gen("{\n");
+
+ if ( has_guess_block_as_first_item((Junction *)q->p1) )
+ {
+ gen("zzGUESS_BLOCK\n");
+ }
+
+ /* L o o k F o r I n i t A c t i o n */
+ if ( ((Junction *)q->p1)->jtype == aSubBlk )
+ a = findImmedAction( ((Junction *)q->p1)->p1 );
+ else
+ a = findImmedAction( q->p1 ); /* only one alternative in rule */
+ if ( a!=NULL && !a->is_predicate)
+ {
+ /* MR21 */ if (!a->noHoist) dumpActionPlus(a, a->action, output, tabs, a->file, a->line, 1);
+ a->done = 1; /* ignore action. We have already handled it */
+ }
+
+ BlkLevel++;
+ q->visited = TRUE; /* mark RULE as visited for FIRST/FOLLOW */
+ BlockPreambleOption((Junction *)q->p1, NULL); /* MR21 */
+ f = genBlk((Junction *)q->p1, RuleBlk, &max_k, &need_right_curly, &lastAltEmpty /* MR23 */);
+ if ( q->p1 != NULL )
+ if ( ((Junction *)q->p1)->p2 != NULL )
+ {tab(); makeErrorClause((Junction *)q->p1,f,max_k,0 /* use plus block bypass ? */);}
+ { int i; for (i=1; i<=need_right_curly; i++) {tabs--; gen("}\n");} }
+ freeBlkFsets((Junction *)q->p1);
+ q->visited = FALSE;
+ --BlkLevel;
+ if ( !GenCC ) gen1("zzEXIT(zztasp%d);\n", BlkLevel);
+
+ genTraceOut(q);
+
+ if ( q->ret!=NULL ) gen("return _retv;\n") else gen("return;\n");
+ /* E r r o r R e c o v e r y */
+ NewSet();
+ rk = empty;
+
+/* MR14 */ if (r->dontComputeErrorSet) {
+/* MR14 */ follow=empty;
+ } else {
+ MR_pointerStackReset(&MR_BackTraceStack); /* MR14 */
+ MR_ErrorSetComputationActive=1;
+ REACH(q->end, 1, &rk, follow);
+ MR_ErrorSetComputationActive=0;
+ require (MR_BackTraceStack.count == 0,"K: MR_BackTraceStack.count != 0");
+ }
+
+ FillSet( follow );
+ set_free( follow );
+
+ /* MR20 G. Hobbelt
+ Isn't it so that "fail:" is ONLY referenced when:
+
+ !FoundException || FoundGuessBlk ?
+
+ Therefore add the "if" around this piece of code generation...
+
+ Should guessing mode also use _handler label instead of "fail"
+ when exception handling is active? gen can automatically put
+ "if (guessing)" there so as to skip all kinds of user code.
+
+ */
+
+ if ( !FoundException || FoundGuessBlk ) /* MR20 G. Hobbelt */
+ { /* MR20 G. Hobbelt */
+ _gen("fail:\n");
+ if ( !GenCC ) gen("zzEXIT(zztasp1);\n");
+ if ( FoundGuessBlk ) {
+ if ( !GenCC ) {gen("if ( zzguessing ) zzGUESS_FAIL;\n");}
+ else gen("if ( guessing ) zzGUESS_FAIL;\n");
+ }
+ if ( q->erraction!=NULL )
+ dumpAction(q->erraction, output, tabs, q->file, q->line, 1);
+ if ( GenCC )
+ {
+ gen1("syn(zzBadTok, %s, zzMissSet, zzMissTok, zzErrk);\n",
+ r->egroup==NULL?"(ANTLRChar *)\"\"":r->egroup);
+ }
+ else
+ {
+ gen1("zzsyn(zzMissText, zzBadTok, %s, zzMissSet, zzMissTok, zzErrk, zzBadText);\n",
+ r->egroup==NULL?"(ANTLRChar *)\"\"":r->egroup);
+ }
+ gen3("%sresynch(setwd%d, 0x%x);\n", GenCC?"":"zz", wordnum, 1<<setnum);
+
+ if ( q->ret!=NULL ) {
+ genTraceOut(q);
+ gen("return _retv;\n");
+ } else if ( q->exceptions!=NULL ) {
+ genTraceOut(q);
+ gen("return;\n");
+ } else if (!FoundException) { /* MR10 */
+ genTraceOut(q); /* MR10 */
+ };
+
+ } /* MR20 G. Hobbelt */
+
+ if ( !GenCC ) gen("}\n");
+
+ /* Gen code for exception handlers */
+ /* make sure each path out contains genTraceOut() */
+
+ if ( q->exceptions!=NULL )
+ {
+
+ gen("/* exception handlers */\n");
+
+ dumpExceptions(q->exceptions);
+
+ if ( !r->has_rule_exception )
+ {
+ _gen("_handler:\n");
+ gen("zzdflthandlers(_signal,_retsignal);\n");
+ }
+/* MR20 G. Gobbelt The label "adios" is never referenced */
+
+#if 0
+ _gen("_adios:\n");
+#endif
+ if ( q->ret!=NULL ) {
+ genTraceOut(q);
+ gen("return _retv;\n");
+ }
+ else {
+ genTraceOut(q);
+ gen("return;\n");
+ }
+ }
+ else if ( FoundException )
+ {
+ _gen("_handler:\n");
+ gen("zzdflthandlers(_signal,_retsignal);\n");
+
+/* MR1 */
+/* MR1 7-Apr-97 Fix suggested by: John Bair (jbair@iftime.com) */
+/* MR1 */
+
+ if ( q->ret != NULL) { /* MR1 */
+ genTraceOut(q); /* MR10 */
+ gen("return _retv;\n"); /* MR1 */
+ } else { /* MR1 */
+ genTraceOut(q); /* MR10 */
+ gen("return;\n") ; /* MR1 */
+ }; /* MR1 */
+ }
+
+ tabs--;
+ gen("}\n");
+
+/* MR10 Tired of looking at stacks that are as deep as the number of */
+/* MR10 rules. Changes recursion to iteration. */
+
+ MR_releaseResourcesUsedInRule( (Node *) q ); /* MR10 */
+
+ if (InfoT) {
+ fprintf(output,"\n/* tnodes created for rule %s: %d */\n",
+ q->rname, (TnodesAllocated-TnodesAllocatedPrevRule) );
+ };
+
+ TnodesAllocatedPrevRule=TnodesAllocated;
+
+ if (q->p2 == NULL) dumpAfterActions( output );
+ q=(Junction *)q->p2;
+ require(q==NULL || q->jtype==RuleBlk,"RuleBlk p2 does not point to another RuleBlk");
+
+} while (q != NULL);
+
+/**** The old code ****/
+/**** if ( q->p2 != NULL ) {TRANS(q->p2);} ****/ /* generate code for next rule too */
+/**** else dumpAfterActions( output ); ****/
+
+}
+
+
+/* This is for the function definition, not the declaration. */
+
+static void
+#ifdef __USE_PROTOS
+DumpFuncHeader( Junction *q, RuleEntry *r )
+#else
+DumpFuncHeader( q, r )
+Junction *q;
+RuleEntry *r;
+#endif
+{
+/* */
+/* MR1 10-Apr-97 MR1 Simplify insertion of commas in function header */
+/* */
+ int needComma; /* MR1 */
+
+
+ /* A N S I */
+ _gen("\n");
+ if ( q->ret!=NULL )
+ {
+ if ( hasMultipleOperands(q->ret) ) /* MR23 */
+ {
+ if (GenCC) gen2("%s::_rv%d\n", CurrentClassName, r->rulenum)
+ else gen1("struct _rv%d\n",r->rulenum);
+ }
+ else
+ {
+ DumpType(q->ret, output);
+ gen("\n");
+ }
+ }
+ else
+ {
+ _gen("void\n");
+ }
+/* MR1 */
+/* MR1 10-Apr-97 133MR1 Replace __STDC__ with __USE_PROTOS */
+/* MR1 */
+ if ( !GenCC ) _gen("#ifdef __USE_PROTOS\n"); /* MR1 */
+ if ( !GenCC ) gen2("%s%s(", RulePrefix, q->rname)
+ else gen3("%s::%s%s(", CurrentClassName, RulePrefix,q->rname);
+
+ /* If we generate C++ method names, we must hide default arguments */
+ /* which can appear in the parameter declaration list. */
+ /* NOTICE: this is done only here, for the method definition, but */
+ /* not for the method declaration inside the class */
+ /* definition. This is exactly the behaviour defined in */
+ /* C++ standard for default paramters. */
+
+ DumpANSIFunctionArgDef(output,q, 0 /* emit initializers ? */);
+ _gen("\n");
+
+ if ( GenCC ) {
+ gen("{\n");
+ return;
+ }
+
+ /* K & R */
+ gen("#else\n");
+ gen2("%s%s(", RulePrefix, q->rname);
+ needComma=0; /* MR1 */
+ if ( GenAST ) /* MR1 */
+ { /* MR1 */
+ _gen("_root"); /* MR1 */
+ needComma=1; /* MR1 */
+ } /* MR1 */
+ if ( FoundException ) /* MR1 */
+ { /* MR1 */
+ if (needComma) {_gen(",");needComma=0;}; /* MR1 */
+ _gen("_retsignal"); /* MR1 */
+ needComma=1; /* MR1 */
+ } /* MR1 */
+/* MR5 Change below by Jan Mikkelsen (janm@zeta.org.au) 26-May-97 MR5 */
+ DumpListOfParmNames( q->pdecl, output, needComma ); /* MR5 */
+ gen(")\n");
+ if ( GenAST ) gen("AST **_root;\n");
+ if ( FoundException ) gen("int *_retsignal;\n");
+ DumpOldStyleParms( q->pdecl, output );
+ gen("#endif\n");
+ gen("{\n");
+}
+
+void
+#ifdef __USE_PROTOS
+DumpANSIFunctionArgDef(FILE *f, Junction *q, int bInitializer)
+#else
+DumpANSIFunctionArgDef(f,q,bInitializer)
+FILE *f;
+Junction *q;
+int bInitializer;
+#endif
+{
+ if ( GenAST )
+ {
+ if ( GenCC ) {fprintf(f,"ASTBase **_root");}
+ else fprintf(f,"AST**_root");
+ if ( !FoundException && q->pdecl!=NULL ) fprintf(f,",");
+ }
+ if ( FoundException )
+ {
+ if ( GenAST ) fprintf(f,",");
+ fprintf(f,"int *_retsignal");
+ if ( q->pdecl!=NULL ) {
+ fprintf(f,",");
+ }
+ }
+ if ( q->pdecl!=NULL ) {
+ DumpFormals(f, q->pdecl, bInitializer); /* MR23 */
+ }
+ else {
+ if ( !GenAST && !FoundException ) {
+ fprintf(f,"void");
+ }
+ }
+ fprintf(f,")");
+}
+
+void
+#ifdef __USE_PROTOS
+genJunction( Junction *q )
+#else
+genJunction( q )
+Junction *q;
+#endif
+{
+ require(q->ntype == nJunction, "genJunction: not junction");
+ require(q->jtype == Generic, "genJunction: not generic junction");
+
+ if ( q->p1 != NULL ) TRANS(q->p1);
+ if ( q->p2 != NULL ) TRANS(q->p2);
+}
+
+void
+#ifdef __USE_PROTOS
+genEndBlk( Junction *q )
+#else
+genEndBlk( q )
+Junction *q;
+#endif
+{
+}
+
+void
+#ifdef __USE_PROTOS
+genEndRule( Junction *q )
+#else
+genEndRule( q )
+Junction *q;
+#endif
+{
+}
+
+void
+#ifdef __USE_PROTOS
+genHdr( int file )
+#else
+genHdr( file )
+int file;
+#endif
+{
+ int i;
+
+ _gen("/*\n");
+ _gen(" * A n t l r T r a n s l a t i o n H e a d e r\n");
+ _gen(" *\n");
+ _gen(" * Terence Parr, Will Cohen, and Hank Dietz: 1989-2001\n");
+ _gen(" * Purdue University Electrical Engineering\n");
+ _gen(" * With AHPCRC, University of Minnesota\n");
+ _gen1(" * ANTLR Version %s\n", Version);
+ _gen(" *\n");
+/* MR10 */ _gen(" * ");
+/* MR10 */ for (i=0 ; i < Save_argc ; i++) {
+/* MR10 */ _gen(" ");
+/* MR10 */ _gen(Save_argv[i]);
+/* MR10 */ };
+ _gen("\n");
+ _gen(" *\n");
+ _gen(" */\n\n");
+ if (FirstAction != NULL ) dumpAction( FirstAction, output, 0, -1, 0, 1); /* MR11 MR15b */
+ _gen1("#define ANTLR_VERSION %s\n", VersionDef);
+ _gen("#include \"pcctscfg.h\"\n");
+ _gen("#include \"pccts_stdio.h\"\n");
+ if ( strcmp(ParserName, DefaultParserName)!=0 )
+ _gen2("#define %s %s\n", DefaultParserName, ParserName);
+ if ( strcmp(ParserName, DefaultParserName)!=0 )
+ {_gen1("#include \"%s\"\n", RemapFileName);}
+ OutLineInfo(output,1,FileStr[file]);
+ if ( GenCC ) {
+ if ( UserTokenDefsFile != NULL )
+ fprintf(output, "#include %s\n", UserTokenDefsFile);
+ else
+ fprintf(output, "#include \"%s\"\n", DefFileName);
+ }
+
+ if ( HdrAction != NULL ) dumpAction( HdrAction, output, 0, -1, 0, 1);
+ if ( !GenCC && FoundGuessBlk )
+ {
+ _gen("#define ZZCAN_GUESS\n");
+ _gen("#include \"pccts_setjmp.h\"\n"); /* MR15 K.J. Cummings (cummings@peritus.com) */
+ }
+ if ( FoundException )
+ {
+ _gen("#define EXCEPTION_HANDLING\n");
+ _gen1("#define NUM_SIGNALS %d\n", NumSignals);
+ }
+ if ( !GenCC && OutputLL_k > 1 ) _gen1("#define LL_K %d\n", OutputLL_k);
+ if ( GenAST&&!GenCC ) _gen("#define GENAST\n\n");
+ if ( GenAST ) {
+ if ( GenCC ) {_gen1("#include \"%s\"\n\n", ASTBASE_H);}
+ else _gen("#include \"ast.h\"\n\n");
+ }
+ if ( !GenCC && DemandLookahead ) _gen("#define DEMAND_LOOK\n\n");
+#ifdef DUM
+ if ( !GenCC && LexGen ) {
+ _gen1("#define zzEOF_TOKEN %d\n", (TokenInd!=NULL?TokenInd[EofToken]:EofToken));
+ }
+#endif
+ /* ###WARNING: This will have to change when SetWordSize changes */
+ if ( !GenCC ) _gen1("#define zzSET_SIZE %d\n", NumWords(TokenNum-1)*sizeof(unsigned));
+ if (TraceGen) {
+ _gen("#ifndef zzTRACE_RULES\n"); /* MR20 */
+ _gen("#define zzTRACE_RULES\n"); /* MR20 */
+ _gen("#endif\n"); /* MR22 */
+ };
+ if ( !GenCC ) {_gen("#include \"antlr.h\"\n");}
+ else {
+ _gen1("#include \"%s\"\n", APARSER_H);
+ _gen1("#include \"%s.h\"\n", CurrentClassName);
+ }
+ if ( !GenCC ) {
+ if ( UserDefdTokens )
+ {_gen1("#include %s\n", UserTokenDefsFile);}
+ /* still need this one as it has the func prototypes */
+ _gen1("#include \"%s\"\n", DefFileName);
+ }
+ /* still need this one as it defines the DLG interface */
+ if ( !GenCC ) _gen("#include \"dlgdef.h\"\n");
+ if ( LexGen && GenCC ) _gen1("#include \"%s\"\n", DLEXERBASE_H);
+ if ( GenCC ) _gen1("#include \"%s\"\n", ATOKPTR_H);
+ if ( !GenCC && LexGen ) _gen1("#include \"%s\"\n", ModeFileName);
+
+/* MR10 Ofer Ben-Ami (gremlin@cs.huji.ac.il) */
+/* MR10 Finally, a definition of the Purify macro */
+
+ if (PURIFY == TRUE) { /* MR23 */
+ _gen("\n/* MR23 In order to remove calls to PURIFY use the antlr"); /* MR23 */
+ _gen(" -nopurify option */\n\n"); /* MR23 */
+ _gen("#ifndef PCCTS_PURIFY\n");
+ _gen("#define PCCTS_PURIFY(r,s) memset((char *) &(r),'\\0',(s));\n");
+ _gen("#endif\n\n");
+ } /* MR23 */
+}
+
+void
+#ifdef __USE_PROTOS
+genHdr1( int file )
+#else
+genHdr1( file )
+int file;
+#endif
+{
+ ListNode *p;
+
+ genHdr(file);
+ if ( GenAST )
+ {
+ if ( !GenCC ) {
+ _gen("#include \"ast.c\"\n");
+ _gen("zzASTgvars\n\n");
+ }
+ }
+ if ( !GenCC ) _gen("ANTLR_INFO\n");
+ if ( BeforeActions != NULL )
+ {
+ for (p = BeforeActions->next; p!=NULL; p=p->next)
+ {
+ UserAction *ua = (UserAction *)p->elem;
+ dumpAction( ua->action, output, 0, ua->file, ua->line, 1);
+ }
+ }
+
+ if ( !FoundException ) return;
+
+ if ( GenCC )
+ {
+ _gen1("\nvoid %s::\n", CurrentClassName);
+ _gen("zzdflthandlers( int _signal, int *_retsignal )\n");
+ _gen("{\n");
+ }
+ else
+ {
+ _gen("\nvoid\n");
+/* MR1 */
+/* MR1 10-Apr-97 133MR1 Replace __STDC__ with __USE_PROTOS */
+/* MR1 */
+ _gen("#ifdef __USE_PROTOS\n"); /* MR1 */
+ _gen("zzdflthandlers( int _signal, int *_retsignal )\n");
+ _gen("#else\n");
+ _gen("zzdflthandlers( _signal, _retsignal )\n");
+ _gen("int _signal;\n");
+ _gen("int *_retsignal;\n");
+ _gen("#endif\n");
+ _gen("{\n");
+ }
+ tabs++;
+ if ( DefaultExGroup!=NULL )
+ {
+ dumpException(DefaultExGroup, 1);
+ if ( !hasDefaultException(DefaultExGroup) )
+ {
+ gen("default :\n");
+ tabs++;
+ gen("*_retsignal = _signal;\n");
+ tabs--;
+ gen("}\n");
+ }
+ }
+ else {
+ gen("*_retsignal = _signal;\n");
+ }
+
+ tabs--;
+ _gen("}\n\n");
+}
+
+void
+#ifdef __USE_PROTOS
+genStdPCCTSIncludeFile( FILE *f,char *gate ) /* MR10 */
+#else
+genStdPCCTSIncludeFile( f , gate) /* MR10 */
+FILE *f;
+char * gate; /* MR10 */
+#endif
+{
+/* MR10 Ramanathan Santhanam (ps@kumaran.com) */
+/* MR10 Same preprocessor symbol use to gate stdpccts.h */
+/* MR10 even when two grammars are in use. */
+/* MR10 Derive gate symbol from -fh filename */
+
+ if (gate == NULL) {
+ fprintf(f,"#ifndef STDPCCTS_H\n"); /* MR10 */
+ fprintf(f,"#define STDPCCTS_H\n"); /* MR10 */
+ } else {
+ fprintf(f,"#ifndef STDPCCTS_%s_H\n",gate); /* MR10 */
+ fprintf(f,"#define STDPCCTS_%s_H\n",gate); /* MR10 */
+ };
+ fprintf(f,"/*\n");
+ if (gate == NULL) {
+ fprintf(f," * %s -- P C C T S I n c l u d e\n", stdpccts);
+ } else {
+ fprintf(f," * Standard PCCTS include file with -fh %s -- P C C T S I n c l u d e\n", stdpccts);
+ }
+ fprintf(f," *\n");
+ fprintf(f," * Terence Parr, Will Cohen, and Hank Dietz: 1989-2001\n");
+ fprintf(f," * Purdue University Electrical Engineering\n");
+ fprintf(f," * With AHPCRC, University of Minnesota\n");
+ fprintf(f," * ANTLR Version %s\n", Version);
+ fprintf(f," */\n\n");
+
+ fprintf(f,"#ifndef ANTLR_VERSION\n");
+ fprintf(f,"#define ANTLR_VERSION %s\n", VersionDef);
+ fprintf(f,"#endif\n\n");
+
+ if (FirstAction != NULL ) dumpAction(FirstAction, f, 0, -1, 0, 1); /* MR11 */
+
+ fprintf(f,"#include \"pcctscfg.h\"\n");
+ fprintf(f,"#include \"pccts_stdio.h\"\n");
+ if ( GenCC )
+ {
+ if ( UserDefdTokens )
+ fprintf(f, "#include %s\n", UserTokenDefsFile);
+ else {
+ fprintf(f, "#include \"%s\"\n", DefFileName);
+ }
+
+ fprintf(f, "#include \"%s\"\n", ATOKEN_H);
+
+ if ( HdrAction != NULL ) dumpAction( HdrAction, f, 0, -1, 0, 1);
+
+ fprintf(f, "#include \"%s\"\n", ATOKENBUFFER_H);
+
+ if ( OutputLL_k > 1 ) fprintf(f,"static const unsigned LL_K=%d;\n", OutputLL_k);
+ if ( GenAST ) {
+ fprintf(f, "#include \"%s\"\n", ASTBASE_H);
+ }
+
+ if (TraceGen) {
+ fprintf(f,"#ifndef zzTRACE_RULES\n"); /* MR20 */
+ fprintf(f,"#define zzTRACE_RULES\n"); /* MR20 */
+ fprintf(f,"#endif\n"); /* MR22 */
+ };
+
+ fprintf(f,"#include \"%s\"\n", APARSER_H);
+ fprintf(f,"#include \"%s.h\"\n", CurrentClassName);
+ if ( LexGen ) fprintf(f,"#include \"%s\"\n", DLEXERBASE_H);
+ fprintf(f, "#endif\n");
+ return;
+ }
+
+ if ( strcmp(ParserName, DefaultParserName)!=0 )
+ fprintf(f, "#define %s %s\n", DefaultParserName, ParserName);
+ if ( strcmp(ParserName, DefaultParserName)!=0 )
+ fprintf(f, "#include \"%s\"\n", RemapFileName);
+ if ( UserTokenDefsFile != NULL )
+ fprintf(f, "#include %s\n", UserTokenDefsFile);
+ if ( HdrAction != NULL ) dumpAction( HdrAction, f, 0, -1, 0, 1);
+ if ( FoundGuessBlk )
+ {
+ fprintf(f,"#define ZZCAN_GUESS\n");
+ fprintf(f,"#include \"pccts_setjmp.h\"\n");
+ }
+ if (TraceGen) {
+ fprintf(f,"#ifndef zzTRACE_RULES\n"); /* MR20 */
+ fprintf(f,"#define zzTRACE_RULES\n"); /* MR20 */
+ fprintf(f,"#endif\n"); /* MR22 */
+ };
+ if ( OutputLL_k > 1 ) fprintf(f,"#define LL_K %d\n", OutputLL_k);
+ if ( GenAST ) fprintf(f,"#define GENAST\n");
+ if ( FoundException )
+ {
+/* MR1 7-Apr-97 1.33MR1 */
+/* MR1 Fix suggested by: */
+/* MR1 Francois-Xavier Fontaine (fontaine_f@istvax.ist.lu) */
+
+ fprintf(f,"#define EXCEPTION_HANDLING\n"); /* MR1 */
+ fprintf(f,"#define NUM_SIGNALS %d\n", NumSignals); /* MR1 */
+ }
+ if ( DemandLookahead ) fprintf(f,"#define DEMAND_LOOK\n");
+#ifdef DUM
+ if ( LexGen ) fprintf(f, "#define zzEOF_TOKEN %d\n", (TokenInd!=NULL?TokenInd[EofToken]:EofToken));
+#endif
+ /* ###WARNING: This will have to change when SetWordSize changes */
+ fprintf(f, "#define zzSET_SIZE %d\n", NumWords(TokenNum-1)*sizeof(unsigned));
+ if (TraceGen) {
+ fprintf(f,"#ifndef zzTRACE_RULES\n"); /* MR20 */
+ fprintf(f,"#define zzTRACE_RULES\n"); /* MR20 */
+ fprintf(f,"#endif\n"); /* MR22 */
+ };
+ fprintf(f,"#include \"antlr.h\"\n");
+ if ( GenAST ) fprintf(f,"#include \"ast.h\"\n");
+ if ( UserDefdTokens )
+ fprintf(f, "#include %s\n", UserTokenDefsFile);
+ /* still need this one as it has the func prototypes */
+ fprintf(f, "#include \"%s\"\n", DefFileName);
+ /* still need this one as it defines the DLG interface */
+ fprintf(f,"#include \"dlgdef.h\"\n");
+ /* don't need this one unless DLG is used */
+ if ( LexGen ) fprintf(f,"#include \"%s\"\n", ModeFileName);
+ fprintf(f,"#endif\n");
+}
+
+/* dump action 's' to file 'output' starting at "local" tab 'tabs'
+ Dump line information in front of action if GenLineInfo is set
+ If file == -1 then GenLineInfo is ignored.
+ The user may redefine the LineInfoFormatStr to his/her liking
+ most compilers will like the default, however.
+
+ June '93; changed so that empty lines are left alone so that
+ line information is correct for the compiler/debuggers.
+*/
+void
+#ifdef __USE_PROTOS
+dumpAction( char *s, FILE *output, int tabs, int file, int line,
+int final_newline )
+#else
+dumpAction( s, output, tabs, file, line, final_newline )
+char *s;
+FILE *output;
+int tabs;
+int file;
+int line;
+int final_newline;
+#endif
+{
+ int inDQuote, inSQuote;
+ require(s!=NULL, "dumpAction: NULL action");
+ require(output!=NULL, eMsg1("dumpAction: output FILE is NULL for %s",s));
+
+ if ( GenLineInfo && file != -1 )
+ {
+ OutLineInfo(output,line,FileStr[file]);
+ }
+ PastWhiteSpace( s );
+ /* don't print a tab if first non-white char is a # (preprocessor command) */
+ if ( *s!='#' ) {TAB;}
+ inDQuote = inSQuote = FALSE;
+ while ( *s != '\0' )
+ {
+ if ( *s == '\\' )
+ {
+ fputc( *s++, output ); /* Avoid '"' Case */
+ if ( *s == '\0' ) return;
+ if ( *s == '\'' ) fputc( *s++, output );
+ if ( *s == '\"' ) fputc( *s++, output );
+ }
+ if ( *s == '\'' )
+ {
+ if ( !inDQuote ) inSQuote = !inSQuote;
+ }
+ if ( *s == '"' )
+ {
+ if ( !inSQuote ) inDQuote = !inDQuote;
+ }
+ if ( *s == '\n' )
+ {
+ fputc('\n', output);
+ s++;
+ PastWhiteSpace( s );
+ if ( *s == '}' )
+ {
+ --tabs;
+ TAB;
+ fputc( *s++, output );
+ continue;
+ }
+ if ( *s == '\0' ) return;
+ if ( *s != '#' ) /* #define, #endif etc.. start at col 1 */
+ {
+ TAB;
+ }
+ }
+ if ( *s == '}' && !(inSQuote || inDQuote) )
+ {
+ --tabs; /* Indent one fewer */
+ }
+ if ( *s == '{' && !(inSQuote || inDQuote) )
+ {
+ tabs++; /* Indent one more */
+ }
+ fputc( *s, output );
+ s++;
+ }
+ if ( final_newline ) fputc('\n', output);
+}
+
+static void
+#ifdef __USE_PROTOS
+dumpAfterActions( FILE *output )
+#else
+dumpAfterActions( output )
+FILE *output;
+#endif
+{
+ ListNode *p;
+ require(output!=NULL, "dumpAfterActions: output file was NULL for some reason");
+ if ( AfterActions != NULL )
+ {
+ for (p = AfterActions->next; p!=NULL; p=p->next)
+ {
+ UserAction *ua = (UserAction *)p->elem;
+ dumpAction( ua->action, output, 0, ua->file, ua->line, 1);
+ }
+ }
+ fclose( output );
+}
+
+/*
+ * Find the next action in the stream of execution. Do not pass
+ * junctions with more than one path leaving them.
+ * Only pass generic junctions.
+ *
+ * Scan forward while (generic junction with p2==NULL)
+ * If we stop on an action, return ptr to the action
+ * else return NULL;
+ */
+static ActionNode *
+#ifdef __USE_PROTOS
+findImmedAction( Node *q )
+#else
+findImmedAction( q )
+Node *q;
+#endif
+{
+ Junction *j;
+ require(q!=NULL, "findImmedAction: NULL node");
+ require(q->ntype>=1 && q->ntype<=NumNodeTypes, "findImmedAction: invalid node");
+
+ while ( q->ntype == nJunction )
+ {
+ j = (Junction *)q;
+ if ( j->jtype != Generic || j->p2 != NULL ) return NULL;
+ q = j->p1;
+ if ( q == NULL ) return NULL;
+ }
+ if ( q->ntype == nAction ) return (ActionNode *)q;
+ return NULL;
+}
+
+static void
+#ifdef __USE_PROTOS
+dumpRetValAssign( char *retval, char *ret_def, RuleRefNode * ruleRef /* MR30 */)
+#else
+dumpRetValAssign( retval, ret_def, ruleRef /* MR30 */)
+char *retval;
+char *ret_def;
+RuleRefNode *ruleRefNode;
+#endif
+{
+ char *q = ret_def;
+
+ tab();
+ while ( *retval != '\0' && *q != '\0')
+ {
+ while ( isspace((*retval)) ) retval++;
+ while ( *retval!=',' && *retval!='\0' ) fputc(*retval++, output);
+ fprintf(output, " = _trv.");
+
+ DumpNextNameInDef(&q, output);
+ while ( isspace(*q) ) q++;
+ fputc(';', output); fputc(' ', output);
+ if ( *retval == ',' ) retval++;
+ }
+ if (*retval == '\0' && *q != '\0') {
+/* MR30 */ errFL("Fewer output values than output formals for rule reference",
+/* MR30 */ FileStr[ruleRef->file],ruleRef->line);
+ }
+ if (*retval != '\0' && *q == '\0') {
+/* MR30 */ errFL("More output actuals than output formals for rule reference",
+/* MR30 */ FileStr[ruleRef->file],ruleRef->line);
+ }
+}
+
+/* This function computes the set of tokens that can possibly be seen k
+ * tokens in the future from point j
+ */
+
+static set
+#ifdef __USE_PROTOS
+ComputeErrorSet( Junction *j, int k, int usePlusBlockBypass)
+#else
+ComputeErrorSet( j, k, usePlusBlockBypass )
+Junction *j;
+int k;
+int usePlusBlockBypass;
+#endif
+{
+ Junction *alt1;
+ set a, rk, f;
+ require(j->ntype==nJunction, "ComputeErrorSet: non junction passed");
+
+ f = rk = empty;
+ for (alt1=j; alt1!=NULL; alt1 = (Junction *)alt1->p2)
+ {
+ if (alt1->ignore && ! usePlusBlockBypass) continue; /* MR21 - Ignore aPlusBlk forward p2 */
+ REACH(alt1->p1, k, &rk, a);
+ require(set_nil(rk), "ComputeErrorSet: rk != nil");
+ set_free(rk);
+ set_orin(&f, a);
+ set_free(a);
+ }
+ return f;
+}
+
+static char *
+#ifdef __USE_PROTOS
+tokenFollowSet(TokNode *p)
+#else
+tokenFollowSet(p)
+TokNode *p;
+#endif
+{
+ static char buf[100];
+ set rk, a;
+ int n;
+ rk = empty;
+
+ REACH(p->next, 1, &rk, a);
+ require(set_nil(rk), "rk != nil");
+ set_free(rk);
+ n = DefErrSet( &a, 0, NULL );
+ set_free(a);
+ if ( GenCC )
+ sprintf(buf, "err%d", n);
+ else
+ sprintf(buf, "zzerr%d", n);
+ return buf;
+}
+
+static void
+#ifdef __USE_PROTOS
+makeErrorClause( Junction *q, set f, int max_k, int usePlusBlockBypass )
+#else
+makeErrorClause( q, f, max_k, usePlusBlockBypass )
+Junction *q;
+set f;
+int max_k;
+int usePlusBlockBypass;
+#endif
+{
+ char * handler_id=""; /* MR7 */
+ int nilf=0; /* MR13 */
+ RuleEntry *ruleEntry; /* MR14 */
+
+ if ( FoundException )
+ {
+ _gen("else {\n");
+ tabs++;
+ if ( FoundGuessBlk )
+ {
+ if ( GenCC ) {gen("if ( guessing ) goto fail;\n");}
+ else gen("if ( zzguessing ) goto fail;\n");
+ }
+ gen("if (_sva) _signal=NoViableAlt;\n");
+ gen("else _signal=NoSemViableAlt;\n");
+ if (q->outerEG != NULL) {
+ handler_id=q->outerEG->altID;
+#if 0
+ } else {
+ printf("q->curAltNum=%d q->exception_label=%s\n",q->curAltNum,q->exception_label);
+ gen("*** DEBUG *** outerEG==NULL\n");
+#endif
+ };
+ gen1("goto %s_handler; /* MR7 */\n",handler_id); /* MR7 */
+ tabs--;
+ gen("}\n");
+ return;
+ }
+
+ if ( max_k == 1 )
+ {
+/* MR13 */ nilf=set_nil(f);
+ if ( GenCC ) {
+ _gen1("else {FAIL(1,err%d", DefErrSet1(1,&f,1,NULL));
+ } else {
+ _gen1("else {zzFAIL(1,zzerr%d", DefErrSet1(1,&f,1,NULL));
+ };
+ set_free(f);
+ }
+ else
+ {
+ int i;
+ set_free(f);
+ if ( GenCC ) {_gen1("else {FAIL(%d", max_k);}
+ else _gen1("else {zzFAIL(%d", max_k);
+
+ ruleEntry = (RuleEntry *) hash_get(Rname,q->rname);
+
+ for (i=1; i<=max_k; i++)
+ {
+/* MR14 */ if (ruleEntry->dontComputeErrorSet) {
+/* MR14 */ f=empty;
+ } else {
+ f = ComputeErrorSet(q, i, usePlusBlockBypass /* use plus block bypass ? */ );
+ }
+
+ if ( GenCC ) {_gen1(",err%d", DefErrSet( &f, 1, NULL ));}
+ else _gen1(",zzerr%d", DefErrSet( &f, 1, NULL ));
+
+ set_free(f);
+ }
+ }
+ _gen(",&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}\n");
+/* MR13 */ if (nilf) {
+/* MR13 */ errFL("empty error set for alt - probably because of undefined rule or infinite left recursion",
+/* MR13 */ FileStr[q->file],q->line);
+/* MR13 */ gen(" /* MR13 empty error set for this alt - undef rule ? infinite left recursion ? */");
+/* MR13 */ };
+}
+
+static /* MR7 */
+#ifdef __USE_PROTOS
+char * findOuterHandlerLabel(ExceptionGroup *eg) /* MR7 */
+#else
+char * findOuterHandlerLabel(eg) /* MR7 */
+ExceptionGroup *eg; /* MR7 */
+#endif
+{
+ char *label=NULL; /* MR7 */
+ ExceptionGroup *outerEG; /* MR7 */
+
+ if (eg->forRule == 0) { /* MR7 */
+ if (eg->labelEntry != NULL) { /* MR7 */
+ outerEG=eg->labelEntry->outerEG; /* MR7 */
+ if (outerEG != NULL) { /* MR7 */
+ label=outerEG->altID; /* MR7 */
+ outerEG->used=1; /* MR7 */
+ }; /* MR7 */
+ } else if (eg->outerEG != NULL) { /* MR7 */
+ outerEG=eg->outerEG; /* MR7 */
+ label=outerEG->altID; /* MR7 */
+ outerEG->used=1; /* MR7 */
+ }; /* MR7 */
+ }; /* MR7 */
+ return (label==NULL ? "" : label); /* MR7 */
+} /* MR7 */
+
+/*** debug ***/
+#if 0
+** static /* MR7 */
+** #ifdef __USE_PROTOS
+** char * findOuterAltHandlerLabel(Junction *startJ) /* MR7 */
+** #else
+** char * findOuterAltHandlerLabel(startJ) /* MR7 */
+** Junction *startJ; /* MR7 */
+** #endif
+** { /* MR7 */
+** char *label=NULL; /* MR7 */
+** Junction *alt; /* MR7 */
+** /* MR7 */
+** for (alt=startJ; alt != NULL; alt=alt->outerAltstart) { /* MR7 */
+** label=alt->exception_label; /* MR7 */
+** if (label != NULL) break; /* MR7 */
+** }; /* MR7 */
+** return (label==NULL ? "" : label); /* MR7 */
+** } /* MR7 */
+#endif
+
+#ifdef __USE_PROTOS
+static void OutLineInfo(FILE *file,int line,char *fileName)
+#else
+static void OutLineInfo(file,line,fileName)
+ FILE * file;
+ int line;
+ char * fileName;
+#endif
+{
+ static char * prevFileName=NULL;
+ static char * prevFileNameMS=NULL;
+
+ char * p;
+ char * q;
+
+ if (! GenLineInfo) return;
+
+ if (!GenLineInfoMS) {
+ fprintf(file, LineInfoFormatStr,line,fileName);
+ } else {
+ if (fileName == prevFileName) {
+ fprintf(file, LineInfoFormatStr,line,prevFileNameMS);
+ } else {
+ if (prevFileNameMS != NULL) free (prevFileNameMS);
+ prevFileNameMS=(char *)calloc(1,strlen(fileName)+1);
+ require(prevFileNameMS != NULL,"why not do this in calloc wrapper");
+ q=prevFileNameMS;
+ for (p=fileName; *p != 0; p++) {
+ *q=*p;
+ if (*q == '\\') *q='/';
+ q++;
+ }
+ }
+ prevFileName=fileName;
+ };
+}
+
+#if 0
+
+/* MR21 */
+
+#ifdef __USE_PROTOS
+void OutFirstSetSymbol(Junction *q, char * pSymbol)
+#else
+void OutFirstSetSymbol(q, pSymbol)
+ Junction* q;
+ char * pSymbol
+#endif
+{
+
+ set f;
+ if (pSymbol == NULL) return;
+ gen1("/** #FirstSetSymbol(%s) **/\n",pSymbol);
+ f = ComputeErrorSet(q, 1, 0 /* use plus block bypass ? */);
+ DefErrSetWithSuffix (0 /* nil ok */, &f,0 /* no substitute */, pSymbol, "");
+ set_free(f);
+}
+#endif
+
+/* MR21 */
+
+#ifdef __USE_PROTOS
+void BlockPreambleOption(Junction *q, char * pSymbol)
+#else
+void BlockPreambleOption(q, pSymbol)
+ Junction* q;
+ char * pSymbol;
+#endif
+{
+ set f = empty;
+ if (pSymbol != NULL) {
+ f = ComputeErrorSet(q, 1, 0 /* use plus block bypass ? */);
+ gen1("/** #FirstSetSymbol(%s) **/\n",pSymbol);
+ DefErrSetWithSuffix (0 /* nil ok */, &f,0 /* no substitute */, pSymbol, "");
+ }
+ set_free(f);
+}
+
+/* MR21 */
+
+void
+#ifdef __USE_PROTOS
+dumpActionPlus(ActionNode *a, char *s, FILE *output, int tabs, int file, int line,
+int final_newline )
+#else
+dumpActionPlus(a, s, output, tabs, file, line, final_newline )
+ActionNode *a;
+char *s;
+FILE *output;
+int tabs;
+int file;
+int line;
+int final_newline;
+#endif
+{
+ dumpAction(s,output,tabs,file,line,final_newline);
+}
+
+
+#if 0
+** #ifdef __USE_PROTOS
+** void MR_ErrorSets(Junction *q, int max_k, int usePlusBlockBypass)
+** #else
+** void MR_ErrorSets(q, max_k, usePlusBlockBypass)
+** Junction *q;
+** int max_k;
+** int usePlusBlockBypass;
+** #endif
+** {
+** int k;
+** set setResult;
+** Junction* alt1;
+** Junction* p;
+** set rk;
+**
+** require (max_k <= CLL_k, "k > CLL_k");
+**
+**
+** for (k = 1; k <= CLL_k; k++) {set_clr(q->fset[k]); }
+**
+** for (k = 1; k <= max_k; k++) {
+** for (alt1=q; alt1 != NULL; alt1 = (Junction *)alt1->p2)
+** {
+** if (alt1->ignore && ! usePlusBlockBypass) continue;
+** p = analysis_point((Junction *)alt1->p1);
+** REACH(p, k, &rk, setResult);
+** require(set_nil(rk), "rk != nil");
+** set_orin(&q->fset[k], setResult);
+** }
+** }
+** }
+#endif
+
+
+#ifdef __USE_PROTOS
+void DumpInitializers(FILE* output, RuleEntry *r, char * pReturn)
+#else
+void DumpInitializers(output, r, pReturn)
+FILE* output;
+RuleEntry *r;
+char * pReturn;
+#endif
+{
+ char *p = pReturn;
+ char *pDataType;
+ char *pSymbol;
+ char *pEqualSign;
+ char *pValue;
+ char *pSeparator;
+ int nest = 0;
+ char *q;
+
+ require(pReturn!=NULL, "DumpInitializer: invalid string");
+
+ while (*p != 0) {
+ p = endFormal(p,
+ &pDataType,
+ &pSymbol,
+ &pEqualSign,
+ &pValue,
+ &pSeparator,
+ &nest);
+ if (nest != 0) return;
+ if (pValue != NULL) {
+ tab();
+ q = strBetween(pSymbol, pEqualSign, pSeparator);
+ fprintf(output, "_retv.%s", q);
+ q = strBetween(pValue, NULL, pSeparator);
+ fprintf(output, " = %s;\n", q);
+ }
+ }
+}
+
+#ifdef __USE_PROTOS
+void DumpFormals(FILE* output, char * pReturn, int bInitializer)
+#else
+void DumpFormals(output, pReturn, bInitializer)
+FILE* output;
+char * pReturn;
+int bInitializer;
+#endif
+{
+ char *p = pReturn;
+ char *pDataType;
+ char *pSymbol;
+ char *pEqualSign;
+ char *pValue;
+ char *pSeparator;
+ int nest = 0;
+ char *q;
+ int count = 0;
+
+ require(pReturn!=NULL, "DumpFormals: invalid string");
+
+ while (*p != 0) {
+ p = endFormal(p,
+ &pDataType,
+ &pSymbol,
+ &pEqualSign,
+ &pValue,
+ &pSeparator,
+ &nest);
+ if (nest != 0) return;
+ if (count > 0) fprintf(output,",");
+ if (pDataType != NULL && pSymbol != NULL) {
+ q = strBetween(pDataType, pSymbol, pSeparator);
+ fprintf(output, "%s", q);
+ q = strBetween(pSymbol, pEqualSign, pSeparator);
+ fprintf(output," %s",q);
+ if (pValue != NULL) {
+ q = strBetween(pValue, NULL, pSeparator);
+ if (bInitializer != 0) {
+ fprintf(output, " = %s", q);
+ }
+ }
+ }
+ count++;
+ }
+}
+
+/* MR23 Check for empty alt in a more intelligent way.
+ Previously, an empty alt for genBlk had to point directly
+ to the endBlock. This did not work once I changed {...}
+ blocks to look like (...|...| epsilon) since there were
+ intervening generics. This fixes the problem for this
+ particular case. Things like actions or empty blocks of
+ various kinds will still cause problems, but I wasnt't
+ prepared to handle pathological cases like (A|()*). It
+ does handle (A | ()), which is a recommended idiom for
+ epsilon.
+
+ Actually, this isn't quite correct since it doesn't handle
+ the case of the ignore bit in the plus block bypass, but
+ I'm too tired to figure out the correct fix, and will just
+ work around it.
+*/
+
+#ifdef __USE_PROTOS
+int isEmptyAlt(Node * alt, Node * endBlock)
+#else
+int isEmptyAlt(alt, endBlock)
+Node * alt;
+Node * endBlock;
+#endif
+{
+ Node * n = alt;
+ Junction * j;
+ while (n != endBlock) {
+ switch (n->ntype) {
+
+ case nRuleRef:
+ return 0;
+
+ case nToken:
+ return 0;
+
+ case nAction:
+ return 0;
+
+ case nJunction:
+ goto JUNCTION;
+
+ default:
+ fatal_internal("Invalid node type");
+ return 0;
+ }
+JUNCTION:
+ j = (Junction *) n;
+
+ switch (j->jtype) {
+ case Generic:
+ {
+ n = j->p1;
+ goto NEXT;
+ }
+
+ case aSubBlk:
+ {
+ n = j->p1; /* MR26 */
+ goto NEXT; /* MR26 */
+ }
+
+ case EndBlk:
+ return 0;
+
+ case EndRule:
+ return 1;
+
+ default:
+ return 0;
+ }
+NEXT: continue;
+ }
+ return 1;
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/generic.h b/BaseTools/Source/C/VfrCompile/Pccts/antlr/generic.h new file mode 100644 index 0000000000..8d736d5200 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/generic.h @@ -0,0 +1,286 @@ +/*
+ * generic.h -- generic include stuff for new PCCTS ANTLR.
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2001
+ */
+
+#define StrSame 0
+
+#define DefaultParserName "zzparser"
+
+/* MR9 JVincent@novell.com Allow user to override default ZZLEXBUFSIZE */
+/* MR11 thm Raise antlr's own default ZZLEXBUFSIZE to 8k */
+/* MR22 thm Raise antlr's own default ZZLEXBUFSIZE to 32k */
+
+#ifndef ZZLEXBUFSIZE
+#define ZZLEXBUFSIZE 32000
+#endif
+
+/* Tree/FIRST/FOLLOW defines -- valid only after all grammar has been read */
+#define ALT TokenNum+1
+#define SET TokenNum+2
+#define TREE_REF TokenNum+3
+
+ /* E r r o r M a c r o s */
+
+#define fatal(err) fatalFL(err, __FILE__, __LINE__)
+#define fatal_internal(err) fatal_intern(err, __FILE__, __LINE__)
+
+
+#define eMsg1(s,a) eMsg3(s,a,NULL,NULL)
+#define eMsg2(s,a,b) eMsg3(s,a,b,NULL)
+
+ /* S a n i t y C h e c k i n g */
+
+#ifndef require
+#define require(expr, err) {if ( !(expr) ) fatal_internal(err);}
+#endif
+
+ /* L i s t N o d e s */
+
+typedef struct _ListNode {
+ void *elem; /* pointer to any kind of element */
+ struct _ListNode *next;
+ } ListNode;
+
+/* Define a Cycle node which is used to track lists of cycles for later
+ * reconciliation by ResolveFoCycles().
+ */
+typedef struct _c {
+ int croot; /* cycle root */
+ set cyclicDep; /* cyclic dependents */
+ unsigned deg; /* degree of FOLLOW set of croot */
+ } Cycle;
+
+typedef struct _e {
+ int tok; /* error class name == TokenStr[tok] */
+ ListNode *elist; /* linked list of elements in error set */
+ set eset;
+ int setdeg; /* how big is the set */
+ int lexclass; /* which lex class is it in? */
+ } ECnode;
+
+typedef struct _TCnode {
+ int tok; /* token class name */
+ ListNode *tlist; /* linked list of elements in token set */
+ set tset;
+ int lexclass; /* which lex class is it in? */
+ unsigned char dumped; /* this def has been been dumped */
+ unsigned char dumpedComplement; /* this def has been been dumped */
+ unsigned setnum; /* which set number is this guy? (if dumped) */
+ unsigned setnumComplement; /* MR23 */
+ unsigned setnumErrSet; /* MR23 which set is this #tokclass error set (if dumped) */
+ unsigned setnumErrSetComplement; /* MR23 */
+ } TCnode;
+
+typedef struct _ft {
+ char *token; /* id of token type to remap */
+ int tnum; /* move token type to which token position */
+ } ForcedToken;
+
+typedef struct _ContextGuardPredicates { /* MR13 */
+ Predicate *pred; /* MR13 */
+ } ContextGuardPredicates; /* MR13 */
+
+#define newListNode (ListNode *) calloc(1, sizeof(ListNode));
+#define newCycle (Cycle *) calloc(1, sizeof(Cycle));
+#define newECnode (ECnode *) calloc(1, sizeof(ECnode));
+#define newTCnode (TCnode *) calloc(1, sizeof(TCnode));
+
+
+ /* H a s h T a b l e E n t r i e s */
+
+typedef struct _t { /* Token name or expression */
+ char *str;
+ struct _t *next;
+ int token; /* token number */
+ unsigned char classname; /* is it a err/tok class name or token */
+ TCnode *tclass; /* ptr to token class */
+ char *action;
+ char *akaString;
+ } TermEntry;
+
+typedef struct _r { /* Rule name and ptr to start of rule */
+ char *str;
+ struct _t *next;
+ int rulenum; /* RulePtr[rulenum]== ptr to RuleBlk junction */
+ unsigned char noAST;/* gen AST construction code? (def==gen code) */
+ char *egroup; /* which error group (err reporting stuff) */
+#if 0
+ /* MR27 This appears to never be used. Delete this code later. */
+
+ ListNode *el_labels;/* list of element labels ref in all of rule */
+#endif
+ ListNode *ast_labels_in_actions; /* MR27 */
+ unsigned char has_rule_exception;
+ char dontComputeErrorSet; /* MR14 - don't compute error set
+ special for rule in alpha part of
+ (alpha)? beta block */
+ } RuleEntry;
+
+typedef struct _f { /* cache Fi/Fo set */
+ char *str; /* key == (rulename, computation, k) */
+ struct _f *next;
+ set fset; /* First/Follow of rule */
+ set rk; /* set of k's remaining to be done after ruleref */
+ int incomplete; /* only w/FOLLOW sets. Use only if complete */
+ } CacheEntry;
+
+typedef struct _LabelEntry { /* element labels */
+ char *str;
+ struct _f *next;
+ Node *elem; /* which element does it point to? */
+ ExceptionGroup *ex_group;
+ /* Is there an exception attached to label? */
+ ExceptionGroup *outerEG; /* MR7 */
+ /* next EG if ex_group doesn't catch it MR7 */
+ struct _LabelEntry *pendingLink; /* MR7 */
+ /* too lazy to use ListNode ? MR7 */
+ int curAltNum; /* MR7 */
+ } LabelEntry;
+
+typedef struct _SignalEntry {
+ char *str;
+ struct _f *next;
+ int signum; /* unique signal number */
+ } SignalEntry;
+
+typedef struct _PredEntry { /* MR11 predicate name and ptr to string */
+ char *str;
+ struct _PredEntry *next;
+ int file;
+ int line;
+ Predicate *pred;
+ char *predLiteral;
+ } PredEntry;
+
+typedef struct _PointerStack { /* MR10 */
+ int count;
+ int size;
+ void **data;
+ } PointerStack;
+
+#define newTermEntry(s) (TermEntry *) newEntry(s, sizeof(TermEntry))
+#define newRuleEntry(s) (RuleEntry *) newEntry(s, sizeof(RuleEntry))
+#define newCacheEntry(s) (CacheEntry *) newEntry(s, sizeof(CacheEntry))
+#define newLabelEntry(s) (LabelEntry *) newEntry(s, sizeof(LabelEntry))
+#define newSignalEntry(s) (SignalEntry *) newEntry(s, sizeof(SignalEntry))
+#define newPredEntry(s) (PredEntry *) newEntry(s,sizeof(PredEntry))
+
+typedef struct _UserAction {
+ char *action;
+ int file, line;
+ } UserAction;
+
+
+ /* L e x i c a l C l a s s */
+
+/* to switch lex classes, switch ExprStr and Texpr (hash table) */
+typedef struct _lc {
+ char *classnum, **exprs;
+ Entry **htable;
+ } LClass;
+
+typedef struct _exprOrder {
+ char *expr;
+ int lclass;
+ } Expr;
+
+
+typedef Graph Attrib;
+
+ /* M a x i m u m s */
+
+/* MR20 Note G. Hobbelt These values are superceded by values in hash.h */
+
+#ifndef HashTableSize
+#define HashTableSize 253
+#endif
+#ifndef StrTableSize
+#define StrTableSize 15000 /* all tokens, nonterminals, rexprs stored here */
+#endif
+#define MaxLexClasses 50 /* how many automatons */
+/* TokenStart and EofToken are ignored if #tokdefs meta-op is used */
+#define TokenStart 2 /* MUST be in 1 + EofToken */
+#define EofToken 1 /* Always predefined to be 1 */
+
+#ifndef MaxNumFiles
+#define MaxNumFiles 99
+#endif
+
+/**** MR9 JVincent@novell.com Move to pcctscfg.h */
+/**** #define MaxFileName 300 ****/ /* MR9 Move to pcctscfg.h */ /* largest file name size */
+
+#define MaxRuleName 100 /* largest rule name size */
+#define TSChunk 100 /* how much to expand TokenStr/ExprStr each time */
+#define TIChunk TSChunk /* expand TokenInd by same as TokenStr to mirror them */
+#define FoStackSize 100 /* deepest FOLLOW recursion possible */
+
+#define MaxClassDeclStuff 256 /* MR10 */
+
+#define NumPredefinedSignals 3
+
+ /* S t a n d a r d S i g n a l s */
+
+#define sigNoSignal 0
+#define sigMismatchedToken 1
+#define sigNoViableAlt 2
+#define sigNoSemViableAlt 3
+
+
+
+/* AST token types */
+#define ASTexclude 0
+#define ASTchild 1
+#define ASTroot 2
+#define ASTinclude 3 /* include subtree made by rule ref */
+
+
+#define PredictionVariable "zzpr_expr"
+#define PredictionLexClassSuffix "_zzpred"
+
+#define WildCardString "WildCard"
+
+#if 0
+ /* Removed in version 1.33MR19
+ Don't understand why this never caused problems before
+ */
+
+ /*********************************************************
+ #ifndef ANTLRm
+ #define ANTLRm(st, f, _m) zzbufsize = ZZLEXBUFSIZE;\
+ zzmode(_m); \
+ zzenterANTLR(f); \
+ st; ++zzasp; \
+ zzleaveANTLR(f);
+ #endif
+ *********************************************************/
+#endif
+
+#include "proto.h"
+#include "pcctscfg.h" /* MR14 */
+#include <string.h>
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/globals.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/globals.c new file mode 100644 index 0000000000..59d00320a0 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/globals.c @@ -0,0 +1,484 @@ +/*
+ * globals.c -- File containing all variables/tables visible to all files.
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2001
+ */
+
+#include <stdio.h>
+
+#include "pcctscfg.h"
+
+#include "set.h"
+#include "syn.h"
+#include "hash.h"
+#include "generic.h"
+
+char Version[] = "1.33MR33" ; /* PCCTS version number */ /* MRXXX */
+char VersionDef[] = "13333"; /* same (except int equiv for preproc symbol) */ /* MRXXX */
+
+char LexStartSymbol[] = "START";/* Name of starting lexical class/automaton */
+char *RemapFileName = "remap.h";
+char *DlgFileName = "parser.dlg";
+char *DefFileName = "tokens.h";
+char *ErrFileName = "err.c";
+char *ModeFileName = "mode.h";
+char *StdMsgName = NULL;
+
+char *ParserName = DefaultParserName;
+
+/* list of PCCTS supplied support symbols; these are renamed when more than
+ * one ANTLR-generated parsers are linked together to avoid name conflicts.
+ * Can't use '##' ANSIC preprocessor concat operator with K&R and:
+ * #define zzskip zzparser ## skip
+ * will not work for ANSI/C++ as 'zzparserskip' is created w/o zzparser
+ * being substituted--ack!!!
+ */
+char *StandardSymbols[] = {
+/* ANTLR stuff */
+ "zzStackOvfMsg",
+ "zzasp",
+ "zzaStack",
+ "inf_tokens",
+ "inf_text",
+ "inf_text_buffer",
+ "inf_text_buffer_ptr",
+ "inf_text_buffer_size",
+ "inf_labase",
+ "inf_last",
+ "inf_lap",
+ "zztokenLA",
+ "zztextLA",
+ "zzlap",
+ "zzlabase",
+ "zztoktext",
+ "zztoken",
+ "zzdirty",
+ "zzguessing",
+ "zzguess_start",
+ "zzresynch",
+ "zzinf_tokens",
+ "zzinf_text",
+ "zzinf_text_buffer",
+ "zzinf_labase",
+ "zzinf_last",
+ "zzfill_inf_look",
+ "zzFAIL",
+ "zzsave_antlr_state",
+ "zzrestore_antlr_state",
+ "zzsyn",
+ "zzset_el",
+ "zzset_deg",
+ "zzedecode",
+ "_zzsetmatch",
+ "_zzmatch",
+ "_inf_zzgettok",
+ "zzconsumeUntil",
+ "zzconsumeUntilToken",
+ "_zzmatch_wsig",
+ "_zzsetmatch_wsig",
+ "_zzmatch_wdfltsig",
+ "_zzsetmatch_wdfltsig",
+ "zzdflthandlers",
+/* DLG stuff */
+ "zzreal_line",
+ "zzcharfull",
+ "zzerr",
+ "zzlextext",
+ "zzbegexpr",
+ "zzendexpr",
+ "zzbufsize",
+ "zzbegcol",
+ "zzendcol",
+ "zzline",
+ "zzchar",
+ "zzbufovf",
+ "zzrdstream",
+ "zzrdfunc",
+ "zzrdstr",
+ "zzclose_stream",
+ "zzsave_dlg_state",
+ "zzrestore_dlg_state",
+ "zzmode",
+ "zzskip",
+ "zzmore",
+ "zzreplchar",
+ "zzreplstr",
+ "zzgettok",
+ "zzadvance",
+ "zzerrstd",
+ "zzerr_in",
+ "zzconstr_attr",
+ "zzempty_attr",
+ "zzerraction",
+ "zztokens", /* list of token regular expressions */
+ "dfa",
+ "accepts",
+ "actions",
+ "zzTraceOptionValue", /* MR10 */
+ "zzTraceGuessOptionValue", /* MR10 */
+ "zzTraceCurrentRuleName", /* MR10 */
+ "zzTraceDepth", /* MR10 */
+ "zzGuessSeq", /* MR10 */
+ "zzSyntaxErrCount", /* MR11 */
+ "zzLexErrCount", /* MR11 */
+ "zzTraceGuessDone", /* MR13 - BJS */
+ "zzTraceGuessFail", /* MR13 - BJS */
+ "zzTraceGuessOption", /* MR13 - BJS */
+ "zzTraceIn", /* MR13 - BJS */
+ "zzTraceOption", /* MR13 - BJS */
+ "zzTraceOut", /* MR13 - BJS */
+ "zzTraceReset", /* MR13 - BJS */
+ NULL /* must be present */
+};
+
+/* list of PCCTS supplied support functions; these are renamed when more than
+ * one ANTLR-generated parsers are linked together to avoid name conflicts.
+ */
+char *ASTSymbols[] = {
+ "AST",
+ "zzast_sp",
+ "zzastStack",
+ "zzlink",
+ "zzastnew",
+ "zzsubchild",
+ "zzsubroot",
+ "zzpre_ast",
+ "zzfree_ast",
+ "zztmake",
+ "zzdup_ast",
+ "zztfree",
+ "zzdouble_link",
+ NULL /* must be present */
+};
+
+/* Current ambiguity examination information */
+int CurAmbigAlt1, CurAmbigAlt2, CurAmbigline, CurAmbigfile;
+char *CurAmbigbtype;
+
+
+ /* M e t h o d T a b l e s */
+/*
+ * The following tables are used to fill syntax diagram nodes with the correct
+ * function pointers for computing FIRST sets and printing themselves.
+ */
+
+/* fpTraverse[node type] == pointer to function that calculates trees
+ * representing the FIRST sets for that node (maintains spatial info).
+ * We use 'struct _tree' not 'tree' due to a g++ 2.4.3 bug.
+ */
+#ifdef __cplusplus
+struct _tree *(*fpTraverse[NumNodeTypes+1])(... /* Node *, int, set * */) = {
+ NULL,
+ (struct _tree *(*)(...)) tJunc,
+ (struct _tree *(*)(...)) tRuleRef,
+ (struct _tree *(*)(...)) tToken,
+ (struct _tree *(*)(...)) tAction
+};
+#else
+Tree *(*fpTraverse[NumNodeTypes+1])() = {
+ NULL,
+ tJunc,
+ tRuleRef,
+ tToken,
+ tAction
+};
+#endif
+
+/* fpReach[node type] == pointer to function that calculates FIRST set for
+ * that node. (r stands for reach). We use 'struct _set' not 'set'
+ * due to a g++ 2.4.3 bug.
+ */
+#ifdef __cplusplus
+struct _set (*fpReach[NumNodeTypes+1])(... /* Node *, int, set * */) = {
+ NULL,
+ (struct _set (*)(...)) rJunc,
+ (struct _set (*)(...)) rRuleRef,
+ (struct _set (*)(...)) rToken,
+ (struct _set (*)(...)) rAction
+};
+#else
+set (*fpReach[NumNodeTypes+1])() = {
+ NULL,
+ rJunc,
+ rRuleRef,
+ rToken,
+ rAction
+};
+#endif
+
+/* fpPrint[node type] == pointer to function that knows how to print that node. */
+#ifdef __cplusplus
+void (*fpPrint[NumNodeTypes+1])(... /* Node * */) = {
+ NULL,
+ (void (*)(...)) pJunc,
+ (void (*)(...)) pRuleRef,
+ (void (*)(...)) pToken,
+ (void (*)(...)) pAction
+};
+#else
+void (*fpPrint[NumNodeTypes+1])() = {
+ NULL,
+ pJunc,
+ pRuleRef,
+ pToken,
+ pAction
+};
+#endif
+
+char *decodeJType[] = {
+ "invalid",
+ "aSubBlk",
+ "aOptBlk",
+ "aLoopBlk",
+ "EndBlk",
+ "RuleBlk",
+ "Generic",
+ "EndRule",
+ "aPlusBlk",
+ "aLoopBegin"
+};
+
+
+ /* H a s h T a b l e s */
+
+Entry **Tname, /* Table of all token names (maps name to tok num)*/
+ **Texpr, /* Table of all token expressions
+ (maps expr to tok num) */
+ **Rname, /* Table of all Rules (has ptr to start of rule) */
+ **Fcache, /* Cache of First/Follow Computations */
+ **Tcache; /* Tree cache; First/Follow for permute trees */
+Entry **Elabel; /* Table of all element label names */
+Entry **Sname; /* Signal names */
+Entry **Pname; /* symbolic predicate names MR11 */
+
+
+ /* V a r i a b l e s */
+
+int Save_argc; /* MR10 */
+char **Save_argv; /* MR10 */
+int EpToken=0; /* Imaginary Epsilon token number */
+int WildCardToken=0;
+int CurFile= -1; /* Index into FileStr table */
+char *CurPredName=NULL; /* MR11 */
+char *CurRule=NULL; /* Pointer to current rule name */
+int CurRuleDebug=0; /* MR13 debug flag */
+RuleEntry *CurRuleNode=NULL;/* Pointer to current rule node in syntax tree */
+char *CurRetDef=NULL; /* Pointer to current return type definition */
+char *CurParmDef=NULL; /* Pointer to current parameter definition */
+Junction *CurRuleBlk=NULL; /* Pointer to current block node for enclosing block */
+ListNode *CurExGroups=NULL; /* Current list of exception groups for rule/alts */
+ListNode *CurElementLabels=NULL;
+ListNode *CurAstLabelsInActions=NULL; /* MR27 */
+
+/* MR10 used by <<>>? to set "label_used_in_semantic_pred" */
+/* MR10 this will force LT(i) assignment even in guess mode */
+
+ListNode *CurActionLabels=NULL; /* MR10 Element Labels appearing in last action */
+int numericActionLabel=0 ; /* MR10 << ... $1 ... >> or << ... $1 ... >>? */
+ListNode *NumericPredLabels=NULL; /* MR10 << ... $1 ... >>? ONLY */
+ListNode *ContextGuardPredicateList=NULL; /* MR13 for re-evaluating predicates
+ after meta tokens are defined */
+
+int CurBlockID=0; /* Unique int for each block */
+int CurAltNum=0;
+Junction *CurAltStart = NULL; /* Junction node that starts the alt */
+Junction *OuterAltStart = NULL; /* For chaining exception groups MR7 */
+int NumRules=0; /* Rules are from 1 to n */
+FILE *output=NULL; /* current parser output file */
+FILE *input=NULL; /* current grammar input file */
+char *FileStr[MaxNumFiles];/* Ptr to array of file names on command-line */
+int NumFiles=0; /* current grammar file number */
+#ifdef __cplusplus
+void (**fpTrans)(...), /* array of ptrs to funcs that translate nodes */
+ (**fpJTrans)(...); /* ... that translate junctions */
+#else
+void (**fpTrans)(), /* array of ptrs to funcs that translate nodes */
+ (**fpJTrans)(); /* ... that translate junctions */
+#endif
+int **FoStack; /* Array of LL_k ptrs to stacks of rule numbers */
+int **FoTOS; /* FOLLOW stack top-of-stack pointers */
+Junction *SynDiag = NULL; /* Pointer to start of syntax diagram */
+int BlkLevel=1; /* Current block level. Set by antlr.g, used by
+ * scanner to translate $i.j attributes */
+set reserved_positions; /* set of token positions reserved by '#token T=i' cmds */
+set all_tokens; /* set of all token types */
+set imag_tokens; /* set of all imaginary token types (EpToken, errclasses...) */
+set tokclasses; /* set of all token class token types */
+ListNode *ForcedTokens = 0; /* list of token_id/token_num pairs to remap */
+ListNode *MetaTokenNodes=NULL; /* list of meta token refs such as token classes etc... */
+int *TokenInd=NULL; /* an indirection level between token num and position
+ * of that token def in TokenStr and ExprStr */
+int LastTokenCounted=0; /* ==TokenNum if no token renumbering (same as old TokenNum) */
+int TokenNum=TokenStart;
+char **TokenStr=NULL; /* map token # to token name */
+char **ExprStr=NULL; /* map token # to expr */
+Junction **RulePtr=NULL; /* map rule # to RuleBlk node of rule */
+ListNode *ExprOrder=NULL; /* list of exprs as they are found in grammar */
+ListNode *BeforeActions=NULL;/* list of grammar actions before rules */
+ListNode *AfterActions=NULL;/* list of grammar actions after rules */
+ListNode *LexActions=NULL; /* list of lexical actions */
+
+/* MR1 */
+/* MR1 11-Apr-97 Provide mechanism for inserting code into DLG class */
+/* MR1 via #lexmember <<....>> */
+/* MR1 via #lexprefix <<....>> */
+/* MR1 */
+
+ListNode *LexMemberActions=NULL;/* list of lexical header member decl MR1 */
+ListNode *LexPrefixActions=NULL;/* list of lexical header #include decl MR1 */
+ListNode **Cycles=NULL; /* list of cycles (for each k) found when
+ doing FOLLOWs */
+ListNode *eclasses=NULL; /* list of error classes */
+ListNode *tclasses=NULL; /* list of token classes */
+LClass lclass[MaxLexClasses]; /* array of lex class definitions */
+int CurrentLexClass; /* index into lclass */
+int NumLexClasses=0; /* in range 1..MaxLexClasses (init 0) */
+
+char *HdrAction=NULL; /* action defined with #header */
+char *FirstAction=NULL; /* action defined with #first MR11 */
+FILE *ErrFile; /* sets and error recovery stuff */
+FILE *DefFile=NULL; /* list of tokens, return value structs, setwd defs */
+FILE *MRinfoFile=NULL; /* MR10 information file */
+int MRinfo=0; /* MR10 */
+int MRinfoSeq=0; /* MR10 */
+int InfoP=0; /* MR10 predicates */
+int InfoT=0; /* MR10 tnodes */
+int InfoF=0; /* MR10 first/follow sets */
+int InfoM=0; /* MR10 monitor progress */
+int InfoO=0; /* MR12 orphan rules */
+int TnodesInUse=0; /* MR10 */
+int TnodesPeak=0; /* MR10 */
+int TnodesAllocated=0; /* MR10 */
+int TnodesReportThreshold=0; /* MR11 */
+int PotentialSuppression=0; /* MR10 */
+int PotentialDummy=0; /* MR10 */
+int CannotContinue=FALSE;
+int OutputLL_k = 1; /* LL_k for parsing must be power of 2 */
+int action_file; /* used to track start of action */
+int action_line;
+int FoundGuessBlk=0; /* there is a (...)? block somewhere in grammar */
+int FoundException=0; /* there is an exception somewhere in grammar */
+/* MR6 Distinguish between @ operator and real exception */
+/* MR6 by keeping separate flags for @ operator and real exceptions */
+int FoundAtOperator=0; /* MR6 */
+int FoundExceptionGroup=0; /* MR6 */
+int pLevel=0; /* print Level */
+int pAlt1,pAlt2; /* print "==>" in front of these alts */
+
+/* C++ output stuff */
+FILE *Parser_h, /* where subclass of ANTLRParser goes */
+ *Parser_c; /* where code for subclass of ANTLRParser goes */
+char Parser_h_Name[MaxFileName+1] = "";
+char Parser_c_Name[MaxFileName+1] = "";
+char MRinfoFile_Name[MaxFileName+1] = ""; /* MR10 */
+char *ClassDeclStuff=NULL; /* MR10 */
+char *BaseClassName=NULL; /* MR22 */
+/* list of actions inside the #class {...} defs */
+ListNode *class_before_actions=NULL;
+ListNode *class_after_actions=NULL;
+
+char CurrentClassName[MaxRuleName]="";
+int no_classes_found=1;
+char *UserTokenDefsFile;
+int UserDefdTokens=0; /* found #tokdefs? */
+char *OutputDirectory=TopDirectory;
+ExceptionGroup *DefaultExGroup = NULL;
+int NumSignals = NumPredefinedSignals;
+int ContextGuardTRAV=0;
+
+char *MR_AmbAidRule=NULL; /* MR11 */
+int MR_AmbAidLine=0; /* MR11 */
+int MR_AmbAidDepth=0; /* MR11 */
+int MR_AmbAidMultiple=0; /* MR11 */
+int MR_skipped_e3_report=0; /* MR11 */
+int MR_usingPredNames=0; /* MR11 */
+int MR_BadExprSets=0; /* MR13 */
+int MR_Inhibit_Tokens_h_Gen=0; /* MR13 */
+int NewAST=0; /* MR13 */
+int tmakeInParser=0; /* MR23 */
+int AlphaBetaTrace=0; /* MR14 */
+int MR_BlkErr=0; /* MR21 */
+int MR_AlphaBetaMessageCount=0; /* MR14 */
+int MR_AlphaBetaWarning=0; /* MR14 */
+int MR_ErrorSetComputationActive=0; /* MR14 */
+int MR_MaintainBackTrace=0; /* MR14 */
+set MR_CompromisedRules; /* MR14 */
+
+Junction *MR_RuleBlkWithHalt; /* MR10 */
+
+ /* C m d - L i n e O p t i o n s */
+
+int LL_k=1; /* how many tokens of full lookahead */
+int CLL_k= -1; /* how many tokens of compressed lookahead */
+int PrintOut = FALSE; /* print out the grammar */
+int PrintAnnotate = FALSE;/* annotate printout with FIRST sets */
+int CodeGen=TRUE; /* Generate output code? */
+int LexGen=TRUE; /* Generate lexical files? (tokens.h, parser.dlg) */
+int GenAST=FALSE; /* Generate AST's? */
+int GenANSI=FALSE; /* Generate ANSI code where necessary */
+int GenExprSetsOpt=TRUE;/* use sets not (LA(1)==tok) expression lists */
+int GenCR=FALSE; /* Generate cross reference? */
+int GenLineInfo=FALSE; /* Generate # line "file" stuff? */
+int GenLineInfoMS=FALSE;/* Like -gl but replace "\" with "/" for MS C/C++ systems */
+int TraceGen=FALSE; /* Generate code to trace rule invocation */
+int elevel=1; /* error level for ambiguity messages */
+int GenEClasseForRules=0;/* don't generate eclass for each rule */
+int TreeResourceLimit= -1;/* don't limit tree resource */
+int DemandLookahead = 0;/* demand/delayed lookahead or not */
+char *RulePrefix = ""; /* prefix each generated rule with this */
+char *stdpccts = "stdpccts.h";/* where to generate std pccts include file */
+int GenStdPccts = 0; /* don't gen stdpccts.h? */
+int ParseWithPredicates = 1;
+int WarningLevel = 1;
+int UseStdout = 0; /* MR6 */
+int TabWidth = 2; /* MR6 */ /* MR27 */
+int HoistPredicateContext = 0;
+int MRhoisting = 0; /* MR9 */
+int MRhoistingk = 0; /* MR13 */
+int MR_debugGenRule=0; /* MR11 */
+
+int GenCC = 0; /* Generate C++ output */
+
+PointerStack MR_BackTraceStack={0,0,NULL}; /* MR10 */
+PointerStack MR_PredRuleRefStack={0,0,NULL}; /* MR10 */
+PointerStack MR_RuleBlkWithHaltStack={0,0,NULL}; /* MR10 */
+
+/* DontCopyTokens and Pragma_DupLabeledTokens were a bad idea. I've just
+ turned them off rather than backpatching the code. Who knows? We
+ may need them in the future.
+ */
+int DontCopyTokens = 1; /* in C++, don't copy ANTLRToken passed to ANTLR */
+
+/* Remember if LT(i), LA(i), or LATEXT(i) used in an action which is not
+ a predicate. If so, give a warning for novice users.
+*/
+
+int LTinTokenAction = 0; /* MR23 */
+int PURIFY = 1; /* MR23 */
+
+int CurBlockID_array[MAX_BLK_LEVEL]; /* MR23 */
+int CurAltNum_array[MAX_BLK_LEVEL]; /* MR23 */
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/hash.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/hash.c new file mode 100644 index 0000000000..68fe8fd227 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/hash.c @@ -0,0 +1,221 @@ +/*
+ * hash.c
+ *
+ * Manage hash tables.
+ *
+ * The following functions are visible:
+ *
+ * char *mystrdup(char *); Make space and copy string
+ * Entry **newHashTable(); Create and return initialized hash table
+ * Entry *hash_add(Entry **, char *, Entry *)
+ * Entry *hash_get(Entry **, char *)
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2001
+ */
+
+#include <stdio.h>
+#include "pcctscfg.h"
+#include "hash.h"
+
+#ifdef __USE_PROTOS
+#include <stdlib.h>
+#else
+#ifdef VAXC
+#include <stdlib.h>
+#else
+#include <malloc.h>
+#endif
+#endif
+#include <string.h>
+
+#define StrSame 0
+
+#define fatal(err) \
+ {fprintf(stderr, "%s(%d):", __FILE__, __LINE__); \
+ fprintf(stderr, " %s\n", err); exit(PCCTS_EXIT_FAILURE);}
+#define require(expr, err) {if ( !(expr) ) fatal(err);}
+
+static unsigned size = HashTableSize;
+static char *strings = NULL;
+static char *strp;
+static unsigned strsize = StrTableSize;
+
+/* create the hash table and string table for terminals (string table only once) */
+Entry **
+#ifdef __USE_PROTOS
+newHashTable( void )
+#else
+newHashTable( )
+#endif
+{
+ Entry **table;
+
+ table = (Entry **) calloc(size, sizeof(Entry *));
+ require( table != NULL, "cannot allocate hash table");
+ if ( strings == NULL )
+ {
+ strings = (char *) calloc(strsize, sizeof(char));
+ require( strings != NULL, "cannot allocate string table");
+ strp = strings;
+ }
+ return table;
+}
+
+void
+#ifdef __USE_PROTOS
+killHashTable( Entry **table )
+#else
+killHashTable( table )
+Entry **table;
+#endif
+{
+ /* for now, just free table, forget entries */
+ free( (char *) table ); /* MR10 cast */
+}
+
+/* Given a table, add 'rec' with key 'key' (add to front of list). return ptr to entry */
+Entry *
+#ifdef __USE_PROTOS
+hash_add( Entry **table, char *key, Entry *rec )
+#else
+hash_add( table, key, rec )
+Entry **table;
+char *key;
+Entry *rec;
+#endif
+{
+ unsigned h=0;
+ char *p=key;
+ require(table!=NULL && key!=NULL && rec!=NULL, "add: invalid addition");
+
+ Hash(p,h,size);
+ rec->next = table[h]; /* Add to singly-linked list */
+ table[h] = rec;
+ return rec;
+}
+
+/* Return ptr to 1st entry found in table under key (return NULL if none found) */
+Entry *
+#ifdef __USE_PROTOS
+hash_get( Entry **table, char *key )
+#else
+hash_get( table, key )
+Entry **table;
+char *key;
+#endif
+{
+ unsigned h=0;
+ char *p=key;
+ Entry *q;
+/* require(table!=NULL && key!=NULL, "get: invalid table and/or key");*/
+ if ( !(table!=NULL && key!=NULL) ) *((char *) 34) = 3;
+
+ Hash(p,h,size);
+ for (q = table[h]; q != NULL; q = q->next)
+ {
+ if ( strcmp(key, q->str) == StrSame ) return( q );
+ }
+ return( NULL );
+}
+
+#ifdef DEBUG_HASH
+void
+#ifdef __USE_PROTOS
+hashStat( Entry **table )
+#else
+hashStat( table )
+Entry **table;
+#endif
+{
+ static unsigned short count[20];
+ int i,n=0,low=0, hi=0;
+ Entry **p;
+ float avg=0.0;
+
+ for (i=0; i<20; i++) count[i] = 0;
+ for (p=table; p<&(table[size]); p++)
+ {
+ Entry *q = *p;
+ int len;
+
+ if ( q != NULL && low==0 ) low = p-table;
+ len = 0;
+ if ( q != NULL ) fprintf(stderr, "[%d]", p-table);
+ while ( q != NULL )
+ {
+ len++;
+ n++;
+ fprintf(stderr, " %s", q->str);
+ q = q->next;
+ if ( q == NULL ) fprintf(stderr, "\n");
+ }
+ count[len]++;
+ if ( *p != NULL ) hi = p-table;
+ }
+
+ fprintf(stderr, "Storing %d recs used %d hash positions out of %d\n",
+ n, size-count[0], size);
+ fprintf(stderr, "%f %% utilization\n",
+ ((float)(size-count[0]))/((float)size));
+ for (i=0; i<20; i++)
+ {
+ if ( count[i] != 0 )
+ {
+ avg += (((float)(i*count[i]))/((float)n)) * i;
+ fprintf(stderr, "Bucket len %d == %d (%f %% of recs)\n",
+ i, count[i], ((float)(i*count[i]))/((float)n));
+ }
+ }
+ fprintf(stderr, "Avg bucket length %f\n", avg);
+ fprintf(stderr, "Range of hash function: %d..%d\n", low, hi);
+}
+#endif
+
+/* Add a string to the string table and return a pointer to it.
+ * Bump the pointer into the string table to next avail position.
+ */
+char *
+#ifdef __USE_PROTOS
+mystrdup( char *s )
+#else
+mystrdup( s )
+char *s;
+#endif
+{
+ char *start=strp;
+ require(s!=NULL, "mystrdup: NULL string");
+
+ while ( *s != '\0' )
+ {
+ require( strp <= &(strings[strsize-2]),
+ "string table overflow\nIncrease StrTableSize in hash.h and recompile hash.c\n");
+ *strp++ = *s++;
+ }
+ *strp++ = '\0';
+
+ return( start );
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/hash.h b/BaseTools/Source/C/VfrCompile/Pccts/antlr/hash.h new file mode 100644 index 0000000000..3969c40b4a --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/hash.h @@ -0,0 +1,73 @@ +/*
+ * hash.h -- define hash table entries, sizes, hash function...
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2001
+ */
+
+ /* H a s h T a b l e S t u f f */
+
+#ifndef HashTableSize
+#define HashTableSize 553
+#endif
+
+#ifndef StrTableSize
+#ifdef PC32
+#define StrTableSize 1000000
+#endif
+#endif
+
+#ifndef StrTableSize
+#ifdef PC
+#define StrTableSize 655200
+#endif
+#endif
+
+#ifndef StrTableSize
+#define StrTableSize 1000000
+#endif
+
+typedef struct _entry { /* Minimum hash table entry -- superclass */
+ char *str;
+ struct _entry *next;
+ } Entry;
+
+/* Hash 's' using 'size', place into h (s is modified) */
+#define Hash(s,h,size) \
+ {while ( *s != '\0' ) h = (h<<1) + *s++; \
+ h %= size;}
+
+#ifdef __USE_PROTOS
+Entry *hash_get(Entry **, char *),
+ **newHashTable(void),
+ *hash_add(Entry **, char *, Entry *);
+
+void killHashTable(Entry **);
+
+#else
+Entry *hash_get(), **newHashTable(), *hash_add();
+void killHashTable(); /* MR9 23-Sep-97 */
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/lex.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/lex.c new file mode 100644 index 0000000000..8c524fe465 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/lex.c @@ -0,0 +1,878 @@ +/*
+ * lex.c -- Generate all of the lexical type files: parser.dlg tokens.h
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2001
+ */
+
+#include <stdio.h>
+#include <ctype.h>
+/* MR1 */
+/* MR1 10-Apr-97 MR1 Replace use of __STDC__ with __USE_PROTOS */
+/* MR1 */
+#include "pcctscfg.h"
+#include "set.h"
+#include "syn.h"
+#include "hash.h"
+#include "generic.h"
+
+#define DLGErrorString "invalid token"
+
+/* Generate a complete lexical description of the lexemes found in the grammar */
+void
+#ifdef __USE_PROTOS
+genLexDescr( void )
+#else
+genLexDescr( )
+#endif
+{
+ ListNode *p;
+ FILE *dlgFile = fopen(OutMetaName(DlgFileName), "w");
+ require(dlgFile!=NULL, eMsg1("genLexFile: cannot open %s", OutMetaName(DlgFileName)) );
+#ifdef SPECIAL_FOPEN
+ special_fopen_actions(OutMetaName(DlgFileName)); /* MR1 */
+#endif
+ fprintf(dlgFile, "<<\n");
+ fprintf(dlgFile, "/* %s -- DLG Description of scanner\n", DlgFileName);
+ fprintf(dlgFile, " *\n");
+ fprintf(dlgFile, " * Generated from:");
+ {int i; for (i=0; i<NumFiles; i++) fprintf(dlgFile, " %s", FileStr[i]);}
+ fprintf(dlgFile, "\n");
+ fprintf(dlgFile, " *\n");
+ fprintf(dlgFile, " * Terence Parr, Will Cohen, and Hank Dietz: 1989-2001\n");
+ fprintf(dlgFile, " * Purdue University Electrical Engineering\n");
+ fprintf(dlgFile, " * With AHPCRC, University of Minnesota\n");
+ fprintf(dlgFile, " * ANTLR Version %s\n", Version);
+ fprintf(dlgFile, " */\n\n");
+ if (FirstAction != NULL ) dumpAction( FirstAction, dlgFile, 0, -1, 0, 1 ); /* MR11 MR15b */
+ fprintf(dlgFile, "#define ANTLR_VERSION %s\n", VersionDef);
+ if ( GenCC )
+ {
+ if ( !UserDefdTokens ) fprintf(dlgFile, "#include \"%s\"\n", DefFileName);
+ else fprintf(dlgFile, "#include %s\n", UserTokenDefsFile);
+ fprintf(dlgFile, "#include \"%s\"\n", ATOKEN_H);
+ if ( GenAST ) fprintf(dlgFile, "#include \"%s\"\n", ASTBASE_H);
+ if ( HdrAction != NULL ) dumpAction( HdrAction, dlgFile, 0, -1, 0, 1 );
+ }
+ else
+ {
+ fprintf(dlgFile, "#include \"pcctscfg.h\"\n");
+ fprintf(dlgFile, "#include \"pccts_stdio.h\"\n");
+ if ( strcmp(ParserName, DefaultParserName)!=0 )
+ fprintf(dlgFile, "#define %s %s\n", DefaultParserName, ParserName);
+ if ( strcmp(ParserName, DefaultParserName)!=0 )
+ fprintf(dlgFile, "#include \"%s\"\n", RemapFileName);
+ if ( HdrAction != NULL ) dumpAction( HdrAction, dlgFile, 0, -1, 0, 1 );
+ if ( FoundGuessBlk )
+ {
+ fprintf(dlgFile, "#define ZZCAN_GUESS\n");
+ fprintf(dlgFile, "#include \"pccts_setjmp.h\"\n");
+ }
+ if ( OutputLL_k > 1 ) fprintf(dlgFile, "#define LL_K %d\n", OutputLL_k);
+ if ( DemandLookahead ) fprintf(dlgFile, "#define DEMAND_LOOK\n");
+ if (TraceGen) {
+ fprintf(dlgFile,"#ifndef zzTRACE_RULES\n"); /* MR20 */
+ fprintf(dlgFile,"#define zzTRACE_RULES\n"); /* MR20 */
+ fprintf(dlgFile,"#endif\n"); /* MR22 */
+ };
+ fprintf(dlgFile, "#include \"antlr.h\"\n");
+ if ( GenAST ) {
+ fprintf(dlgFile, "#include \"ast.h\"\n");
+ }
+ if ( UserDefdTokens )
+ fprintf(dlgFile, "#include %s\n", UserTokenDefsFile);
+ /* still need this one as it has the func prototypes */
+ fprintf(dlgFile, "#include \"%s\"\n", DefFileName);
+ fprintf(dlgFile, "#include \"dlgdef.h\"\n");
+ fprintf(dlgFile, "LOOKAHEAD\n");
+ fprintf(dlgFile, "\n");
+ fprintf(dlgFile, "void\n");
+ fprintf(dlgFile, "#ifdef __USE_PROTOS\n");
+ fprintf(dlgFile, "zzerraction(void)\n");
+ fprintf(dlgFile, "#else\n");
+ fprintf(dlgFile, "zzerraction()\n");
+ fprintf(dlgFile, "#endif\n");
+ fprintf(dlgFile, "{\n");
+ fprintf(dlgFile, "\t(*zzerr)(\"%s\");\n", DLGErrorString);
+ fprintf(dlgFile, "\tzzadvance();\n");
+ fprintf(dlgFile, "\tzzskip();\n");
+ fprintf(dlgFile, "}\n");
+ }
+ fprintf(dlgFile, ">>\n\n");
+
+ /* dump all actions */
+
+/* MR1 */
+/* MR1 11-Apr-97 Provide mechanism for inserting code into DLG class */
+/* MR1 via <<%%lexmember ....>> & <<%%lexprefix ...>> */
+/* MR1 */
+ if (LexActions != NULL) {
+ for (p = LexActions->next; p!=NULL; p=p->next)
+ {
+/* MR1 */ fprintf(dlgFile, "<<%%%%lexaction\n");
+ dumpAction( (char *)p->elem, dlgFile, 0, -1, 0, 1 );
+ fprintf(dlgFile, ">>\n\n");
+ }
+ };
+
+/* MR1 */ if (GenCC) {
+/* MR1 */ fprintf(dlgFile,"<<%%%%parserclass %s>>\n\n",CurrentClassName);
+/* MR1 */ };
+
+/* MR1 */ if (LexPrefixActions != NULL) {
+/* MR1 */ for (p = LexPrefixActions->next; p!=NULL; p=p->next)
+/* MR1 */ {
+/* MR1 */ fprintf(dlgFile, "<<%%%%lexprefix\n");
+/* MR1 */ dumpAction( (char *)p->elem, dlgFile, 0, -1, 0, 1 );
+/* MR1 */ fprintf(dlgFile, ">>\n\n");
+/* MR1 */ }
+/* MR1 */ };
+
+/* MR1 */ if (LexMemberActions != NULL) {
+/* MR1 */ for (p = LexMemberActions->next; p!=NULL; p=p->next)
+/* MR1 */ {
+/* MR1 */ fprintf(dlgFile, "<<%%%%lexmember\n");
+/* MR1 */ dumpAction( (char *)p->elem, dlgFile, 0, -1, 0, 1 );
+/* MR1 */ fprintf(dlgFile, ">>\n\n");
+/* MR1 */ }
+/* MR1 */ };
+
+ /* dump all regular expression rules/actions (skip sentinel node) */
+ if ( ExprOrder == NULL ) {
+ warnNoFL("no regular expressions found in grammar");
+ }
+ else dumpLexClasses(dlgFile);
+ fprintf(dlgFile, "%%%%\n");
+ fclose( dlgFile );
+}
+
+/* For each lexical class, scan ExprOrder looking for expressions
+ * in that lexical class. Print out only those that match.
+ * Each element of the ExprOrder list has both an expr and an lclass
+ * field.
+ */
+void
+#ifdef __USE_PROTOS
+dumpLexClasses( FILE *dlgFile )
+#else
+dumpLexClasses( dlgFile )
+FILE *dlgFile;
+#endif
+{
+ int i;
+ TermEntry *t;
+ ListNode *p;
+ Expr *q;
+
+ for (i=0; i<NumLexClasses; i++)
+ {
+ fprintf(dlgFile, "\n%%%%%s\n\n", lclass[i].classnum);
+ for (p=ExprOrder->next; p!=NULL; p=p->next)
+ {
+ q = (Expr *) p->elem;
+ if ( q->lclass != i ) continue;
+ lexmode(i);
+ t = (TermEntry *) hash_get(Texpr, q->expr);
+ require(t!=NULL, eMsg1("genLexDescr: rexpr %s not in hash table",q->expr) );
+ if ( t->token == EpToken ) continue;
+ fprintf(dlgFile, "%s\n\t<<\n", StripQuotes(q->expr));
+ /* replace " killed by StripQuotes() */
+ q->expr[ strlen(q->expr) ] = '"';
+ if ( !GenCC ) {
+ if ( TokenString(t->token) != NULL )
+ fprintf(dlgFile, "\t\tNLA = %s;\n", TokenString(t->token));
+ else
+ fprintf(dlgFile, "\t\tNLA = %d;\n", t->token);
+ }
+ if ( t->action != NULL ) dumpAction( t->action, dlgFile, 2,-1,0,1 );
+ if ( GenCC ) {
+ if ( TokenString(t->token) != NULL )
+ fprintf(dlgFile, "\t\treturn %s;\n", TokenString(t->token));
+ else
+ fprintf(dlgFile, "\t\treturn (ANTLRTokenType)%d;\n", t->token);
+ }
+ fprintf(dlgFile, "\t>>\n\n");
+ }
+ }
+}
+
+/* Strip the leading path (if any) from a filename */
+char *
+#ifdef __USE_PROTOS
+StripPath( char *fileName )
+#else
+StripPath( fileName )
+char *fileName;
+#endif
+{
+ char *p;
+ static char dirSym[2] = DirectorySymbol;
+
+ if(NULL != (p = strrchr(fileName, dirSym[0])))
+ p++;
+ else
+ p = fileName;
+
+ return(p);
+}
+
+/* Generate a list of #defines && list of struct definitions for
+ * aggregate retv's */
+void
+#ifdef __USE_PROTOS
+genDefFile( void )
+#else
+genDefFile( )
+#endif
+{
+ int i;
+
+ /* If C++ mode and #tokdef used, then don't need anything in here since
+ * C++ puts all definitions in the class file name.
+ */
+ if ( GenCC && UserTokenDefsFile ) return;
+ if ( MR_Inhibit_Tokens_h_Gen) return;
+
+ DefFile = fopen(OutMetaName(DefFileName), "w");
+ require(DefFile!=NULL, eMsg1("genDefFile: cannot open %s", OutMetaName(DefFileName)) );
+#ifdef SPECIAL_FOPEN
+ special_fopen_actions(OutMetaName(DefFileName)); /* MR1 */
+#endif
+ fprintf(DefFile, "#ifndef %s\n", StripPath(gate_symbol(DefFileName)));
+ fprintf(DefFile, "#define %s\n", StripPath(gate_symbol(DefFileName)));
+
+ fprintf(DefFile, "/* %s -- List of labelled tokens and stuff\n", DefFileName);
+ fprintf(DefFile, " *\n");
+ fprintf(DefFile, " * Generated from:");
+ for (i=0; i<NumFiles; i++) fprintf(DefFile, " %s", FileStr[i]);
+ fprintf(DefFile, "\n");
+ fprintf(DefFile, " *\n");
+ fprintf(DefFile, " * Terence Parr, Will Cohen, and Hank Dietz: 1989-2001\n");
+ fprintf(DefFile, " * Purdue University Electrical Engineering\n");
+ fprintf(DefFile, " * ANTLR Version %s\n", Version);
+ fprintf(DefFile, " */\n");
+
+ if ( !GenCC && LexGen ) {
+ fprintf(DefFile,"#define zzEOF_TOKEN %d\n",
+ TokenInd!=NULL?TokenInd[EofToken]:EofToken);
+ }
+
+ if ( !UserDefdTokens )
+ {
+ int first=1;
+
+ if ( GenCC ) fprintf(DefFile, "enum ANTLRTokenType {\n");
+ for (i=1; i<TokenNum; i++)
+ {
+ /* Don't do EpToken or expr w/o labels */
+ if ( TokenString(i)!=NULL && i != EpToken )
+ {
+ TermEntry *p;
+
+ if ( WarningLevel>1 )
+ {
+ int j;
+ /* look in all lexclasses for the reg expr */
+
+/* MR10 Derek Pappas */
+/* MR10 A #tokclass doesn't have associated regular expressiones */
+/* MR10 so don't warn user about it's omission */
+
+ p = (TermEntry *) hash_get(Tname, TokenString(i));
+
+ if (p != NULL && ! p->classname) {
+ for (j=0; j<NumLexClasses; j++)
+ {
+ lexmode(j);
+ if ( ExprString(i)!=NULL ) break;
+ }
+ if ( j>=NumLexClasses )
+ {
+ warnNoFL(eMsg1("token label has no associated rexpr: %s",TokenString(i)));
+ }
+ };
+ }
+ require((p=(TermEntry *)hash_get(Tname, TokenString(i))) != NULL,
+ "token not in sym tab when it should be");
+ if ( !p->classname )
+ {
+ if ( GenCC ) {
+ if ( !first ) fprintf(DefFile, ",\n");
+ first = 0;
+ fprintf(DefFile, "\t%s=%d", TokenString(i), i);
+ }
+ else
+ fprintf(DefFile, "#define %s %d\n", TokenString(i), i);
+ }
+ }
+ }
+/* MR1 */
+/* MR1 10-Apr-97 133MR1 Prevent use of varying sizes of integer */
+/* MR1 for the enum ANTLRTokenType */
+/* MR1 */
+ if ( GenCC ) { /* MR1 */
+ if ( !first ) fprintf(DefFile, ",\n"); /* MR14 */
+ fprintf(DefFile, "\tDLGminToken=0"); /* MR1 */
+ fprintf(DefFile, ",\n\tDLGmaxToken=9999};\n"); /* MR1 */
+ }; /* MR1 */
+ }
+
+ if ( !GenCC ) GenRulePrototypes(DefFile, SynDiag);
+
+ fprintf(DefFile, "\n#endif\n");
+}
+
+void
+#ifdef __USE_PROTOS
+GenRemapFile( void )
+#else
+GenRemapFile( )
+#endif
+{
+ if ( strcmp(ParserName, DefaultParserName)!=0 )
+ {
+ FILE *f;
+ int i;
+
+ f = fopen(OutMetaName(RemapFileName), "w");
+ require(f!=NULL, eMsg1("GenRemapFile: cannot open %s", OutMetaName(RemapFileName)) );
+#ifdef SPECIAL_FOPEN
+ special_fopen_actions(OutMetaName(RemapFileName)); /* MR1 */
+#endif
+ fprintf(f, "/* %s -- List of symbols to remap\n", RemapFileName);
+ fprintf(f, " *\n");
+ fprintf(f, " * Generated from:");
+ for (i=0; i<NumFiles; i++) fprintf(f, " %s", FileStr[i]);
+ fprintf(f, "\n");
+ fprintf(f, " *\n");
+ fprintf(f, " * Terence Parr, Will Cohen, and Hank Dietz: 1989-2001\n");
+ fprintf(f, " * Purdue University Electrical Engineering\n");
+ fprintf(f, " * ANTLR Version %s\n", Version);
+ fprintf(f, " */\n");
+
+ GenRuleFuncRedefs(f, SynDiag);
+ GenPredefinedSymbolRedefs(f);
+ if ( GenAST ) GenASTSymbolRedefs(f);
+ GenSetRedefs(f);
+
+ fclose(f);
+ }
+}
+
+/* Generate a bunch of #defines that rename all functions to be "ParserName_func" */
+void
+#ifdef __USE_PROTOS
+GenRuleFuncRedefs( FILE *f, Junction *p )
+#else
+GenRuleFuncRedefs( f, p )
+FILE *f;
+Junction *p;
+#endif
+{
+ fprintf(f, "\n/* rename rule functions to be 'ParserName_func' */\n");
+ while ( p!=NULL )
+ {
+ fprintf(f, "#define %s %s_%s\n", p->rname, ParserName, p->rname);
+ p = (Junction *)p->p2;
+ }
+}
+
+/* Generate a bunch of #defines that rename all standard symbols to be
+ * "ParserName_symbol". The list of standard symbols to change is in
+ * globals.c.
+ */
+void
+#ifdef __USE_PROTOS
+GenPredefinedSymbolRedefs( FILE *f )
+#else
+GenPredefinedSymbolRedefs( f )
+FILE *f;
+#endif
+{
+ char **p;
+
+ fprintf(f, "\n/* rename PCCTS-supplied symbols to be 'ParserName_symbol' */\n");
+ for (p = &StandardSymbols[0]; *p!=NULL; p++)
+ {
+ fprintf(f, "#define %s %s_%s\n", *p, ParserName, *p);
+ }
+}
+
+/* Generate a bunch of #defines that rename all AST symbols to be
+ * "ParserName_symbol". The list of AST symbols to change is in
+ * globals.c.
+ */
+void
+#ifdef __USE_PROTOS
+GenASTSymbolRedefs( FILE *f )
+#else
+GenASTSymbolRedefs( f )
+FILE *f;
+#endif
+{
+ char **p;
+
+ fprintf(f, "\n/* rename PCCTS-supplied AST symbols to be 'ParserName_symbol' */\n");
+ for (p = &ASTSymbols[0]; *p!=NULL; p++)
+ {
+ fprintf(f, "#define %s %s_%s\n", *p, ParserName, *p);
+ }
+}
+
+/* redefine all sets generated by ANTLR; WARNING: 'zzerr', 'setwd' must match
+ * use in bits.c (DumpSetWd() etc...)
+ */
+void
+#ifdef __USE_PROTOS
+GenSetRedefs( FILE *f )
+#else
+GenSetRedefs( f )
+FILE *f;
+#endif
+{
+ int i;
+
+ for (i=1; i<=wordnum; i++)
+ {
+ fprintf(f, "#define setwd%d %s_setwd%d\n", i, ParserName, i);
+ }
+ for (i=1; i<=esetnum; i++)
+ {
+ fprintf(f, "#define zzerr%d %s_err%d\n", i, ParserName, i);
+ }
+}
+
+/* Find all return types/parameters that require structs and def
+ * all rules with ret types.
+ *
+ * This is for the declaration, not the definition.
+ */
+void
+#ifdef __USE_PROTOS
+GenRulePrototypes( FILE *f, Junction *p )
+#else
+GenRulePrototypes( f, p )
+FILE *f;
+Junction *p;
+#endif
+{
+ int i;
+
+ i = 1;
+ while ( p!=NULL )
+ {
+ if ( p->ret != NULL )
+ {
+/* MR23 */ if ( hasMultipleOperands(p->ret) )
+ {
+ DumpRetValStruct(f, p->ret, i);
+ }
+ fprintf(f, "\n#ifdef __USE_PROTOS\n");
+/* MR23 */ if ( hasMultipleOperands(p->ret) )
+ {
+ fprintf(f, "extern struct _rv%d", i);
+ }
+ else
+ {
+ fprintf(f, "extern ");
+ DumpType(p->ret, f);
+ }
+ fprintf(f, " %s%s(", RulePrefix, p->rname);
+ DumpANSIFunctionArgDef(f,p,1 /* emit initializers ? */);
+ fprintf(f, ";\n");
+ fprintf(f, "#else\n");
+/* MR23 */ if ( hasMultipleOperands(p->ret) )
+ {
+ fprintf(f, "extern struct _rv%d", i);
+ }
+ else
+ {
+ fprintf(f, "extern ");
+ DumpType(p->ret, f);
+ }
+ fprintf(f, " %s%s();\n", RulePrefix, p->rname);
+ fprintf(f, "#endif\n");
+ }
+ else
+ {
+ fprintf(f, "\n#ifdef __USE_PROTOS\n");
+ fprintf(f, "void %s%s(", RulePrefix, p->rname);
+ DumpANSIFunctionArgDef(f,p, 1 /* emit initializers ? */ );
+ fprintf(f, ";\n");
+#ifdef OLD
+ if ( p->pdecl != NULL || GenAST )
+ {
+ if ( GenAST ) {
+ fprintf(f, "AST **%s",(p->pdecl!=NULL)?",":"");
+ }
+ if ( p->pdecl!=NULL ) fprintf(f, "%s", p->pdecl);
+ }
+ else fprintf(f, "void");
+ fprintf(f, ");\n");
+#endif
+ fprintf(f, "#else\n");
+ fprintf(f, "extern void %s%s();\n", RulePrefix, p->rname);
+ fprintf(f, "#endif\n");
+ }
+ i++;
+ p = (Junction *)p->p2;
+ }
+}
+
+/* Define all rules in the class.h file; generate any required
+ * struct definitions first, however.
+ */
+void
+#ifdef __USE_PROTOS
+GenRuleMemberDeclarationsForCC( FILE *f, Junction *q )
+#else
+GenRuleMemberDeclarationsForCC( f, q )
+FILE *f;
+Junction *q;
+#endif
+{
+ Junction *p = q;
+ int i;
+
+ fprintf(f, "private:\n");
+
+ /* Dump dflt handler declaration */
+ fprintf(f, "\tvoid zzdflthandlers( int _signal, int *_retsignal );\n\n");
+
+ fprintf(f, "public:\n");
+
+ /* Dump return value structs */
+ i = 1;
+ while ( p!=NULL )
+ {
+ if ( p->ret != NULL )
+ {
+/* MR23 */ if ( hasMultipleOperands(p->ret) )
+ {
+ DumpRetValStruct(f, p->ret, i);
+ }
+ }
+ i++;
+ p = (Junction *)p->p2;
+ }
+
+ /* Dump member func defs && CONSTRUCTOR */
+ fprintf(f, "\t%s(ANTLRTokenBuffer *input);\n", CurrentClassName);
+/*
+ fprintf(f, "\t%s(ANTLRTokenBuffer *input, ANTLRTokenType eof);\n",
+ CurrentClassName);
+*/
+
+ i = 1;
+ p = q;
+ while ( p!=NULL )
+ {
+ if ( p->ret != NULL )
+ {
+/* MR23 */ if ( hasMultipleOperands(p->ret) )
+ {
+ fprintf(f, "\tstruct _rv%d", i);
+ }
+ else
+ {
+ fprintf(f, "\t");
+ DumpType(p->ret, f);
+ }
+ fprintf(f, " %s%s(",RulePrefix,p->rname);
+ DumpANSIFunctionArgDef(f,p, 1 /* emit initializers ? */ );
+ fprintf(f, ";\n");
+#ifdef OLD
+ if ( p->pdecl != NULL || GenAST )
+ {
+ if ( GenAST ) fprintf(f, "ASTBase **%s",(p->pdecl!=NULL)?",":"");
+ if ( p->pdecl!=NULL ) fprintf(f, "%s", p->pdecl);
+ }
+ fprintf(f, ");\n");
+#endif
+ }
+ else
+ {
+ fprintf(f, "\tvoid %s%s(",RulePrefix,p->rname);
+ DumpANSIFunctionArgDef(f,p, 1 /* emit initializers ? */);
+ fprintf(f, ";\n");
+#ifdef OLD
+ if ( p->pdecl != NULL || GenAST )
+ {
+ if ( GenAST ) fprintf(f, "ASTBase **%s",(p->pdecl!=NULL)?",":"");
+ if ( p->pdecl!=NULL ) fprintf(f, "%s", p->pdecl);
+ }
+ fprintf(f, ");\n");
+#endif
+ }
+ i++;
+ p = (Junction *)p->p2;
+ }
+}
+
+/* Given a list of ANSI-style parameter declarations, print out a
+ * comma-separated list of the symbols (w/o types).
+ * Basically, we look for a comma, then work backwards until start of
+ * the symbol name. Then print it out until 1st non-alnum char. Now,
+ * move on to next parameter.
+ *
+ */
+
+/* MR5 Jan Mikkelsen 26-May-97 - added initalComma parameter */
+
+void
+#ifdef __USE_PROTOS
+DumpListOfParmNames(char *pdecl, FILE *output, int initialComma) /* MR5 */
+#else
+DumpListOfParmNames(pdecl, output, initialComma) /* MR5 */
+char *pdecl; /* MR5 */
+FILE *output; /* MR5 */
+int initialComma; /* MR5 */
+#endif
+{
+ int firstTime = 1, done = 0;
+ require(output!=NULL, "DumpListOfParmNames: NULL parm");
+
+ if ( pdecl == NULL ) return;
+ while ( !done )
+ {
+ if ( !firstTime || initialComma ) putc(',', output); /* MR5 */
+ done = DumpNextNameInDef(&pdecl, output);
+ firstTime = 0;
+ }
+}
+
+/* given a list of parameters or return values, dump the next
+ * name to output. Return 1 if last one just printed, 0 if more to go.
+ */
+
+/* MR23 Total rewrite */
+
+int
+#ifdef __USE_PROTOS
+DumpNextNameInDef( char **q, FILE *output )
+#else
+DumpNextNameInDef( q, output )
+char **q;
+FILE *output;
+#endif
+{
+ char *p;
+ char *t;
+ char *pDataType;
+ char *pSymbol;
+ char *pEqualSign;
+ char *pValue;
+ char *pSeparator;
+ int nest = 0;
+
+ p = endFormal(*q,
+ &pDataType,
+ &pSymbol,
+ &pEqualSign,
+ &pValue,
+ &pSeparator,
+ &nest);
+
+ /* MR26 Handle rule arguments such as: IIR_Bool (IIR_Decl::*contstraint)()
+ For this we need to strip off anything which follows the symbol.
+ */
+
+/* MR26 */ t = pSymbol;
+/* MR26 */ if (t != NULL) {
+/* MR26 */ for (t = pSymbol; *t != 0; t++) {
+/* MR26 */ if (! (isalpha(*t) || isdigit(*t) || *t == '_' || *t == '$')) break;
+/* MR26 */ }
+/* MR26 */ }
+/* MR26 */ fprintf(output,strBetween(pSymbol, t, pSeparator));
+
+ *q = p;
+ return (*pSeparator == 0);
+}
+
+/* Given a list of ANSI-style parameter declarations, dump K&R-style
+ * declarations, one per line for each parameter. Basically, convert
+ * comma to semi-colon, newline.
+ */
+void
+#ifdef __USE_PROTOS
+DumpOldStyleParms( char *pdecl, FILE *output )
+#else
+DumpOldStyleParms( pdecl, output )
+char *pdecl;
+FILE *output;
+#endif
+{
+ require(output!=NULL, "DumpOldStyleParms: NULL parm");
+
+ if ( pdecl == NULL ) return;
+ while ( *pdecl != '\0' )
+ {
+ if ( *pdecl == ',' )
+ {
+ pdecl++;
+ putc(';', output); putc('\n', output);
+ while ( *pdecl==' ' || *pdecl=='\t' || *pdecl=='\n' ) pdecl++;
+ }
+ else {putc(*pdecl, output); pdecl++;}
+ }
+ putc(';', output);
+ putc('\n', output);
+}
+
+/* Take in a type definition (type + symbol) and print out type only */
+/* MR23 Total rewrite */
+
+void
+#ifdef __USE_PROTOS
+DumpType( char *s, FILE *f )
+#else
+DumpType( s, f )
+char *s;
+FILE *f;
+#endif
+{
+ char *p;
+ char *pDataType;
+ char *pSymbol;
+ char *pEqualSign;
+ char *pValue;
+ char *pSeparator;
+ int nest = 0;
+
+ require(s!=NULL, "DumpType: invalid type string");
+
+ p = endFormal(s,
+ &pDataType,
+ &pSymbol,
+ &pEqualSign,
+ &pValue,
+ &pSeparator,
+ &nest);
+ fprintf(f,strBetween(pDataType, pSymbol, pSeparator));
+}
+
+/* check to see if string e is a word in string s */
+int
+#ifdef __USE_PROTOS
+strmember( char *s, char *e )
+#else
+strmember( s, e )
+char *s;
+char *e;
+#endif
+{
+ register char *p;
+ require(s!=NULL&&e!=NULL, "strmember: NULL string");
+
+ if ( *e=='\0' ) return 1; /* empty string is always member */
+ do {
+ while ( *s!='\0' && !isalnum(*s) && *s!='_' )
+ ++s;
+ p = e;
+ while ( *p!='\0' && *p==*s ) {p++; s++;}
+ if ( *p=='\0' ) {
+ if ( *s=='\0' ) return 1;
+ if ( !isalnum (*s) && *s != '_' ) return 1;
+ }
+ while ( isalnum(*s) || *s == '_' )
+ ++s;
+ } while ( *s!='\0' );
+ return 0;
+}
+
+#if 0
+
+/* MR23 Replaced by hasMultipleOperands() */
+
+int
+#ifdef __USE_PROTOS
+HasComma( char *s )
+#else
+HasComma( s )
+char *s;
+#endif
+{
+ while (*s!='\0')
+ if ( *s++ == ',' ) return 1;
+ return 0;
+}
+#endif
+
+
+/* MR23 Total rewrite */
+
+void
+#ifdef __USE_PROTOS
+DumpRetValStruct( FILE *f, char *ret, int i )
+#else
+DumpRetValStruct( f, ret, i )
+FILE *f;
+char *ret;
+int i;
+#endif
+{
+ char *p = ret;
+ char *pDataType;
+ char *pSymbol;
+ char *pEqualSign;
+ char *pValue;
+ char *pSeparator;
+ int nest = 0;
+
+ fprintf(f, "\nstruct _rv%d {\n", i);
+ while (*p != 0 && nest == 0) {
+ p = endFormal(p,
+ &pDataType,
+ &pSymbol,
+ &pEqualSign,
+ &pValue,
+ &pSeparator,
+ &nest);
+ fprintf(f,"\t");
+ fprintf(f,strBetween(pDataType, pSymbol, pSeparator));
+ fprintf(f," ");
+ fprintf(f,strBetween(pSymbol, pEqualSign, pSeparator));
+ fprintf(f,";\n");
+ }
+ fprintf(f,"};\n");
+}
+
+/* given "s" yield s -- DESTRUCTIVE (we modify s if starts with " else return s) */
+char *
+#ifdef __USE_PROTOS
+StripQuotes( char *s )
+#else
+StripQuotes( s )
+char *s;
+#endif
+{
+ if ( *s == '"' )
+ {
+ s[ strlen(s)-1 ] = '\0'; /* remove last quote */
+ return( s+1 ); /* return address past initial quote */
+ }
+ return( s );
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/main.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/main.c new file mode 100644 index 0000000000..051ee4ec5d --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/main.c @@ -0,0 +1,1747 @@ +/*
+ * main.c -- main program for PCCTS ANTLR.
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2001
+ */
+
+/* To set a breakpoint just before exit look for "cleanUp". */
+/* To set a breakpoint for fatal error look for "fatal_intern" */
+
+#include <stdio.h>
+
+#include "pcctscfg.h"
+#include "stdpccts.h"
+
+#define MAX_INT_STACK 50
+static int istack[MAX_INT_STACK]; /* Int stack */
+static int isp = MAX_INT_STACK;
+
+static int DontAcceptFiles = 0; /* if stdin, don't read files */
+static int DontAcceptStdin = 0; /* if files seen first, don't accept stdin */
+
+static int tnodes_used_in_guard_predicates_etc; /* MR10 */
+
+ /* C m d - L i n e O p t i o n S t r u c t & F u n c s */
+
+typedef struct _Opt {
+ char *option;
+ int arg;
+#ifdef __cplusplus
+ void (*process)(...);
+#else
+ void (*process)();
+#endif
+ char *descr;
+ } Opt;
+
+#ifdef __USE_PROTOS
+extern void ProcessArgs(int, char **, Opt *);
+#else
+extern void ProcessArgs();
+#endif
+
+#ifdef __USE_PROTOS
+int ci_strequ(char *a,char *b)
+#else
+int ci_strequ(a,b)
+ char *a;
+ char *b;
+#endif
+{
+ for ( ;*a != 0 && *b != 0; a++, b++) {
+ if (toupper(*a) != toupper(*b)) return 0;
+ }
+ return (*a == *b);
+}
+
+static void
+#ifdef __USE_PROTOS
+pStdin( void )
+#else
+pStdin( )
+#endif
+{
+ if ( DontAcceptStdin )
+ {
+ warnNoFL("'-' (stdin) ignored as files were specified first");
+ return;
+ }
+
+ require(NumFiles<MaxNumFiles,"exceeded max # of input files");
+ FileStr[NumFiles++] = "stdin";
+ DontAcceptFiles = 1;
+}
+
+static void
+#ifdef __USE_PROTOS
+pFile( char *s )
+#else
+pFile( s )
+char *s;
+#endif
+{
+ if ( *s=='-' ) { warnNoFL( eMsg1("invalid option: '%s'",s) ); return; }
+ if ( DontAcceptFiles )
+ {
+ warnNoFL(eMsg1("file '%s' ignored as '-' (stdin option) was specified first",s));
+ return;
+ }
+
+ require(NumFiles<MaxNumFiles,"exceeded max # of input files");
+ FileStr[NumFiles++] = s;
+ DontAcceptStdin = 1;
+}
+
+/* MR14
+ Allow input to be a file containing a list of files
+ Bernard Giroud (b_giroud@decus.ch)
+*/
+
+static void
+#ifdef __USE_PROTOS
+pFileList( char *s, char *t )
+#else
+pFileList( s, t )
+char *s;
+char *t;
+#endif
+{
+#define MaxFLArea 1024
+ FILE *fl;
+ static char Fn_in_Fl[MaxFLArea] = "";
+ char one_fn[MaxFileName];
+ char *flp = &Fn_in_Fl[0];
+ int fnl, left = MaxFLArea, i;
+
+ if ( *t=='-' ) { warnNoFL( eMsg1("invalid option: '%s'",t) ); return; }
+ if ( DontAcceptFiles )
+ {
+ warnNoFL(eMsg1("file '%s' ignored as '-' (stdin option) was specified first",t));
+ return;
+ }
+
+ if ((fl = fopen(t, "r")) == NULL)
+ {
+ warnNoFL(eMsg1("file '%s' can't be opened", t));
+ return;
+ }
+ for (;;)
+ {
+ if (fgets(one_fn, 128 - 1, fl) == NULL)
+ break;
+ fnl = strlen(one_fn);
+ require(fnl<=left, "no more room in File List Area");
+ /* drop the trailing LF */
+ if (one_fn[fnl - 1] == 0x0a) one_fn[fnl - 1] = ' ';
+ strcat(Fn_in_Fl, one_fn);
+ left = left - fnl;
+ require(NumFiles<MaxNumFiles,"exceeded max # of input files");
+ FileStr[NumFiles++] = flp;
+ flp = flp + fnl;
+ }
+ fclose(fl);
+ for (i=0;i < MaxFLArea;i++) if (Fn_in_Fl[i] == ' ') Fn_in_Fl[i] = '\0';
+ DontAcceptStdin = 1;
+}
+
+static void
+#ifdef __USE_PROTOS
+pLLK( char *s, char *t )
+#else
+pLLK( s, t )
+char *s;
+char *t;
+#endif
+{
+ LL_k = atoi(t);
+ if ( LL_k <= 0 ) {
+ warnNoFL("must have at least one token of lookahead (setting to 1)");
+ LL_k = 1;
+ }
+}
+
+static void
+#ifdef __USE_PROTOS
+pCk( char *s, char *t )
+#else
+pCk( s, t )
+char *s;
+char *t;
+#endif
+{
+ CLL_k = atoi(t);
+ if ( CLL_k <= 0 ) {
+ warnNoFL("must have at least one token of look-ahead (setting to 1)");
+ CLL_k = 1;
+ }
+}
+
+static void /* MR6 */
+#ifdef __USE_PROTOS
+pTab( char *s, char *t ) /* MR6 */
+#else
+pTab( s, t ) /* MR6 */
+char *s; /* MR6 */
+char *t; /* MR6 */
+#endif
+{ /* MR6 */
+ TabWidth = atoi(t); /* MR6 */
+ if ( TabWidth < 0 || TabWidth > 8 ) { /* MR6 */
+ warnNoFL("tab width must be between 1 and 8"); /* MR6 */
+ TabWidth=0; /* MR6 */
+ } /* MR6 */
+} /* MR6 */
+
+static int ambAidDepthSpecified=0; /* MR11 */
+
+static void /* MR11 */
+#ifdef __USE_PROTOS
+pAAd( char *s, char *t ) /* MR11 */
+#else
+pAAd( s, t ) /* MR11 */
+char *s; /* MR11 */
+char *t; /* MR11 */
+#endif
+{ /* MR11 */
+ ambAidDepthSpecified=1; /* MR11 */
+ MR_AmbAidDepth = atoi(t); /* MR11 */
+} /* MR11 */
+
+static void /* MR11 */
+#ifdef __USE_PROTOS
+pTreport( char *s, char *t ) /* MR11 */
+#else
+pTreport( s, t ) /* MR11 */
+ char *s; /* MR11 */
+ char *t; /* MR11 */
+#endif
+{ /* MR11 */
+ TnodesReportThreshold = atoi(t); /* MR11 */
+} /* MR11 */
+
+#ifdef __USE_PROTOS
+void chkGTFlag(void) /* 7-Apr-97 MR1 */
+#else
+void chkGTFlag() /* 7-Apr-97 MR1 */
+#endif
+{
+ if ( !GenAST )
+ warn("#-variable or other AST item referenced w/o -gt option");
+}
+
+
+#ifdef __USE_PROTOS
+static void pInfo(char *s, char *t) /* MR10 */
+#else
+static void pInfo(s,t) /* MR10 */
+ char *s;
+ char *t;
+#endif
+{
+ char *p;
+ int q;
+ for (p=t; *p != 0; p++) {
+ q=tolower(*p);
+ if (q=='t') {
+ InfoT=1;
+ } else if (q=='p') {
+ InfoP=1;
+ } else if (q=='m') {
+ InfoM=1;
+ } else if (q=='o') {
+ InfoO=1;
+ } else if (q=='0') {
+ ; /* nothing */
+ } else if (q=='f') {
+ InfoF=1;
+ } else {
+ warnNoFL(eMsgd("unrecognized -info option \"%c\"",(int)*p));
+ };
+ };
+}
+
+#ifdef __USE_PROTOS
+static void pCGen(void) { CodeGen = FALSE; LexGen = FALSE; }
+static void pLGen(void) { LexGen = FALSE; }
+static void pXTGen(void){ MR_Inhibit_Tokens_h_Gen = TRUE; }
+static void pTGen(void) { TraceGen = TRUE; }
+static void pSGen(void) { GenExprSetsOpt = FALSE; }
+static void pPrt(void) { PrintOut = TRUE; pCGen(); pLGen(); }
+static void pPrtA(void) { PrintOut = TRUE; PrintAnnotate = TRUE; pCGen(); pLGen(); }
+static void pAst(void) { GenAST = TRUE; }
+static void pANSI(void) { GenANSI = TRUE; }
+static void pCr(void) { GenCR = TRUE; }
+static void pNOPURIFY(void) { PURIFY = FALSE; }
+/*static void pCt(void) { warnNoFL("-ct option is now the default"); }*/
+static void pLI(void) { GenLineInfo = TRUE; GenLineInfoMS = FALSE; } /* MR14 */
+static void pLIms(void) { GenLineInfo = TRUE; GenLineInfoMS = TRUE; } /* MR14 */
+static void pFr(char *s, char *t) {RemapFileName = t;}
+static void pFe(char *s, char *t) {ErrFileName = t;}
+static void pFl(char *s, char *t) {DlgFileName = t;}
+static void pFm(char *s, char *t) {ModeFileName = t;}
+static void pFt(char *s, char *t) {DefFileName = t;}
+
+static void pE1(void) { elevel = 1; }
+static void pE2(void) { elevel = 2; }
+static void pE3(void) { elevel = 3; }
+static void pEGen(void) { GenEClasseForRules = 1; }
+static void pDL(void)
+ {
+ DemandLookahead = 1;
+ if ( GenCC ) {
+ warnNoFL("-gk does not work currently in C++ mode; -gk turned off");
+ DemandLookahead = 0;
+ }
+ }
+
+static void pAA(char *s,char *t) {MR_AmbAidRule = t;} /* MR11 */
+static void pAAm(char *s){MR_AmbAidMultiple = 1;} /* MR11 */
+static void pGHdr(void) { GenStdPccts = 1; }
+static void pFHdr(char *s, char *t) { stdpccts = t; pGHdr(); }
+static void pW1(void) { WarningLevel = 1; }
+static void pNewAST(void) { NewAST = 1; } /* MR13 */
+static void ptmakeInParser(void) { tmakeInParser = 1; } /* MR23 */
+static void pAlpha(void) { AlphaBetaTrace = 1; } /* MR14 */
+static void pMR_BlkErr(void) { MR_BlkErr = 1; } /* MR21 */
+static void pStdout(void) {UseStdout = 1; } /* MR6 */
+static void pW2(void) { WarningLevel = 2; }
+static void pCC(void) { GenCC = TRUE; }
+#else
+static void pCGen() { CodeGen = FALSE; LexGen = FALSE; }
+static void pLGen() { LexGen = FALSE; }
+static void pXTGen(){ MR_Inhibit_Tokens_h_Gen = TRUE; } /* MR14 */
+static void pTGen() { TraceGen = TRUE; }
+static void pSGen() { GenExprSetsOpt = FALSE; }
+static void pPrt() { PrintOut = TRUE; pCGen(); pLGen(); }
+static void pPrtA() { PrintOut = TRUE; PrintAnnotate = TRUE; pCGen(); pLGen(); }
+static void pAst() { GenAST = TRUE; }
+static void pANSI() { GenANSI = TRUE; }
+static void pCr() { GenCR = TRUE; }
+static void pNOPURIFY() { PURIFY = FALSE; }
+
+/*static void pCt() { warnNoFL("-ct option is now the default"); }*/
+static void pLI() { GenLineInfo = TRUE; GenLineInfoMS = FALSE; } /* MR14 */
+static void pLIms() { GenLineInfo = TRUE; GenLineInfoMS = TRUE; } /* MR14 */
+static void pFr(s,t) char *s, *t; {RemapFileName = t;}
+static void pFe(s,t) char *s, *t; {ErrFileName = t;}
+static void pFl(s,t) char *s, *t; {DlgFileName = t;}
+static void pFm(s,t) char *s, *t; {ModeFileName = t;}
+static void pFt(s,t) char *s, *t; {DefFileName = t;}
+
+static void pE1() { elevel = 1; }
+static void pE2() { elevel = 2; }
+static void pE3() { elevel = 3; }
+static void pEGen() { GenEClasseForRules = 1; }
+static void pDL()
+ {
+ DemandLookahead = 1;
+ if ( GenCC ) {
+ warnNoFL("-gk does not work currently in C++ mode; -gk turned off");
+ DemandLookahead = 0;
+ }
+ }
+
+static void pAA(s,t) char *s; char *t; {MR_AmbAidRule = t;} /* MR11 BJS 20-Mar-98 */
+static void pAAm(s) char *s; {MR_AmbAidMultiple = 1;} /* MR11 BJS 20-Mar-98 */
+static void pGHdr() { GenStdPccts = 1; }
+static void pFHdr(s,t) char *s, *t; { stdpccts = t; pGHdr(); }
+static void pW1() { WarningLevel = 1; }
+static void pNewAST() { NewAST = 1; } /* MR13 */
+static void ptmakeInParser() { tmakeInParser = 1; } /* MR23 */
+static void pAlpha() { AlphaBetaTrace = 1; } /* MR14 */
+static void pMR_BlkErr() { MR_BlkErr = 1; } /* MR21 */
+static void pStdout() {UseStdout = 1; } /* MR6 */
+static void pW2() { WarningLevel = 2; }
+static void pCC() { GenCC = TRUE; }
+#endif
+
+static void
+#ifdef __USE_PROTOS
+pPre( char *s, char *t )
+#else
+pPre( s, t )
+char *s;
+char *t;
+#endif
+{
+ RulePrefix = t;
+}
+
+static void
+#ifdef __USE_PROTOS
+pOut( char *s, char *t )
+#else
+pOut( s, t )
+char *s;
+char *t;
+#endif
+{
+ OutputDirectory = t;
+}
+
+static void
+#ifdef __USE_PROTOS
+pPred( void )
+#else
+pPred( )
+#endif
+{
+ warnNoFL("-pr is no longer used (predicates employed if present); see -prc, -mrhoist, -mrhoistk");
+/*
+** if ( DemandLookahead )
+** warnNoFL("-gk conflicts with -pr; -gk turned off");
+** DemandLookahead = 0;
+** HoistPredicateContext = 0;
+*/
+}
+
+static void
+#ifdef __USE_PROTOS
+pPredCtx( char *s, char *t )
+#else
+pPredCtx(s,t)
+char *s;
+char *t;
+#endif
+{
+ if ( ci_strequ(t,"on")) HoistPredicateContext = 1;
+ else if ( ci_strequ(t,"off")) HoistPredicateContext = 0;
+ if ( DemandLookahead )
+ {
+ warnNoFL("-gk incompatible with semantic predicate usage; -gk turned off");
+ DemandLookahead = 0;
+ }
+}
+
+static void
+#ifdef __USE_PROTOS
+pMRhoist( char *s, char *t )
+#else
+pMRhoist(s,t)
+char *s;
+char *t;
+#endif
+{
+ if ( ci_strequ(t,"on")) MRhoisting = 1;
+ else if ( ci_strequ(t,"off")==0 ) MRhoisting = 0;
+ if (MRhoisting) {
+ fprintf(stderr,"Maintenance Release style hoisting enabled for predicates with lookahead depth = 1\n");
+ fprintf(stderr," No longer considered experimental\n");
+ fprintf(stderr," Can't consider suppression for predicates with lookahead depth > 1\n");
+ fprintf(stderr," Implies -prc on but does *not* imply -mrhoistk for k>1 predicates\n");
+ fprintf(stderr," This is a reminder, not a warning or error.\n");
+ };
+}
+
+static void
+#ifdef __USE_PROTOS
+pMRhoistk( char *s, char *t )
+#else
+pMRhoistk(s,t)
+char *s;
+char *t;
+#endif
+{
+ if ( ci_strequ(t,"on")) MRhoistingk = 1;
+ else if ( ci_strequ(t,"off")==0 ) MRhoistingk = 0;
+ if (MRhoistingk) {
+ fprintf(stderr,"EXPERIMENTAL Maintenance Release style hoisting enabled\n");
+ fprintf(stderr," Applies to predicates with lookahead depth > 1\n");
+ fprintf(stderr," Implies -prc on and -mrhoist on\n");
+ };
+}
+
+static void
+#ifdef __USE_PROTOS
+pTRes( char *s, char *t )
+#else
+pTRes( s, t )
+char *s;
+char *t;
+#endif
+{
+ TreeResourceLimit = atoi(t);
+ if ( TreeResourceLimit <= 0 )
+ {
+ warnNoFL("analysis resource limit (# of tree nodes) must be greater than 0");
+ TreeResourceLimit = -1; /* set to no limit */
+ }
+}
+
+Opt options[] = {
+#ifdef __cplusplus
+ { "-CC", 0, (void (*)(...)) pCC, "Generate C++ output (default=FALSE)"},
+ { "-ck", 1, (void (*)(...)) pCk, "Set compressed lookahead depth; fast approximate lookahead"},
+ { "-cr", 0, (void (*)(...)) pCr, "Generate cross reference (default=FALSE)"},
+ { "-e1", 0, (void (*)(...)) pE1, "Ambiguities/errors shown in low detail (default)"},
+ { "-e2", 0, (void (*)(...)) pE2, "Ambiguities/errors shown in more detail"},
+ { "-e3", 0, (void (*)(...)) pE3,
+ "Ambiguities for k>1 grammars shown with exact tuples (not lookahead sets)"},
+ { "-f", 1, (void (*)(...)) pFileList,"Read names of grammar files from specified file"}, /* MR14 */
+ { "-fe", 1, (void (*)(...)) pFe, "Rename err.c"},
+ { "-fh", 1, (void (*)(...)) pFHdr, "Rename stdpccts.h header (turns on -gh)"},
+ { "-fl", 1, (void (*)(...)) pFl, "Rename lexical output--parser.dlg"},
+ { "-fm", 1, (void (*)(...)) pFm, "Rename mode.h"},
+ { "-fr", 1, (void (*)(...)) pFr, "Rename remap.h"},
+ { "-ft", 1, (void (*)(...)) pFt, "Rename tokens.h"},
+ { "-ga", 0, (void (*)(...)) pANSI, "Generate ANSI-compatible code (default=FALSE)"},
+ { "-gc", 0, (void (*)(...)) pCGen, "Do not generate output parser code (default=FALSE)"},
+ { "-gd", 0, (void (*)(...)) pTGen, "Generate code to trace rule invocation (default=FALSE)"},
+ { "-ge", 0, (void (*)(...)) pEGen, "Generate an error class for each non-terminal (default=FALSE)"},
+ { "-gh", 0, (void (*)(...)) pGHdr, "Generate stdpccts.h for non-ANTLR-generated-files to include"},
+ { "-gk", 0, (void (*)(...)) pDL, "Generate parsers that delay lookahead fetches until needed"},
+ { "-gl", 0, (void (*)(...)) pLI, "Generate line info about grammar actions in parser"},
+ { "-glms", 0, (void (*)(...)) pLIms,"Like -gl but replace '\\' with '/' in #line filenames for MS C/C++ systems"},
+ { "-gp", 1, (void (*)(...)) pPre, "Prefix all generated rule functions with a string"},
+ { "-gs", 0, (void (*)(...)) pSGen, "Do not generate sets for token expression lists (default=FALSE)"},
+ { "-gt", 0, (void (*)(...)) pAst, "Generate code for Abstract-Syntax-Trees (default=FALSE)"},
+ { "-gx", 0, (void (*)(...)) pLGen, "Do not generate lexical (dlg-related) files (default=FALSE)"},
+ { "-gxt",0, (void (*)(...)) pXTGen, "Do not generate tokens.h (default=FALSE)"},
+ { "-k", 1, (void (*)(...)) pLLK, "Set full LL(k) lookahead depth (default==1)"},
+ { "-o", 1, (void (*)(...)) pOut, OutputDirectoryOption},
+ { "-p", 0, (void (*)(...)) pPrt, "Print out the grammar w/o actions (default=no)"},
+ { "-pa", 0, (void (*)(...)) pPrtA, "Print out the grammar w/o actions & w/FIRST sets (default=no)"},
+ { "-pr",0, (void (*)(...)) pPred, "no longer used; predicates employed if present"},
+ { "-prc", 1, (void (*)(...)) pPredCtx,"Turn on/off computation of context for hoisted predicates"},
+ { "-rl", 1, (void (*)(...)) pTRes, "Limit max # of tree nodes used by grammar analysis"},
+ { "-stdout",0, (void (*)(...)) pStdout,"Send grammar.c/grammar.cpp to stdout"}, /* MR6 */
+ { "-tab", 1, (void (*)(...)) pTab, "Width of tabs (1 to 8) for grammar.c/grammar.cpp files"}, /* MR6 */
+ { "-w1", 0, (void (*)(...)) pW1, "Set the warning level to 1 (default)"},
+ { "-w2", 0, (void (*)(...)) pW2, "Ambiguities yield warnings even if predicates or (...)? block"},
+ { "-", 0, (void (*)(...)) pStdin, "Read grammar from stdin" },
+ { "-mrhoist",1, (void (*)(...)) pMRhoist, /* MR9 */
+ "Turn on/off k=1 Maintenance Release style hoisting"}, /* MR9 */
+ { "-mrhoistk",1, (void (*)(...)) pMRhoistk, /* MR9 */
+ "Turn on/off EXPERIMENTAL k>1 Maintenance Release style hoisting"}, /* MR13 */
+ { "-aa" , 1, (void (*)(...)) pAA, "Ambiguity aid for a rule (rule name or line number)"}, /* MR11 */
+ { "-aam" , 0, (void (*)(...)) pAAm,
+ "Lookahead token may appear multiple times in -aa listing"}, /* MR11 */
+ { "-aad" , 1, (void (*)(...)) pAAd,
+ "Limits exp growth of -aa listing - default=1 (max=ck value)"}, /* MR11 */
+ { "-info", 1, (void (*)(...)) pInfo,
+ "Extra info: p=pred t=tnodes f=first/follow m=monitor o=orphans 0=noop"}, /* MR12 */
+ { "-treport",1,(void (*)(...)) pTreport,
+ "Report when tnode usage exceeds value during ambiguity resolution"}, /* MR11 */
+ { "-newAST", 0, (void (*)(...)) pNewAST,
+ "In C++ mode use \"newAST(...)\" rather than \"new AST(...)\""}, /* MR13 */
+ { "-tmake", 0, (void (*)(...)) ptmakeInParser,
+ "In C++ mode use parser's tmake method rather than \"ASTBase::tmake(...)\""}, /* MR23 */
+ { "-alpha",0,(void (*)(...)) pAlpha,
+ "Provide additional information for \"(alpha)? beta\" error messages"}, /* MR14 */
+ { "-mrblkerr",0,(void (*)(...)) pMR_BlkErr, /* MR21 */
+ "EXPERIMENTAL change to (...)* and (...)+ syntax error sets"}, /* MR21 */
+ { "-nopurify",0,(void (*)(...)) pNOPURIFY,
+ "Don't use the notorious PURIFY macro (replaced by MR23 initial value syntax) to zero return arguments of rules"}, /* MR23 */
+ { "*", 0, (void (*)(...)) pFile, "" }, /* anything else is a file */
+#else
+ { "-CC", 0, pCC, "Generate C++ output (default=FALSE)"},
+ { "-cr", 0, pCr, "Generate cross reference (default=FALSE)"},
+ { "-ck", 1, pCk, "Set compressed lookahead depth; fast approximate lookahead"},
+ { "-e1", 0, pE1, "Ambiguities/errors shown in low detail (default)"},
+ { "-e2", 0, pE2, "Ambiguities/errors shown in more detail"},
+ { "-e3", 0, pE3, "Ambiguities for k>1 grammars shown with exact tuples (not lookahead sets)"},
+ { "-f", 1, pFileList,"Read names of grammar files from specified file"}, /* MR14 */
+ { "-fe", 1, pFe, "Rename err.c"},
+ { "-fh", 1, pFHdr, "Rename stdpccts.h header (turns on -gh)"},
+ { "-fl", 1, pFl, "Rename lexical output--parser.dlg"},
+ { "-fm", 1, pFm, "Rename mode.h"},
+ { "-fr", 1, pFr, "Rename remap.h"},
+ { "-ft", 1, pFt, "Rename tokens.h"},
+ { "-ga", 0, pANSI, "Generate ANSI-compatible code (default=FALSE)"},
+ { "-gc", 0, pCGen, "Do not generate output parser code (default=FALSE)"},
+ { "-gd", 0, pTGen, "Generate code to trace rule invocation (default=FALSE)"},
+ { "-ge", 0, pEGen, "Generate an error class for each non-terminal (default=FALSE)"},
+ { "-gh", 0, pGHdr, "Generate stdpccts.h for non-ANTLR-generated-files to include"},
+ { "-gk", 0, pDL, "Generate parsers that delay lookahead fetches until needed"},
+ { "-gl", 0, pLI, "Generate line info about grammar actions in C parser"},
+ { "-glms", 0, pLIms,"Like -gl but replace '\\' with '/' in #line filenames for MS C/C++ systems"},
+ { "-gp", 1, pPre, "Prefix all generated rule functions with a string"},
+ { "-gs", 0, pSGen, "Do not generate sets for token expression lists (default=FALSE)"},
+ { "-gt", 0, pAst, "Generate code for Abstract-Syntax-Trees (default=FALSE)"},
+ { "-gx", 0, pLGen, "Do not generate lexical (dlg-related) files (default=FALSE)"},
+ { "-gxt",0, pXTGen, "Do not generate tokens.h (default=FALSE)"},
+ { "-k", 1, pLLK, "Set full LL(k) lookahead depth (default==1)"},
+ { "-o", 1, pOut, OutputDirectoryOption},
+ { "-p", 0, pPrt, "Print out the grammar w/o actions (default=no)"},
+ { "-pa", 0, pPrtA, "Print out the grammar w/o actions & w/FIRST sets (default=no)"},
+ { "-pr",0, pPred, "no longer used; predicates employed if present"},
+ { "-prc", 1, pPredCtx,"Turn on/off computation of context for hoisted predicates"},
+ { "-rl", 1, pTRes, "Limit max # of tree nodes used by grammar analysis"},
+ { "-stdout",0, pStdout, "Send grammar.c/grammar.cpp to stdout"}, /* MR6 */
+ { "-tab", 1, pTab, "Width of tabs (1 to 8) for grammar.c/grammar.cpp files"}, /* MR6 */
+ { "-w1", 0, pW1, "Set the warning level to 1 (default)"},
+ { "-w2", 0, pW2, "Ambiguities yield warnings even if predicates or (...)? block"},
+ { "-mrhoist",1,pMRhoist, /* MR9 */
+ "Turn on/off k=1 Maintenance Release style hoisting"}, /* MR9 */
+ { "-mrhoistk",1,pMRhoistk, /* MR13 */
+ "Turn on/off k>1 EXPERIMENTAL Maintenance Release style hoisting"}, /* MR13 */
+ { "-aa" ,1,pAA, "Ambiguity aid for a rule (rule name or line number)"}, /* MR11 */
+ { "-aam" ,0,pAAm,
+ "Lookahead token may appear multiple times in -aa listing"}, /* MR11 */
+ { "-aad" ,1,pAAd,
+ "Limits exp growth of -aa listing - default=1 (max=ck value)"}, /* MR11 */
+ { "-info",1,pInfo,
+ "Extra info: p=pred t=tnodes f=first/follow m=monitor o=orphans 0=noop"}, /* MR11 */
+ { "-treport",1,pTreport,
+ "Report when tnode usage exceeds value during ambiguity resolution"}, /* MR11 */
+ { "-newAST", 0, pNewAST,
+ "In C++ mode use \"newAST(...)\" rather than \"new AST(...)\""}, /* MR13 */
+ { "-tmake", 0, ptmakeInParser,
+ "In C++ mode use parser's tmake method rather than \"ASTBase::tmake(...)\""}, /* MR23 */
+ { "-alpha",0, pAlpha,
+ "Provide additional information for \"(alpha)? beta\" error messages"}, /* MR14 */
+ { "-mrblkerr",0,pMR_BlkErr, /* MR21 */
+ "EXPERIMENTAL change to (...)* and (...)+ syntax error sets"}, /* MR21 */
+ { "-nopurify",0,pNOPURIFY,
+ "Don't use the notorious PURIFY macro (replaced by MR23 initial value syntax) to zero return arguments of rules"}, /* MR23 */
+ { "-", 0, pStdin, "Read grammar from stdin" },
+ { "*", 0, pFile, "" }, /* anything else is a file */
+#endif
+ { NULL, 0, NULL }
+ };
+
+void readDescr();
+void cleanUp();
+
+#ifdef __USE_PROTOS
+static void buildRulePtr( void );
+static void help( void );
+static void init( void );
+static void CompleteTokenSetRefs( void );
+static void ensure_no_C_file_collisions(char *);
+static void CompleteContextGuards(void);
+#else
+static void buildRulePtr( );
+static void help( );
+static void init( );
+static void CompleteTokenSetRefs( );
+static void ensure_no_C_file_collisions();
+static void CompleteContextGuards();
+#endif
+
+static void
+#ifdef __USE_PROTOS /* <BJS> */
+report_numericPredLabels(ActionNode *a)
+#else
+report_numericPredLabels(a)
+ActionNode *a;
+#endif
+{ /* MR10 */
+ warnFL("numeric references to attributes (e.g. $i or $i.j) in semantic pred will be null during guess mode", /* MR10 */
+ FileStr[a->file],a->line); /* MR10 */
+} /* MR10 */
+
+ /* M a i n */
+
+int
+#ifdef __USE_PROTOS
+main( int argc, char *argv[] )
+#else
+main( argc, argv )
+int argc;
+char *argv[];
+#endif
+{
+ int i;
+ static char EPSTR[] = "[Ep]";
+
+ Save_argc=argc; /* MR10 */
+ Save_argv=argv; /* MR10 */
+
+/* malloc_debug(8);*/
+
+#ifdef SPECIAL_INITS
+ special_inits(); /* MR1 */
+#endif
+ fprintf(stderr, "Antlr parser generator Version %s 1989-2001\n", Version);
+ if ( argc == 1 ) { help(); zzDIE; }
+ ProcessArgs(argc-1, &(argv[1]), options);
+
+/* MR14 */ if (MR_AmbAidRule && AlphaBetaTrace) {
+/* MR14 */ fatal("Can't specify both -aa (ambiguity aid) and -alpha (\"(alpha)? beta\" aid)");
+/* MR14 */ }
+
+ if (MRhoistingk) { /* MR13 */
+ HoistPredicateContext=1; /* MR13 */
+ MRhoisting=1; /* MR13 */
+ }; /* MR13 */
+ if (MRhoisting && ! HoistPredicateContext) {
+/*** warnNoFL("Using \"-mrhoist\" forces \"-prc on\""); ***/
+ HoistPredicateContext=1;
+ };
+ if (HoistPredicateContext && ! MRhoisting) {
+ warnNoFL("When using predicate context (-prc on) -mrhoist on is recommended");
+ }
+ /* Fix lookahead depth */
+ /* Compressed lookahead must always be larger than or equal to full lookahead */
+ if ( CLL_k < LL_k && CLL_k>0 )
+ {
+ warnNoFL("must have compressed lookahead >= full LL(k) lookahead (setting -ck to -k)");
+ CLL_k = LL_k;
+ }
+ if ( CLL_k == -1 ) CLL_k = LL_k;
+ OutputLL_k = CLL_k;
+ if ( ((CLL_k-1)&CLL_k)!=0 ) { /* output ll(k) must be power of 2 */
+ int n;
+ for(n=1; n<CLL_k; n<<=1) {;}
+ OutputLL_k = n;
+ };
+
+ if (MR_BlkErr) {
+ warnNoFL("The -mrblkerr option is EXPERIMENTAL");
+ if (LL_k > 1) {
+ warnNoFL("The -mrblkerr option is designed only for k=1 ck=1 grammars");
+ }
+ };
+
+ if ( ! ambAidDepthSpecified) {
+ MR_AmbAidDepth=1;
+ } else {
+ if (MR_AmbAidDepth > CLL_k || MR_AmbAidDepth <= 0) {
+ warnNoFL(eMsgd(
+ "Ambiguity aid depth (\"-aad ...\") must be a number between 1 and max(k,ck)=%d",CLL_k));
+ MR_AmbAidDepth=1;
+ };
+ if (MR_AmbAidDepth == 0) {
+ MR_AmbAidDepth=2;
+ };
+ };
+
+ if (MR_AmbAidRule != NULL) MR_AmbAidLine=atoi(MR_AmbAidRule);
+
+ fpTrans = &(C_Trans[0]); /* Translate to C Language */
+ fpJTrans = &(C_JTrans[0]);
+ init();
+ lexclass(LexStartSymbol);
+
+ readDescr();
+ LastTokenCounted = TokenNum;
+ RemapForcedTokens();
+ if ( CannotContinue ) {cleanUp(); zzDIE;}
+ if ( GenCC && no_classes_found ) fatal("required grammar class not found (exiting...)");
+ if ( WarningLevel>1 && HdrAction == NULL )
+ warnNoFL("no #header action was found");
+ if ( FoundAtOperator && ! FoundExceptionGroup) {
+ warnNoFL("found the exception operator '@' - but no exception group was found");
+ };
+ EpToken = addTname(EPSTR); /* add imaginary token epsilon */
+ set_orel(EpToken, &imag_tokens);
+
+ /* this won't work for hand-built scanners since EofToken is not
+ * known. Forces EOF to be token type 1.
+ */
+ set_orel(EofToken, &imag_tokens);
+
+ set_size(NumWords(TokenNum-1));
+
+ /* compute the set of all known token types
+ * It represents the set of tokens from 1 to last_token_num + the
+ * reserved positions above that (if any). Don't include the set of
+ * imaginary tokens such as the token/error classes or EOF.
+ */
+ {
+ set a;
+ a = set_dup(reserved_positions);
+ for (i=1; i<TokenNum; i++) { set_orel(i, &a); }
+ all_tokens = set_dif(a, imag_tokens);
+ set_free(a);
+ }
+
+ ComputeTokSets(); /* Compute #tokclass sets */
+ CompleteTokenSetRefs(); /* Change complex nodes in syn diag */
+ CompleteContextGuards(); /* MR13 */
+
+ if ( CodeGen ) genDefFile(); /* create tokens.h */
+ if ( LexGen ) genLexDescr(); /* create parser.dlg */
+
+ if ( GenStdPccts )
+ {
+ FILE *f = fopen(OutMetaName(stdpccts), "w");
+ if ( f==NULL ) {warnNoFL( eMsg1("can't create %s",OutMetaName(stdpccts)) );}
+ else
+ {
+#ifdef SPECIAL_FOPEN
+ special_fopen_actions(OutMetaName(stdpccts)); /* MR1 */
+#endif
+ if (strcmp(stdpccts,"stdpccts.h") == 0) { /* MR10 */
+ genStdPCCTSIncludeFile(f,NULL); /* MR10 */
+ } else { /* MR10 */
+ genStdPCCTSIncludeFile(f,pcctsBaseName(stdpccts)); /* MR32 */
+ };
+ fclose(f);
+ }
+ }
+
+ buildRulePtr(); /* create mapping from rule # to RuleBlk junction */
+ ComputeErrorSets();
+ FoLink( (Node *)SynDiag ); /* add follow links to end of all rules */
+
+ if ( GenCR ) GenCrossRef( SynDiag );
+
+ if ( CodeGen )
+ {
+ if ( SynDiag == NULL )
+ {
+ warnNoFL("no grammar description recognized");
+ cleanUp();
+ zzDIE;
+ }
+ else if ( !GenCC ) {
+ ErrFile = fopen(OutMetaName(ErrFileName), "w");
+ require(ErrFile != NULL, "main: can't open err file");
+#ifdef SPECIAL_FOPEN
+ special_fopen_actions(OutMetaName(ErrFileName)); /* MR1 */
+#endif
+ NewSetWd();
+ GenErrHdr();
+ TRANS(SynDiag); /* Translate to the target language */
+ DumpSetWd();
+ DumpRemainingTokSets();
+ fclose( ErrFile );
+ }
+ else {
+ strcpy(Parser_h_Name, CurrentClassName);
+ strcat(Parser_h_Name, ".h");
+ strcpy(Parser_c_Name, CurrentClassName);
+ strcat(Parser_c_Name, CPP_FILE_SUFFIX);
+ ensure_no_C_file_collisions(Parser_c_Name);
+ Parser_h = fopen(OutMetaName(Parser_h_Name), "w");
+ require(Parser_h != NULL, "main: can't open class Parserx.h file");
+#ifdef SPECIAL_FOPEN
+ special_fopen_actions(OutMetaName(Parser_h_Name)); /* MR1 */
+#endif
+ Parser_c = fopen(OutMetaName(Parser_c_Name), "w");
+ require(Parser_c != NULL, "main: can't open class Parserx.c file");
+#ifdef SPECIAL_FOPEN
+ special_fopen_actions(OutMetaName(Parser_c_Name)); /* MR1 */
+#endif
+ GenParser_h_Hdr();
+ if ( class_before_actions != NULL )
+ {
+ ListNode *p;
+ for (p = class_before_actions->next; p!=NULL; p=p->next)
+ {
+ UserAction *ua = (UserAction *)p->elem;
+ dumpAction( ua->action, Parser_h, 0, ua->file, ua->line, 1);
+ }
+ }
+ GenParser_c_Hdr();
+ fprintf(Parser_h, "protected:\n"); /* MR20 */
+ NewSetWd();
+ TRANS(SynDiag); /* Translate to the target language */
+ DumpSetWd();
+ GenRuleMemberDeclarationsForCC(Parser_h, SynDiag);
+ if ( class_after_actions != NULL )
+ {
+ ListNode *p;
+ for (p = class_after_actions->next; p!=NULL; p=p->next)
+ {
+ UserAction *ua = (UserAction *)p->elem;
+ dumpAction( ua->action, Parser_h, 0, ua->file, ua->line, 1);
+ }
+ }
+ DumpRemainingTokSets();
+ fprintf(Parser_h, "};\n");
+ fprintf(Parser_h, "\n#endif /* %s_h */\n", CurrentClassName);
+ fclose( Parser_h );
+ fclose( Parser_c );
+ }
+ }
+
+ MR_orphanRules(stderr);
+ if (LTinTokenAction && WarningLevel >= 2) {
+ if (GenCC) {
+ warnNoFL("At least one <<action>> following a token match contains a reference to LT(...)\n this will reference the immediately preceding token,\n not the one which follows as is the case with semantic predicates.");
+ }
+ warnNoFL("At least one <<action>> following a token match contains a reference to LA(...) or LATEXT(...)\n this will reference the immediately preceding token,\n not the one which follows as is the case with semantic predicates.");
+ }
+
+ if ( PrintOut )
+ {
+ if ( SynDiag == NULL ) {warnNoFL("no grammar description recognized");}
+ else PRINT(SynDiag);
+ }
+
+#ifdef DBG_LL1
+#endif
+ GenRemapFile(); /* create remap.h */
+/* MR10 */ if (FoundGuessBlk) {
+#ifdef __cplusplus__
+/* MR10 */ list_apply(NumericPredLabels, (void (*)(void *))report_numericPredLabels);
+#else
+#ifdef __USE_PROTOS
+/* MR10 */ list_apply(NumericPredLabels, (void (*)(void *))report_numericPredLabels);
+#else
+/* MR10 */ list_apply(NumericPredLabels,report_numericPredLabels);
+#endif
+#endif
+/* MR10 */ };
+
+ if (InfoT && TnodesAllocated > 0) {
+ if (TnodesPeak > 10000) {
+ fprintf(stdout,"\nTree Nodes: peak %dk created %dk lost %d\n",
+ (TnodesPeak/1000),
+ (TnodesAllocated/1000),
+ TnodesInUse-tnodes_used_in_guard_predicates_etc);
+ } else {
+ fprintf(stdout,"\nTree Nodes: peak %d created %d lost %d\n",
+ TnodesPeak,
+ TnodesAllocated,
+ TnodesInUse-tnodes_used_in_guard_predicates_etc);
+ };
+ };
+ if (InfoF) {
+ DumpFcache();
+ };
+ if (MR_skipped_e3_report) {
+ fprintf(stderr,"note: use -e3 to get exact information on ambiguous tuples\n");
+ };
+ if (MR_BadExprSets != 0) {
+ fprintf(stderr,"note: Unreachable C or C++ code was generated for empty expression sets,\n");
+ fprintf(stderr," probably due to undefined rules or infinite left recursion.\n");
+ fprintf(stderr," To locate: search the generated code for \"empty set expression\"\n");
+ };
+ if (MR_AmbAidRule != NULL && MR_matched_AmbAidRule==0) {
+ RuleEntry *q = (RuleEntry *) hash_get(Rname,MR_AmbAidRule);
+ if (MR_AmbAidLine == 0 && q == NULL) {
+ warnNoFL(eMsg2("there is no rule \"%s\" so \"-aa %s\" will never match",
+ MR_AmbAidRule,MR_AmbAidRule));
+ } else {
+ warnNoFL(eMsg1("there was no ambiguity that matched \"-aa %s\"",MR_AmbAidRule));
+ };
+ };
+ if (AlphaBetaTrace) {
+
+ if (MR_AlphaBetaMessageCount == 0) {
+ fprintf(stderr,"note: there were no messages about \"(alpha)? beta\" blocks added to the generated code\n");
+ } else {
+ fprintf(stderr,"note: there were %d messages about \"(alpha)? beta\" blocks added to the generated code\n",
+ MR_AlphaBetaMessageCount);
+ }
+
+ if (set_null(MR_CompromisedRules)) {
+ fprintf(stderr,"note: the list of rules with compromised follow sets is empty\n");
+ } else {
+ fprintf(stderr,"note: the following is a list of rules which *may* have incorrect\n");
+ fprintf(stderr," follow sets computed as a result of an \"(alpha)? beta\" block\n");
+ fprintf(stderr,"\n");
+ MR_dumpRuleSet(MR_CompromisedRules);
+ fprintf(stderr,"\n");
+ }
+ }
+ cleanUp();
+ exit(PCCTS_EXIT_SUCCESS);
+ return 0; /* MR11 make compilers happy */
+}
+
+static void
+#ifdef __USE_PROTOS
+init( void )
+#else
+init( )
+#endif
+{
+ SignalEntry *q;
+
+ Tname = newHashTable();
+ Rname = newHashTable();
+ Fcache = newHashTable();
+ Tcache = newHashTable();
+ Sname = newHashTable();
+ Pname = newHashTable(); /* MR11 */
+
+ /* Add default signal names */
+ q = (SignalEntry *)hash_add(Sname,
+ "NoViableAlt",
+ (Entry *)newSignalEntry("NoViableAlt"));
+ require(q!=NULL, "cannot alloc signal entry");
+ q->signum = sigNoViableAlt;
+ q = (SignalEntry *)hash_add(Sname,
+ "MismatchedToken",
+ (Entry *)newSignalEntry("MismatchedToken"));
+ require(q!=NULL, "cannot alloc signal entry");
+ q->signum = sigMismatchedToken;
+ q = (SignalEntry *)hash_add(Sname,
+ "NoSemViableAlt",
+ (Entry *)newSignalEntry("NoSemViableAlt"));
+ require(q!=NULL, "cannot alloc signal entry");
+ q->signum = sigNoSemViableAlt;
+
+ reserved_positions = empty;
+ all_tokens = empty;
+ imag_tokens = empty;
+ tokclasses = empty;
+ TokenStr = (char **) calloc(TSChunk, sizeof(char *));
+ require(TokenStr!=NULL, "main: cannot allocate TokenStr");
+ FoStack = (int **) calloc(CLL_k+1, sizeof(int *));
+ require(FoStack!=NULL, "main: cannot allocate FoStack");
+ FoTOS = (int **) calloc(CLL_k+1, sizeof(int *));
+ require(FoTOS!=NULL, "main: cannot allocate FoTOS");
+ Cycles = (ListNode **) calloc(CLL_k+1, sizeof(ListNode *));
+ require(Cycles!=NULL, "main: cannot allocate Cycles List");
+ MR_CompromisedRules=empty; /* MR14 */
+}
+
+static void
+#ifdef __USE_PROTOS
+help( void )
+#else
+help( )
+#endif
+{
+ Opt *p = options;
+ fprintf(stderr, "antlr [options] f1 f2 ... fn\n");
+ while ( *(p->option) != '*' )
+ {
+ fprintf(stderr, " %-9s%s %s\n",
+ p->option,
+ (p->arg)?"___":" ",
+ p->descr);
+ p++;
+ }
+}
+
+/* The RulePtr array is filled in here. RulePtr exists primarily
+ * so that sets of rules can be maintained for the FOLLOW caching
+ * mechanism found in rJunc(). RulePtr maps a rule num from 1 to n
+ * to a pointer to its RuleBlk junction where n is the number of rules.
+ */
+static void
+#ifdef __USE_PROTOS
+buildRulePtr( void )
+#else
+buildRulePtr( )
+#endif
+{
+ int r=1;
+ Junction *p = SynDiag;
+ RulePtr = (Junction **) calloc(NumRules+1, sizeof(Junction *));
+ require(RulePtr!=NULL, "cannot allocate RulePtr array");
+
+ while ( p!=NULL )
+ {
+ require(r<=NumRules, "too many rules???");
+ RulePtr[r++] = p;
+ p = (Junction *)p->p2;
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+dlgerror(const char *s)
+#else
+dlgerror(s)
+char *s;
+#endif
+{
+ fprintf(stderr, ErrHdr, FileStr[CurFile], zzline);
+ fprintf(stderr, " lexical error: %s (text was '%s')\n",
+ ((s == NULL) ? "Lexical error" : s), zzlextext);
+}
+
+void
+#ifdef __USE_PROTOS
+readDescr( void )
+#else
+readDescr( )
+#endif
+{
+ zzerr = dlgerror;
+ input = NextFile();
+ if ( input==NULL ) fatal("No grammar description found (exiting...)");
+ ANTLR(grammar(), input);
+ tnodes_used_in_guard_predicates_etc=TnodesInUse; /* MR10 */
+}
+
+FILE *
+#ifdef __USE_PROTOS
+NextFile( void )
+#else
+NextFile( )
+#endif
+{
+ FILE *f;
+
+ for (;;)
+ {
+ CurFile++;
+ if ( CurFile >= NumFiles ) return(NULL);
+ if ( ci_strequ(FileStr[CurFile],"stdin")) return stdin;
+ f = fopen(FileStr[CurFile], "r");
+ if ( f == NULL )
+ {
+ warnNoFL( eMsg1("file %s doesn't exist; ignored", FileStr[CurFile]) );
+ }
+ else
+ {
+ return(f);
+ }
+ }
+}
+
+/*
+ * Return a string corresponding to the output file name associated
+ * with the input file name passed in.
+ *
+ * Observe the following rules:
+ *
+ * f.e --> f".c"
+ * f --> f".c"
+ * f. --> f".c"
+ * f.e.g --> f.e".c"
+ *
+ * Where f,e,g are arbitrarily long sequences of characters in a file
+ * name.
+ *
+ * In other words, if a ".x" appears on the end of a file name, make it
+ * ".c". If no ".x" appears, append ".c" to the end of the file name.
+ *
+ * C++ mode using .cpp not .c.
+ *
+ * Use malloc() for new string.
+ */
+
+char *
+#ifdef __USE_PROTOS
+outname( char *fs )
+#else
+outname( fs )
+char *fs;
+#endif
+{
+ if ( GenCC) {
+ return outnameX(fs,CPP_FILE_SUFFIX);
+ } else {
+ return outnameX(fs,".c");
+ };
+}
+
+char *
+#ifdef __USE_PROTOS
+outnameX( char *fs ,char *suffix)
+#else
+outnameX( fs , suffix )
+char *fs;
+char *suffix;
+#endif
+{
+ static char buf[MaxFileName+1];
+ char *p;
+ require(fs!=NULL&&*fs!='\0', "outname: NULL filename");
+
+ p = buf;
+ strcpy(buf, fs);
+ while ( *p != '\0' ) {p++;} /* Stop on '\0' */
+ while ( *p != '.' && p != buf ) {--p;} /* Find '.' */
+ if ( p != buf ) *p = '\0'; /* Found '.' */
+ require(strlen(buf) + 2 < (size_t)MaxFileName, "outname: filename too big");
+ strcat(buf,suffix);
+ return( buf );
+}
+
+void
+#ifdef __USE_PROTOS
+fatalFL( char *err_, char *f, int l )
+#else
+fatalFL( err_, f, l )
+char *err_;
+char *f;
+int l;
+#endif
+{
+ fprintf(stderr, ErrHdr, f, l);
+ fprintf(stderr, " %s\n", err_);
+ cleanUp();
+ exit(PCCTS_EXIT_FAILURE);
+}
+
+void
+#ifdef __USE_PROTOS
+fatal_intern( char *err_, char *f, int l )
+#else
+fatal_intern( err_, f, l )
+char *err_;
+char *f;
+int l;
+#endif
+{
+ fprintf(stderr, ErrHdr, f, l);
+ fprintf(stderr, " #$%%*&@# internal error: %s\n", err_);
+ fprintf(stderr, ErrHdr, f, l);
+ fprintf(stderr, " [complain to nearest government official\n");
+ fprintf(stderr, ErrHdr, f, l);
+ fprintf(stderr, " or send hate-mail to parrt@parr-research.com;\n");
+ fprintf(stderr, ErrHdr, f, l);
+ fprintf(stderr, " please pray to the ``bug'' gods that there is a trival fix.]\n");
+ cleanUp();
+ exit(PCCTS_EXIT_FAILURE);
+}
+
+void
+#ifdef __USE_PROTOS
+cleanUp( void )
+#else
+cleanUp( )
+#endif
+{
+ if ( DefFile != NULL) fclose( DefFile );
+}
+
+/* sprintf up to 3 strings */
+char *
+#ifdef __USE_PROTOS
+eMsg3( char *s, char *a1, char *a2, char *a3 )
+#else
+eMsg3( s, a1, a2, a3 )
+char *s;
+char *a1;
+char *a2;
+char *a3;
+#endif
+{
+ static char buf[250]; /* DANGEROUS as hell !!!!!! */
+
+ sprintf(buf, s, a1, a2, a3);
+ return( buf );
+}
+
+/* sprintf a decimal */
+char *
+#ifdef __USE_PROTOS
+eMsgd( char *s, int d )
+#else
+eMsgd( s, d )
+char *s;
+int d;
+#endif
+{
+ static char buf[250]; /* DANGEROUS as hell !!!!!! */
+
+ sprintf(buf, s, d);
+ return( buf );
+}
+
+char *
+#ifdef __USE_PROTOS
+eMsgd2( char *s, int d1,int d2)
+#else
+eMsgd2( s, d1, d2 )
+char *s;
+int d1;
+int d2;
+#endif
+{
+ static char buf[250]; /* DANGEROUS as hell !!!!!! */
+
+ sprintf(buf, s, d1, d2);
+ return( buf );
+}
+
+void
+#ifdef __USE_PROTOS
+s_fprT( FILE *f, set e )
+#else
+s_fprT( f, e )
+FILE *f;
+set e;
+#endif
+{
+ register unsigned *p;
+ unsigned *q;
+
+ if ( set_nil(e) ) return;
+ if ( (q=p=set_pdq(e)) == NULL ) fatal_internal("Can't alloc space for set_pdq");
+ fprintf(f, "{");
+ while ( *p != nil )
+ {
+ fprintf(f, " %s", TerminalString(*p));
+ p++;
+ }
+ fprintf(f, " }");
+ free((char *)q);
+}
+
+/* Return the token name or regular expression for a token number. */
+char *
+#ifdef __USE_PROTOS
+TerminalString( int token )
+#else
+TerminalString( token )
+int token;
+#endif
+{
+ int j;
+ static char imag_name[20];
+
+ /* look in all lexclasses for the token */
+ if ( TokenString(token) != NULL ) return TokenString(token);
+ for (j=0; j<NumLexClasses; j++)
+ {
+ lexmode(j);
+ if ( ExprString(token) != NULL ) return ExprString(token);
+ }
+
+ if (1) {
+ sprintf(imag_name,"UnknownToken#%d",token); /* MR13 */
+ return imag_name; /* MR13 */
+ }
+
+ require(j<NumLexClasses, eMsgd("No label or expr for token %d",token));
+ return "invalid";
+}
+
+ /* S i m p l e I n t S t a c k */
+
+void
+#ifdef __USE_PROTOS
+pushint( int i )
+#else
+pushint( i )
+int i;
+#endif
+{
+ require(isp>0, "pushint: stack overflow");
+ istack[--isp] = i;
+}
+
+int
+#ifdef __USE_PROTOS
+popint( void )
+#else
+popint( )
+#endif
+{
+ require(isp<MAX_INT_STACK, "popint: stack underflow");
+ return istack[isp++];
+}
+
+int
+#ifdef __USE_PROTOS
+istacksize( void )
+#else
+istacksize( )
+#endif
+{
+ return MAX_INT_STACK-isp;
+}
+
+void
+#ifdef __USE_PROTOS
+istackreset( void )
+#else
+istackreset( )
+#endif
+{
+ isp = MAX_INT_STACK;
+}
+
+int
+#ifdef __USE_PROTOS
+istackempty( void )
+#else
+istackempty( )
+#endif
+{
+ return isp==MAX_INT_STACK;
+}
+
+int
+#ifdef __USE_PROTOS
+topint( void )
+#else
+topint( )
+#endif
+{
+ require(isp<MAX_INT_STACK, "topint: stack underflow");
+ return istack[isp];
+}
+
+void
+#ifdef __USE_PROTOS
+ProcessArgs( int argc, char **argv, Opt *options )
+#else
+ProcessArgs( argc, argv, options )
+int argc;
+char **argv;
+Opt *options;
+#endif
+{
+ Opt *p;
+ require(argv!=NULL, "ProcessArgs: command line NULL");
+
+ while ( argc-- > 0 )
+ {
+ p = options;
+ while ( p->option != NULL )
+ {
+ if ( strcmp(p->option, "*") == 0 ||
+ ci_strequ(p->option, *argv) == 1 )
+ {
+ if ( p->arg )
+ {
+/* MR9 26-Sep-97 Check for argv valid */
+ if (argc-- > 0) {
+ (*p->process)( *argv, *(argv+1) );
+ argv++;
+ } else {
+fprintf(stderr,"error: required argument for option %s omitted\n",*argv);
+exit(PCCTS_EXIT_FAILURE);
+ };
+ }
+ else
+ (*p->process)( *argv );
+ break;
+ }
+ p++;
+ }
+ argv++;
+ }
+}
+
+static void
+#ifdef __USE_PROTOS
+CompleteContextGuards(void)
+#else
+CompleteContextGuards()
+#endif
+{
+ ListNode * p;
+ Predicate * pred;
+
+ if (ContextGuardPredicateList == NULL) return;
+
+ for (p=ContextGuardPredicateList->next; p != NULL; p=p->next) {
+ pred=(Predicate *)p->elem;
+ recomputeContextGuard(pred);
+ }
+}
+
+/* Go back into the syntax diagram and compute all meta tokens; i.e.
+ * turn all '.', ranges, token class refs etc... into actual token sets
+ */
+static void
+#ifdef __USE_PROTOS
+CompleteTokenSetRefs(void)
+#else
+CompleteTokenSetRefs()
+#endif
+{
+ ListNode *p;
+
+ if ( MetaTokenNodes==NULL ) return;
+ for (p = MetaTokenNodes->next; p!=NULL; p=p->next)
+ {
+ set a,b;
+
+ TokNode *q = (TokNode *)p->elem;
+ if ( q->wild_card )
+ {
+ q->tset = all_tokens;
+ }
+ else if ( q->tclass!=NULL )
+ {
+ if ( q->complement ) q->tset = set_dif(all_tokens, q->tclass->tset);
+ else q->tset = q->tclass->tset;
+ }
+ else if ( q->upper_range!=0 )
+ {
+ /* we have a range on our hands: make a set from q->token .. q->upper_range */
+ int i;
+ a = empty;
+ for (i=q->token; i<=q->upper_range; i++) { set_orel(i, &a); } /* MR13 */
+
+/* MR13 */ if (q->complement) {
+/* MR13 */ q->tset = set_dif(all_tokens, a);
+/* MR13 */ set_free(a);
+/* MR13 */ } else {
+/* MR13 */ q->tset = a;
+/* MR13 */ }
+
+ }
+
+ /* at this point, it can only be a complemented single token */
+ else if ( q->complement )
+ {
+ a = set_of(q->token);
+ b = set_dif(all_tokens, a);
+ set_free(a);
+ q->tset=b;
+ }
+ else fatal("invalid meta token");
+ }
+}
+
+/* MR10: Jeff Vincent
+ MR10: Changed to remove directory information from n only if
+ MR10: if OutputDirectory was changed by user (-o option)
+*/
+
+char *
+#ifdef __USE_PROTOS
+OutMetaName(char *n)
+#else
+OutMetaName(n)
+char *n;
+#endif
+{
+ static char *dir_sym = DirectorySymbol;
+ static char newname[MaxFileName+1];
+ char *p;
+
+ /* If OutputDirectory is same as TopDirectory (platform default) then leave n alone. */
+ if (strcmp(OutputDirectory, TopDirectory) == 0) /* TopDirectory is "." on Unix. */
+ return n;
+
+ /* p will point to filename without path information */
+ if ((p = strrchr(n, *dir_sym)) != NULL) /* Directory symbol is "/" on Unix. */
+ p++;
+ else
+ p = n;
+
+ /* Copy new output directory into newname[] */
+ strcpy(newname, OutputDirectory);
+
+ /* if new output directory does not have trailing dir_sym, add it! */
+ if (newname[strlen(newname)-1] != *dir_sym) {
+ strcat(newname, dir_sym);
+ }
+ strcat(newname, p);
+ return newname;
+}
+
+char *
+#ifdef __USE_PROTOS
+pcctsBaseName(char *n) /* MR32 */
+#else
+pcctsBaseName(n)
+char *n;
+#endif
+{
+ static char newname[MaxFileName+1];
+ static char* dir_sym = DirectorySymbol;
+ int count = 0;
+ char *p;
+
+ p = n;
+
+ while ( *p != '\0' ) {p++;} /* go to end of string */
+ while ( (*p != *dir_sym) && (p != n) ) {--p;} /* Find last DirectorySymbol */
+ while ( *p == *dir_sym) p++; /* step forward if we're on a dir symbol */
+ while ( *p != '\0' && *p != '.')
+ {
+ newname[count++] = *p;
+ p++;
+ } /* create a new name */
+ newname[count] = '\0';
+ return newname;
+}
+
+static void
+#ifdef __USE_PROTOS
+ensure_no_C_file_collisions(char *class_c_file)
+#else
+ensure_no_C_file_collisions(class_c_file)
+char *class_c_file;
+#endif
+{
+ int i;
+
+ for (i=0; i<NumFiles; i++)
+ {
+
+#ifdef PCCTS_CASE_INSENSITIVE_FILE_NAME
+ /* assume that file names are case insensitive */
+ if ( STRICMP(outname(FileStr[i]), class_c_file)==0 )
+#else
+ if ( strcmp(outname(FileStr[i]), class_c_file)==0 )
+#endif
+ {
+ fatal(eMsg1("class def output file conflicts with parser output file: %s",
+ outname(FileStr[i])));
+ }
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+warnNoFL(char *err)
+#else
+warnNoFL(err)
+char *err;
+#endif
+{
+ fprintf(stderr, "warning: %s\n", err);
+}
+
+void
+#ifdef __USE_PROTOS
+warnFL(char *err,char *f,int l)
+#else
+warnFL(err,f,l)
+char *f;
+int l;
+char *err;
+#endif
+{
+ fprintf(stderr, ErrHdr, f, l);
+ fprintf(stderr, " warning: %s\n", err);
+}
+
+void
+#ifdef __USE_PROTOS
+warn(char *err)
+#else
+warn(err)
+char *err;
+#endif
+{
+ /* back up the file number if we hit an error at the end of the last file */
+ if ( CurFile >= NumFiles && CurFile >= 1 ) CurFile--;
+ fprintf(stderr, ErrHdr, FileStr[CurFile], zzline);
+ fprintf(stderr, " warning: %s\n", err);
+}
+
+void
+#ifdef __USE_PROTOS
+warnNoCR( char *err )
+#else
+warnNoCR( err )
+char *err;
+#endif
+{
+ /* back up the file number if we hit an error at the end of the last file */
+ if ( CurFile >= NumFiles && CurFile >= 1 ) CurFile--;
+ fprintf(stderr, ErrHdr, FileStr[CurFile], zzline);
+ fprintf(stderr, " warning: %s", err);
+}
+
+void
+#ifdef __USE_PROTOS
+errNoFL(char *err)
+#else
+errNoFL(err)
+char *err;
+#endif
+{
+ fprintf(stderr, "error: %s\n", err);
+}
+
+void
+#ifdef __USE_PROTOS
+errFL(char *err,char *f,int l)
+#else
+errFL(err,f,l)
+char *err;
+char *f;
+int l;
+#endif
+{
+ fprintf(stderr, ErrHdr, f, l);
+ fprintf(stderr, " error: %s\n", err);
+}
+
+void
+#ifdef __USE_PROTOS
+err(char *err)
+#else
+err(err)
+char *err;
+#endif
+{
+ /* back up the file number if we hit an error at the end of the last file */
+ if ( CurFile >= NumFiles && CurFile >= 1 ) CurFile--;
+ fprintf(stderr, ErrHdr, FileStr[CurFile], zzline);
+ fprintf(stderr, " error: %s\n", err);
+}
+
+void
+#ifdef __USE_PROTOS
+errNoCR( char *err )
+#else
+errNoCR( err )
+char *err;
+#endif
+{
+ /* back up the file number if we hit an error at the end of the last file */
+ if ( CurFile >= NumFiles && CurFile >= 1 ) CurFile--;
+ fprintf(stderr, ErrHdr, FileStr[CurFile], zzline);
+ fprintf(stderr, " error: %s", err);
+}
+
+UserAction *
+#ifdef __USE_PROTOS
+newUserAction(char *s)
+#else
+newUserAction(s)
+char *s;
+#endif
+{
+ UserAction *ua = (UserAction *) calloc(1, sizeof(UserAction));
+ require(ua!=NULL, "cannot allocate UserAction");
+
+ ua->action = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
+ strcpy(ua->action, s);
+ return ua;
+}
+
+/* Added by TJP September 1994 */
+/* Take in file.h and return file_h; names w/o '.'s are left alone */
+char *
+#ifdef __USE_PROTOS
+gate_symbol(char *name)
+#else
+gate_symbol(name)
+char *name;
+#endif
+{
+ static char buf[100];
+ char *p;
+ sprintf(buf, "%s", name);
+
+ for (p=buf; *p!='\0'; p++)
+ {
+ if ( *p=='.' ) *p = '_';
+ }
+ return buf;
+}
+
+char *
+#ifdef __USE_PROTOS
+makeAltID(int blockid, int altnum)
+#else
+makeAltID(blockid, altnum)
+int blockid;
+int altnum;
+#endif
+{
+ static char buf[100];
+ char *p;
+ sprintf(buf, "_blk%d_alt%d", blockid, altnum);
+ p = (char *)malloc(strlen(buf)+1);
+ strcpy(p, buf);
+ return p;
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/makefile b/BaseTools/Source/C/VfrCompile/Pccts/antlr/makefile new file mode 100644 index 0000000000..478a3a1ccf --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/makefile @@ -0,0 +1,218 @@ +#
+# Makefile for ANTLR 1.33
+#
+# SOFTWARE RIGHTS
+#
+# We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+# Set (PCCTS) -- PCCTS is in the public domain. An individual or
+# company may do whatever they wish with source code distributed with
+# PCCTS or the code generated by PCCTS, including the incorporation of
+# PCCTS, or its output, into commerical software.
+#
+# We encourage users to develop software with PCCTS. However, we do ask
+# that credit is given to us for developing PCCTS. By "credit",
+# we mean that if you incorporate our source code into one of your
+# programs (commercial product, research project, or otherwise) that you
+# acknowledge this fact somewhere in the documentation, research report,
+# etc... If you like PCCTS and have developed a nice tool with the
+# output, please mention that you developed it using PCCTS. In
+# addition, we ask that this header remain intact in our source code.
+# As long as these guidelines are kept, we expect to continue enhancing
+# this system and expect to make other tools available as they are
+# completed.
+#
+# ANTLR 1.33
+# Terence Parr
+# Parr Research Corporation
+# with Purdue University
+# and AHPCRC, University of Minnesota
+# 1989-1995
+#
+# Ported to Borland C++, IBM C-Set/2 and Microsoft 6.0 by
+# Ed Harfmann
+# Micro Data Base Systems
+# Lafayette, Indiana
+#
+SET=../support/set
+PCCTS_H=../h
+
+##
+## Uncomment the appropriate section to build
+## (both targets and 'make' variable definitions)
+## Note that UNIX is the default
+##
+
+#
+# OS/2 & DOS 16 bit using MSC 6.0
+#
+#CC=cl
+#ANTLR=..\bin\antlr
+#DLG=..\bin\dlg
+#CFLAGS= -I. -I$(SET) -I$(PCCTS_H) /AL /Za /W3 -DPC -DUSER_ZZSYN
+#OUT_OBJ = -Fo
+#LIBS=/NOD:LLIBCE LLIBCEP
+#OBJ_EXT = obj
+#
+#antlr.exe: antlr.obj scan.obj err.obj bits.obj build.obj fset2.obj \
+# fset.obj gen.obj globals.obj hash.obj lex.obj main.obj \
+# misc.obj set.obj pred.obj egamn.obj
+# link @<<
+#$** /NOI
+#$@ /STACK:14336
+#
+#$(LIBS: = +^
+#)
+#$(DEF_FILE) $(LFLAGS) ;
+#<<
+# bind $@ c:\os2\doscalls.lib
+# copy *.exe ..\bin
+#
+
+#
+# Borland C++ for DOS
+#
+#CC=bcc
+#ANTLR=..\bin\antlr
+#DLG=..\bin\dlg
+#CFLAGS= -I. -I$(SET) -I$(PCCTS_H) -ml -ff- -w- -DPC -DUSER_ZZSYN
+#OUT_OBJ = -o
+#LIBS= emu mathl cl
+#OBJ_EXT = obj
+#
+#antlr.exe: antlr.obj scan.obj err.obj bits.obj build.obj fset2.obj \
+# fset.obj gen.obj globals.obj hash.obj lex.obj main.obj \
+# misc.obj set.obj pred.obj egman.obj mrhoist.obj fcache.obj
+# tlink @&&|
+#C0L $**
+#$@ /Tde /c
+#
+#$(LIBS)
+#$(DEF_FILE) $(LFLAGS) ;
+#|
+# copy *.exe ..\bin
+#
+
+#
+# C-Set/2 for OS/2
+#
+#CC=icc
+#CFLAGS= -I. -I$(SET) -I$(PCCTS_H) /Sa /W3 -DUSER_ZZSYN -D__STDC__
+#OUT_OBJ = -Fo
+#LIBS=
+#ANTLR=..\bin\antlr
+#DLG=..\bin\dlg
+#OBJ_EXT = obj
+#
+#antlr.exe: antlr.obj scan.obj err.obj bits.obj build.obj fset2.obj \
+# fset.obj gen.obj globals.obj hash.obj lex.obj main.obj \
+# misc.obj set.obj pred.obj egman.obj mrhoist.obj fcache.obj
+# link386 @<<
+#$** /NOI
+#$@ /STACK:32768
+#
+#$(LIBS: = +^
+#)
+#$(DEF_FILE) $(LFLAGS) ;
+#<<
+# copy *.exe ..\bin
+#
+
+#
+# Borland C++ for OS/2
+#
+#CC=bcc
+#CFLAGS= -I. -I$(SET) -I$(PCCTS_H) -w- -v -DUSER_ZZSYN
+#OUT_OBJ = -o
+#LIBS= c2 os2
+#
+#ANTLR=..\bin\antlr
+#DLG=..\bin\dlg
+#OBJ_EXT = obj
+#antlr.exe: antlr.obj scan.obj err.obj bits.obj build.obj fset2.obj \
+# fset.obj gen.obj globals.obj hash.obj lex.obj main.obj \
+# misc.obj set.obj pred.obj egman.obj mrhoist.obj fcache.obj
+# tlink @&&|
+#c02 $** -c -v
+#antlr.exe
+#
+#C2 os2
+#
+#|
+# copy *.exe ..\bin
+#
+
+# *********** Target list of PC machines ***********
+#
+# Don't worry about the ambiguity messages coming from antlr
+# for making antlr.c etc... [should be 10 of them, I think]
+#
+#antlr.c stdpccts.h parser.dlg tokens.h err.c : antlr.g
+# $(ANTLR) antlr.g
+#
+#antlr.$(OBJ_EXT): antlr.c mode.h tokens.h
+#
+#scan.$(OBJ_EXT): scan.c mode.h tokens.h
+#
+#scan.c mode.h: parser.dlg
+# $(DLG) -C2 parser.dlg scan.c
+#
+#set.$(OBJ_EXT): $(SET)/set.c
+# $(CC) $(CFLAGS) -c $(OUT_OBJ)set.$(OBJ_EXT) $(SET)/set.c
+
+
+
+#
+# UNIX (default)
+#
+CC=gcc
+COPT=-O
+ANTLR=${BIN_DIR}/antlr
+DLG=${BIN_DIR}/dlg
+OBJ_EXT=o
+OUT_OBJ = -o
+CFLAGS= $(COPT) -I. -I$(SET) -I$(PCCTS_H) -DUSER_ZZSYN $(COTHER) -DZZLEXBUFSIZE=65536
+#
+# SGI Users, use this CFLAGS
+#
+#CFLAGS= -O -I. -I$(SET) -I$(PCCTS_H) -DUSER_ZZSYN -woff 3262
+OBJ=antlr.o scan.o err.o bits.o build.o fset2.o fset.o gen.o \
+ globals.o hash.o lex.o main.o misc.o set.o pred.o egman.o mrhoist.o fcache.o
+
+$(BIN_DIR)/antlr : $(OBJ) $(SRC)
+ $(CC) $(CFLAGS) -o $(BIN_DIR)/antlr $(OBJ)
+
+# what files does PCCTS generate (both ANTLR and DLG)
+PCCTS_GEN=antlr.c scan.c err.c tokens.h mode.h parser.dlg stdpccts.h remap.h
+
+SRC=antlr.c scan.c err.c bits.c build.c fset2.c fset.c gen.c globals.c \
+ hash.c lex.c main.c misc.c $(SET)/set.c pred.c egman.c mrhoist.c fcache.c
+
+#
+# Don't worry about the ambiguity messages coming from antlr
+# for making antlr.c etc... [should be 10 of them, I think]
+#
+#antlr.c stdpccts.h parser.dlg tokens.h err.c : antlr.g
+# $(ANTLR) -gh antlr.g
+
+antlr.o : antlr.c mode.h tokens.h
+
+scan.o : scan.c mode.h tokens.h
+
+#scan.c mode.h: parser.dlg
+# $(DLG) -C2 parser.dlg scan.c
+
+set.o : $(SET)/set.c
+ $(CC) $(CFLAGS) -c -o set.o $(SET)/set.c
+
+
+#
+# ****** These next targets are common to UNIX and PC world ********
+#
+
+#clean up all the intermediate files
+clean:
+ rm -f $(BIN_DIR)/antlr *.$(OBJ_EXT) core
+
+#remove everything in clean plus the PCCTS files generated
+scrub:
+ rm -f $(PCCTS_GEN) *.$(OBJ_EXT) core
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/makefile.cygwin b/BaseTools/Source/C/VfrCompile/Pccts/antlr/makefile.cygwin new file mode 100644 index 0000000000..956de0be07 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/makefile.cygwin @@ -0,0 +1,219 @@ +#
+# Makefile for ANTLR 1.33
+#
+# SOFTWARE RIGHTS
+#
+# We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+# Set (PCCTS) -- PCCTS is in the public domain. An individual or
+# company may do whatever they wish with source code distributed with
+# PCCTS or the code generated by PCCTS, including the incorporation of
+# PCCTS, or its output, into commerical software.
+#
+# We encourage users to develop software with PCCTS. However, we do ask
+# that credit is given to us for developing PCCTS. By "credit",
+# we mean that if you incorporate our source code into one of your
+# programs (commercial product, research project, or otherwise) that you
+# acknowledge this fact somewhere in the documentation, research report,
+# etc... If you like PCCTS and have developed a nice tool with the
+# output, please mention that you developed it using PCCTS. In
+# addition, we ask that this header remain intact in our source code.
+# As long as these guidelines are kept, we expect to continue enhancing
+# this system and expect to make other tools available as they are
+# completed.
+#
+# ANTLR 1.33
+# Terence Parr
+# Parr Research Corporation
+# with Purdue University
+# and AHPCRC, University of Minnesota
+# 1989-1995
+#
+# Ported to Borland C++, IBM C-Set/2 and Microsoft 6.0 by
+# Ed Harfmann
+# Micro Data Base Systems
+# Lafayette, Indiana
+#
+SET=../support/set
+PCCTS_H=../h
+
+##
+## Uncomment the appropriate section to build
+## (both targets and 'make' variable definitions)
+## Note that UNIX is the default
+##
+
+#
+# OS/2 & DOS 16 bit using MSC 6.0
+#
+#CC=cl
+#ANTLR=..\bin\antlr
+#DLG=..\bin\dlg
+#CFLAGS= -I. -I$(SET) -I$(PCCTS_H) /AL /Za /W3 -DPC -DUSER_ZZSYN
+#OUT_OBJ = -Fo
+#LIBS=/NOD:LLIBCE LLIBCEP
+#OBJ_EXT = obj
+#
+#antlr.exe: antlr.obj scan.obj err.obj bits.obj build.obj fset2.obj \
+# fset.obj gen.obj globals.obj hash.obj lex.obj main.obj \
+# misc.obj set.obj pred.obj egamn.obj
+# link @<<
+#$** /NOI
+#$@ /STACK:14336
+#
+#$(LIBS: = +^
+#)
+#$(DEF_FILE) $(LFLAGS) ;
+#<<
+# bind $@ c:\os2\doscalls.lib
+# copy *.exe ..\bin
+#
+
+#
+# Borland C++ for DOS
+#
+#CC=bcc
+#ANTLR=..\bin\antlr
+#DLG=..\bin\dlg
+#CFLAGS= -I. -I$(SET) -I$(PCCTS_H) -ml -ff- -w- -DPC -DUSER_ZZSYN
+#OUT_OBJ = -o
+#LIBS= emu mathl cl
+#OBJ_EXT = obj
+#
+#antlr.exe: antlr.obj scan.obj err.obj bits.obj build.obj fset2.obj \
+# fset.obj gen.obj globals.obj hash.obj lex.obj main.obj \
+# misc.obj set.obj pred.obj egman.obj mrhoist.obj fcache.obj
+# tlink @&&|
+#C0L $**
+#$@ /Tde /c
+#
+#$(LIBS)
+#$(DEF_FILE) $(LFLAGS) ;
+#|
+# copy *.exe ..\bin
+#
+
+#
+# C-Set/2 for OS/2
+#
+#CC=icc
+#CFLAGS= -I. -I$(SET) -I$(PCCTS_H) /Sa /W3 -DUSER_ZZSYN -D__STDC__
+#OUT_OBJ = -Fo
+#LIBS=
+#ANTLR=..\bin\antlr
+#DLG=..\bin\dlg
+#OBJ_EXT = obj
+#
+#antlr.exe: antlr.obj scan.obj err.obj bits.obj build.obj fset2.obj \
+# fset.obj gen.obj globals.obj hash.obj lex.obj main.obj \
+# misc.obj set.obj pred.obj egman.obj mrhoist.obj fcache.obj
+# link386 @<<
+#$** /NOI
+#$@ /STACK:32768
+#
+#$(LIBS: = +^
+#)
+#$(DEF_FILE) $(LFLAGS) ;
+#<<
+# copy *.exe ..\bin
+#
+
+#
+# Borland C++ for OS/2
+#
+#CC=bcc
+#CFLAGS= -I. -I$(SET) -I$(PCCTS_H) -w- -v -DUSER_ZZSYN
+#OUT_OBJ = -o
+#LIBS= c2 os2
+#
+#ANTLR=..\bin\antlr
+#DLG=..\bin\dlg
+#OBJ_EXT = obj
+#antlr.exe: antlr.obj scan.obj err.obj bits.obj build.obj fset2.obj \
+# fset.obj gen.obj globals.obj hash.obj lex.obj main.obj \
+# misc.obj set.obj pred.obj egman.obj mrhoist.obj fcache.obj
+# tlink @&&|
+#c02 $** -c -v
+#antlr.exe
+#
+#C2 os2
+#
+#|
+# copy *.exe ..\bin
+#
+
+# *********** Target list of PC machines ***********
+#
+# Don't worry about the ambiguity messages coming from antlr
+# for making antlr.c etc... [should be 10 of them, I think]
+#
+#antlr.c stdpccts.h parser.dlg tokens.h err.c : antlr.g
+# $(ANTLR) antlr.g
+#
+#antlr.$(OBJ_EXT): antlr.c mode.h tokens.h
+#
+#scan.$(OBJ_EXT): scan.c mode.h tokens.h
+#
+#scan.c mode.h: parser.dlg
+# $(DLG) -C2 parser.dlg scan.c
+#
+#set.$(OBJ_EXT): $(SET)/set.c
+# $(CC) $(CFLAGS) -c $(OUT_OBJ)set.$(OBJ_EXT) $(SET)/set.c
+
+
+
+#
+# UNIX (default)
+#
+BIN_DIR=../../../../bin
+CC=gcc
+COPT=-O
+ANTLR=$(BIN_DIR)/antlr.exe
+DLG=${BIN_DIR}/dlg.exe
+OBJ_EXT=o
+OUT_OBJ = -o
+CFLAGS= $(COPT) -I. -I$(SET) -I$(PCCTS_H) -DUSER_ZZSYN $(COTHER) -DZZLEXBUFSIZE=65536
+#
+# SGI Users, use this CFLAGS
+#
+#CFLAGS= -O -I. -I$(SET) -I$(PCCTS_H) -DUSER_ZZSYN -woff 3262
+OBJ=antlr.o scan.o err.o bits.o build.o fset2.o fset.o gen.o \
+ globals.o hash.o lex.o main.o misc.o set.o pred.o egman.o mrhoist.o fcache.o
+
+antlr : $(OBJ) $(SRC)
+ $(CC) $(CFLAGS) -o $(BIN_DIR)/antlr.exe $(OBJ)
+
+# what files does PCCTS generate (both ANTLR and DLG)
+PCCTS_GEN=antlr.c scan.c err.c tokens.h mode.h parser.dlg stdpccts.h remap.h
+
+SRC=antlr.c scan.c err.c bits.c build.c fset2.c fset.c gen.c globals.c \
+ hash.c lex.c main.c misc.c $(SET)/set.c pred.c egman.c mrhoist.c fcache.c
+
+#
+# Don't worry about the ambiguity messages coming from antlr
+# for making antlr.c etc... [should be 10 of them, I think]
+#
+#antlr.c stdpccts.h parser.dlg tokens.h err.c : antlr.g
+# $(ANTLR) -gh antlr.g
+
+antlr.o : antlr.c mode.h tokens.h
+
+scan.o : scan.c mode.h tokens.h
+
+#scan.c mode.h: parser.dlg
+# $(DLG) -C2 parser.dlg scan.c
+
+set.o : $(SET)/set.c
+ $(CC) $(CFLAGS) -c -o set.o $(SET)/set.c
+
+
+#
+# ****** These next targets are common to UNIX and PC world ********
+#
+
+#clean up all the intermediate files
+clean:
+ rm -f *.$(OBJ_EXT) core
+
+#remove everything in clean plus the PCCTS files generated
+scrub:
+ rm -f $(PCCTS_GEN) *.$(OBJ_EXT) core
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/makefile1 b/BaseTools/Source/C/VfrCompile/Pccts/antlr/makefile1 new file mode 100644 index 0000000000..dffc709478 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/makefile1 @@ -0,0 +1,96 @@ +#
+# Makefile for ANTLR 1.33
+#
+# SOFTWARE RIGHTS
+#
+# We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+# Set (PCCTS) -- PCCTS is in the public domain. An individual or
+# company may do whatever they wish with source code distributed with
+# PCCTS or the code generated by PCCTS, including the incorporation of
+# PCCTS, or its output, into commerical software.
+#
+# We encourage users to develop software with PCCTS. However, we do ask
+# that credit is given to us for developing PCCTS. By "credit",
+# we mean that if you incorporate our source code into one of your
+# programs (commercial product, research project, or otherwise) that you
+# acknowledge this fact somewhere in the documentation, research report,
+# etc... If you like PCCTS and have developed a nice tool with the
+# output, please mention that you developed it using PCCTS. In
+# addition, we ask that this header remain intact in our source code.
+# As long as these guidelines are kept, we expect to continue enhancing
+# this system and expect to make other tools available as they are
+# completed.
+#
+# ANTLR 1.33
+# Terence Parr
+# Parr Research Corporation
+# with Purdue University
+# and AHPCRC, University of Minnesota
+# 1989-1995
+#
+# Ported to Borland C++, IBM C-Set/2 and Microsoft 6.0 by
+# Ed Harfmann
+# Micro Data Base Systems
+# Lafayette, Indiana
+#
+SET=../support/set
+PCCTS_H=../h
+
+#
+# UNIX (default)
+#
+CC=cc
+ANTLR=${WORKSPACE}/Tools/bin/antlr
+DLG=${WORKSPACE}/Tools/bin/dlg
+OBJ_EXT=o
+OUT_OBJ = -o
+ANSI=-ansi
+AOTHER=
+CFLAGS= -O0 -g -I. -I$(SET) -I$(PCCTS_H) -DUSER_ZZSYN $(COTHER) $(ANSI) -DZZLEXBUFSIZE=32000
+#
+# SGI Users, use this CFLAGS
+#
+#CFLAGS= -O -I. -I$(SET) -I$(PCCTS_H) -DUSER_ZZSYN -woff 3262
+
+OBJ=antlr.o scan.o err.o bits.o build.o fset2.o fset.o gen.o \
+ globals.o hash.o lex.o main.o misc.o set.o pred.o egman.o mrhoist.o fcache.o $(OBJOTHER)
+
+antlr : $(OBJ) $(SRC)
+ $(CC) $(CFLAGS) -o antlr $(OBJ)
+ mv antlr ${WORKSPACE}/Tools/bin
+
+# what files does PCCTS generate (both ANTLR and DLG)
+PCCTS_GEN=antlr.c scan.c err.c tokens.h mode.h parser.dlg stdpccts.h remap.h
+
+SRC=antlr.c scan.c err.c bits.c build.c fset2.c fset.c gen.c globals.c \
+ hash.c lex.c main.c misc.c $(SET)/set.c pred.c egman.c mrhoist.c fcache.c
+
+#
+# Don't worry about the ambiguity messages coming from antlr
+# for making antlr.c etc... [should be 10 of them, I think]
+#
+antlr.c stdpccts.h parser.dlg tokens.h err.c : antlr.g
+ $(ANTLR) -gh antlr.g $(AOTHER)
+
+antlr.o : antlr.c mode.h tokens.h
+
+scan.o : scan.c mode.h tokens.h
+
+scan.c mode.h: parser.dlg
+ $(DLG) -C2 parser.dlg scan.c
+
+set.o : $(SET)/set.c
+ $(CC) $(CFLAGS) -c -o set.o $(SET)/set.c
+
+
+#
+# ****** These next targets are common to UNIX and PC world ********
+#
+
+#clean up all the intermediate files
+clean:
+ rm -f *.$(OBJ_EXT) core
+
+#remove everything in clean plus the PCCTS files generated
+scrub:
+ rm -f $(PCCTS_GEN) *.$(OBJ_EXT) core
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/misc.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/misc.c new file mode 100644 index 0000000000..3f58da34c5 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/misc.c @@ -0,0 +1,1864 @@ +/*
+ * misc.c
+ *
+ * Manage tokens, regular expressions.
+ * Print methods for debugging
+ * Compute follow lists onto tail ends of rules.
+ *
+ * The following functions are visible:
+ *
+ * int addTname(char *); Add token name
+ * int addTexpr(char *); Add token expression
+ * int Tnum(char *); Get number of expr/token
+ * void Tklink(char *, char *); Link a name with an expression
+ * int hasAction(expr); Does expr already have action assigned?
+ * void setHasAction(expr); Indicate that expr now has an action
+ * Entry *newEntry(char *,int); Create new table entry with certain size
+ * void list_add(ListNode **list, char *e)
+ * void list_free(ListNode **list, int freeData); *** MR10 ***
+ * void list_apply(ListNode *list, void (*f)())
+ * void lexclass(char *m); switch to new/old lexical class
+ * void lexmode(int i); switch to old lexical class i
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2001
+ */
+
+#include <stdio.h>
+#include "pcctscfg.h"
+#include "set.h"
+#include "syn.h"
+#include "hash.h"
+#include "generic.h"
+#include "dlgdef.h"
+#include <ctype.h>
+
+static int tsize=TSChunk; /* size of token str arrays */
+
+static void
+#ifdef __USE_PROTOS
+RemapForcedTokensInSyntaxDiagram(Node *);
+#else
+RemapForcedTokensInSyntaxDiagram();
+#endif
+
+ /* T o k e n M a n i p u l a t i o n */
+
+/*
+ * add token 't' to the TokenStr/Expr array. Make more room if necessary.
+ * 't' is either an expression or a token name.
+ *
+ * There is only one TokenStr array, but multiple ExprStr's. Therefore,
+ * for each lex class (element of lclass) we must extend the ExprStr array.
+ * ExprStr's and TokenStr are always all the same size.
+ *
+ * Also, there is a Texpr hash table for each automaton.
+ */
+static void
+#ifdef __USE_PROTOS
+Ttrack( char *t )
+#else
+Ttrack( t )
+char *t;
+#endif
+{
+ if ( TokenNum >= tsize ) /* terminal table overflow? */
+ {
+ char **p;
+ int i, more, j;
+
+ more = TSChunk * (1 + ((TokenNum-tsize) / TSChunk));
+ tsize += more;
+ TokenStr = (char **) realloc((char *)TokenStr, tsize*sizeof(char *));
+ require(TokenStr != NULL, "Ttrack: can't extend TokenStr");
+ for (i=0; i<NumLexClasses; i++)
+ {
+ lclass[i].exprs = (char **)
+ realloc((char *)lclass[i].exprs, tsize*sizeof(char *));
+ require(lclass[i].exprs != NULL, "Ttrack: can't extend ExprStr");
+ for (p= &lclass[i].exprs[tsize-more],j=1; j<=more; j++) *p++ = NULL;
+ }
+ for (p= &TokenStr[tsize-more],i=1; i<=more; i++) *p++ = NULL;
+ lexmode( CurrentLexClass ); /* reset ExprStr in case table moved */
+ }
+ /* note: we use the actual ExprStr/TokenStr array
+ * here as TokenInd doesn't exist yet
+ */
+ if ( *t == '"' ) ExprStr[TokenNum] = t;
+ else TokenStr[TokenNum] = t;
+}
+
+static Expr *
+#ifdef __USE_PROTOS
+newExpr( char *e )
+#else
+newExpr( e )
+char *e;
+#endif
+{
+ Expr *p = (Expr *) calloc(1, sizeof(Expr));
+ require(p!=NULL, "newExpr: cannot alloc Expr node");
+
+ p->expr = e;
+ p->lclass = CurrentLexClass;
+ return p;
+}
+
+/* switch to lexical class/mode m. This amounts to creating a new
+ * lex mode if one does not already exist and making ExprStr point
+ * to the correct char string array. We must also switch Texpr tables.
+ *
+ * BTW, we need multiple ExprStr arrays because more than one automaton
+ * may have the same label for a token, but with different expressions.
+ * We need to track an expr for each automaton. If we disallowed this
+ * feature, only one ExprStr would be required.
+ */
+void
+#ifdef __USE_PROTOS
+lexclass( char *m )
+#else
+lexclass( m )
+char *m;
+#endif
+{
+ int i;
+ TermEntry *p;
+ static char EOFSTR[] = "\"@\"";
+
+ if ( hash_get(Tname, m) != NULL )
+ {
+ warn(eMsg1("lexclass name conflicts with token/errclass label '%s'",m));
+ }
+ /* does m already exist? */
+ i = LexClassIndex(m);
+ if ( i != -1 ) {lexmode(i); return;}
+ /* must make new one */
+ NumLexClasses++;
+ CurrentLexClass = NumLexClasses-1;
+ require(NumLexClasses<=MaxLexClasses, "number of allowable lexclasses exceeded\nIncrease MaxLexClasses in generic.h and recompile all C files");
+ lclass[CurrentLexClass].classnum = m;
+ lclass[CurrentLexClass].exprs = (char **) calloc(tsize, sizeof(char *));
+ require(lclass[CurrentLexClass].exprs!=NULL,
+ "lexclass: cannot allocate ExprStr");
+ lclass[CurrentLexClass].htable = newHashTable();
+ ExprStr = lclass[CurrentLexClass].exprs;
+ Texpr = lclass[CurrentLexClass].htable;
+ /* define EOF for each automaton */
+ p = newTermEntry( EOFSTR );
+ p->token = EofToken; /* couldn't have remapped tokens yet, use EofToken */
+ hash_add(Texpr, EOFSTR, (Entry *)p);
+ list_add(&ExprOrder, (void *)newExpr(EOFSTR));
+ /* note: we use the actual ExprStr array
+ * here as TokenInd doesn't exist yet
+ */
+ ExprStr[EofToken] = EOFSTR;
+}
+
+void
+#ifdef __USE_PROTOS
+lexmode( int i )
+#else
+lexmode( i )
+int i;
+#endif
+{
+ require(i<NumLexClasses, "lexmode: invalid mode");
+ ExprStr = lclass[i].exprs;
+ Texpr = lclass[i].htable;
+ CurrentLexClass = i;
+}
+
+/* return index into lclass array of lexical class. return -1 if nonexistent */
+int
+#ifdef __USE_PROTOS
+LexClassIndex( char *cl )
+#else
+LexClassIndex( cl )
+char *cl;
+#endif
+{
+ int i;
+
+ for (i=0; i<NumLexClasses; i++)
+ {
+ if ( strcmp(lclass[i].classnum, cl) == 0 ) return i;
+ }
+ return -1;
+}
+
+int
+#ifdef __USE_PROTOS
+hasAction( char *expr )
+#else
+hasAction( expr )
+char *expr;
+#endif
+{
+ TermEntry *p;
+ require(expr!=NULL, "hasAction: invalid expr");
+
+ p = (TermEntry *) hash_get(Texpr, expr);
+ require(p!=NULL, eMsg1("hasAction: expr '%s' doesn't exist",expr));
+ return (p->action!=NULL);
+}
+
+void
+#ifdef __USE_PROTOS
+setHasAction( char *expr, char *action )
+#else
+setHasAction( expr, action )
+char *expr;
+char *action;
+#endif
+{
+ TermEntry *p;
+ require(expr!=NULL, "setHasAction: invalid expr");
+
+ p = (TermEntry *) hash_get(Texpr, expr);
+ require(p!=NULL, eMsg1("setHasAction: expr '%s' doesn't exist",expr));
+ p->action = action;
+}
+
+ForcedToken *
+#ifdef __USE_PROTOS
+newForcedToken(char *token, int tnum)
+#else
+newForcedToken(token, tnum)
+char *token;
+int tnum;
+#endif
+{
+ ForcedToken *ft = (ForcedToken *) calloc(1, sizeof(ForcedToken));
+ require(ft!=NULL, "out of memory");
+ ft->token = token;
+ ft->tnum = tnum;
+ return ft;
+}
+
+/*
+ * Make a token indirection array that remaps token numbers and then walk
+ * the appropriate symbol tables and SynDiag to change token numbers
+ */
+void
+#ifdef __USE_PROTOS
+RemapForcedTokens(void)
+#else
+RemapForcedTokens()
+#endif
+{
+ ListNode *p;
+ ForcedToken *q;
+ int max_token_number=0; /* MR9 23-Sep-97 Removed "unsigned" */
+ int i;
+
+ if ( ForcedTokens == NULL ) return;
+
+ /* find max token num */
+ for (p = ForcedTokens->next; p!=NULL; p=p->next)
+ {
+ q = (ForcedToken *) p->elem;
+ if ( q->tnum > max_token_number ) max_token_number = q->tnum;
+ }
+ fprintf(stderr, "max token number is %d\n", max_token_number);
+
+ /* make token indirection array */
+ TokenInd = (int *) calloc(max_token_number+1, sizeof(int));
+ LastTokenCounted = TokenNum;
+ TokenNum = max_token_number+1;
+ require(TokenInd!=NULL, "RemapForcedTokens: cannot allocate TokenInd");
+
+ /* fill token indirection array and change token id htable ; swap token indices */
+ for (i=1; i<TokenNum; i++) TokenInd[i] = i;
+ for (p = ForcedTokens->next; p!=NULL; p=p->next)
+ {
+ TermEntry *te;
+ int old_pos, t;
+
+ q = (ForcedToken *) p->elem;
+ fprintf(stderr, "%s forced to %d\n", q->token, q->tnum);
+ te = (TermEntry *) hash_get(Tname, q->token);
+ require(te!=NULL, "RemapForcedTokens: token not in hash table");
+ old_pos = te->token;
+ fprintf(stderr, "Before: TokenInd[old_pos==%d] is %d\n", old_pos, TokenInd[old_pos]);
+ fprintf(stderr, "Before: TokenInd[target==%d] is %d\n", q->tnum, TokenInd[q->tnum]);
+ q = (ForcedToken *) p->elem;
+ t = TokenInd[old_pos];
+ TokenInd[old_pos] = q->tnum;
+ TokenInd[q->tnum] = t;
+ te->token = q->tnum; /* update token type id symbol table */
+ fprintf(stderr, "After: TokenInd[old_pos==%d] is %d\n", old_pos, TokenInd[old_pos]);
+ fprintf(stderr, "After: TokenInd[target==%d] is %d\n", q->tnum, TokenInd[q->tnum]);
+
+ /* Change the token number in the sym tab entry for the exprs
+ * at the old position of the token id and the target position
+ */
+ /* update expr at target (if any) of forced token id */
+ if ( q->tnum < TokenNum ) /* is it a valid position? */
+ {
+ for (i=0; i<NumLexClasses; i++)
+ {
+ if ( lclass[i].exprs[q->tnum]!=NULL )
+ {
+ /* update the symbol table for this expr */
+ TermEntry *e = (TermEntry *) hash_get(lclass[i].htable, lclass[i].exprs[q->tnum]);
+ require(e!=NULL, "RemapForcedTokens: expr not in hash table");
+ e->token = old_pos;
+ fprintf(stderr, "found expr '%s' at target %d in lclass[%d]; changed to %d\n",
+ lclass[i].exprs[q->tnum], q->tnum, i, old_pos);
+ }
+ }
+ }
+ /* update expr at old position (if any) of forced token id */
+ for (i=0; i<NumLexClasses; i++)
+ {
+ if ( lclass[i].exprs[old_pos]!=NULL )
+ {
+ /* update the symbol table for this expr */
+ TermEntry *e = (TermEntry *) hash_get(lclass[i].htable, lclass[i].exprs[old_pos]);
+ require(e!=NULL, "RemapForcedTokens: expr not in hash table");
+ e->token = q->tnum;
+ fprintf(stderr, "found expr '%s' for id %s in lclass[%d]; changed to %d\n",
+ lclass[i].exprs[old_pos], q->token, i, q->tnum);
+ }
+ }
+ }
+
+ /* Update SynDiag */
+ RemapForcedTokensInSyntaxDiagram((Node *)SynDiag);
+}
+
+static void
+#ifdef __USE_PROTOS
+RemapForcedTokensInSyntaxDiagram(Node *p)
+#else
+RemapForcedTokensInSyntaxDiagram(p)
+Node *p;
+#endif
+{
+ Junction *j = (Junction *) p;
+ RuleRefNode *r = (RuleRefNode *) p;
+ TokNode *t = (TokNode *)p;
+
+ if ( p==NULL ) return;
+ require(p->ntype>=1 && p->ntype<=NumNodeTypes, "Remap...: invalid diagram node");
+ switch ( p->ntype )
+ {
+ case nJunction :
+ if ( j->visited ) return;
+ if ( j->jtype == EndRule ) return;
+ j->visited = TRUE;
+ RemapForcedTokensInSyntaxDiagram( j->p1 );
+ RemapForcedTokensInSyntaxDiagram( j->p2 );
+ j->visited = FALSE;
+ return;
+ case nRuleRef :
+ RemapForcedTokensInSyntaxDiagram( r->next );
+ return;
+ case nToken :
+ if ( t->remapped ) return; /* we've been here before */
+ t->remapped = 1;
+ fprintf(stderr, "remapping %d to %d\n", t->token, TokenInd[t->token]);
+ t->token = TokenInd[t->token];
+ RemapForcedTokensInSyntaxDiagram( t->next );
+ return;
+ case nAction :
+ RemapForcedTokensInSyntaxDiagram( ((ActionNode *)p)->next );
+ return;
+ default :
+ fatal_internal("invalid node type");
+ }
+}
+
+/*
+ * Add a token name. Return the token number associated with it. If it already
+ * exists, then return the token number assigned to it.
+ *
+ * Track the order in which tokens are found so that the DLG output maintains
+ * that order. It also lets us map token numbers to strings.
+ */
+int
+#ifdef __USE_PROTOS
+addTname( char *token )
+#else
+addTname( token )
+char *token;
+#endif
+{
+ TermEntry *p;
+ require(token!=NULL, "addTname: invalid token name");
+
+ if ( (p=(TermEntry *)hash_get(Tname, token)) != NULL ) return p->token;
+ p = newTermEntry( token );
+ Ttrack( p->str );
+ p->token = TokenNum++;
+ hash_add(Tname, token, (Entry *)p);
+ return p->token;
+}
+
+/* This is the same as addTname except we force the TokenNum to be tnum.
+ * We don't have to use the Forced token stuff as no tokens will have
+ * been defined with #tokens when this is called. This is only called
+ * when a #tokdefs meta-op is used.
+ */
+int
+#ifdef __USE_PROTOS
+addForcedTname( char *token, int tnum )
+#else
+addForcedTname( token, tnum )
+char *token;
+int tnum;
+#endif
+{
+ TermEntry *p;
+ require(token!=NULL, "addTname: invalid token name");
+
+ if ( (p=(TermEntry *)hash_get(Tname, token)) != NULL ) return p->token;
+ p = newTermEntry( token );
+ Ttrack( p->str );
+ p->token = tnum;
+ hash_add(Tname, token, (Entry *)p);
+ return p->token;
+}
+
+/*
+ * Add a token expr. Return the token number associated with it. If it already
+ * exists, then return the token number assigned to it.
+ */
+int
+#ifdef __USE_PROTOS
+addTexpr( char *expr )
+#else
+addTexpr( expr )
+char *expr;
+#endif
+{
+ TermEntry *p;
+ require(expr!=NULL, "addTexpr: invalid regular expression");
+
+ if ( (p=(TermEntry *)hash_get(Texpr, expr)) != NULL ) return p->token;
+ p = newTermEntry( expr );
+ Ttrack( p->str );
+ /* track the order in which they occur */
+ list_add(&ExprOrder, (void *)newExpr(p->str));
+ p->token = TokenNum++;
+ hash_add(Texpr, expr, (Entry *)p);
+ return p->token;
+}
+
+/* return the token number of 'term'. Return 0 if no 'term' exists */
+int
+#ifdef __USE_PROTOS
+Tnum( char *term )
+#else
+Tnum( term )
+char *term;
+#endif
+{
+ TermEntry *p;
+ require(term!=NULL, "Tnum: invalid terminal");
+
+ if ( *term=='"' ) p = (TermEntry *) hash_get(Texpr, term);
+ else p = (TermEntry *) hash_get(Tname, term);
+ if ( p == NULL ) return 0;
+ else return p->token;
+}
+
+/* associate a Name with an expr. If both have been already assigned
+ * token numbers, then an error is reported. Add the token or expr
+ * that has not been added if no error. This 'represents' the #token
+ * ANTLR pseudo-op. If both have not been defined, define them both
+ * linked to same token number.
+ */
+void
+#ifdef __USE_PROTOS
+Tklink( char *token, char *expr )
+#else
+Tklink( token, expr )
+char *token;
+char *expr;
+#endif
+{
+ TermEntry *p, *q;
+ require(token!=NULL && expr!=NULL, "Tklink: invalid token name and/or expr");
+
+ p = (TermEntry *) hash_get(Tname, token);
+ q = (TermEntry *) hash_get(Texpr, expr);
+ if ( p != NULL && q != NULL ) /* both defined */
+ {
+ warn( eMsg2("token name %s and rexpr %s already defined; ignored",
+ token, expr) );
+ return;
+ }
+ if ( p==NULL && q==NULL ) /* both not defined */
+ {
+ int t = addTname( token );
+ q = newTermEntry( expr );
+ hash_add(Texpr, expr, (Entry *)q);
+ q->token = t;
+ /* note: we use the actual ExprStr array
+ * here as TokenInd doesn't exist yet
+ */
+ ExprStr[t] = q->str;
+ /* track the order in which they occur */
+ list_add(&ExprOrder, (void *)newExpr(q->str));
+ return;
+ }
+ if ( p != NULL ) /* one is defined, one is not */
+ {
+ q = newTermEntry( expr );
+ hash_add(Texpr, expr, (Entry *)q);
+ q->token = p->token;
+ ExprStr[p->token] = q->str; /* both expr and token str defined now */
+ list_add(&ExprOrder, (void *)newExpr(q->str));
+ }
+ else /* trying to associate name with expr here*/
+ {
+ p = newTermEntry( token );
+ hash_add(Tname, token, (Entry *)p);
+ p->token = q->token;
+ TokenStr[p->token] = p->str;/* both expr and token str defined now */
+ }
+}
+
+/*
+ * Given a string, this function allocates and returns a pointer to a
+ * hash table record of size 'sz' whose "str" pointer is reset to a position
+ * in the string table.
+ */
+Entry *
+#ifdef __USE_PROTOS
+newEntry( char *text, int sz )
+#else
+newEntry( text, sz )
+char *text;
+int sz;
+#endif
+{
+ Entry *p;
+ require(text!=NULL, "new: NULL terminal");
+
+ if ( (p = (Entry *) calloc(1,sz)) == 0 )
+ {
+ fatal_internal("newEntry: out of memory for terminals\n");
+ exit(PCCTS_EXIT_FAILURE);
+ }
+ p->str = mystrdup(text);
+
+ return(p);
+}
+
+/*
+ * add an element to a list.
+ *
+ * Any non-empty list has a sentinel node whose 'elem' pointer is really
+ * a pointer to the last element. (i.e. length(list) = #elemIn(list)+1).
+ * Elements are appended to the list.
+ */
+void
+#ifdef __USE_PROTOS
+list_add( ListNode **list, void *e )
+#else
+list_add( list, e )
+ListNode **list;
+void *e;
+#endif
+{
+ ListNode *p, *tail;
+ require(e!=NULL, "list_add: attempting to add NULL list element");
+
+ p = newListNode;
+ require(p!=NULL, "list_add: cannot alloc new list node");
+ p->elem = e;
+ if ( *list == NULL )
+ {
+ ListNode *sentinel = newListNode;
+ require(sentinel!=NULL, "list_add: cannot alloc sentinel node");
+ *list=sentinel;
+ sentinel->next = p;
+ sentinel->elem = (char *)p; /* set tail pointer */
+ }
+ else /* find end of list */
+ {
+ tail = (ListNode *) (*list)->elem; /* get tail pointer */
+ tail->next = p;
+ (*list)->elem = (char *) p; /* reset tail */
+ }
+}
+
+/* MR10 list_free() frees the ListNode elements in the list */
+/* MR10 if freeData then free the data elements of the list too */
+
+void
+#ifdef __USE_PROTOS
+list_free(ListNode **list,int freeData)
+#else
+list_free(list,freeData)
+ ListNode **list;
+ int freeData;
+#endif
+{
+ ListNode *p;
+ ListNode *next;
+
+ if (list == NULL) return;
+ if (*list == NULL) return;
+ for (p=*list; p != NULL; p=next) {
+ next=p->next;
+ if (freeData && p->elem != NULL) {
+ free( (char *) p->elem);
+ };
+ free( (char *) p);
+ };
+ *list=NULL;
+}
+
+void
+#ifdef __USE_PROTOS
+list_apply( ListNode *list, void (*f)(void *) )
+#else
+list_apply( list, f )
+ListNode *list;
+void (*f)();
+#endif
+{
+ ListNode *p;
+ require(f!=NULL, "list_apply: NULL function to apply");
+
+ if ( list == NULL ) return;
+ for (p = list->next; p!=NULL; p=p->next) (*f)( p->elem );
+}
+
+/* MR27 */
+
+#ifdef __USE_PROTOS
+int list_search_cstring(ListNode *list, char * cstring)
+#else
+int list_search_cstring(list, cstring)
+ ListNode * list;
+ char * cstring;
+#endif
+{
+ ListNode *p;
+ if (list == NULL ) return 0;
+ for (p = list->next; p!=NULL; p=p->next) {
+ if (p->elem == NULL) continue;
+ if (0 == strcmp((char *) p->elem , cstring)) return 1;
+ }
+ return 0;
+}
+
+ /* F O L L O W C y c l e S t u f f */
+
+/* make a key based upon (rulename, computation, k value).
+ * Computation values are 'i'==FIRST, 'o'==FOLLOW.
+ */
+
+/* MR10 Make the key all characters so it can be read easily */
+/* MR10 by a simple dump program. Also, separates */
+/* MR10 'o' and 'i' from rule name */
+
+char *
+#ifdef __USE_PROTOS
+Fkey( char *rule, int computation, int k )
+#else
+Fkey( rule, computation, k )
+char *rule;
+int computation;
+int k;
+#endif
+{
+ static char key[MaxRuleName+2+2+1]; /* MR10 */
+ int i;
+
+ if ( k > 99 ) /* MR10 */
+ fatal("k>99 is too big for this implementation of ANTLR!\n"); /* MR10 */
+ if ( (i=strlen(rule)) > MaxRuleName ) /* MR10 */
+ fatal( eMsgd("rule name > max of %d\n", MaxRuleName) ); /* MR10 */
+ strcpy(key,rule);
+
+/* MR10 */ key[i]='*';
+/* MR10 */ key[i+1] = (char) computation; /* MR20 G. Hobbelt */
+/* MR10 */ if (k < 10) {
+/* MR10 */ key[i+2] = (char) ( '0' + k);
+/* MR10 */ key[i+3] = '\0';
+/* MR10 */ } else {
+/* MR10 */ key[i+2] = (char) ( '0' + k/10);
+/* MR10 */ key[i+3] = (char) ( '0' + k % 10);
+/* MR10 */ key[i+4] = '\0';
+/* MR10 */ };
+
+ return key;
+}
+
+/* Push a rule onto the kth FOLLOW stack */
+void
+#ifdef __USE_PROTOS
+FoPush( char *rule, int k )
+#else
+FoPush( rule, k )
+char *rule;
+int k;
+#endif
+{
+ RuleEntry *r;
+ require(rule!=NULL, "FoPush: tried to push NULL rule");
+ require(k<=CLL_k, "FoPush: tried to access non-existent stack");
+
+ /*fprintf(stderr, "FoPush(%s)\n", rule);*/
+ r = (RuleEntry *) hash_get(Rname, rule);
+ if ( r == NULL ) {fatal_internal( eMsg1("rule %s must be defined but isn't", rule) );}
+ if ( FoStack[k] == NULL ) /* Does the kth stack exist yet? */
+ {
+ /*fprintf(stderr, "allocating FoStack\n");*/
+ FoStack[k] = (int *) calloc(FoStackSize, sizeof(int));
+ require(FoStack[k]!=NULL, "FoPush: cannot allocate FOLLOW stack\n");
+ }
+ if ( FoTOS[k] == NULL )
+ {
+ FoTOS[k]=FoStack[k];
+ *(FoTOS[k]) = r->rulenum;
+ }
+ else
+ {
+#ifdef MEMCHK
+ require(valid(FoStack[k]), "FoPush: invalid FoStack");
+#endif
+ if ( FoTOS[k] >= &(FoStack[k][FoStackSize-1]) )
+ fatal( eMsgd("exceeded max depth of FOLLOW recursion (%d)\n",
+ FoStackSize) );
+ require(FoTOS[k]>=FoStack[k],
+ eMsg1("FoPush: FoStack stack-ptr is playing out of its sandbox",
+ rule));
+ ++(FoTOS[k]);
+ *(FoTOS[k]) = r->rulenum;
+ }
+ {
+ /*
+**** int *p;
+**** fprintf(stderr, "FoStack[k=%d]:\n", k);
+**** for (p=FoStack[k]; p<=FoTOS[k]; p++)
+**** {
+**** fprintf(stderr, "\t%s\n", RulePtr[*p]->rname);
+**** }
+ */
+ }
+}
+
+/* Pop one rule off of the FOLLOW stack. TOS ptr is NULL if empty. */
+void
+#ifdef __USE_PROTOS
+FoPop( int k )
+#else
+FoPop( k )
+int k;
+#endif
+{
+ require(k<=CLL_k, "FoPop: tried to access non-existent stack");
+ /*fprintf(stderr, "FoPop\n");*/
+ require(FoTOS[k]>=FoStack[k]&&FoTOS[k]<=&(FoStack[k][FoStackSize-1]),
+ "FoPop: FoStack stack-ptr is playing out of its sandbox");
+ if ( FoTOS[k] == FoStack[k] ) FoTOS[k] = NULL;
+ else (FoTOS[k])--;
+}
+
+/* Compute FOLLOW cycle.
+ * Mark all FOLLOW sets for rules in cycle as incomplete.
+ * Then, save cycle on the cycle list (Cycles) for later resolution.
+ * The Cycle is stored in the form:
+ * (head of cycle==croot, rest of rules in cycle==cyclicDep)
+ *
+ * e.g. (Fo means "FOLLOW of", "-->" means requires or depends on)
+ *
+ * Fo(x)-->Fo(a)-->Fo(b)-->Fo(c)-->Fo(x)
+ * ^----Infinite recursion (cycle)
+ *
+ * the cycle would be: x -> {a,b,c} or stored as (x,{a,b,c}). Fo(x) depends
+ * on the FOLLOW of a,b, and c. The root of a cycle is always complete after
+ * Fo(x) finishes. Fo(a,b,c) however are not. It turns out that all rules
+ * in a FOLLOW cycle have the same FOLLOW set.
+ */
+void
+#ifdef __USE_PROTOS
+RegisterCycle( char *rule, int k )
+#else
+RegisterCycle( rule, k )
+char *rule;
+int k;
+#endif
+{
+ CacheEntry *f;
+ Cycle *c;
+ int *p;
+ RuleEntry *r;
+ require(rule!=NULL, "RegisterCycle: tried to register NULL rule");
+ require(k<=CLL_k, "RegisterCycle: tried to access non-existent stack");
+
+ /*fprintf(stderr, "RegisterCycle(%s)\n", rule);*/
+ /* Find cycle start */
+ r = (RuleEntry *) hash_get(Rname, rule);
+ require(r!=NULL,eMsg1("rule %s must be defined but isn't", rule));
+ require(FoTOS[k]>=FoStack[k]&&FoTOS[k]<=&(FoStack[k][FoStackSize-1]),
+ eMsg1("RegisterCycle(%s): FoStack stack-ptr is playing out of its sandbox",
+ rule));
+/*** if ( FoTOS[k]<FoStack[k]||FoTOS[k]>&(FoStack[k][FoStackSize-1]) )
+**** {
+**** fprintf(stderr, "RegisterCycle(%s): FoStack stack-ptr is playing out of its sandbox\n",
+**** rule);
+**** fprintf(stderr, "RegisterCycle: sp==0x%x out of bounds 0x%x...0x%x\n",
+**** FoTOS[k], FoStack[k], &(FoStack[k][FoStackSize-1]));
+**** exit(PCCTS_EXIT_FAILURE);
+**** }
+****/
+
+#ifdef MEMCHK
+ require(valid(FoStack[k]), "RegisterCycle: invalid FoStack");
+#endif
+ for (p=FoTOS[k]; *p != r->rulenum && p >= FoStack[k]; --p) {;}
+ require(p>=FoStack[k], "RegisterCycle: FoStack is screwed up beyond belief");
+ if ( p == FoTOS[k] ) return; /* don't worry about cycles to oneself */
+
+ /* compute cyclic dependents (rules in cycle except head) */
+ c = newCycle;
+ require(c!=NULL, "RegisterCycle: couldn't alloc new cycle");
+ c->cyclicDep = empty;
+ c->croot = *p++; /* record root of cycle */
+ for (; p<=FoTOS[k]; p++)
+ {
+ /* Mark all dependent rules as incomplete */
+ f = (CacheEntry *) hash_get(Fcache, Fkey(RulePtr[*p]->rname,'o',k));
+ if ( f==NULL )
+ {
+ f = newCacheEntry( Fkey(RulePtr[*p]->rname,'o',k) );
+ hash_add(Fcache, Fkey(RulePtr[*p]->rname,'o',k), (Entry *)f);
+ }
+ f->incomplete = TRUE;
+
+ set_orel(*p, &(c->cyclicDep)); /* mark rule as dependent of croot */
+ }
+ list_add(&(Cycles[k]), (void *)c);
+}
+
+/* make all rules in cycle complete
+ *
+ * while ( some set has changed ) do
+ * for each cycle do
+ * if degree of FOLLOW set for croot > old degree then
+ * update all FOLLOW sets for rules in cyclic dependency
+ * change = TRUE
+ * endif
+ * endfor
+ * endwhile
+ */
+void
+#ifdef __USE_PROTOS
+ResolveFoCycles( int k )
+#else
+ResolveFoCycles( k )
+int k;
+#endif
+{
+ ListNode *p, *q;
+ Cycle *c;
+ int changed = 1;
+ CacheEntry *f,*g;
+ int r;
+/* int i; */ /* MR10 not useful */
+ unsigned d;
+
+ unsigned *cursor; /* MR10 */
+ unsigned *origin; /* MR10 */
+
+ /*fprintf(stderr, "Resolving following cycles for %d\n", k);*/
+ while ( changed )
+ {
+ changed = 0;
+/* MR10 i = 0; */
+ for (p = Cycles[k]->next; p!=NULL; p=p->next)
+ {
+ c = (Cycle *) p->elem;
+ /*fprintf(stderr, "cycle %d: %s -->", i++, RulePtr[c->croot]->rname);*/
+ /*s_fprT(stderr, c->cyclicDep);*/
+ /*fprintf(stderr, "\n");*/
+ f = (CacheEntry *)
+ hash_get(Fcache, Fkey(RulePtr[c->croot]->rname,'o',k));
+ require(f!=NULL, eMsg1("FOLLOW(%s) must be in cache but isn't", RulePtr[c->croot]->rname) );
+ if ( (d=set_deg(f->fset)) > c->deg )
+ {
+ /*fprintf(stderr, "Fo(%s) has changed\n", RulePtr[c->croot]->rname);*/
+ changed = 1;
+ c->deg = d; /* update cycle FOLLOW set degree */
+
+/* MR10 */ origin=set_pdq(c->cyclicDep);
+/* MR10 */ for (cursor=origin; *cursor != nil; cursor++) {
+/* MR10 */ r=*cursor;
+
+/******** while ( !set_nil(c->cyclicDep) ) { *****/
+/******** r = set_int(c->cyclicDep); *****/
+/******** set_rm(r, c->cyclicDep); *****/
+
+ /*fprintf(stderr, "updating Fo(%s)\n", RulePtr[r]->rname);*/
+ g = (CacheEntry *)
+ hash_get(Fcache, Fkey(RulePtr[r]->rname,'o',k));
+ require(g!=NULL, eMsg1("FOLLOW(%s) must be in cache but isn't", RulePtr[r]->rname) );
+ set_orin(&(g->fset), f->fset);
+ g->incomplete = FALSE;
+ }
+/* MR10 */ free( (char *) origin);
+/* MR10 */ origin=NULL;
+ }
+ }
+/* MR10 - this if statement appears to be meaningless since i is always 0 */
+/* MR10 if ( i == 1 ) changed = 0; */ /* if only 1 cycle, no need to repeat */
+ }
+ /* kill Cycle list */
+ for (q = Cycles[k]->next; q != NULL; q=p)
+ {
+ p = q->next;
+ set_free( ((Cycle *)q->elem)->cyclicDep );
+ free((char *)q);
+ }
+ free( (char *)Cycles[k] );
+ Cycles[k] = NULL;
+}
+
+
+ /* P r i n t i n g S y n t a x D i a g r a m s */
+
+static void
+#ifdef __USE_PROTOS
+pBlk( Junction *q, int btype )
+#else
+pBlk( q, btype )
+Junction *q;
+int btype;
+#endif
+{
+ int k,a;
+ Junction *alt, *p;
+
+ q->end->pvisited = TRUE;
+ if ( btype == aLoopBegin )
+ {
+ require(q->p2!=NULL, "pBlk: invalid ()* block");
+ PRINT(q->p1);
+ alt = (Junction *)q->p2;
+ PRINT(alt->p1);
+ if ( PrintAnnotate )
+ {
+ printf(" /* Opt ");
+ k = 1;
+ while ( !set_nil(alt->fset[k]) )
+ {
+ s_fprT(stdout, alt->fset[k]);
+ if ( k++ == CLL_k ) break;
+ if ( !set_nil(alt->fset[k]) ) printf(", ");
+ }
+ printf(" */\n");
+ }
+ return;
+ }
+ for (a=1,alt=q; alt != NULL; alt= (Junction *) alt->p2, a++)
+ {
+ if ( alt->p1 != NULL ) PRINT(alt->p1);
+ if ( PrintAnnotate )
+ {
+ printf( " /* [%d] ", alt->altnum);
+ k = 1;
+ while ( !set_nil(alt->fset[k]) )
+ {
+ s_fprT(stdout, alt->fset[k]);
+ if ( k++ == CLL_k ) break;
+ if ( !set_nil(alt->fset[k]) ) printf(", ");
+ }
+ if ( alt->p2 == NULL && btype == aOptBlk )
+ printf( " (optional branch) */\n");
+ else printf( " */\n");
+ }
+
+ /* ignore implied empty alt of Plus blocks */
+ if ( alt->p2 != NULL && ((Junction *)alt->p2)->ignore ) break;
+
+ if ( alt->p2 != NULL && !(((Junction *)alt->p2)->p2==NULL && btype == aOptBlk) )
+ {
+ if ( pLevel == 1 )
+ {
+ printf("\n");
+ if ( a+1==pAlt1 || a+1==pAlt2 ) printf("=>");
+ printf("\t");
+ }
+ else printf(" ");
+ printf("|");
+ if ( pLevel == 1 )
+ {
+ p = (Junction *) ((Junction *)alt->p2)->p1;
+ while ( p!=NULL )
+ {
+ if ( p->ntype==nAction )
+ {
+ p=(Junction *)((ActionNode *)p)->next;
+ continue;
+ }
+ if ( p->ntype!=nJunction )
+ {
+ break;
+ }
+ if ( p->jtype==EndBlk || p->jtype==EndRule )
+ {
+ p = NULL;
+ break;
+ }
+ p = (Junction *)p->p1;
+ }
+ if ( p==NULL ) printf("\n\t"); /* Empty alt? */
+ }
+ }
+ }
+ q->end->pvisited = FALSE;
+}
+
+/* How to print out a junction */
+void
+#ifdef __USE_PROTOS
+pJunc( Junction *q )
+#else
+pJunc( q )
+Junction *q;
+#endif
+{
+ int dum_k;
+ int doing_rule;
+ require(q!=NULL, "pJunc: NULL node");
+ require(q->ntype==nJunction, "pJunc: not junction");
+
+ if ( q->pvisited == TRUE ) return;
+ q->pvisited = TRUE;
+ switch ( q->jtype )
+ {
+ case aSubBlk :
+ if ( PrintAnnotate ) First(q, 1, q->jtype, &dum_k);
+ if ( q->end->p1 != NULL && ((Junction *)q->end->p1)->ntype==nJunction &&
+ ((Junction *)q->end->p1)->jtype == EndRule ) doing_rule = 1;
+ else doing_rule = 0;
+ pLevel++;
+ if ( pLevel==1 )
+ {
+ if ( pAlt1==1 ) printf("=>");
+ printf("\t");
+ }
+ else printf(" ");
+ if ( doing_rule )
+ {
+ if ( pLevel==1 ) printf(" ");
+ pBlk(q,q->jtype);
+ }
+ else {
+ printf("(");
+ if ( pLevel==1 ) printf(" ");
+ pBlk(q,q->jtype);
+ if ( pLevel>1 ) printf(" ");
+ printf(")");
+ }
+ if ( q->guess ) printf("?");
+ pLevel--;
+ if ( PrintAnnotate ) freeBlkFsets(q);
+ if ( q->end->p1 != NULL ) PRINT(q->end->p1);
+ break;
+ case aOptBlk :
+ if ( PrintAnnotate ) First(q, 1, q->jtype, &dum_k);
+ pLevel++;
+ if ( pLevel==1 )
+ {
+ if ( pAlt1==1 ) printf("=>");
+ printf("\t");
+ }
+ else printf(" ");
+ printf("{");
+ if ( pLevel==1 ) printf(" ");
+ pBlk(q,q->jtype);
+ if ( pLevel>1 ) printf(" ");
+ else printf("\n\t");
+ printf("}");
+ pLevel--;
+ if ( PrintAnnotate ) freeBlkFsets(q);
+ if ( q->end->p1 != NULL ) PRINT(q->end->p1);
+ break;
+ case aLoopBegin :
+ if ( PrintAnnotate ) First(q, 1, q->jtype, &dum_k);
+ pLevel++;
+ if ( pLevel==1 )
+ {
+ if ( pAlt1==1 ) printf("=>");
+ printf("\t");
+ }
+ else printf(" ");
+ printf("(");
+ if ( pLevel==1 ) printf(" ");
+ pBlk(q,q->jtype);
+ if ( pLevel>1 ) printf(" ");
+ else printf("\n\t");
+ printf(")*");
+ pLevel--;
+ if ( PrintAnnotate ) freeBlkFsets(q);
+ if ( q->end->p1 != NULL ) PRINT(q->end->p1);
+ break;
+ case aLoopBlk :
+ if ( PrintAnnotate ) First(q, 1, q->jtype, &dum_k);
+ pBlk(q,q->jtype);
+ if ( PrintAnnotate ) freeBlkFsets(q);
+ break;
+ case aPlusBlk :
+ if ( PrintAnnotate ) First(q, 1, q->jtype, &dum_k);
+ pLevel++;
+ if ( pLevel==1 )
+ {
+ if ( pAlt1==1 ) printf("=>");
+ printf("\t");
+ }
+ else printf(" ");
+ printf("(");
+ if ( pLevel==1 ) printf(" ");
+ pBlk(q,q->jtype);
+ if ( pLevel>1 ) printf(" ");
+ printf(")+");
+ pLevel--;
+ if ( PrintAnnotate ) freeBlkFsets(q);
+ if ( q->end->p1 != NULL ) PRINT(q->end->p1);
+ break;
+ case EndBlk :
+ break;
+ case RuleBlk :
+ printf( "\n%s :\n", q->rname);
+ PRINT(q->p1);
+ if ( q->p2 != NULL ) PRINT(q->p2);
+ break;
+ case Generic :
+ if ( q->p1 != NULL ) PRINT(q->p1);
+ q->pvisited = FALSE;
+ if ( q->p2 != NULL ) PRINT(q->p2);
+ break;
+ case EndRule :
+ printf( "\n\t;\n");
+ break;
+ }
+ q->pvisited = FALSE;
+}
+
+/* How to print out a rule reference node */
+void
+#ifdef __USE_PROTOS
+pRuleRef( RuleRefNode *p )
+#else
+pRuleRef( p )
+RuleRefNode *p;
+#endif
+{
+ require(p!=NULL, "pRuleRef: NULL node");
+ require(p->ntype==nRuleRef, "pRuleRef: not rule ref node");
+
+ printf( " %s", p->text);
+ PRINT(p->next);
+}
+
+/* How to print out a terminal node */
+void
+#ifdef __USE_PROTOS
+pToken( TokNode *p )
+#else
+pToken( p )
+TokNode *p;
+#endif
+{
+ require(p!=NULL, "pToken: NULL node");
+ require(p->ntype==nToken, "pToken: not token node");
+
+ if ( p->wild_card ) printf(" .");
+ printf( " %s", TerminalString(p->token));
+ PRINT(p->next);
+}
+
+/* How to print out a terminal node */
+void
+#ifdef __USE_PROTOS
+pAction( ActionNode *p )
+#else
+pAction( p )
+ActionNode *p;
+#endif
+{
+ require(p!=NULL, "pAction: NULL node");
+ require(p->ntype==nAction, "pAction: not action node");
+
+ PRINT(p->next);
+}
+
+ /* F i l l F o l l o w L i s t s */
+
+/*
+ * Search all rules for all rule reference nodes, q to rule, r.
+ * Add q->next to follow list dangling off of rule r.
+ * i.e.
+ *
+ * r: -o-R-o-->o--> Ptr to node following rule r in another rule
+ * |
+ * o--> Ptr to node following another reference to r.
+ *
+ * This is the data structure employed to avoid FOLLOW set computation. We
+ * simply compute the FIRST (reach) of the EndRule Node which follows the
+ * list found at the end of all rules which are referenced elsewhere. Rules
+ * not invoked by other rules have no follow list (r->end->p1==NULL).
+ * Generally, only start symbols are not invoked by another rule.
+ *
+ * Note that this mechanism also gives a free cross-reference mechanism.
+ *
+ * The entire syntax diagram is layed out like this:
+ *
+ * SynDiag
+ * |
+ * v
+ * o-->R1--o
+ * |
+ * o-->R2--o
+ * |
+ * ...
+ * |
+ * o-->Rn--o
+ *
+ */
+void
+#ifdef __USE_PROTOS
+FoLink( Node *p )
+#else
+FoLink( p )
+Node *p;
+#endif
+{
+ RuleEntry *q;
+ Junction *j = (Junction *) p;
+ RuleRefNode *r = (RuleRefNode *) p;
+
+ if ( p==NULL ) return;
+ require(p->ntype>=1 && p->ntype<=NumNodeTypes,
+ eMsgd("FoLink: invalid diagram node: ntype==%d",p->ntype));
+ switch ( p->ntype )
+ {
+ case nJunction :
+ if ( j->fvisited ) return;
+ if ( j->jtype == EndRule ) return;
+ j->fvisited = TRUE;
+ FoLink( j->p1 );
+ FoLink( j->p2 );
+/* MR14 */
+/* MR14 */ /* Need to determine whether the guess block is an */
+/* MR14 */ /* of the form (alpha)? beta before follow sets are */
+/* MR14 */ /* computed. This is necessary to solve problem */
+/* MR14 */ /* of doing follow on the alpha of an (alpha)? beta block. */
+/* MR14 */
+/* MR14 */ /* This is performed by analysis_point as a side-effect. */
+/* MR14 */
+/* MR14 */
+/* MR14 */ if (j->jtype == aSubBlk && j->guess) {
+/* MR14 */ Junction *ignore;
+/* MR14 */ ignore=analysis_point(j);
+/* MR14 */ }
+/* MR14 */
+ return;
+ case nRuleRef :
+ if ( r->linked ) return;
+ q = (RuleEntry *) hash_get(Rname, r->text);
+ if ( q == NULL )
+ {
+ warnFL( eMsg1("rule %s not defined",r->text), FileStr[r->file], r->line );
+ }
+ else
+ {
+ if ( r->parms!=NULL && RulePtr[q->rulenum]->pdecl==NULL )
+ {
+ warnFL( eMsg1("rule %s accepts no parameter(s)", r->text),
+ FileStr[r->file], r->line );
+ }
+ if ( r->parms==NULL && RulePtr[q->rulenum]->pdecl!=NULL )
+ {
+ warnFL( eMsg1("rule %s requires parameter(s)", r->text),
+ FileStr[r->file], r->line );
+ }
+ if ( r->assign!=NULL && RulePtr[q->rulenum]->ret==NULL )
+ {
+ warnFL( eMsg1("rule %s yields no return value(s)", r->text),
+ FileStr[r->file], r->line );
+ }
+ if ( r->assign==NULL && RulePtr[q->rulenum]->ret!=NULL )
+ {
+ warnFL( eMsg1("rule %s returns a value(s)", r->text),
+ FileStr[r->file], r->line );
+ }
+ if ( !r->linked )
+ {
+ addFoLink( r->next, r->rname, RulePtr[q->rulenum] );
+ r->linked = TRUE;
+ }
+ }
+ FoLink( r->next );
+ return;
+ case nToken :
+ FoLink( ((TokNode *)p)->next );
+ return;
+ case nAction :
+ FoLink( ((ActionNode *)p)->next );
+ return;
+ default :
+ fatal_internal("invalid node type");
+ }
+}
+
+/*
+ * Add a reference to the end of a rule.
+ *
+ * 'r' points to the RuleBlk node in a rule. r->end points to the last node
+ * (EndRule jtype) in a rule.
+ *
+ * Initial:
+ * r->end --> o
+ *
+ * After:
+ * r->end --> o-->o--> Ptr to node following rule r in another rule
+ * |
+ * o--> Ptr to node following another reference to r.
+ *
+ * Note that the links are added to the head of the list so that r->end->p1
+ * always points to the most recently added follow-link. At the end, it should
+ * point to the last reference found in the grammar (starting from the 1st rule).
+ */
+void
+#ifdef __USE_PROTOS
+addFoLink( Node *p, char *rname, Junction *r )
+#else
+addFoLink( p, rname, r )
+Node *p;
+char *rname;
+Junction *r;
+#endif
+{
+ Junction *j;
+ require(r!=NULL, "addFoLink: incorrect rule graph");
+ require(r->end!=NULL, "addFoLink: incorrect rule graph");
+ require(r->end->jtype==EndRule, "addFoLink: incorrect rule graph");
+ require(p!=NULL, "addFoLink: NULL FOLLOW link");
+
+ j = newJunction();
+ j->rname = rname; /* rname on follow links point to target rule */
+ j->p1 = p; /* link to other rule */
+ j->p2 = (Node *) r->end->p1;/* point to head of list */
+ r->end->p1 = (Node *) j; /* reset head to point to new node */
+}
+
+void
+#ifdef __USE_PROTOS
+GenCrossRef( Junction *p )
+#else
+GenCrossRef( p )
+Junction *p;
+#endif
+{
+ set a;
+ Junction *j;
+ RuleEntry *q;
+ unsigned e;
+ require(p!=NULL, "GenCrossRef: why are you passing me a null grammar?");
+
+ printf("Cross Reference:\n\n");
+ a = empty;
+ for (; p!=NULL; p = (Junction *)p->p2)
+ {
+ printf("Rule %20s referenced by {", p->rname);
+ /* make a set of rules for uniqueness */
+ for (j = (Junction *)(p->end)->p1; j!=NULL; j = (Junction *)j->p2)
+ {
+ q = (RuleEntry *) hash_get(Rname, j->rname);
+ require(q!=NULL, "GenCrossRef: FoLinks are screwed up");
+ set_orel(q->rulenum, &a);
+ }
+ for (; !set_nil(a); set_rm(e, a))
+ {
+ e = set_int(a);
+ printf(" %s", RulePtr[e]->rname);
+ }
+ printf(" }\n");
+ }
+ set_free( a );
+}
+
+/*
+ The single argument is a pointer to the start of an element of a
+ C++ style function prototypet list. Given a pointer to the start of
+ an formal we must locate the comma (or the end of the string)
+ and locate the datatype, formal name, and initial value expression.
+
+ The function returns a pointer to the character following the comma
+ which terminates the formal declaration, or a pointer to the end of
+ the string if none was found.
+
+ I thought we were parsing specialists, how come I'm doing this by
+ hand written code ?
+
+ Examples of input:
+
+ Foo f,
+ Foo f = Foo(1),
+ Foo f = Foo(1,2),
+ Foo f = &farray[1,2],
+ Foo f = ",",
+ Foo f = ',',
+ TFoo<int,char> f = TFoo<int,char>(1,2),
+
+ A non-zero value for nesting indicates a problem matching '(' and ')',
+ '[' and ']', '<' and '>', '{' and '}', or improperly terminated string
+ or character literal.
+
+*/
+
+
+/*
+ * Don't care if it is a valid string literal or not, just find the end
+ * Start with pointer to leading "\""
+ */
+
+#ifdef __USE_PROTOS
+char * skipStringLiteral(char *pCurrent)
+#else
+char * skipStringLiteral(pCurrent)
+char *pCurrent;
+#endif
+{
+ char *p = pCurrent;
+ if (*p == 0) return p;
+ require (*p == '\"', "skipStringLiteral")
+ p++;
+ for (p = p; *p != 0; p++) {
+ if (*p == '\\') {
+ p++;
+ if (*p == 0) break;
+ p++;
+ }
+ if (*p == '\"') {
+ p++;
+ break;
+ }
+ }
+ return p;
+}
+
+/*
+ * Don't care if it is a valid character literal or not, just find the end
+ * Start with pointer to leading "'"
+ */
+
+#ifdef __USE_PROTOS
+char * skipCharLiteral(char *pStart)
+#else
+char * skipCharLiteral(pStart)
+ char *pStart;
+#endif
+{
+ char *p = pStart;
+ if (*p == 0) return p;
+ require (*p == '\'', "skipCharLiteral")
+ p++;
+ for (p = p; *p != 0; p++) {
+ if (*p == '\\') {
+ p++;
+ if (*p == 0) break;
+ p++;
+ }
+ if (*p == '\'') {
+ p++;
+ break;
+ }
+ }
+ return p;
+}
+
+#ifdef __USE_PROTOS
+char * skipSpaces(char *pStart)
+#else
+char * skipSpaces(pStart)
+char * pStart;
+#endif
+{
+ char *p = pStart;
+ while (*p != 0 && isspace(*p)) p++;
+ return p;
+}
+
+#ifdef __USE_PROTOS
+char * skipToSeparatorOrEqualSign(char *pStart, int *pNest)
+#else
+char * skipToSeparatorOrEqualSign(pStart, pNest)
+char *pStart;
+int *pNest;
+#endif
+{
+ char *p = pStart;
+
+ int nest = 0;
+
+ *pNest = (-1);
+
+ while (*p != 0) {
+ switch (*p) {
+
+ case '(' :
+ case '[' :
+ case '<' :
+ case '{' :
+ nest++;
+ p++;
+ break;
+
+ case ')' :
+ case ']' :
+ case '>' :
+ case '}' :
+ nest--;
+ p++;
+ break;
+
+ case '"' :
+ p = skipStringLiteral(p);
+ break;
+
+ case '\'' :
+ p = skipCharLiteral(p);
+ break;
+
+ case '\\':
+ p++;
+ if (*p == 0) goto EXIT;
+ p++;
+ break;
+
+ case ',':
+ case '=':
+ if (nest == 0) goto EXIT;
+ p++;
+ break;
+
+ default:
+ p++;
+ }
+ }
+EXIT:
+ *pNest = nest;
+ return p;
+}
+
+#ifdef __USE_PROTOS
+char * skipToSeparator(char *pStart, int *pNest)
+#else
+char * skipToSeparator(pStart, pNest)
+char *pStart;
+int *pNest;
+#endif
+{
+ char * p = pStart;
+ for ( ; ; ) {
+ p = skipToSeparatorOrEqualSign(p, pNest);
+ if (*pNest != 0) return p;
+ if (*p == ',') return p;
+ if (*p == 0) return p;
+ p++;
+ }
+}
+
+/* skip to just past the "=" separating the declaration from the initialization value */
+
+#ifdef __USE_PROTOS
+char * getInitializer(char *pStart)
+#else
+char * getInitializer(pStart)
+char * pStart;
+#endif
+{
+ char *p;
+ char *pDataType;
+ char *pSymbol;
+ char *pEqualSign;
+ char *pValue;
+ char *pSeparator;
+ int nest = 0;
+
+ require(pStart!=NULL, "getInitializer: invalid string");
+
+ p = endFormal(pStart,
+ &pDataType,
+ &pSymbol,
+ &pEqualSign,
+ &pValue,
+ &pSeparator,
+ &nest);
+ if (nest != 0) return NULL;
+ if (pEqualSign == NULL) return NULL;
+ if (pValue == NULL) return NULL;
+ return strBetween(pValue, NULL, pSeparator);
+}
+
+/*
+ Examines the string from pStart to pEnd-1.
+ If the string has 0 length or is entirely white space
+ returns 1. Otherwise 0.
+*/
+
+#ifdef __USE_PROTOS
+int isWhiteString(const char *pStart, const char *pEnd)
+#else
+int isWhiteString(pStart, pEnd)
+const char *pStart;
+const char *pEnd;
+#endif
+{
+ const char *p;
+ for (p = pStart; p < pEnd; p++) {
+ if (! isspace(*p)) return 0;
+ }
+ return 1;
+}
+
+/*
+ This replaces HasComma() which couldn't distinguish
+
+ foo ["a,b"]
+
+ from:
+
+ foo[a,b]
+
+*/
+
+#ifdef __USE_PROTOS
+int hasMultipleOperands(char *pStart)
+#else
+int hasMultipleOperands(pStart)
+char *pStart;
+#endif
+{
+ char *p = pStart;
+ int nest = 0;
+
+ p = skipSpaces(p);
+ if (*p == 0) return 0;
+ p = skipToSeparator(p, &nest);
+ if (nest == 0 && *p == ',') return 1;
+ return 0;
+}
+
+
+#define MAX_STR_BETWEEN_WORK_AREA 1000
+
+static char strBetweenWorkArea[MAX_STR_BETWEEN_WORK_AREA];
+
+
+/*
+ strBetween(pStart, pNext, pStop)
+
+ Creates a null terminated string by copying the text between two pointers
+ to a work area. The start of the string is pStart. The end of the string
+ is the character before pNext, or if pNext is null then the character before
+ pStop. Trailing spaces are not included in the copy operation.
+
+ This is used when a string contains several parts. The pNext part may be
+ optional. The pStop will stop the scan when the optional part is not present
+ (is a null pointer).
+*/
+
+#ifdef __USE_PROTOS
+char *strBetween(char *pStart, char *pNext, char *pStop)
+#else
+char *strBetween(pStart, pNext, pStop)
+char *pStart;
+char *pNext;
+char *pStop;
+#endif
+{
+ char *p;
+ char *q = strBetweenWorkArea;
+ const char *pEnd;
+
+ pEnd = (pNext != NULL) ? pNext : pStop;
+
+ require (pEnd != NULL, "pEnd == NULL");
+ require (pEnd >= pStart, "pEnd < pStart");
+ for (pEnd--; pEnd >= pStart; pEnd--) { /* MR31 */
+ if (! isspace(*pEnd)) break;
+ }
+ for (p = pStart;
+ p <= pEnd && q < &strBetweenWorkArea[MAX_STR_BETWEEN_WORK_AREA-2];
+ p++, q++) {
+ *q = *p;
+ }
+ *q = 0;
+ return strBetweenWorkArea;
+}
+
+/*
+ function Returns pointer to character following separator at
+ value which to continue search for next formal. If at the
+ end of the string a pointer to the null byte at the
+ end of the string is returned.
+
+ pStart Pointer to the starting position of the formal list
+
+ This may be the middle of a longer string, for example
+ when looking for the end of formal #3 starting from
+ the middle of the complete formal list.
+
+ ppDataType Returns a pointer to the start of the data type in the
+ formal. Example: pointer to "Foo".
+
+ ppSymbol Returns a pointer to the start of the formal symbol.
+ Example: pointer to "f".
+
+ ppEqualSign Returns a pointer to the equal sign separating the
+ formal symbol from the initial value. If there is
+ no "=" then this will be NULL.
+
+ ppValue Returns a pointer to the initial value part of the
+ formal declaration. Example: pointer to "&farray[1,2]"
+
+ ppSeparator Returns a pointer to the character which terminated the
+ scan. This should be a pointer to a comma or a null
+ byte which terminates the string.
+
+ pNest Returns the nesting level when a separator was found.
+ This is non-zero for any kind of error. This is zero
+ for a successful parse of this portion of the formal
+ list.
+
+*/
+
+#ifdef __USE_PROTOS
+char * endFormal(char *pStart,
+ char **ppDataType,
+ char **ppSymbol,
+ char **ppEqualSign,
+ char **ppValue,
+ char **ppSeparator,
+ int *pNest)
+#else
+char * endFormal(pStart,
+ ppDataType,
+ ppSymbol,
+ ppEqualSign,
+ ppValue,
+ ppSeparator,
+ pNest)
+char *pStart;
+char **ppDataType;
+char **ppSymbol;
+char **ppEqualSign;
+char **ppValue;
+char **ppSeparator;
+int *pNest;
+
+#endif
+{
+ char *p = pStart;
+ char *q;
+
+ *ppDataType = NULL;
+ *ppSymbol = NULL;
+ *ppEqualSign = NULL;
+ *ppValue = NULL;
+ *ppSeparator = NULL;
+
+ *pNest = 0;
+
+ /* The first non-blank is the start of the datatype */
+
+ p = skipSpaces(p);
+ if (*p == 0) goto EXIT;
+ *ppDataType = p;
+
+ /* We are not looking for the symbol, we are looking
+ for the separator that follows the symbol. Then
+ we'll back up.
+
+ Search for the ',' or '=" or null terminator.
+ */
+
+ p = skipToSeparatorOrEqualSign(p, pNest);
+
+ if (*pNest != 0) goto EXIT;
+
+ /*
+ Work backwards to find start of symbol
+ Skip spaces between the end of symbol and separator
+ Assume that there are no spaces in the formal, but
+ there is a space preceding the formal
+ */
+
+ for (q = &p[-1]; q >= *ppDataType; q--) {
+ if (! isspace(*q)) break;
+ }
+ if (q < *ppDataType) goto EXIT;
+
+ /*
+ MR26 Handle things like: IIR_Bool (IIR_Decl::*constraint)()
+ Backup until we hit the end of a symbol string, then find the
+ start of the symbol string. This wont' work for functions
+ with prototypes, but works for the most common cases. For
+ others, use typedef names.
+ */
+
+/* MR26 */ for (q = q; q >= *ppDataType; q--) {
+/* MR26 */ if (isalpha(*q) || isdigit(*q) || *q == '_' || *q == '$') break;
+/* MR26 */ }
+/* MR26 */ if (q < *ppDataType) goto EXIT;
+
+ for (q = q; q >= *ppDataType; q--) {
+ if ( ! (isalpha(*q) || isdigit(*q) || *q == '_' || *q == '$')) break;
+ }
+
+ *ppSymbol = &q[1];
+
+ if (*p == ',' || *p == 0) {
+ *ppSeparator = p;
+ goto EXIT;
+ }
+
+ *ppEqualSign = p;
+ p = skipSpaces(++p);
+ *ppValue = p;
+ if (*p == 0) goto EXIT;
+
+
+ while (*p != 0 && *pNest == 0 && *p != ',') {
+ p = skipToSeparator(p, pNest);
+ }
+ if (*pNest == 0) *ppSeparator = p;
+
+EXIT:
+ if (*p == ',') p++;
+ return p;
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/mode.h b/BaseTools/Source/C/VfrCompile/Pccts/antlr/mode.h new file mode 100644 index 0000000000..c08bf31ac7 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/mode.h @@ -0,0 +1,12 @@ +#define START 0
+#define STRINGS 1
+#define ACTION_STRINGS 2
+#define ACTION_CHARS 3
+#define ACTION_COMMENTS 4
+#define TOK_DEF_COMMENTS 5
+#define TOK_DEF_CPP_COMMENTS 6
+#define ACTION_CPP_COMMENTS 7
+#define CPP_COMMENTS 8
+#define COMMENTS 9
+#define ACTIONS 10
+#define PARSE_ENUM_FILE 11
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/mrhoist.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/mrhoist.c new file mode 100644 index 0000000000..110bf5996f --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/mrhoist.c @@ -0,0 +1,3030 @@ +/*
+ * mrhoist.c
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33MR10
+ *
+ */
+
+#include <stdio.h>
+
+#include "pcctscfg.h"
+
+#include "set.h"
+#include "syn.h"
+#include "hash.h"
+#include "generic.h"
+#include "dlgdef.h"
+#include <ctype.h>
+
+#ifdef __USE_PROTOS
+void dumppred(Predicate *);
+#else
+void dumppred();
+#endif
+
+/*
+ Try to determine whether predicate "first" is true for
+ all cases where "second" is true. Comparison takes place
+ without regard to context.
+ Assumes that predicate symbols have been expanded.
+ Assumes that there are no NAND or NOR nodes
+
+*/
+
+#ifdef __USE_PROTOS
+int MR_secondPredicateUnreachable(Predicate *first,Predicate *second)
+#else
+int MR_secondPredicateUnreachable(first,second)
+ Predicate *first;
+ Predicate *second;
+#endif
+{
+ Predicate *f;
+ Predicate *s;
+
+ if (first == NULL) {
+ return 1;
+ } else if (second == NULL) {
+ return 0;
+ } else if (first->down == NULL && second->down == NULL) {
+ if (first->source == second->source &&
+ first->inverted == second->inverted) {
+ return 1; /* look identical - will never reach alt2 */
+ } else {
+ return 0; /* look different */
+ };
+ } else if (first->down == NULL && second->down != NULL) {
+
+ if (second->expr == PRED_AND_LIST) {
+
+ /* unreachable if first covers any child of second */
+
+ for (s=second->down; s != NULL; s=s->right) {
+ if (MR_secondPredicateUnreachable(first,s)) {
+ return 1;
+ };
+ };
+ return 0;
+ } else if (second->expr == PRED_OR_LIST) {
+
+ /* unreachable if first covers every child of second */
+
+ for (s=second->down; s != NULL; s=s->right) {
+ if (!MR_secondPredicateUnreachable(first,s)) {
+ return 0;
+ };
+ };
+ return 1;
+ } else {
+ require (0,"Illegal pred->expr");
+ return 0; /* MR20 Make compiler happy */
+ };
+ } else if (first->down != NULL && second->down == NULL) {
+ if (first->expr == PRED_AND_LIST) {
+
+ /* unreachable if every child of first covers second */
+
+ for (f=first->down; f != NULL; f=f->right) {
+ if (!MR_secondPredicateUnreachable(f,second)) {
+ return 0;
+ };
+ };
+ return 1;
+ } else if (first->expr == PRED_OR_LIST) {
+
+ /* unreachable if any child of first covers second */
+
+ for (f=first->down; f != NULL; f=f->right) {
+ if (MR_secondPredicateUnreachable(f,second)) {
+ return 1;
+ };
+ };
+ return 0;
+ } else {
+ require (0,"Illegal predicate->expr");
+ return 0; /* MR20 Make compiler happy */
+ };
+ } else {
+
+ if (first->expr == PRED_AND_LIST && second->expr == PRED_AND_LIST) {
+
+ /* unreachable if each child of first covers at least one child of second */
+
+ for (f=first->down; f != NULL ; f=f->right) {
+ for (s=second->down; s != NULL ; s=s->right) {
+ if (MR_secondPredicateUnreachable(f,s)) goto A_next_f;
+ };
+ return 0;
+A_next_f:
+ continue;
+ };
+ return 1;
+
+ } else if (first->expr == PRED_AND_LIST && second->expr == PRED_OR_LIST) {
+
+ /* unreachable if each child of first covers ALL of second's children */
+
+ for (f=first->down; f != NULL ; f=f->right) {
+ for (s=second->down; s != NULL ; s=s->right) {
+ if (!MR_secondPredicateUnreachable(f,s)) return 0;
+ };
+ };
+ return 1;
+
+ } else if (first->expr == PRED_OR_LIST && second->expr == PRED_AND_LIST) {
+
+ /* unreachable if any child of second is covered by any child of first */
+
+ for (f=first->down; f != NULL ; f=f->right) {
+ for (s=second->down; s != NULL ; s=s->right) {
+ if (MR_secondPredicateUnreachable(f,s)) return 1;
+ };
+ };
+ return 0;
+
+ } else if (first->expr == PRED_OR_LIST && second->expr == PRED_OR_LIST) {
+
+ /* unreachable if every child of second is covered by some child of first */
+
+ for (f=first->down; f != NULL ; f=f->right) {
+ for (s=second->down; s != NULL ; s=s->right) {
+ if (MR_secondPredicateUnreachable(f,s)) goto B_next_f;
+ };
+ return 0;
+B_next_f:
+ continue;
+ };
+ return 1;
+
+ } else {
+ require (0,"Illegal predicate->expr");
+ return 0; /* MR20 Make compiler happy */
+ };
+ };
+ return 0; /* MR20 MSVC 5.0 complains about missing return statement */
+}
+
+#ifdef __USE_PROTOS
+void MR_xxxIndent(FILE *f,int depth)
+#else
+void MR_xxxIndent(f,depth)
+ FILE *f;
+ int depth;
+#endif
+{
+ int i;
+
+ for (i=0; i<depth ; i++) {
+ fprintf(f," ");
+ };
+}
+
+#ifdef __USE_PROTOS
+void MR_stderrIndent(int depth)
+#else
+void MR_stderrIndent(depth)
+ int depth;
+#endif
+{
+ MR_xxxIndent(stderr,depth);
+}
+
+#ifdef __USE_PROTOS
+void MR_outputIndent(int depth)
+#else
+void MR_outputIndent(depth)
+ int depth;
+#endif
+{
+ MR_xxxIndent(output,depth);
+}
+
+#ifdef __USE_PROTOS
+void MR_set_reuse(set *s)
+#else
+void MR_set_reuse(s)
+ set *s;
+#endif
+{
+ set_free(*s);
+ *s=empty;
+}
+
+#ifdef __USE_PROTOS
+void MR_dumpPredRuleRefStack(FILE *iounit,int indent)
+#else
+void MR_dumpPredRuleRefStack(iounit,indent)
+ FILE *iounit;
+ int indent;
+#endif
+{
+ int i;
+ int j;
+ int count=MR_PredRuleRefStack.count;
+ RuleRefNode *rrn=NULL;
+ Junction *lastOne;
+
+ if (count == 0) {
+ fprintf(iounit,"empty\n");
+ return;
+ };
+ for (i=0; i < count; i++) {
+ rrn=(RuleRefNode *) MR_PredRuleRefStack.data[i];
+ for (j=0; j<indent; j++) fprintf(iounit," ");
+ fprintf(iounit,"#%-2d in rule %s (line %d %s) to rule %s\n",
+ i,rrn->rname,rrn->line,FileStr[rrn->file],rrn->text);
+ };
+ lastOne=MR_ruleReferenced(rrn);
+ if (lastOne != NULL) {
+ for (j=0; j<indent; j++) fprintf(iounit," ");
+ fprintf(iounit,"#%-2d in rule %s (line %d %s)\n",
+ count,lastOne->rname,lastOne->line,FileStr[lastOne->file]);
+ };
+}
+
+#ifdef __USE_PROTOS
+void MR_dumpTreeF(FILE *f,int depth,Tree *tree,int across)
+#else
+void MR_dumpTreeF(f,depth,tree,across)
+ FILE *f;
+ Tree *tree;
+ int depth;
+ int across;
+#endif
+{
+ int newAcross=across;
+
+ if (tree == NULL ) return;
+ if (tree->down != NULL ) {
+ fprintf(output,"\n");
+ MR_outputIndent(depth);
+ fprintf(output, "(root =");
+ };
+ if (tree->token == ALT ) {
+ fprintf(output," %-16s","Alt");
+ } else if (tree->token==EpToken ) {
+ fprintf(output,"(%d)%13s",tree->v.rk," ");
+ } else {
+ fprintf(output," %-16s",TerminalString(tree->token));
+ };
+ if (tree->down != NULL) {
+ fprintf(output,"\n");
+ MR_outputIndent(depth+1);
+ MR_dumpTreeF(f,depth+1,tree->down,1);
+ newAcross=0;
+ fprintf(output,"\n");
+ MR_outputIndent(depth);
+ fprintf(output,")");
+ };
+ if (newAcross > 3) {
+ fprintf(output,"\n");
+ MR_outputIndent(depth);
+ newAcross=0;
+ };
+ MR_dumpTreeF(f,depth,tree->right,newAcross+1);
+}
+
+#ifdef __USE_PROTOS
+void MR_dumpTreeX(int depth,Tree *tree,int across)
+#else
+void MR_dumpTreeX(depth,tree,across)
+ Tree *tree;
+ int depth;
+ int across;
+#endif
+{
+ MR_dumpTreeF(output,depth,tree,across);
+}
+
+#ifdef __USE_PROTOS
+void MR_dumpTokenSet(FILE *f,int depth,set s)
+#else
+void MR_dumpTokenSet(f,depth,s)
+ FILE *f;
+ int depth;
+ set s;
+#endif
+{
+ int i;
+ int j;
+
+ unsigned *pdq;
+
+ if (set_nil(s)) {
+ fprintf(f,"\n");
+ MR_xxxIndent(f,depth+1);
+ fprintf(f,"nil\n");
+ return;
+ };
+
+ pdq=set_pdq(s);
+ require(pdq != NULL,"set_pdq failed");
+ i=0;
+ for (i=0 ; ; i=i+4) {
+ fprintf(f,"\n");
+ MR_xxxIndent(f,depth+1);
+ for (j=0; j < 4 ; j++) {
+ if (pdq[i+j] == nil) break;
+ fprintf(f," %-16s",TerminalString(pdq[i+j]));
+ };
+ if (pdq[i+j] == nil) break;
+ };
+ fprintf(f,"\n");
+ free( (char *) pdq);
+}
+
+#ifdef __USE_PROTOS
+void MR_dumpPred1(int depth,Predicate *p,int withContext)
+#else
+void MR_dumpPred1(depth,p,withContext)
+ int depth;
+ Predicate *p;
+ int withContext;
+#endif
+{
+ unsigned k;
+
+ if (p == NULL) {
+ MR_outputIndent(depth);
+ fprintf(output,"The predicate is empty (or always true)\n\n");
+ return;
+ };
+ if (p->down != NULL) {
+ MR_outputIndent(depth);
+ if (p->inverted) {
+
+ /* MR14a Left out print expression in fprintf
+ Reported by Manuel Kessler (mlkessle@cip.physik.uni-wuerzburg.de)
+ */
+
+ if (p->expr == PRED_AND_LIST) fprintf(output,"%s NAND (not AND) expr\n\n",p->expr);
+ if (p->expr == PRED_OR_LIST) fprintf(output,"%s NOR (not OR) expr\n\n",p->expr);
+ } else {
+ fprintf(output,"%s expr\n\n",p->expr);
+ };
+ } else {
+ MR_outputIndent(depth);
+ fprintf(output,"pred %s <<%s>>?\n",
+ (p->inverted ? " *not*" : ""),
+ (p->expr == NULL ? "null expr" : p->expr));
+ MR_outputIndent(depth+1);
+ fprintf(output," ");
+ fprintf(output," depth=k=%d",p->k);
+ if (p->source != NULL && p->source->guardpred) {
+ fprintf(output," (\"=>\" guard)");
+ }
+ if (p->source != NULL && p->source->ampersandPred != NULL) {
+ fprintf(output," (\"&&\" guard)");
+ };
+ k=set_int(p->completionSet);
+ if (k != nil) {
+ fprintf(output," Incomplete Set at k=%d !",k);
+ };
+ k=set_int(p->completionTree);
+ if (k != nil) {
+ fprintf(output," Incomplete Tree at k=%d !",k);
+ };
+ if (p->source != NULL) {
+ fprintf(output," rule %s line %d %s",
+ p->source->rname,p->source->line,FileStr[p->source->file]);
+ };
+ fprintf(output,"\n");
+ if (withContext &&
+ (HoistPredicateContext ||
+ ! set_nil(p->scontext[1]) ||
+ p->tcontext != NULL)) {
+ if (p->k == 1) {
+ MR_outputIndent(depth+1);
+ fprintf(output,"set context: ");
+ MR_dumpTokenSet(output,depth+1,p->scontext[1]);
+ }
+ if (p->k != 1) {
+ MR_outputIndent(depth+1);
+ fprintf(output,"tree context:");
+ if (p->tcontext == NULL) {
+ fprintf(output," null");
+ } else {
+ MR_dumpTreeX(depth+2,p->tcontext,0);
+ };
+ fprintf(output,"\n");
+ };
+ };
+ fprintf(output,"\n");
+ };
+ if (p->down != NULL) {
+ MR_dumpPred1(depth+1,p->down,withContext);
+ };
+ if (p->right != NULL) {
+ MR_dumpPred1(depth,p->right,withContext);
+ };
+}
+
+#ifdef __USE_PROTOS
+void MR_dumpPred(Predicate *p,int withContext)
+#else
+void MR_dumpPred(p,withContext)
+ Predicate *p;
+ int withContext;
+#endif
+{
+ MR_dumpPred1(0,p,withContext);
+}
+
+#ifdef __USE_PROTOS
+Tree * MR_make_tree_from_set(set s)
+#else
+Tree * MR_make_tree_from_set(s)
+ set s;
+#endif
+{
+ Tree *t=NULL;
+ Tree *node;
+ Tree **tp=&t;
+ int i;
+
+ unsigned *pdq=set_pdq(s);
+
+ if (pdq != NULL) {
+ for (i=0 ; pdq[i] != nil ; i++) {
+ node=tnode( (int) pdq[i]);
+ *tp=node;
+ tp=&(node->right);
+ };
+ *tp=NULL;
+ free ( (char *) pdq);
+ };
+ return t;
+}
+
+#ifdef __USE_PROTOS
+void MR_check_pred_too_long(Predicate *p,set completion)
+#else
+void MR_check_pred_too_long(p,completion)
+ Predicate *p;
+ set completion;
+#endif
+{
+ if (p != NULL &&
+ p->source != NULL &&
+ ! p->source->predTooLong) {
+ if ( !set_nil(completion)) {
+ p->source->predTooLong=1;
+warnFL("It is unusual (but ok) for a semantic predicate to test context past the end of its own rule",
+ FileStr[p->source->file],p->source->line);
+ };
+ };
+}
+
+#ifdef __USE_PROTOS
+int MR_predicate_context_completed(Predicate *p)
+#else
+int MR_predicate_context_completed(p)
+ Predicate *p;
+#endif
+{
+ if (p == NULL) return 1;
+ if (p->expr != PRED_AND_LIST &&
+ p->expr != PRED_OR_LIST) {
+ if ( ! set_nil(p->completionSet)) return 0;
+ if ( ! set_nil(p->completionTree)) return 0;
+ };
+ return MR_predicate_context_completed(p->down) &
+ MR_predicate_context_completed(p->right);
+}
+
+#ifdef __USE_PROTOS
+Node * MR_advance(Node *n)
+#else
+Node * MR_advance(n)
+ Node *n;
+#endif
+{
+ if (n == NULL) return NULL;
+ switch (n->ntype) {
+ case nJunction: return ((Junction *)n)->p1;
+ case nToken: return ((TokNode *)n)->next;
+ case nRuleRef: return ((RuleRefNode *)n)->next;
+ case nAction: return ((ActionNode *)n)->next;
+ default: return NULL;
+ };
+ return NULL; /* MSVC 5.0 complains about missing return statement */
+}
+
+#ifdef __USE_PROTOS
+Junction * MR_find_endRule(Node *n)
+#else
+Junction * MR_find_endRule(n)
+ Node *n;
+#endif
+{
+ Node *next;
+ if (n == NULL) return NULL;
+ for (next=n; next != NULL; next=MR_advance(next)) {
+ if (next->ntype == nJunction &&
+ ( (Junction *) next)->jtype == EndRule) {
+ break;
+ };
+ };
+ return (Junction *)next;
+}
+
+/*
+ Intersection: a branch which is shorter is chosen
+ over one which is longer: (A B C) intersect (A B) yields (A B).
+
+ AND: a branch which is longer is chosen over the one
+ which is shorter: (A B C) AND (A B) yields (A B C)
+
+*/
+
+#ifdef __USE_PROTOS
+Tree *MR_computeTreeIntersection(Tree *l,Tree *r)
+#else
+Tree *MR_computeTreeIntersection(l,r)
+ Tree *l;
+ Tree *r;
+#endif
+{
+ Tree *result=NULL;
+ Tree **tail;
+ Tree *p;
+ Tree *q;
+ Tree *match;
+
+ if (l == NULL || r == NULL) return NULL;
+ for (p=l; p != NULL; p=p->right) {
+ require(p->token != EpToken,"MR_computeTreeIntersection: p->EpToken unexpected\n");
+ require (p->token != ALT,"MR_computeTreeIntersection: p->ALT unexpected\n");
+ };
+ for (q=r; q != NULL; q=q->right) {
+ require(q->token != EpToken,"MR_computeTreeIntersection: q->EpToken unexpected\n");
+ require(q->token != ALT,"MR_computeTreeIntersection: q->ALT unexpected\n");
+ };
+
+ result=tnode(ALT);
+ tail=&(result->down);
+
+ for (p=l; p != NULL ; p=p->right) {
+ for (q=r; q != NULL ; q=q->right) {
+ if (p->token == q->token) {
+ match=tnode(p->token);
+ match->down=MR_computeTreeIntersection(p->down,q->down);
+ *tail=match;
+ tail=&(match->right);
+ };
+ };
+ };
+
+ *tail=NULL;
+ result=tshrink(result);
+ result=tflatten( result );
+ result=tleft_factor( result );
+ return result;
+}
+
+/* the predicates which are ANDed together have a common
+ context: they must all have common roots. Thus the
+ AND operation is more like an OR operation because
+ branches which are longer are grafted onto shorter
+ branches of the AND tree. For instance combining
+ (A B C) with (A B C D) gives (A B C D). There
+ should never be a case of (A B C) and (A B D) because
+ they have the same context.
+
+ Actually, this may not be true once one throws in
+ guard predicates which are defined by the user, not
+ the context.
+*/
+
+/* requires input trees to be in "canonical" format */
+
+#ifdef __USE_PROTOS
+Tree *MR_computeTreeAND(Tree *l,Tree *r)
+#else
+Tree *MR_computeTreeAND(l,r)
+ Tree *l;
+ Tree *r;
+#endif
+{
+ Tree *result=NULL;
+ Tree **tail;
+ Tree *p;
+ Tree *q;
+ Tree *match;
+
+ if (l == NULL) return tdup(r);
+ if (r == NULL) return tdup(l);
+
+ for (p=l; p != NULL; p=p->right) {
+/**** require(p->token != EpToken,"MR_computeTreeAND: p->EpToken unexpected\n"); ****/
+ require (p->token != ALT,"MR_computeTreeAND: p->ALT unexpected\n");
+ };
+ for (q=r; q != NULL; q=q->right) {
+/**** require(q->token != EpToken,"MR_computeTreeAND: q->EpToken unexpected\n"); ****/
+ require(q->token != ALT,"MR_computeTreeAND: q->ALT unexpected\n");
+ };
+
+ result=tnode(ALT);
+ tail=&(result->down);
+
+ for (p=l; p != NULL ; p=p->right) {
+ for (q=r; q != NULL ; q=q->right) {
+ if (p->token == q->token) {
+ match=tnode(p->token);
+ match->down=MR_computeTreeAND(p->down,q->down);
+ *tail=match;
+ tail=&(match->right);
+ };
+ };
+ };
+
+ *tail=NULL;
+ result=tshrink(result);
+ result=tflatten( result );
+ result=tleft_factor( result );
+ return result;
+}
+
+#ifdef __USE_PROTOS
+void MR_union_plain_sets1(Predicate *p,set *theUnion)
+#else
+void MR_union_plain_sets1(p,theUnion)
+ Predicate *p;
+ set *theUnion;
+#endif
+{
+ if (p == NULL) return;
+ MR_union_plain_sets1(p->down,theUnion);
+ MR_union_plain_sets1(p->right,theUnion);
+ set_orin(theUnion,p->plainSet);
+ return;
+}
+
+#ifdef __USE_PROTOS
+set MR_union_plain_sets(Predicate *p)
+#else
+set MR_union_plain_sets(p)
+ Predicate *p;
+#endif
+{
+ set theUnion;
+
+ theUnion=empty;
+
+ MR_union_plain_sets1(p,&theUnion);
+ return theUnion;
+}
+
+/* does NOT left factor: do not want to merge
+ (A B) with (A) to get (A B)
+ in fact the opposite: (A B) with (A) gives (A)
+*/
+
+#ifdef __USE_PROTOS
+Tree *MR_compute_pred_tree_ctxXX(Predicate *p)
+#else
+Tree *MR_compute_pred_tree_ctxXX(p)
+ Predicate *p;
+#endif
+{
+ Tree *result=NULL;
+ Predicate *q;
+ Tree *t;
+
+ if (p == NULL) return NULL;
+
+/* this appears strange: why do we OR the context
+ of and AND predicate ? It is because of the way
+ that predicates are evaluated: if the context is
+ wrong then it's the same as if the predicate was
+ true. That means that even when one leg of an
+ AND has unmatched context, if the other leg has
+ matched context and is true then the predicate
+ succeeds. It's only when all the legs have unmatched
+ context that this one can skip evaluation of the
+ predicates.
+*/
+ if (p->expr == PRED_OR_LIST ||
+ p->expr == PRED_AND_LIST) {
+ for (q=p->down; q != NULL ; q=q->right) {
+ t=MR_compute_pred_tree_ctxXX(q);
+ result=tappend(result,t);
+ t=NULL;
+ };
+
+ result=tshrink(result);
+ result=tflatten( result );
+
+/* does NOT left factor: do not want to merge
+ (A B) with (A) to get (A B)
+ in fact the opposite: (A B) with (A) gives (A)
+*/
+
+/**** result=tleft_factor( result ); ****/
+ return result;
+ };
+
+#if 0
+** if (p->expr == PRED_AND_LIST) {
+**
+** Predicate *l;
+** Predicate *r;
+** Tree *l1;
+** Tree *r1;
+** Tree *prevl1;
+**
+** l=p->down;
+** require (l->right != NULL,"MR_compute_pred_tree - AND has only one child");
+**
+**/* l1 and r1 should already be in "canonical" format */
+**
+** l1=MR_compute_pred_tree(l);
+** for (r=l->right; r != NULL; r=r->right) {
+** r1=MR_compute_pred_tree(r);
+** prevl1=l1;
+** l1=MR_computeTreeAND(l1,r1);
+** Tfree(r1);
+** Tfree(prevl1);
+** };
+**
+**/* result from computeTreeAND should be in "canonical" format */
+**
+** result=l1;
+**
+**/* result of MR_computeTreeAND should be in "canonical" format */
+**
+** return result;
+** };
+#endif
+
+ if (p->k == 1) {
+ result=MR_make_tree_from_set(p->scontext[1]);
+ } else {
+ result=tdup(p->tcontext);
+ result=MR_remove_epsilon_from_tree(result);
+ result=tshrink(result);
+ result=tflatten(result);
+ result=tleft_factor(result);
+ };
+ return result;
+}
+
+#ifdef __USE_PROTOS
+void MR_pred_depth(Predicate *p,int *maxDepth)
+#else
+void MR_pred_depth(p,maxDepth)
+ Predicate *p;
+ int *maxDepth;
+#endif
+{
+ if (p == NULL) return;
+ if (p->expr != PRED_OR_LIST &&
+ p->expr != PRED_AND_LIST) {
+ if (p->k > *maxDepth) *maxDepth=p->k;
+ };
+ MR_pred_depth(p->down,maxDepth);
+ MR_pred_depth(p->right,maxDepth);
+}
+
+/* this computes the OR of all the contexts */
+
+#ifdef __USE_PROTOS
+set MR_compute_pred_set(Predicate *p)
+#else
+set MR_compute_pred_set(p)
+ Predicate *p;
+#endif
+{
+ set result;
+ Predicate *q;
+
+ result=empty;
+
+ if (p == NULL) return empty;
+
+ if (p->expr == PRED_OR_LIST ||
+ p->expr == PRED_AND_LIST) { /* yes, I do mean PRED_AND_LIST ! */
+ /* remember: r1: (A)? => <<p>>? r2; */
+ /* r2: (B)? => <<q>>? r3; */
+ set t;
+
+ t=empty;
+ result=empty;
+
+ for (q=p->down; q != NULL; q=q->right) {
+ t=MR_compute_pred_set(q);
+ set_orin(&result,t);
+ set_free(t);
+ };
+ return result;
+ } else if (p->k > 1) {
+ return empty;
+ } else {
+ return set_dup(p->scontext[1]);
+ };
+}
+
+#ifdef __USE_PROTOS
+set MR_First(int ck,Junction *j,set *incomplete)
+#else
+set MR_First(ck,j,incomplete)
+ int ck;
+ Junction *j;
+ set *incomplete;
+#endif
+{
+ Junction *p;
+ set tokensUsed;
+
+ tokensUsed=empty;
+
+ require(j->ntype==nJunction, "MR_First: non junction passed");
+
+ p = analysis_point((Junction *)j->p1);
+
+ REACH(p,ck,incomplete,tokensUsed);
+
+ return tokensUsed;
+}
+
+#ifdef __USE_PROTOS
+void MR_cleanup_pred_trees(Predicate *p)
+#else
+void MR_cleanup_pred_trees(p)
+ Predicate *p;
+#endif
+{
+ Tree *t;
+
+ if (p == NULL) return;
+ if (p->expr != PRED_OR_LIST &&
+ p->expr != PRED_AND_LIST) {
+ t=p->tcontext;
+ t=tshrink(t);
+ t=tflatten(t);
+ t=tleft_factor(t);
+ p->tcontext=t;
+ };
+ MR_cleanup_pred_trees(p->down);
+ MR_cleanup_pred_trees(p->right);
+}
+
+/* does NOT return canonical tree */
+
+#ifdef __USE_PROTOS
+Tree * MR_remove_epsilon_from_tree(Tree *t)
+#else
+Tree * MR_remove_epsilon_from_tree(t)
+ Tree *t;
+#endif
+{
+ if (t == NULL) return NULL;
+
+ /* I think ALT can be ignored as a special case */
+
+ if (t->token != EpToken) {
+ t->down=MR_remove_epsilon_from_tree(t->down);
+ t->right=MR_remove_epsilon_from_tree(t->right);
+ return t;
+ } else {
+ Tree *u;
+ u=MR_remove_epsilon_from_tree(t->right);
+ t->right=NULL;
+ Tfree(t);
+ return u;
+ };
+}
+
+#ifdef __USE_PROTOS
+void MR_complete_set(int predDepth,set *tokensUsed,set *incomplete)
+#else
+void MR_complete_set(predDepth,tokensUsed,incomplete)
+ int predDepth;
+ set *tokensUsed;
+ set *incomplete;
+#endif
+{
+ int i;
+ RuleRefNode *ruleRef;
+ set rk2;
+ set b;
+ int k2;
+ Junction *save_MR_RuleBlkWithHalt;
+
+ if (set_int(*incomplete) > (unsigned) predDepth) {
+ return;
+ };
+
+ require(MR_PredRuleRefStack.count == MR_RuleBlkWithHaltStack.count,
+ "RuleRefStack and RuleBlkWithHaltStack not same size");
+
+ require(MR_RuleBlkWithHalt == NULL ||
+ (MR_RuleBlkWithHalt->jtype == RuleBlk && MR_RuleBlkWithHalt->end->halt == TRUE),
+ "RuleBlkWithHalt has no halt set");
+
+ save_MR_RuleBlkWithHalt=MR_RuleBlkWithHalt;
+
+ if (MR_RuleBlkWithHalt != NULL) {
+ MR_RuleBlkWithHalt->end->halt=FALSE;
+ };
+
+ for (i=MR_PredRuleRefStack.count-1; i >= 0 ; i--) {
+ ruleRef=(RuleRefNode *)MR_PredRuleRefStack.data[i];
+ if (ruleRef == NULL) continue;
+
+ MR_RuleBlkWithHalt=(Junction *)MR_RuleBlkWithHaltStack.data[i];
+ if (MR_RuleBlkWithHalt != NULL) MR_RuleBlkWithHalt->end->halt=TRUE;
+
+ rk2=empty;
+ b=empty;
+
+ while ( !set_nil(*incomplete) ) {
+ k2=set_int(*incomplete);
+ if (k2 > predDepth) break; /* <=== another exit from loop */
+ set_rm(k2,*incomplete);
+ REACH(ruleRef->next,k2,&rk2,b);
+ set_orin(tokensUsed,b);
+ set_free(b);
+ };
+
+ if (MR_RuleBlkWithHalt != NULL) MR_RuleBlkWithHalt->end->halt=FALSE;
+
+ set_orin(incomplete,rk2); /* remember what we couldn't do */
+ set_free(rk2);
+ if (set_int(*incomplete) > (unsigned) predDepth) break; /* <=== another exit from loop */
+ };
+
+ MR_RuleBlkWithHalt=save_MR_RuleBlkWithHalt;
+ if (MR_RuleBlkWithHalt != NULL) {
+ MR_RuleBlkWithHalt->end->halt=TRUE;
+ };
+}
+
+#ifdef __USE_PROTOS
+void MR_complete_tree(int predDepth,Tree **t,set *incomplete)
+#else
+void MR_complete_tree(predDepth,t,incomplete)
+ int predDepth;
+ Tree **t;
+ set *incomplete;
+#endif
+{
+ int i;
+ RuleRefNode *ruleRef;
+ set rk2;
+ Tree *u;
+ unsigned k2;
+ Junction *save_MR_RuleBlkWithHalt;
+ int saveConstrainSearch;
+
+ if (set_int(*incomplete) > (unsigned) predDepth) {
+ return;
+ };
+
+ require(MR_PredRuleRefStack.count == MR_RuleBlkWithHaltStack.count,
+ "RuleRefStack and RuleBlkWithHaltStack not same size");
+
+ require(MR_RuleBlkWithHalt == NULL ||
+ (MR_RuleBlkWithHalt->jtype == RuleBlk && MR_RuleBlkWithHalt->end->halt == TRUE),
+ "RuleBlkWithHalt has no halt set");
+
+ save_MR_RuleBlkWithHalt=MR_RuleBlkWithHalt;
+ saveConstrainSearch=ConstrainSearch;
+ ConstrainSearch=0;
+
+ if (MR_RuleBlkWithHalt != NULL) {
+ MR_RuleBlkWithHalt->end->halt=FALSE;
+ };
+
+ for (i=MR_PredRuleRefStack.count-1; i >= 0 ; i--) {
+ ruleRef=(RuleRefNode *)MR_PredRuleRefStack.data[i];
+ if (ruleRef == NULL) continue;
+
+ MR_RuleBlkWithHalt=(Junction *)MR_RuleBlkWithHaltStack.data[i];
+
+ if (MR_RuleBlkWithHalt != NULL) MR_RuleBlkWithHalt->end->halt=TRUE;
+
+ rk2=empty;
+
+ while ( !set_nil(*incomplete) ) {
+ k2 = set_int(*incomplete);
+ if (k2 > (unsigned) predDepth) break; /* <=== another exit from loop */
+ set_rm(k2,*incomplete);
+ u = NULL;
+
+ TRAV(ruleRef->next,k2,&rk2,u);
+
+ /* any subtrees missing k2 tokens, add u onto end */
+
+ *t=tlink(*t,u,k2);
+ Tfree(u);
+ }
+
+ set_orin(incomplete,rk2); /* remember what we couldn't do */
+ set_free(rk2);
+
+ if (MR_RuleBlkWithHalt != NULL) MR_RuleBlkWithHalt->end->halt=FALSE;
+
+ if (set_int(*incomplete) > (unsigned) predDepth) break; /* <=== another exit from loop */
+ };
+
+ MR_RuleBlkWithHalt=save_MR_RuleBlkWithHalt;
+
+ if (MR_RuleBlkWithHalt != NULL) {
+ MR_RuleBlkWithHalt->end->halt=TRUE;
+ };
+ ConstrainSearch=saveConstrainSearch;
+}
+
+#ifdef __USE_PROTOS
+void MR_complete_predicates(int predDepth,Predicate *pred)
+#else
+void MR_complete_predicates(predDepth,pred)
+ int predDepth;
+ Predicate *pred;
+#endif
+{
+ if (pred == NULL) return;
+ if (pred->expr != PRED_AND_LIST &&
+ pred->expr != PRED_OR_LIST) {
+ MR_complete_set(predDepth,&(pred->scontext[1]),&(pred->completionSet));
+ MR_complete_tree(predDepth,&(pred->tcontext),&(pred->completionTree));
+ };
+ MR_complete_predicates(predDepth,pred->down);
+ MR_complete_predicates(predDepth,pred->right);
+}
+
+#ifdef __USE_PROTOS
+Junction * MR_junctionWithoutP2(Junction *j)
+#else
+Junction * MR_junctionWithoutP2(j)
+ Junction *j;
+#endif
+{
+ Junction *thisAlt;
+
+/* don't want to follow p2 to the next alternative of this rule */
+/* insert a generic node with null p2 if necessary */
+/* however FIRST requires a junction */
+
+ thisAlt=j;
+ if (thisAlt->p2 != NULL) {
+ if (thisAlt->p1->ntype == nJunction) {
+ thisAlt=(Junction *) thisAlt->p1;
+ } else {
+ thisAlt=newJunction();
+ thisAlt->p1=j->p1;
+ thisAlt->rname=j->rname;
+ thisAlt->file=j->file;
+ thisAlt->line=j->line;
+ j->p1=(Node *)thisAlt;
+ };
+ };
+ return thisAlt;
+}
+
+#ifdef __USE_PROTOS
+int MR_tree_equ(Tree *big, Tree *small) {
+#else
+int MR_tree_equ(big,small)
+ Tree *big;
+ Tree *small;
+{
+#endif
+
+ Tree *b;
+ Tree *s;
+ int bcount=0;
+ int scount=0;
+
+ if (small == NULL && big == NULL) return 1;
+ if (small == NULL) return 0;
+ if (big == NULL) return 0;
+
+ if (small->token == ALT) {
+ require(small->right == NULL,
+ "MR_tree_equ: small: ALT node has siblings");
+ return MR_tree_equ(big,small->down);
+ };
+ if (big->token == ALT) {
+ require(big->right == NULL,
+ "MR_tree_equ: big: ALT node has siblings");
+ return MR_tree_equ(big->down,small);
+ };
+ for (s=small; s != NULL; s=s->right) {
+ scount++;
+ require(s->token != EpToken,"MR_tree_equ: s->EpToken unexpected\n");
+ };
+ for (b=big; b != NULL; b=b->right) {
+ bcount++;
+ require(b->token != EpToken,"MR_tree_equ: b->EpToken unexpected\n");
+ };
+
+ if (bcount != scount) return 0;
+
+ for (s=small; s != NULL; s=s->right) {
+ for (b=big; b!= NULL; b=b->right) {
+ if (s->token == b->token) {
+ if (MR_tree_equ(b->down,s->down)) goto next_s;
+ };
+ };
+ return 0;
+next_s:
+ continue;
+ };
+ return 1;
+}
+
+/* this does not compare sources - only contexts ! */
+
+#ifdef __USE_PROTOS
+int MR_identicalContext(Predicate *p,Predicate *q)
+#else
+int MR_identicalContext(p,q)
+ Predicate *p;
+ Predicate *q;
+#endif
+{
+ if (p->k != q->k) return 0;
+ require ( (p->tcontext == NULL) == (q->tcontext == NULL),
+ "tcontext inconsistent");
+ if (p->k == 1) {
+ return set_equ(p->scontext[1],q->scontext[1]);
+ } else {
+ return MR_tree_equ(p->tcontext,q->tcontext);
+ };
+}
+
+#ifdef __USE_PROTOS
+void MR_reportSetSuppression(int predDepth,
+ set predSet,set plainSet,Junction *jPred,Junction *jPlain,Predicate *p)
+#else
+void MR_reportSetSuppression(predDepth,predSet,plainSet,jPred,jPlain,p)
+ int predDepth;
+ set predSet;
+ set plainSet;
+ Junction *jPred;
+ Junction *jPlain;
+ Predicate *p;
+#endif
+{
+ if (InfoP) {
+ fprintf(output,"\n#if 0\n\n");
+ fprintf(output,"Hoisting of predicate suppressed by alternative without predicate.\n");
+ fprintf(output,"The alt without the predicate includes all cases where the predicate is false.\n\n");
+ fprintf(output," WITH predicate: line %d %s\n",jPred->line,FileStr[jPred->file]);
+ if (jPlain != NULL) {
+ fprintf(output," WITHOUT predicate: line %d %s\n",jPlain->line,FileStr[jPlain->file]);
+ } else {
+ fprintf(output," WITHOUT predicate: all alternatives without predicates (combined)\n");
+ };
+ if (predDepth == 1) {
+ fprintf(output,"\nThe context set for the predicate:\n");
+ MR_dumpTokenSet(output,1,predSet);
+ };
+ fprintf(output,"\nThe lookahead set for the alt WITHOUT the semantic predicate:\n");
+ MR_dumpTokenSet(output,1,plainSet);
+ fprintf(output,"\nThe predicate:\n\n");
+ MR_dumpPred1(1,p,1);
+ fprintf(output,"Chain of referenced rules:\n\n");
+ MR_dumpPredRuleRefStack(output,4);
+ fprintf(output,"\n#endif\n");
+ };
+}
+
+#ifdef __USE_PROTOS
+void MR_reportSetRestriction(int predDepth,set predSet,set plainSet,
+ Junction *jPred,Junction *jPlain,Predicate *origPred,Predicate *newPred)
+#else
+void MR_reportSetRestriction(predDepth,predSet,plainSet,jPred,jPlain,origPred,newPred)
+ int predDepth;
+ set predSet;
+ set plainSet;
+ Junction *jPred;
+ Junction *jPlain;
+ Predicate *origPred;
+ Predicate *newPred;
+#endif
+{
+ set intersect;
+
+ intersect=empty;
+
+ if (! InfoP) return;
+ fprintf(output,"\n#if 0\n\n");
+ fprintf(output,"Restricting the context of a predicate because of overlap in the lookahead set\n");
+ fprintf(output," between the alternative with the semantic predicate and one without\n");
+ fprintf(output,"Without this restriction the alternative without the predicate could not\n");
+ fprintf(output," be reached when input matched the context of the predicate and the predicate\n");
+ fprintf(output," was false.\n\n");
+
+ fprintf(output," WITH predicate: line %d %s\n",jPred->line,FileStr[jPred->file]);
+ if (jPlain != NULL) {
+ fprintf(output," WITHOUT predicate: line %d %s\n",jPlain->line,FileStr[jPlain->file]);
+ } else {
+ fprintf(output," WITHOUT predicate: all alternatives without predicates (combined)\n");
+ };
+ if (predDepth == 1) {
+ fprintf(output,"\nThe original context set for the predicate:\n");
+ MR_dumpTokenSet(output,1,predSet);
+ };
+ fprintf(output,"\nThe lookahead set for the alt WITHOUT the semantic predicate:\n");
+ MR_dumpTokenSet(output,1,plainSet);
+ if (predDepth == 1) {
+ fprintf(output,"\nThe intersection of the two sets\n");
+ intersect=set_and(predSet,plainSet);
+ MR_dumpTokenSet(output,1,intersect);
+ set_free(intersect);
+ };
+ fprintf(output,"\nThe original predicate:\n\n");
+ MR_dumpPred1(1,origPred,1);
+ fprintf(output,"The new (modified) form of the predicate:\n\n");
+ MR_dumpPred1(1,newPred,1);
+ fprintf(output,"#endif\n");
+}
+
+/* don't use Pass3 by itself unless you know that inverted is not important */
+
+#ifdef __USE_PROTOS
+Predicate * MR_removeRedundantPredPass3(Predicate *p)
+#else
+Predicate * MR_removeRedundantPredPass3(p)
+ Predicate *p;
+#endif
+{
+ Predicate *q;
+
+ if (p == NULL) return NULL;
+ p->right=MR_removeRedundantPredPass3(p->right);
+ p->down=MR_removeRedundantPredPass3(p->down);
+ if (p->redundant) {
+ q=p->right;
+ p->right=NULL;
+ predicate_free(p);
+ return q;
+ };
+ if (p->expr == PRED_AND_LIST ||
+ p->expr == PRED_OR_LIST) {
+ if (p->down == NULL) {
+ q=p->right;
+ p->right=NULL;
+ predicate_free(p);
+ return q;
+ };
+ if (p->down != NULL && p->down->right == NULL) {
+ q=p->down;
+ q->right=p->right;
+ p->right=NULL;
+ p->down=NULL;
+ return q;
+ };
+ };
+ return p;
+}
+
+#ifdef __USE_PROTOS
+void MR_removeRedundantPredPass2(Predicate *p)
+#else
+void MR_removeRedundantPredPass2(p)
+ Predicate *p;
+#endif
+{
+ Predicate *q;
+
+ if (p == NULL) return;
+
+ if (p->expr == PRED_AND_LIST) {
+ for (q=p->down ; q != NULL ; q=q->right) {
+ MR_removeRedundantPredPass2(q);
+ if (q->isConst) {
+ if (q->constValue == 0) {
+ p->isConst=1;
+ p->constValue=0;
+ return;
+ } else {
+ q->redundant=1;
+ };
+ };
+ };
+ };
+
+ if (p->expr == PRED_OR_LIST) {
+ for (q=p->down ; q != NULL ; q=q->right) {
+ MR_removeRedundantPredPass2(q);
+ if (q->isConst) {
+ if (q->constValue == 0) {
+ q->redundant=1;
+ } else {
+ p->isConst=1;
+ p->constValue=1;
+ return;
+ };
+ };
+ };
+ };
+
+ return;
+}
+
+#if 0
+ this totally ignores the implications of guarded predicates
+ in which the part after the guard could possibly cover a predicate.
+ that would be much harder:
+
+ rule : (A)? => <<p>>? sub1; /* 1 */
+ | (B)? => <<r>>? sub2 /* 2 */
+ sub1 : (A)? => <<q>>? A B /* 3 */
+ | B /* 4 - suppresses line 2 */
+ ;
+#endif
+
+#ifdef __USE_PROTOS
+void MR_apply_restriction1(Predicate *pred,set *plainSet,int *changed)
+#else
+void MR_apply_restriction1(pred,plainSet,changed)
+ Predicate *pred;
+ set *plainSet;
+ int *changed;
+#endif
+{
+ if (pred == NULL) return;
+ MR_apply_restriction1(pred->right,plainSet,changed);
+ if (pred->down != NULL) {
+ MR_apply_restriction1(pred->down,plainSet,changed);
+ } else {
+ set t;
+ if (pred->k == 1) {
+ t=set_dif(pred->scontext[1],*plainSet);
+ if (*changed == 0 &&
+ !set_equ(t,pred->scontext[1])) {
+ *changed=1;
+ };
+ if (set_nil(t)) {
+ pred->redundant=1;
+ };
+ set_free(pred->scontext[1]);
+ pred->scontext[1]=t;
+ };
+ };
+}
+
+#ifdef __USE_PROTOS
+void MR_orin_plainSet(Predicate *p,set plainSet)
+#else
+void MR_orin_plainSet(p,plainSet)
+ Predicate *p;
+ set plainSet;
+#endif
+{
+ if (p == NULL) return;
+ MR_orin_plainSet(p->down,plainSet);
+ MR_orin_plainSet(p->right,plainSet);
+ set_orin(&p->plainSet,plainSet);
+}
+
+Predicate *PRED_SUPPRESS;
+
+#ifdef __USE_PROTOS
+Predicate * MR_find_in_aSubBlk(Junction *alt)
+#else
+Predicate * MR_find_in_aSubBlk(alt)
+ Junction *alt;
+#endif
+{
+ Predicate *root=NULL;
+ Predicate **tail=NULL;
+
+ Junction *p;
+
+ int nAlts=0;
+ Junction **jList;
+ Predicate **predList;
+ int *matchList;
+ set predSet;
+ int i;
+ int j;
+ int m;
+ int predDepth;
+ set incomplete;
+ set union_plainSet;
+ set setChange;
+ int changed;
+ Predicate *newPred;
+ set setDif;
+ Predicate *origPred;
+ int depth1=1; /* const int */
+ set *plainContext;
+ set plainSet;
+
+ predSet=empty;
+ incomplete=empty;
+ union_plainSet=empty;
+ setChange=empty;
+ setDif=empty;
+ plainSet=empty;
+
+ if (PRED_SUPPRESS == NULL) {
+ PRED_SUPPRESS=new_pred();
+ PRED_SUPPRESS->expr="Predicate Suppressed";
+ };
+
+ /* this section just counts the number of "interesting" alternatives */
+ /* in order to allocate arrays */
+
+ for (p=alt; p!=NULL; p=(Junction *)p->p2) {
+ /* ignore empty alts */
+ if ( p->p1->ntype != nJunction ||
+ ((Junction *)p->p1)->jtype != EndBlk ) {
+ nAlts++;
+ };
+ };
+
+ /* if this is a (...)+ block then don't count the last alt because
+ it can't be taken until at least one time through the block.
+ In other words it isn't a real choice until the (...)+ is entered
+ at which point the hoisting issue is moot.
+ Maybe look at "ignore" instead ?
+ */
+
+ if (alt->jtype == aPlusBlk) {
+ nAlts--;
+ };
+
+ jList=(Junction **)calloc(nAlts,sizeof(Junction *));
+ require(jList!=NULL,"cannot allocate MR_find_in_aSubBlk jList");
+
+ plainContext=(set *)calloc(nAlts,sizeof(set));
+ require(plainContext!=NULL,"cannot allocate MR_find_in_aSubBlk plainContext");
+ for (m=0; m < nAlts; m++) plainContext[m]=empty;
+
+ predList=(Predicate **)calloc(nAlts,sizeof(Predicate *));
+ require(predList!=NULL,"cannot allocate MR_find_in_aSubBlk predList");
+
+ matchList=(int *)calloc(nAlts,sizeof(int));
+ require(matchList!=NULL,"cannot allocate MR_find_in_aSubBlk matchList");
+
+ /* this section just fills in the arrays previously allocated */
+ /* the most interesting one is matchList[] */
+ /* */
+ /* bit 0 => this alt has a semantic pred which is "covered" */
+ /* by an alt without a semantic pred. Don't hoist. */
+
+ for (i=0,p=alt;
+ p!=NULL && i<nAlts;
+ i++,p=(Junction *)p->p2) {
+
+ /* ignore empty alts */
+
+ if ( p->p1->ntype != nJunction ||
+ ((Junction *)p->p1)->jtype != EndBlk ) {
+ jList[i]=MR_junctionWithoutP2(p);
+ predList[i]=find_predicates(p->p1); /* should be jList ????? */
+ if (predList[i] != NULL) {
+ MR_cleanup_pred_trees(predList[i]); /* flatten & left factor */
+ plainContext[i]=MR_union_plain_sets(predList[i]);
+ } else {
+ MR_set_reuse(&plainSet);
+ MR_set_reuse(&incomplete);
+ plainSet=MR_First(depth1,jList[i],&incomplete);
+ MR_complete_set(depth1,&plainSet,&incomplete);
+ require(set_nil(incomplete),"couldn't complete k=1");
+ plainContext[i]=plainSet;
+ plainSet=empty;
+ };
+ set_orin(&union_plainSet,plainContext[i]);
+ };
+ };
+
+ if (nAlts == 1) {
+ goto EXIT_SIMPLE;
+ };
+
+/*
+ * Looking for cases where alt i has a semantic pred and alt j does not.
+ * Don't care about cases where lookahead for semantic predicates overlap
+ * because normal predicate hoisting does the correct thing automatically.
+ * Don't care about cases where lookahead for alts without semantic predicates
+ * overlap because normal prediction does the correct thing automatically.
+ *
+ * When we find such a case check for one of three subcases:
+ *
+ * 1. if lookahead for alt i is contained in the lookahead for any
+ * alt j then ignore semantic predicate of alt i
+ * 2. if lookahead for alt i is not contained in the lookahead for
+ * any alt j then add add predicate i to the OR list to be hoisted
+ * 3. if lookahead for alt i overlaps the lookahead for some alt j then
+ * add a dummy semantic predicate for alt j
+ *
+ * There is an implicit assumption that the context of all alternatives following
+ * the rule being processed here are identical (but may vary from hoist to
+ * hoist depending on the place where the rule was invoked that led to hoisting
+ * these predicates. In othere words in the fragment:
+ *
+ * ( <<a>>? a1 a2 a3 | <<b>>? b1 b2 b3 )
+ *
+ * both a3 and b3 have the same follow sets because they are both at the end of
+ * alternatives in the same block.
+ */
+
+ for (i=0; i < nAlts; i++) {
+ if (jList[i] == NULL) continue;
+ if (predList[i] == NULL) continue;
+
+ /* if the predicate depth turns out to be one token only */
+ /* then it is can be easily represented as a set and */
+ /* compared to the junction set create by MR_First() */
+
+ predDepth=0;
+ MR_pred_depth(predList[i],&predDepth);
+ require (predDepth >= 1,"MR_find_in_aSubBlk: pred depth < 1");
+ require (predDepth <= CLL_k,"MR_find_in_aSubBlk: predDepth > CLL_k");
+
+ /* complete predicates to predDepth
+ If completed to depth=1 then the context would be incomplete.
+ The context would be truncated and the predicate simplify routine
+ would have incomplete information. It would lead to
+ either false matches of failure to find true matches.
+ */
+
+ MR_complete_predicates(predDepth,predList[i]);
+
+ if (predList[i] != NULL) {
+ MR_cleanup_pred_trees(predList[i]); /* flatten & left factor */
+ };
+
+ /* If the predicate depth is 1 then it is possible to suppress
+ a predicate completely using a single plain alt. Check for suppression
+ by a single plain alt first because it gives better messages. If that
+ fails try the union of all the plain alts.
+ */
+
+ if (predDepth == 1) {
+
+ MR_set_reuse(&predSet);
+ predSet=MR_compute_pred_set(predList[i]); /* ignores k>1 predicates */
+
+ for (j=0; j < nAlts; j++) {
+ if (jList[j] == NULL) continue;
+ if (j == i) continue;
+
+ MR_set_reuse(&setDif);
+ setDif=set_dif(predSet,plainContext[j]);
+ if (set_nil(setDif)) {
+ matchList[i] |= 1;
+ MR_reportSetSuppression(predDepth,predSet,plainContext[j],jList[i],jList[j],predList[i]);
+ predicate_free(predList[i]);
+ predList[i]=PRED_SUPPRESS;
+ goto next_i;
+ };
+
+ }; /* end loop on j */
+
+ changed=0;
+
+ /* predicate_dup is only to give good error messages */
+ /* remember to do a predicate_free() */
+
+ origPred=predicate_dup(predList[i]);
+ MR_apply_restriction1(predList[i],&union_plainSet,&changed);
+ if (changed) {
+
+ /* don't use Pass3 by itself unless you know that inverted is not important */
+
+ newPred=MR_removeRedundantPredPass3(predList[i]);
+ newPred=MR_predSimplifyALL(newPred);
+ if (newPred == NULL) {
+ matchList[i] |= 1;
+ MR_reportSetSuppression(predDepth,predSet,union_plainSet,jList[i],
+ NULL,origPred);
+ predList[i]=PRED_SUPPRESS;
+ } else {
+ MR_reportSetRestriction(predDepth,predSet,union_plainSet,jList[i],
+ NULL,origPred,newPred);
+ predList[i]=newPred;
+ };
+ };
+ predicate_free(origPred);
+ origPred=NULL;
+ };
+
+ /*
+ If the predicate depth is > 1 then it can't be suppressed completely
+ because the code doesn't support inspection of such things. They're
+ much messier than k=1 sets.
+ */
+
+ if (predDepth > 1 ) {
+
+ changed=0;
+
+ /* predicate_dup is only to give good error messages */
+ /* remember to do a predicate_free() */
+
+ origPred=predicate_dup(predList[i]);
+ MR_apply_restriction1(predList[i],&union_plainSet,&changed);
+ if (changed) {
+ newPred=MR_removeRedundantPredPass3(predList[i]);
+ newPred=MR_predSimplifyALL(newPred);
+ if (newPred == NULL) {
+ matchList[i] |= 1;
+ MR_reportSetSuppression(predDepth,predSet,union_plainSet,jList[i],
+ NULL,origPred);
+ predList[i]=PRED_SUPPRESS;
+ } else {
+ MR_reportSetRestriction(predDepth,predSet,union_plainSet,jList[i],
+ NULL,origPred,newPred);
+ predList[i]=newPred;
+ };
+ };
+ predicate_free(origPred);
+ origPred=NULL;
+ };
+next_i:
+ continue;
+ };
+
+EXIT_SIMPLE:
+
+ root = new_pred();
+ root->expr=PRED_OR_LIST;
+ tail = &(root->down);
+
+ for (i=0 ; i< nAlts ; i++) {
+ if (jList[i] == NULL) continue;
+
+ if (predList[i] == NULL) {
+ continue;
+ } else if ( (matchList[i] & 1) != 0) {
+ if (predList[i] != PRED_SUPPRESS) {
+ predicate_free(predList[i]);
+ };
+ continue;
+ };
+
+ /* make an OR list of predicates */
+
+ *tail=predList[i];
+ tail=&(predList[i]->right);
+ };
+
+ /* if just one pred, remove OR root */
+
+ if (root->down == NULL) {
+ predicate_free(root);
+ root=NULL;
+ } else if (root->down->right == NULL) {
+ Predicate *p=root->down;
+ root->down=NULL;
+ predicate_free(root);
+ root=p;
+ }
+
+ root=MR_predSimplifyALL(root);
+
+ MR_orin_plainSet(root,union_plainSet);
+
+ set_free(predSet);
+ set_free(union_plainSet);
+ set_free(incomplete);
+ set_free(setChange);
+ set_free(setDif);
+
+ for (m=0; m < nAlts; m++) set_free(plainContext[m]);
+
+ free ( (char *) jList);
+ free ( (char *) predList);
+ free ( (char *) matchList);
+ free ( (char *) plainContext);
+
+ return root;
+}
+
+#ifdef __USE_PROTOS
+void MR_predContextPresent(Predicate *p,int *allHaveContext,int *noneHaveContext)
+#else
+void MR_predContextPresent(p,allHaveContext,noneHaveContext)
+ Predicate *p;
+ int *allHaveContext;
+ int *noneHaveContext;
+#endif
+{
+ if (p == NULL) return;
+ MR_predContextPresent(p->right,allHaveContext,noneHaveContext);
+ if (p->expr != PRED_AND_LIST &&
+ p->expr != PRED_OR_LIST) {
+ if (set_nil(p->scontext[1]) == 0 ||
+ (p->tcontext != NULL)) {
+ *noneHaveContext=0;
+ } else {
+ *allHaveContext=0;
+ };
+ };
+ MR_predContextPresent(p->down,allHaveContext,noneHaveContext);
+}
+
+#ifdef __USE_PROTOS
+int MR_pointerStackPush(PointerStack *ps,void *dataPointer)
+#else
+int MR_pointerStackPush(ps,dataPointer)
+ PointerStack *ps;
+ void *dataPointer;
+#endif
+{
+ void **newStack;
+ int newSize;
+ int i;
+
+ if (ps->count == ps->size) {
+ newSize=20+ps->size*2;
+ newStack=(void **)calloc(newSize,sizeof(void *));
+ require (newStack != NULL,"cannot allocate PointerStack");
+ for (i=0; i < ps->size; i++) {
+ newStack[i]=ps->data[i];
+ };
+ if (ps->data != NULL) free( (char *) ps->data);
+ ps->data=newStack;
+ ps->size=newSize;
+ };
+ ps->data[ps->count]=dataPointer;
+ ps->count++;
+ return ps->count-1;
+}
+
+#ifdef __USE_PROTOS
+void * MR_pointerStackPop(PointerStack *ps)
+#else
+void * MR_pointerStackPop(ps)
+ PointerStack *ps;
+#endif
+{
+ void *dataPointer;
+
+ require(ps->count > 0,"MR_pointerStackPop underflow");
+
+ dataPointer=ps->data[ps->count-1];
+ ps->data[ps->count-1]=NULL;
+ (ps->count)--;
+ return dataPointer;
+}
+
+#ifdef __USE_PROTOS
+void * MR_pointerStackTop(PointerStack *ps)
+#else
+void * MR_pointerStackTop(ps)
+ PointerStack *ps;
+#endif
+{
+ require(ps->count > 0,"MR_pointerStackTop underflow");
+ return ps->data[ps->count-1];
+}
+
+#ifdef __USE_PROTOS
+void MR_pointerStackReset(PointerStack *ps)
+#else
+void MR_pointerStackReset(ps)
+ PointerStack *ps;
+#endif
+{
+ int i;
+ if (ps->data != NULL) {
+ for (i=0; i < ps->count ; i++) {
+ ps->data[i]=NULL;
+ };
+ };
+ ps->count=0;
+}
+
+#ifdef __USE_PROTOS
+Junction *MR_nameToRuleBlk(char *name)
+#else
+Junction *MR_nameToRuleBlk(name)
+ char *name;
+#endif
+{
+ RuleEntry *q;
+
+ require (RulePtr != NULL,"MR_nameToRule: RulePtr not initialized");
+
+ if (name == NULL) return NULL;
+
+ q = (RuleEntry *) hash_get(Rname,name);
+
+ if ( q == NULL ) {
+ return NULL;
+ } else {
+ return RulePtr[q->rulenum];
+ };
+}
+
+#ifdef __USE_PROTOS
+Junction * MR_ruleReferenced(RuleRefNode *rrn)
+#else
+Junction * MR_ruleReferenced(rrn)
+ RuleRefNode *rrn;
+#endif
+{
+ return MR_nameToRuleBlk(rrn->text);
+}
+
+#ifdef __USE_PROTOS
+void MR_comparePredLeaves(Predicate *me,Predicate *myParent,Predicate *him,Predicate *hisParent)
+#else
+void MR_comparePredLeaves(me,myParent,him,hisParent)
+ Predicate *me;
+ Predicate *myParent;
+ Predicate *him;
+ Predicate *hisParent;
+#endif
+{
+ if (me == NULL) return;
+ if (me == him) {
+ MR_comparePredLeaves(me->right,myParent,him,hisParent);
+ return;
+ } else if (me->expr == PRED_AND_LIST ||
+ me->expr == PRED_OR_LIST) {
+ MR_comparePredLeaves(me->down,me,him,hisParent);
+ MR_comparePredLeaves(me->right,myParent,him,hisParent);
+ return;
+ } else {
+ if (me->source != NULL) {
+
+ /* predicate->invert can be set only in the predEntry predicates */
+ /* thus they are only visible after the predEntry predicates have been "unfolded" */
+
+ int sameSource=(me->source == him->source);
+ int sameInvert=1 &
+ (1 + me->inverted + him->inverted + me->source->inverted + him->source->inverted);
+ int samePredEntry=(me->source->predEntry != NULL
+ && him->source->predEntry != NULL
+ && me->source->predEntry == him->source->predEntry);
+ if (sameInvert && (sameSource || samePredEntry)) {
+ if (MR_identicalContext(me,him)) {
+
+ /* identical predicates */
+
+ if (hisParent->expr == PRED_OR_LIST &&
+ myParent->expr == PRED_OR_LIST) {
+ me->redundant=1;
+ } else if (hisParent->expr == PRED_AND_LIST &&
+ myParent->expr == PRED_AND_LIST) {
+ me->redundant=1;
+ } else if ( (hisParent->expr == PRED_OR_LIST &&
+ myParent->expr == PRED_AND_LIST)
+ ||
+ (hisParent->expr == PRED_AND_LIST &&
+ myParent->expr == PRED_OR_LIST)
+ ) {
+ myParent->redundant=1;
+ } else {
+ require (0,"MR_comparePredLeaves: not both PRED_LIST");
+ };
+ };
+ }; /* end same source or same predEntrr with same invert sense */
+
+ /* same predEntry but opposite invert sense */
+
+ if (!sameInvert && (sameSource || samePredEntry)) {
+ if (MR_identicalContext(me,him)) {
+ if (hisParent->expr == PRED_OR_LIST &&
+ myParent->expr == PRED_OR_LIST) {
+ myParent->isConst=1;
+ myParent->constValue=1;
+ } else if (hisParent->expr == PRED_AND_LIST &&
+ myParent->expr == PRED_AND_LIST) {
+ myParent->isConst=1;
+ myParent->constValue=0;
+ } else if ( (hisParent->expr == PRED_OR_LIST &&
+ myParent->expr == PRED_AND_LIST)
+ ||
+ (hisParent->expr == PRED_AND_LIST &&
+ myParent->expr == PRED_OR_LIST)
+ ) {
+ me->redundant=1;
+ } else {
+ require (0,"MR_comparePredLeaves: not both PRED_LIST");
+ };
+ };
+ }; /* end same predEntry with opposite invert sense */
+ };
+
+ MR_comparePredLeaves(me->right,myParent,him,hisParent);
+ return;
+ };
+}
+
+#ifdef __USE_PROTOS
+void MR_removeRedundantPredPass1(Predicate *me,Predicate *myParent)
+#else
+void MR_removeRedundantPredPass1(me,myParent)
+ Predicate *me;
+ Predicate *myParent;
+#endif
+{
+ if (me == NULL) return;
+ if (me->redundant) {
+ MR_removeRedundantPredPass1(me->right,myParent);
+ return;
+ };
+ if (me->expr == PRED_AND_LIST ||
+ me->expr == PRED_OR_LIST) {
+ MR_removeRedundantPredPass1(me->down,me);
+ MR_removeRedundantPredPass1(me->right,myParent);
+ } else {
+ require (me->source != NULL,"me->source == NULL");
+ if (myParent != NULL) {
+ MR_comparePredLeaves(myParent->down,myParent,me,myParent);
+ };
+ MR_removeRedundantPredPass1(me->right,myParent);
+ };
+}
+
+/* pretty much ignores things with the inverted bit set */
+
+#ifdef __USE_PROTOS
+Predicate *MR_predFlatten(Predicate *p)
+#else
+Predicate *MR_predFlatten(p)
+ Predicate *p;
+#endif
+{
+ if (p == NULL) return NULL;
+ if (p->expr == PRED_OR_LIST
+ || p->expr == PRED_AND_LIST) {
+
+ Predicate *child;
+ Predicate *gchild;
+ Predicate **tail;
+ Predicate *next;
+ char *PRED_XXX_LIST=p->expr;
+
+ require (p->down != NULL,"MR_predFlatten AND/OR no child");
+
+
+ p->down=MR_predFlatten(p->down);
+ p->right=MR_predFlatten(p->right);
+ child=p->down;
+ if (child->right == NULL) {
+ child->right=p->right;
+ p->right=NULL;
+ p->down=NULL;
+ if (p->inverted) child->inverted=!child->inverted;
+ predicate_free(p);
+ return child;
+ };
+
+ /* make a single list of all children and grandchildren */
+
+ tail=&(p->down);
+ for (child=p->down; child != NULL; child=next) {
+ if (child->expr != PRED_XXX_LIST
+ || child->inverted
+ || child->predEntry != NULL) {
+ *tail=child;
+ tail=&(child->right);
+ next=child->right;
+ } else {
+ for (gchild=child->down;
+ gchild != NULL;
+ gchild=gchild->right) {
+ *tail=gchild;
+ tail=&(gchild->right);
+ };
+ next=child->right;
+ child->right=NULL;
+ child->down=NULL;
+ predicate_free(child);
+ };
+ };
+ *tail=NULL;
+ return p;
+ } else {
+ p->right=MR_predFlatten(p->right);
+ return p;
+ };
+}
+
+static char *alwaysFalseWarning=NULL;
+
+#ifdef __USE_PROTOS
+Predicate *checkPredicateConflict(Predicate *p)
+#else
+Predicate *checkPredicateConflict(p)
+ Predicate *p;
+#endif
+{
+ if (p->isConst) {
+ if (p->constValue == 1) {
+ predicate_free(p);
+ return NULL;
+ } else {
+ if (InfoP && !p->conflictReported) {
+ p->conflictReported=1;
+ fprintf(output,"\n#if 0\n\n");
+ fprintf(output,"The following predicate expression will always be false:\n\n");
+ MR_dumpPred1(1,p,1);
+ fprintf(output,"\n#endif\n");
+ };
+
+ if (alwaysFalseWarning != CurRule) {
+ alwaysFalseWarning=CurRule;
+ if (InfoP) {
+ warnNoFL(eMsg1("one (or more) predicate expression hoisted into rule \"%s\" are always false \
+- see output file for more information",CurRule));
+ } else {
+ warnNoFL(eMsg1("one (or more) predicate expressions hoisted into rule \"%s\" are always false \
+- use \"-info p\" for more information",CurRule));
+ };
+ };
+ };
+ };
+ return p;
+}
+
+
+#ifdef __USE_PROTOS
+int MR_countPredNodes(Predicate *p)
+#else
+int MR_countPredNodes(p)
+ Predicate *p;
+#endif
+{
+ if (p == NULL) return 0;
+ return 1 + MR_countPredNodes(p->down) + MR_countPredNodes(p->right);
+}
+
+#ifdef __USE_PROTOS
+Predicate *MR_predSimplifyALLX(Predicate *p,int skipPass3)
+#else
+Predicate *MR_predSimplifyALLX(p,skipPass3)
+ Predicate *p;
+ int skipPass3;
+#endif
+{
+ int countBefore;
+ int countAfter;
+
+ countAfter=MR_countPredNodes(p);
+
+ do {
+ if (p == NULL) return NULL;
+ if (p->right == NULL && p->down == NULL) return p;
+ countBefore=countAfter;
+ MR_simplifyInverted(p,0);
+ p=MR_predFlatten(p);
+ MR_removeRedundantPredPass1(p,NULL);
+ MR_removeRedundantPredPass2(p);
+ if (! skipPass3) {
+ p=checkPredicateConflict(p);
+ p=MR_removeRedundantPredPass3(p);
+ };
+ countAfter=MR_countPredNodes(p);
+ } while (countBefore != countAfter);
+
+ return p;
+}
+
+#ifdef __USE_PROTOS
+Predicate *MR_predSimplifyALL(Predicate *p)
+#else
+Predicate *MR_predSimplifyALL(p)
+ Predicate *p;
+#endif
+{
+ return MR_predSimplifyALLX(p,0);
+}
+
+#ifdef __USE_PROTOS
+void MR_releaseResourcesUsedInRule(Node *n)
+#else
+void MR_releaseResourcesUsedInRule(n)
+ Node *n;
+#endif
+{
+ Node *next;
+ Junction *j;
+ int i;
+
+ if (n == NULL) return;
+ if (n->ntype == nJunction) {
+ j=(Junction *) n;
+
+ if (j->predicate != NULL) {
+ predicate_free(j->predicate);
+ j->predicate=NULL;
+ };
+ for (i=0; i< CLL_k; i++) {
+ set_free(j->fset[i]);
+ j->fset[i]=empty;
+ };
+ if (j->ftree != NULL) {
+ Tfree(j->ftree);
+ j->ftree=NULL;
+ };
+ if (j->jtype == EndRule) return;
+ if (j->jtype != RuleBlk && j->jtype != EndBlk) {
+ if (j->p2 != NULL && !j->ignore) { /* MR11 */
+ MR_releaseResourcesUsedInRule(j->p2);
+ };
+ };
+ };
+ next=MR_advance(n);
+ MR_releaseResourcesUsedInRule(next);
+}
+
+#ifdef __USE_PROTOS
+int MR_allPredLeaves(Predicate *p)
+#else
+int MR_allPredLeaves(p)
+ Predicate *p;
+#endif
+{
+ Predicate *q;
+
+ if (p == NULL) return 1;
+
+ for (q=p; q != NULL; q=q->right) {
+ if (q->down != NULL) return 0;
+ };
+ return 1;
+}
+
+/* make sure it works for the last rule in a file */
+
+#ifdef __USE_PROTOS
+int MR_offsetFromRule(Node *n)
+#else
+int MR_offsetFromRule(n)
+ Node *n;
+#endif
+{
+ Junction *j;
+ int offset=(-1);
+
+ for (j=SynDiag; j != NULL; j=(Junction *)j->p2) {
+
+ require (j->ntype == nJunction && j->jtype == RuleBlk,"Not a rule block");
+
+ if (n->file < j->file) {
+ return offset;
+ };
+ if (n->file == j->file) {
+ if (n->line < j->line) {
+ return (offset < 0) ? 0 : offset;
+ } else {
+ offset=n->line - j->line;
+ if (offset == 0) return 0;
+ };
+ };
+ };
+ return offset;
+}
+
+#define ruleNameMax 50
+
+static char ruleNameStatic1[ruleNameMax];
+static char ruleNameStatic2[ruleNameMax+10];
+
+#ifdef __USE_PROTOS
+char * MR_ruleNamePlusOffset(Node *n)
+#else
+char * MR_ruleNamePlusOffset(n)
+ Node *n;
+#endif
+{
+ int offset=MR_offsetFromRule(n);
+
+ strncpy(ruleNameStatic1,n->rname,ruleNameMax);
+ if (offset < 0) {
+ sprintf(ruleNameStatic2,"%s/?",ruleNameStatic1);
+ } else {
+ sprintf(ruleNameStatic2,"%s/%d",ruleNameStatic1,offset+1);
+ };
+ return ruleNameStatic2;
+}
+
+#ifdef __USE_PROTOS
+int MR_max_height_of_tree(Tree *t)
+#else
+int MR_max_height_of_tree(t)
+ Tree *t;
+#endif
+{
+ int h;
+ int height=0;
+ Tree *u;
+
+ if (t == NULL) return 0;
+
+ require (t->token != ALT && t->token != EpToken,"MR_max_height_of_tree ALT or EpToken");
+
+ for (u=t; u != NULL; u=u->right) {
+ h=MR_max_height_of_tree(u->down)+1;
+ if (h > height) height=h;
+ };
+ return height;
+}
+
+#ifdef __USE_PROTOS
+int MR_all_leaves_same_height(Tree *t,int depth)
+#else
+int MR_all_leaves_same_height(t,depth)
+ Tree *t;
+ int depth;
+#endif
+{
+ if (t == NULL) {
+ return (depth==0);
+ };
+
+ require (t->token != ALT && t->token != EpToken,"MR_all_leaves_same_height ALT or EpToken");
+
+ if (depth == 0) {
+ return 0;
+ } else {
+ if ( ! MR_all_leaves_same_height(t->down,depth-1)) {
+ return 0;
+ };
+ if (t->right == NULL) {
+ return 1;
+ } else {
+ return MR_all_leaves_same_height(t->right,depth);
+ };
+ };
+}
+
+#ifdef __USE_PROTOS
+void MR_projectTreeOntoSet(Tree *tree,int ck,set *ckset)
+#else
+void MR_projectTreeOntoSet(tree,ck,ckset)
+ Tree *tree;
+ int ck;
+ set *ckset;
+#endif
+{
+ if (tree == NULL) return;
+
+ require(tree->token != EpToken,"MR_projectTreeOntoSet: EpToken unexpected\n");
+
+ MR_projectTreeOntoSet(tree->right,ck,ckset);
+ if (tree->token == ALT) {
+ MR_projectTreeOntoSet(tree->down,ck,ckset);
+ } else {
+ if (ck > 1) {
+ MR_projectTreeOntoSet(tree->down,ck-1,ckset);
+ } else {
+ set_orel(tree->token,ckset);
+ };
+ };
+}
+
+#ifdef __USE_PROTOS
+int MR_comparePredicates(Predicate *a,Predicate *b)
+#else
+int MR_comparePredicates(a,b)
+ Predicate *a;
+ Predicate *b;
+#endif
+{
+ Predicate *p;
+ Predicate *q;
+
+ if (a == b) return 1;
+ if (a == NULL || b == NULL ) return 0;
+ if (a->down == NULL && b->down == NULL) {
+
+ /* predicate->invert can be set only in the predEntry predicates */
+ /* thus they are only visible after the predEntry predicates have been "unfolded" */
+
+ int sameSource=(a->source == b->source);
+ int sameInvert= 1 & (1 +a->inverted + b->inverted +
+ a->source->inverted + b->source->inverted);
+ int samePredEntry=(a->source->predEntry != NULL
+ && b->source->predEntry != NULL
+ && a->source->predEntry == b->source->predEntry);
+ if (sameInvert && (sameSource || samePredEntry)) {
+ if (MR_identicalContext(a,b)) {
+ return 1;
+ };
+ };
+ return 0;
+ };
+ if (a->down == NULL || b->down == NULL) return 0;
+ if (a->expr != b->expr) return 0;
+
+ for (p=a->down; p != NULL; p=p->right) {
+ for (q=b->down; q != NULL; q=q->right) {
+ if (MR_comparePredicates(p,q)) goto NEXT_P;
+ };
+ return 0;
+NEXT_P:
+ continue;
+ };
+ return 1;
+}
+
+/*
+ * action->inverted can be set only when a predicate symbol appears in
+ * a rule: "rule : <<!XXX>>? X". It cannot be set under any
+ * other circumstances. In particular it cannot be set by
+ * "#pred NotA !A" or by "#pred Nota <<!A>>?". The first case
+ * creates a predEntry and the predicate expression of that predEntry
+ * has inverted set. In the second case, the code for handling "!"
+ * is only present in buildAction, which is not called by the #pred
+ * semantic routines, only when a <<...>>? is recognized as part of
+ * a rule definition.
+ *
+ * predicate->inverted can only be set by a predicate created by a #pred
+ * expression, such as "#pred NotA !A" or "#pred NotXY ! (X && Y) or
+ * "#pred XbarY !(X && Y)". In particular, it cannot be set by any
+ * predicate expression occurring under any other circumstances.
+ * The #pred predicate expresssions are stored with in predEntry->pred
+ * and do not normally appear anywhere else until the predicates are
+ * "unfolded" in order to recognize redundancies, conflicts, and
+ * tautologies.
+ *
+ * The unfold routine expands all references to #pred expressions.
+ *
+ * The simplifyInvert goes through and propagates the invert bit so that
+ * all OR and AND nodes are un-inverted.
+ *
+ * Note that !(A and B) => (!A or !B)
+ * !(A or B) => (!A and !B)
+ *
+ * MR_unfold() is called to expand predicate symbols by replacing predicates
+ * that reference predicate entries with the copies of the predicate entries.
+ * Each reference receives a duplicate of the original. This is necessary
+ * because the next phase involves simplification and removal of redundant
+ * predicate nodes. Anyway, the point I'm making is that predicate->invert
+ * should not be set in any predicate until it has been expanded.
+ *
+ * This is a recursive structure, but there is no need for "recursive expansion"
+ * by which I mean a predicate symbol refers to other predicate symbols which
+ * must also be expanded.
+ *
+ * Recursive expansion is *not* performed by this routine because it is not
+ * necessary. Expansion of references is performed by predPrimary when
+ * a new predicate symbol is created by referring to others in the pred expr.
+ */
+
+#ifdef __USE_PROTOS
+Predicate *MR_unfold(Predicate *pred)
+#else
+Predicate *MR_unfold(pred)
+ Predicate *pred;
+#endif
+{
+ Predicate *result;
+
+ if (pred == NULL) return NULL;
+
+ pred->right=MR_unfold(pred->right);
+
+ if (pred->down == NULL) {
+ if (pred->source->predEntry != NULL) {
+ if (pred->source->predEntry->pred == NULL) {
+ ; /* do nothing */ /* a reference to a literal #pred (perhaps with "!" */
+ } else {
+ result=predicate_dup_without_context(pred->source->predEntry->pred);
+ if (pred->inverted) {
+ result->inverted=!result->inverted;
+ };
+ if (pred->source->inverted) {
+ result->inverted=!result->inverted;
+ };
+ result->right=pred->right;
+ pred->right=NULL;
+ predicate_free(pred);
+/*** result=MR_unfold(result); *** not necessary */ /* recursive expansion */
+ return result;
+ };
+ } else {
+ ; /* do nothing */ /* an inline literal predicate */
+ };
+ } else {
+ pred->down=MR_unfold(pred->down);
+ };
+ return pred;
+}
+
+/* this should be called immediately after MR_unfold() and
+ at no other times
+*/
+
+#ifdef __USE_PROTOS
+void MR_simplifyInverted(Predicate *pred,int inverted)
+#else
+void MR_simplifyInverted(pred,inverted)
+ Predicate *pred;
+ int inverted;
+#endif
+{
+ int newInverted;
+
+ if (pred == NULL) return;
+
+ MR_simplifyInverted(pred->right,inverted);
+
+ newInverted= 1 & (inverted + pred->inverted);
+
+ if (pred->down == NULL) {
+ pred->inverted=newInverted;
+ } else {
+ if (newInverted != 0) {
+ if (pred->expr == PRED_AND_LIST) {
+ pred->expr=PRED_OR_LIST;
+ } else {
+ pred->expr=PRED_AND_LIST;
+ };
+ };
+ pred->inverted=0;
+ MR_simplifyInverted(pred->down,newInverted);
+ };
+}
+
+/* only remove it from AND and OR nodes, not leaves */
+
+#ifdef __USE_PROTOS
+void MR_clearPredEntry(Predicate *p)
+#else
+void MR_clearPredEntry(p)
+ Predicate *p;
+#endif
+{
+ if (p == NULL) return;
+ MR_clearPredEntry(p->down);
+ MR_clearPredEntry(p->right);
+ if (p->down != NULL) p->predEntry=NULL;
+}
+
+
+#ifdef __USE_PROTOS
+void MR_orphanRules(FILE *f)
+#else
+void MR_orphanRules(f)
+ FILE *f;
+#endif
+{
+ set a;
+ Junction *p;
+ unsigned e;
+ RuleEntry *re;
+
+ a=empty;
+
+ if (! InfoO) return;
+
+ for (p=SynDiag; p!=NULL; p = (Junction *)p->p2) {
+ if ( (Junction *) (p->end)->p1 == NULL) {
+ re=(RuleEntry *) hash_get(Rname,p->rname);
+ require (re != NULL,"RuleEntry == NULL");
+ set_orel(re->rulenum, &a);
+ }
+ }
+
+ if (set_deg(a) > 1) {
+ fprintf(f,"note: Start rules: {");
+ for (; !set_nil(a); set_rm(e,a)) {
+ e=set_int(a);
+ fprintf(f," %s",RulePtr[e]->rname);
+ };
+ fprintf(f," }\n");
+ };
+ set_free( a );
+}
+
+/* merge (X Y) and (X) to create (X) */
+
+static int *mergeChain;
+static Tree *mergeTree;
+
+#ifdef __USE_PROTOS
+Tree *MR_merge_tree_contexts_client(Tree *t,int chain[])
+#else
+Tree *MR_merge_tree_contexts_client(t,chain)
+ Tree *t;
+ int chain[];
+#endif
+{
+ if (t == NULL) return NULL;
+ if (chain[0] == 0) {
+ Tree *u=t->right;
+ t->right=NULL;
+ Tfree(t);
+ return MR_merge_tree_contexts_client(u,&chain[0]);
+ }
+ if (chain[0] == t->token) {
+ t->down=MR_merge_tree_contexts_client(t->down,&chain[1]);
+ };
+ t->right=MR_merge_tree_contexts_client(t->right,&chain[0]);
+ return t;
+}
+
+#ifdef __USE_PROTOS
+void MR_iterateOverTreeContexts(Tree *t,int chain[])
+#else
+void MR_iterateOverTreeContexts(t,chain)
+ Tree *t;
+ int chain[];
+#endif
+{
+ if (t == NULL) return;
+ chain[0]=t->token;
+ if (t->down != NULL) {
+ MR_iterateOverTreeContexts(t->down,&chain[1]);
+ } else {
+ MR_merge_tree_contexts_client(mergeTree,mergeChain);
+ };
+ MR_iterateOverTreeContexts(t->right,&chain[0]);
+ chain[0]=0;
+}
+
+#ifdef __USE_PROTOS
+Tree *MR_merge_tree_contexts(Tree *t)
+#else
+Tree *MR_merge_tree_contexts(t)
+ Tree *t;
+#endif
+{
+ int h=MR_max_height_of_tree(t);
+
+ mergeTree=t;
+ mergeChain=(int *) calloc(h+1,sizeof(int));
+ require (mergeChain != NULL,"MR_merge_tree_contexts: can't alloc chain");
+ MR_iterateOverTreeContexts(t,mergeChain);
+ t=tshrink(t);
+ t=tflatten(t);
+ t=tleft_factor(t);
+ free ( (char *) mergeChain);
+ mergeChain=NULL;
+ return t;
+}
+
+#ifdef __USE_PROTOS
+Tree *MR_compute_pred_tree_context(Predicate *p)
+#else
+Tree *MR_compute_pred_tree_context(p)
+ Predicate *p;
+#endif
+{
+ Tree *t;
+
+ t=MR_compute_pred_tree_ctxXX(p);
+ MR_merge_tree_contexts(t);
+ return t;
+}
+
+#ifdef __USE_PROTOS
+void MR_guardPred_plainSet(ActionNode *anode,Predicate *pred)
+#else
+void MR_guardPred_plainSet(anode,pred)
+ ActionNode *anode;
+ Predicate *pred;
+#endif
+{
+ Junction *j;
+ Predicate *workPred;
+ set maskSet;
+
+ maskSet=empty;
+
+ if (!MRhoisting) return;
+
+ /* it doesn't really matter whether the predicate has
+ depth k=1 or k>1 because we're not really looking
+ at the predicate itself, just the stuff "behind"
+ the predicate.
+ */
+
+ /* shouldn't have to worry about REACHing off the end
+ of the rule containing the predicate because the
+ Rule->end->halt should have been set already by the
+ the code which handles RuleRef nodes.
+
+ We don't want to REACH off the end of the rule because
+ this would give the "global" follow context rather than
+ the "local" context.
+
+ r1a : (A)? => <<p>>? r2 (A|B)
+ r1b : (A)? => <<p>>? r2 (A|C)
+ r2 : ();
+
+ For r1a we want follow of predicate = {A B}
+ we want plainSet = {B}
+ For r1b we want follow of predicate = {A C}
+ we want plainSet = {C}
+ */
+
+ require (anode->next->ntype == nJunction,"MR_guardpred_plainSet not Junction");
+ j=(Junction *)(anode->next);
+
+ workPred=predicate_dup_without_context(pred);
+ workPred->k=1;
+ workPred->scontext[1]=MR_First(1,j, &(workPred->completionSet) );
+ MR_complete_predicates(1,workPred);
+ if (pred->k == 1) {
+ maskSet=pred->scontext[1];
+ } else {
+ MR_projectTreeOntoSet(pred->tcontext,1,&maskSet);
+ }
+ pred->plainSet=set_dif(workPred->scontext[1],maskSet);
+ predicate_free(workPred);
+}
+
+/*******************************************************************************/
+
+static Tree * suppressTree;
+static int * suppressChain; /* element 0 not used */
+static set * suppressSets;
+static Node * suppressNode;
+static int suppressChainLength;
+int MR_SuppressSearch=0;
+static int suppressSucceeded;
+static Predicate * suppressPredicate;
+
+#ifdef __USE_PROTOS
+int MR_isChain(Tree *t)
+#else
+int MR_isChain(t)
+ Tree *t;
+#endif
+{
+ Tree *u;
+
+ for (u=t; u != NULL; u=u->down) {
+ if (u->right != NULL) return 0;
+ }
+ return 1;
+}
+
+#ifdef __USE_PROTOS
+int MR_suppressK_client(Tree *tree,int tokensInChain[])
+#else
+int MR_suppressK_client(tree,tokensInChain)
+ Tree *tree;
+ int tokensInChain[];
+#endif
+{
+ int i;
+ set *save_fset;
+ int save_ConstrainSearch;
+ set incomplete;
+ Tree *t;
+
+ suppressSucceeded=0; /* volatile */
+
+ if (suppressSets == NULL) {
+ suppressSets=(set *) calloc (CLL_k+1,sizeof(set));
+ require (suppressSets != NULL,"MR_suppressK_client: suppressSets alloc");
+ };
+
+ for (suppressChainLength=1;
+ tokensInChain[suppressChainLength+1] != 0;
+ suppressChainLength++) {};
+
+ require (suppressChainLength != 0,"MR_suppressK_client: chain empty");
+
+ for (i=1 ; i <= suppressChainLength ; i++) {
+ set_clr(suppressSets[i]);
+ set_orel( (unsigned) tokensInChain[i],
+ &suppressSets[i]);
+ };
+
+ save_fset=fset;
+ save_ConstrainSearch=ConstrainSearch;
+
+ fset=suppressSets;
+
+ MR_SuppressSearch=1;
+ MR_AmbSourceSearch=1;
+ MR_MaintainBackTrace=1;
+ ConstrainSearch=1;
+
+ maxk = suppressChainLength;
+
+ incomplete=empty;
+ t=NULL;
+
+/*** constrain = &(fset[1]); ***/
+
+ MR_setConstrainPointer(&(fset[1])); /* MR18 */
+
+ MR_pointerStackReset(&MR_BackTraceStack);
+
+ TRAV(suppressNode,maxk,&incomplete,t);
+
+ Tfree(t);
+
+ require (set_nil(incomplete),"MR_suppressK_client TRAV incomplete");
+ require (MR_BackTraceStack.count == 0,
+ "MR_suppressK_client: MR_BackTraceStack.count != 0");
+ set_free(incomplete);
+
+ ConstrainSearch=save_ConstrainSearch;
+ fset=save_fset;
+
+ MR_AmbSourceSearch=0;
+ MR_MaintainBackTrace=0;
+ MR_SuppressSearch=0;
+ return suppressSucceeded;
+}
+
+#ifdef __USE_PROTOS
+Tree * MR_iterateOverTreeSuppressK(Tree *t,int chain[])
+#else
+Tree * MR_iterateOverTreeSuppressK(t,chain)
+ Tree *t;
+ int chain[];
+#endif
+{
+ if (t == NULL) return NULL;
+ t->right=MR_iterateOverTreeSuppressK(t->right,&chain[0]);
+ chain[0]=t->token;
+ if (t->down != NULL) {
+ t->down=MR_iterateOverTreeSuppressK(t->down,&chain[1]);
+ if (t->down == NULL) {
+ Tree *u=t->right;
+ t->right=NULL;
+ Tfree(t);
+ chain[0]=0;
+ return u;
+ };
+ } else {
+ MR_suppressK_client(suppressTree,suppressChain);
+ if (suppressSucceeded) {
+ Tree *u=t->right;
+ t->right=NULL;
+ Tfree(t);
+ chain[0]=0;
+ return u;
+ };
+ };
+ chain[0]=0;
+ return t;
+}
+
+/* @@@ */
+
+#ifdef __USE_PROTOS
+Predicate * MR_suppressK(Node *j,Predicate *p)
+#else
+Predicate * MR_suppressK(j,p)
+ Node *j;
+ Predicate *p;
+#endif
+{
+ Predicate *result;
+ int guardPred=0;
+ int ampersandPred=0;
+ Node *nodePrime;
+
+ if (! MRhoistingk) {
+ return p;
+ }
+
+ if (! MRhoisting) return p;
+ if (CLL_k == 1) return p;
+
+ if (suppressChain == NULL) {
+ suppressChain=(int *) calloc(CLL_k+2,sizeof(int));
+ require (suppressChain != NULL,"MR_suppressK: can't allocate chain");
+ }
+
+ if (p == NULL) return NULL;
+
+ if (j->ntype == nJunction) {
+ nodePrime=(Node *) MR_junctionWithoutP2( (Junction *) j);
+ } else {
+ nodePrime=j;
+ };
+
+ p->down=MR_suppressK(j,p->down);
+ p->right=MR_suppressK(j,p->right);
+ if (p->down != NULL) {
+ result=p;
+ goto EXIT;
+ };
+ if (p->k == 1) {
+ result=p;
+ goto EXIT;
+ };
+
+ if (p->source != NULL) {
+ if (p->source->guardpred != NULL) guardPred=1;
+ if (p->source->ampersandPred != NULL) ampersandPred=1;
+ }
+
+ suppressPredicate=p;
+ suppressNode=nodePrime; /* was j*/
+
+ suppressTree=p->tcontext;
+
+ if (guardPred || ampersandPred) {
+ p->tcontext=MR_iterateOverTreeSuppressK(suppressTree,&suppressChain[1]);
+ if (p->tcontext == NULL) {
+ predicate_free(p);
+ result=NULL;
+ goto EXIT;
+ };
+ } else {
+ if (MR_isChain(p->tcontext)) {
+ p->tcontext=MR_iterateOverTreeSuppressK(suppressTree,&suppressChain[1]);
+ if (p->tcontext == NULL) {
+ predicate_free(p);
+ result=NULL;
+ goto EXIT;
+ };
+ }
+ }
+ result=p;
+EXIT:
+ return result;
+}
+
+#ifdef __USE_PROTOS
+void MR_suppressSearchReport(void)
+#else
+void MR_suppressSearchReport()
+#endif
+{
+ int i;
+ Node *p;
+ TokNode *tn;
+ int depth;
+ set setAnd;
+
+ /* number of tokens in back trace stack matches length of chain */
+
+ depth=0;
+ for (i=0; i < MR_BackTraceStack.count ; i++) {
+ p=(Node *) MR_BackTraceStack.data[i];
+ if (p->ntype == nToken) depth++;
+ };
+
+ require (depth == suppressChainLength,"depth > suppressChainLength");
+
+ /* token codes match chain */
+
+ depth=0;
+ for (i=0; i < MR_BackTraceStack.count ; i++) {
+ p=(Node *) MR_BackTraceStack.data[i];
+ if (p->ntype != nToken) continue;
+ tn=(TokNode *) p;
+ depth++;
+ if (set_nil(tn->tset)) {
+ require(set_el( (unsigned) tn->token,fset[depth]),
+ "MR_suppressSearchReport: no match to #token in chain");
+ } else {
+ setAnd=set_and(fset[depth],tn->tset);
+ require(!set_nil(setAnd),
+ "MR_suppressSearchReport: no match to #token set in chain");
+ set_free(setAnd);
+ };
+ };
+
+ /* have a match - now remove it from the predicate */
+
+ suppressSucceeded=1;
+
+ if (suppressSucceeded) {
+ fprintf(output,"\n");
+ fprintf(output,"#if 0\n");
+ fprintf(output,"\n");
+ fprintf(output,"Part (or all) of predicate with depth > 1 suppressed by ");
+ fprintf(output,"alternative without predicate\n\n");
+ MR_dumpPred(suppressPredicate,1);
+ fprintf(output,"The token sequence which is suppressed:");
+ fprintf(output," (");
+ for (i=1; i <= suppressChainLength; i++) {
+ fprintf(output," %s",TerminalString(suppressChain[i]));
+ };
+ fprintf(output," )\n");
+ fprintf(output,"The sequence of references which generate that sequence of tokens:\n\n");
+
+ MR_backTraceDumpItemReset();
+
+ for (i=0; i < MR_BackTraceStack.count ; i++) {
+ MR_backTraceDumpItem(output,0,(Node *) MR_BackTraceStack.data[i]);
+ };
+ fprintf(output,"\n");
+ fprintf(output,"#endif\n");
+ }
+}
+
+#ifdef __USE_PROTOS
+void MR_markCompromisedRule(Node *n)
+#else
+void MR_markCompromisedRule(n)
+ Node *n;
+#endif
+{
+ RuleEntry *q;
+ Node *mark=NULL;
+ Junction *j;
+
+ if (n->ntype == nRuleRef) {
+ mark=(Node *) MR_ruleReferenced( (RuleRefNode *) n);
+ } else if (n->ntype == nToken) {
+ mark=n;
+ } else if (n->ntype == nJunction) {
+ j=(Junction *)n;
+ switch (j->jtype) {
+ case aOptBlk:
+ case aLoopBlk:
+ case RuleBlk:
+ case EndRule:
+ case aPlusBlk:
+ case aLoopBegin:
+ mark=n;
+ break;
+ default:
+ break;
+ };
+ }
+
+ if (mark == NULL) return;
+
+ require (RulePtr != NULL,"RulePtr not initialized");
+
+ q = (RuleEntry *) hash_get(Rname,mark->rname);
+ require (q != NULL,"RuleEntry not found");
+ set_orel(q->rulenum,&MR_CompromisedRules);
+}
+
+#ifdef __USE_PROTOS
+void MR_alphaBetaTraceReport(void)
+#else
+void MR_alphaBetaTraceReport()
+#endif
+{
+ int i;
+
+ if (! AlphaBetaTrace) return;
+
+ MR_AlphaBetaMessageCount++;
+
+ fprintf(output,"\n");
+ fprintf(output,"#if 0\n");
+ fprintf(output,"\n");
+ fprintf(output,"Trace of references leading to attempt to compute the follow set of\n");
+ fprintf(output,"alpha in an \"(alpha)? beta\" block. It is not possible for antlr to\n");
+ fprintf(output,"compute this follow set because it is not known what part of beta has\n");
+ fprintf(output,"already been matched by alpha and what part remains to be matched.\n");
+ fprintf(output,"\n");
+ fprintf(output,"Rules which make use of the incorrect follow set will also be incorrect\n");
+ fprintf(output,"\n");
+
+ MR_backTraceDumpItemReset();
+
+ for (i=0; i < MR_BackTraceStack.count ; i++) {
+ MR_backTraceDumpItem(output,0,(Node *) MR_BackTraceStack.data[i]);
+ if (i < MR_BackTraceStack.count-1) {
+ MR_markCompromisedRule( (Node *) MR_BackTraceStack.data[i]);
+ };
+ };
+ fprintf(output,"\n");
+ fprintf(output,"#endif\n");
+}
+
+#ifdef __USE_PROTOS
+void MR_dumpRuleSet(set s)
+#else
+void MR_dumpRuleSet(s)
+ set s;
+#endif
+{
+ unsigned *cursor;
+ unsigned *origin=set_pdq(s);
+
+ require(origin != NULL,"set_pdq failed");
+
+ if (RulePtr == NULL) {
+ fprintf(stderr,"RulePtr[] not yet initialized");
+ } else {
+ for (cursor=origin; *cursor != nil ; cursor++) {
+/**** if (cursor != origin) fprintf(stderr,","); ****/
+ fprintf(stderr," %s",RulePtr[*cursor]->rname);
+ fprintf(stderr,"\n");
+ };
+ free( (char *) origin);
+ };
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/parser.dlg b/BaseTools/Source/C/VfrCompile/Pccts/antlr/parser.dlg new file mode 100644 index 0000000000..8c43dff300 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/parser.dlg @@ -0,0 +1,1387 @@ +<<
+/* parser.dlg -- DLG Description of scanner
+ *
+ * Generated from: antlr.g
+ *
+ * Terence Parr, Will Cohen, and Hank Dietz: 1989-2001
+ * Purdue University Electrical Engineering
+ * With AHPCRC, University of Minnesota
+ * ANTLR Version 1.33MR33
+ */
+
+#define ANTLR_VERSION 13333
+#include "pcctscfg.h"
+#include "pccts_stdio.h"
+
+#include "pcctscfg.h"
+#include "set.h"
+#include <ctype.h>
+#include "syn.h"
+#include "hash.h"
+#include "generic.h"
+#define zzcr_attr(attr,tok,t)
+#include "antlr.h"
+#include "tokens.h"
+#include "dlgdef.h"
+LOOKAHEAD
+
+void
+#ifdef __USE_PROTOS
+zzerraction(void)
+#else
+zzerraction()
+#endif
+{
+ (*zzerr)("invalid token");
+ zzadvance();
+ zzskip();
+}
+>>
+
+<<%%lexaction
+
+/* maintained, but not used for now */
+set AST_nodes_refd_in_actions = set_init;
+int inAlt = 0;
+set attribsRefdFromAction = set_init; /* MR20 */
+int UsedOldStyleAttrib = 0;
+int UsedNewStyleLabel = 0;
+#ifdef __USE_PROTOS
+char *inline_set(char *);
+#else
+char *inline_set();
+#endif
+
+/* MR1 10-Apr-97 MR1 Previously unable to put right shift operator */
+/* MR1 in DLG action */
+
+int tokenActionActive=0; /* MR1 */
+
+
+>>
+
+<<%%lexaction
+
+
+static char *
+#ifdef __USE_PROTOS
+getFileNameFromTheLineInfo(char *toStr, char *fromStr)
+#else
+getFileNameFromTheLineInfo(toStr, fromStr)
+char *toStr, *fromStr;
+#endif
+{
+ int i, j, k;
+
+ if (!fromStr || !toStr) return toStr;
+
+ /* find the first " */
+
+ for (i=0;
+ (i<MaxFileName) &&
+ (fromStr[i] != '\n') &&
+ (fromStr[i] != '\r') &&
+ (fromStr[i] != '\"');
+ i++) /* nothing */ ;
+
+ if ( (i == MaxFileName) ||
+ (fromStr[i] == '\n') ||
+ (fromStr[i] == '\r') ) {
+ return toStr;
+}
+
+ /* find the second " */
+
+ for (j=i+1;
+(j<MaxFileName) &&
+(fromStr[j] != '\n') &&
+(fromStr[j] != '\r') &&
+(fromStr[j] != '\"');
+j++) /* nothing */ ;
+
+ if ((j == MaxFileName) ||
+(fromStr[j] == '\n') ||
+(fromStr[j] == '\r') ) {
+ return toStr;
+}
+
+ /* go back until the last / or \ */
+
+ for (k=j-1;
+(fromStr[k] != '\"') &&
+(fromStr[k] != '/') &&
+(fromStr[k] != '\\');
+k--) /* nothing */ ;
+
+ /* copy the string after " / or \ into toStr */
+
+ for (i=k+1; fromStr[i] != '\"'; i++) {
+toStr[i-k-1] = fromStr[i];
+}
+
+ toStr[i-k-1] = '\0';
+
+ return toStr;
+}
+
+/* MR14 end of a block to support #line in antlr source code */
+
+
+>>
+
+<<%%lexaction
+
+#ifdef __USE_PROTOS
+void mark_label_used_in_sem_pred(LabelEntry *le) /* MR10 */
+#else
+void mark_label_used_in_sem_pred(le) /* MR10 */
+LabelEntry *le;
+#endif
+{
+ TokNode *tn;
+ require (le->elem->ntype == nToken,"mark_label_used... ntype != nToken");
+ tn=(TokNode *)le->elem;
+ require (tn->label != 0,"mark_label_used... TokNode has no label");
+ tn->label_used_in_semantic_pred=1;
+}
+>>
+
+
+%%START
+
+@
+ <<
+ NLA = Eof;
+ /* L o o k F o r A n o t h e r F i l e */
+ {
+ FILE *new_input;
+ new_input = NextFile();
+ if ( new_input == NULL ) { NLA=Eof; return; }
+ fclose( input );
+ input = new_input;
+ zzrdstream( input );
+ zzskip(); /* Skip the Eof (@) char i.e continue */
+ }
+ >>
+
+[\t\ ]+
+ <<
+ NLA = 76;
+ zzskip();
+ >>
+
+\n|\r|\r\n
+ <<
+ NLA = 77;
+ zzline++; zzskip();
+ >>
+
+\[
+ <<
+ NLA = 78;
+ zzmode(ACTIONS); zzmore();
+ istackreset();
+ pushint(']');
+ >>
+
+\<\<
+ <<
+ NLA = 79;
+ action_file=CurFile; action_line=zzline;
+ zzmode(ACTIONS); zzmore();
+ list_free(&CurActionLabels,0); /* MR10 */
+ numericActionLabel=0; /* MR10 */
+ istackreset();
+ pushint('>');
+ >>
+
+\"
+ <<
+ NLA = 80;
+ zzmode(STRINGS); zzmore();
+ >>
+
+/\*
+ <<
+ NLA = 81;
+ zzmode(COMMENTS); zzskip();
+ >>
+
+\*/
+ <<
+ NLA = 82;
+ warn("Missing /*; found dangling */"); zzskip();
+ >>
+
+//
+ <<
+ NLA = 83;
+ zzmode(CPP_COMMENTS); zzskip();
+ >>
+
+#line[\ \t]* [0-9]+ {[\ \t]* \"~[\"]+\" ([\ \t]* [0-9]*)* } (\n|\r|\r\n)
+ <<
+ NLA = 84;
+
+ zzline = atoi(zzbegexpr+5) - 1; zzline++; zzmore();
+ getFileNameFromTheLineInfo(FileStr[CurFile], zzbegexpr);
+ >>
+
+#line ~[\n\r]* (\n|\r|\r\n)
+ <<
+ NLA = 85;
+
+ zzline++; zzmore();
+ >>
+
+\>\>
+ <<
+ NLA = 86;
+ warn("Missing <<; found dangling \>\>"); zzskip();
+ >>
+
+.
+ <<
+ NLA = WildCard;
+ >>
+
+\@
+ <<
+ NLA = 88;
+ FoundException = 1; /* MR6 */
+ FoundAtOperator = 1;
+ >>
+
+{\\}#pragma
+ <<
+ NLA = Pragma;
+ >>
+
+{\\}#FirstSetSymbol
+ <<
+ NLA = FirstSetSymbol;
+ >>
+
+{\\}#header
+ <<
+ NLA = 94;
+ >>
+
+{\\}#first
+ <<
+ NLA = 95;
+ >>
+
+{\\}#parser
+ <<
+ NLA = 96;
+ >>
+
+{\\}#tokdefs
+ <<
+ NLA = 97;
+ >>
+
+\}
+ <<
+ NLA = 98;
+ >>
+
+class
+ <<
+ NLA = 99;
+ >>
+
+\{
+ <<
+ NLA = 102;
+ >>
+
+!
+ <<
+ NLA = 103;
+ >>
+
+\<
+ <<
+ NLA = 104;
+ >>
+
+\>
+ <<
+ NLA = 105;
+ >>
+
+:
+ <<
+ NLA = 106;
+ >>
+
+;
+ <<
+ NLA = 107;
+ >>
+
+{\\}#lexaction
+ <<
+ NLA = 108;
+ >>
+
+{\\}#lexmember
+ <<
+ NLA = 109;
+ >>
+
+{\\}#lexprefix
+ <<
+ NLA = 110;
+ >>
+
+{\\}#pred
+ <<
+ NLA = 111;
+ >>
+
+\|\|
+ <<
+ NLA = 112;
+ >>
+
+&&
+ <<
+ NLA = 113;
+ >>
+
+\(
+ <<
+ NLA = 114;
+ >>
+
+\)
+ <<
+ NLA = 115;
+ >>
+
+{\\}#lexclass
+ <<
+ NLA = 116;
+ >>
+
+{\\}#errclass
+ <<
+ NLA = 117;
+ >>
+
+{\\}#tokclass
+ <<
+ NLA = 118;
+ >>
+
+..
+ <<
+ NLA = 119;
+ >>
+
+{\\}#token
+ <<
+ NLA = 120;
+ >>
+
+=
+ <<
+ NLA = 121;
+ >>
+
+[0-9]+
+ <<
+ NLA = 122;
+ >>
+
+\|
+ <<
+ NLA = 123;
+ >>
+
+\~
+ <<
+ NLA = 124;
+ >>
+
+^
+ <<
+ NLA = 125;
+ >>
+
+approx
+ <<
+ NLA = 126;
+ >>
+
+LL\(1\)
+ <<
+ NLA = 127;
+ >>
+
+LL\(2\)
+ <<
+ NLA = 128;
+ >>
+
+\*
+ <<
+ NLA = 129;
+ >>
+
+\+
+ <<
+ NLA = 130;
+ >>
+
+?
+ <<
+ NLA = 131;
+ >>
+
+=>
+ <<
+ NLA = 132;
+ >>
+
+exception
+ <<
+ NLA = 133;
+ >>
+
+default
+ <<
+ NLA = 134;
+ >>
+
+catch
+ <<
+ NLA = 135;
+ >>
+
+[a-z] [A-Za-z0-9_]*
+ <<
+ NLA = NonTerminal;
+
+ while ( zzchar==' ' || zzchar=='\t' ) {
+ zzadvance();
+ }
+ if ( zzchar == ':' && inAlt ) NLA = LABEL;
+ >>
+
+[A-Z] [A-Za-z0-9_]*
+ <<
+ NLA = TokenTerm;
+
+ while ( zzchar==' ' || zzchar=='\t' ) {
+ zzadvance();
+ }
+ if ( zzchar == ':' && inAlt ) NLA = LABEL;
+ >>
+
+{\\}#[A-Za-z0-9_]*
+ <<
+ NLA = 136;
+ warn(eMsg1("unknown meta-op: %s",LATEXT(1))); zzskip();
+ >>
+
+
+%%STRINGS
+
+@
+ <<
+ NLA = Eof;
+ >>
+
+\"
+ <<
+ NLA = QuotedTerm;
+ zzmode(START);
+ >>
+
+\n|\r|\r\n
+ <<
+ NLA = 3;
+
+ zzline++;
+ warn("eoln found in string");
+ zzskip();
+ >>
+
+\\(\n|\r|\r\n)
+ <<
+ NLA = 4;
+ zzline++; zzmore();
+ >>
+
+\\~[]
+ <<
+ NLA = 5;
+ zzmore();
+ >>
+
+~[\n\r\"\\]+
+ <<
+ NLA = 6;
+ zzmore();
+ >>
+
+
+%%ACTION_STRINGS
+
+@
+ <<
+ NLA = Eof;
+ >>
+
+\"
+ <<
+ NLA = 7;
+ zzmode(ACTIONS); zzmore();
+ >>
+
+\n|\r|\r\n
+ <<
+ NLA = 8;
+
+ zzline++;
+ warn("eoln found in string (in user action)");
+ zzskip();
+ >>
+
+\\(\n|\r|\r\n)
+ <<
+ NLA = 9;
+ zzline++; zzmore();
+ >>
+
+\\~[]
+ <<
+ NLA = 10;
+ zzmore();
+ >>
+
+~[\n\r\"\\]+
+ <<
+ NLA = 11;
+ zzmore();
+ >>
+
+
+%%ACTION_CHARS
+
+@
+ <<
+ NLA = Eof;
+ >>
+
+'
+ <<
+ NLA = 12;
+ zzmode(ACTIONS); zzmore();
+ >>
+
+\n|\r|\r\n
+ <<
+ NLA = 13;
+
+ zzline++;
+ warn("eoln found in char literal (in user action)");
+ zzskip();
+ >>
+
+\\~[]
+ <<
+ NLA = 14;
+ zzmore();
+ >>
+
+~[\n\r'\\]+
+ <<
+ NLA = 15;
+ zzmore();
+ >>
+
+
+%%ACTION_COMMENTS
+
+@
+ <<
+ NLA = Eof;
+ >>
+
+\*/
+ <<
+ NLA = 16;
+ zzmode(ACTIONS); zzmore();
+ >>
+
+\*
+ <<
+ NLA = 17;
+ zzmore();
+ >>
+
+\n|\r|\r\n
+ <<
+ NLA = 18;
+ zzline++; zzmore(); DAWDLE;
+ >>
+
+~[\n\r\*]+
+ <<
+ NLA = 19;
+ zzmore();
+ >>
+
+
+%%TOK_DEF_COMMENTS
+
+@
+ <<
+ NLA = Eof;
+ >>
+
+\*/
+ <<
+ NLA = 20;
+ zzmode(PARSE_ENUM_FILE);
+ zzmore();
+ >>
+
+\*
+ <<
+ NLA = 21;
+ zzmore();
+ >>
+
+\n|\r|\r\n
+ <<
+ NLA = 22;
+ zzline++; zzmore(); DAWDLE;
+ >>
+
+~[\n\r\*]+
+ <<
+ NLA = 23;
+ zzmore();
+ >>
+
+
+%%TOK_DEF_CPP_COMMENTS
+
+@
+ <<
+ NLA = Eof;
+ >>
+
+\n|\r|\r\n
+ <<
+ NLA = 24;
+ zzline++; zzmode(PARSE_ENUM_FILE); zzskip(); DAWDLE;
+ >>
+
+~[\n\r]+
+ <<
+ NLA = 25;
+ zzskip();
+ >>
+
+
+%%ACTION_CPP_COMMENTS
+
+@
+ <<
+ NLA = Eof;
+ >>
+
+\n|\r|\r\n
+ <<
+ NLA = 26;
+ zzline++; zzmode(ACTIONS); zzmore(); DAWDLE;
+ >>
+
+~[\n\r]+
+ <<
+ NLA = 27;
+ zzmore();
+ >>
+
+
+%%CPP_COMMENTS
+
+@
+ <<
+ NLA = Eof;
+ >>
+
+\n|\r|\r\n
+ <<
+ NLA = 28;
+ zzline++; zzmode(START); zzskip(); DAWDLE;
+ >>
+
+~[\n\r]+
+ <<
+ NLA = 29;
+ zzskip();
+ >>
+
+
+%%COMMENTS
+
+@
+ <<
+ NLA = Eof;
+ >>
+
+\*/
+ <<
+ NLA = 30;
+ zzmode(START); zzskip();
+ >>
+
+\*
+ <<
+ NLA = 31;
+ zzskip();
+ >>
+
+\n|\r|\r\n
+ <<
+ NLA = 32;
+ zzline++; zzskip(); DAWDLE;
+ >>
+
+~[\n\r\*]+
+ <<
+ NLA = 33;
+ zzskip();
+ >>
+
+
+%%ACTIONS
+
+@
+ <<
+ NLA = Eof;
+ >>
+
+\>\>
+ <<
+ NLA = Action;
+ /* these do not nest */
+ zzmode(START);
+ NLATEXT[0] = ' ';
+ NLATEXT[1] = ' ';
+ zzbegexpr[0] = ' ';
+ zzbegexpr[1] = ' ';
+ if ( zzbufovf ) {
+ err( eMsgd("action buffer overflow; size %d",ZZLEXBUFSIZE));
+ }
+
+/* MR1 10-Apr-97 MR1 Previously unable to put right shift operator */
+ /* MR1 in DLG action */
+ /* MR1 Doesn't matter what kind of action it is - reset*/
+
+ tokenActionActive=0; /* MR1 */
+ >>
+
+\>\>?
+ <<
+ NLA = Pred;
+ /* these do not nest */
+ zzmode(START);
+ NLATEXT[0] = ' ';
+ NLATEXT[1] = ' ';
+ zzbegexpr[0] = '\0';
+ if ( zzbufovf ) {
+ err( eMsgd("predicate buffer overflow; size %d",ZZLEXBUFSIZE));
+ };
+#ifdef __cplusplus__
+ /* MR10 */ list_apply(CurActionLabels, (void (*)(void *))mark_label_used_in_sem_pred);
+#else
+#ifdef __STDC__
+ /* MR10 */ list_apply(CurActionLabels, (void (*)(void *))mark_label_used_in_sem_pred);
+#else
+#ifdef __USE_PROTOS
+ /* MRxx */ list_apply(CurActionLabels, (void (*)(void *))mark_label_used_in_sem_pred);
+#else
+ /* MR10 */ list_apply(CurActionLabels,mark_label_used_in_sem_pred);
+#endif
+#endif
+#endif
+ >>
+
+\]
+ <<
+ NLA = PassAction;
+ if ( topint() == ']' ) {
+ popint();
+ if ( istackempty() ) /* terminate action */
+ {
+ zzmode(START);
+ NLATEXT[0] = ' ';
+ zzbegexpr[0] = ' ';
+ if ( zzbufovf ) {
+ err( eMsgd("parameter buffer overflow; size %d",ZZLEXBUFSIZE));
+ }
+ }
+ else {
+ /* terminate $[..] and #[..] */
+ if ( GenCC ) zzreplstr("))");
+ else zzreplstr(")");
+ zzmore();
+ }
+ }
+ else if ( topint() == '|' ) { /* end of simple [...] */
+ popint();
+ zzmore();
+ }
+ else zzmore();
+ >>
+
+consumeUntil\( [\ \t]* \{~[\}]+\} [\ \t]* \)
+ <<
+ NLA = 37;
+
+ zzmore();
+ zzreplstr(inline_set(zzbegexpr+
+ strlen("consumeUntil(")));
+ >>
+
+consumeUntil\( ~[\)]+ \)
+ <<
+ NLA = 38;
+ zzmore();
+ >>
+
+\n|\r|\r\n
+ <<
+ NLA = 39;
+ zzline++; zzmore(); DAWDLE;
+ >>
+
+\>
+ <<
+ NLA = 40;
+ zzmore();
+ >>
+
+$
+ <<
+ NLA = 41;
+ zzmore();
+ >>
+
+$$
+ <<
+ NLA = 42;
+ if ( !GenCC ) {zzreplstr("zzaRet"); zzmore();}
+ else err("$$ use invalid in C++ mode");
+ >>
+
+$\[\]
+ <<
+ NLA = 43;
+ if ( !GenCC ) {zzreplstr("zzempty_attr"); zzmore();}
+ else err("$[] use invalid in C++ mode");
+ >>
+
+$\[
+ <<
+ NLA = 44;
+
+ pushint(']');
+ if ( !GenCC ) zzreplstr("zzconstr_attr(");
+ else err("$[..] use invalid in C++ mode");
+ zzmore();
+ >>
+
+$[0-9]+
+ <<
+ NLA = 45;
+ {
+ static char buf[100];
+ numericActionLabel=1; /* MR10 */
+ if ( strlen(zzbegexpr)>(size_t)85 )
+ fatal("$i attrib ref too big");
+ set_orel(atoi(zzbegexpr+1), &attribsRefdFromAction);
+ if ( !GenCC ) sprintf(buf,"zzaArg(zztasp%d,%s)",
+ BlkLevel-1,zzbegexpr+1);
+ else sprintf(buf,"_t%d%s",
+ BlkLevel-1,zzbegexpr+1);
+ zzreplstr(buf);
+ zzmore();
+ UsedOldStyleAttrib = 1;
+ if ( UsedNewStyleLabel )
+ err("cannot mix old-style $i with new-style labels");
+ }
+ >>
+
+$[0-9]+.
+ <<
+ NLA = 46;
+ {
+ static char buf[100];
+ numericActionLabel=1; /* MR10 */
+ if ( strlen(zzbegexpr)>(size_t)85 )
+ fatal("$i.field attrib ref too big");
+ zzbegexpr[strlen(zzbegexpr)-1] = ' ';
+ set_orel(atoi(zzbegexpr+1), &attribsRefdFromAction);
+ if ( !GenCC ) sprintf(buf,"zzaArg(zztasp%d,%s).",
+ BlkLevel-1,zzbegexpr+1);
+ else sprintf(buf,"_t%d%s.",
+ BlkLevel-1,zzbegexpr+1);
+ zzreplstr(buf);
+ zzmore();
+ UsedOldStyleAttrib = 1;
+ if ( UsedNewStyleLabel )
+ err("cannot mix old-style $i with new-style labels");
+ }
+ >>
+
+$[0-9]+.[0-9]+
+ <<
+ NLA = 47;
+ {
+ static char buf[100];
+ static char i[20], j[20];
+ char *p,*q;
+ numericActionLabel=1; /* MR10 */
+ if (strlen(zzbegexpr)>(size_t)85) fatal("$i.j attrib ref too big");
+ for (p=zzbegexpr+1,q= &i[0]; *p!='.'; p++) {
+ if ( q == &i[20] )
+ fatalFL("i of $i.j attrib ref too big",
+ FileStr[CurFile], zzline );
+ *q++ = *p;
+ }
+ *q = '\0';
+ for (p++, q= &j[0]; *p!='\0'; p++) {
+ if ( q == &j[20] )
+ fatalFL("j of $i.j attrib ref too big",
+ FileStr[CurFile], zzline );
+ *q++ = *p;
+ }
+ *q = '\0';
+ if ( !GenCC ) sprintf(buf,"zzaArg(zztasp%s,%s)",i,j);
+ else sprintf(buf,"_t%s%s",i,j);
+ zzreplstr(buf);
+ zzmore();
+ UsedOldStyleAttrib = 1;
+ if ( UsedNewStyleLabel )
+ err("cannot mix old-style $i with new-style labels");
+ }
+ >>
+
+$[_a-zA-Z][_a-zA-Z0-9]*
+ <<
+ NLA = 48;
+ { static char buf[300]; LabelEntry *el;
+ zzbegexpr[0] = ' ';
+ if ( CurRule != NULL &&
+ strcmp(CurRule, &zzbegexpr[1])==0 ) {
+ if ( !GenCC ) zzreplstr("zzaRet");
+ }
+ else if ( CurRetDef != NULL &&
+ strmember(CurRetDef, &zzbegexpr[1])) {
+ if ( hasMultipleOperands( CurRetDef ) ) {
+ require (strlen(zzbegexpr)<=(size_t)285,
+ "$retval attrib ref too big");
+ sprintf(buf,"_retv.%s",&zzbegexpr[1]);
+ zzreplstr(buf);
+ }
+ else zzreplstr("_retv");
+ }
+ else if ( CurParmDef != NULL &&
+ strmember(CurParmDef, &zzbegexpr[1])) {
+ ;
+ }
+ else if ( Elabel==NULL ) {
+ { err("$-variables in actions outside of rules are not allowed"); }
+ } else if ( (el=(LabelEntry *)hash_get(Elabel, &zzbegexpr[1]))!=NULL ) {
+ /* MR10 */
+ /* MR10 */ /* element labels might exist without an elem when */
+ /* MR10 */ /* it is a forward reference (to a rule) */
+ /* MR10 */
+ /* MR10 */ if ( GenCC && (el->elem == NULL || el->elem->ntype==nRuleRef) )
+ /* MR10 */ { err(eMsg1("There are no token ptrs for rule references: '$%s'",&zzbegexpr[1])); }
+ /* MR10 */
+ /* MR10 */ if ( !GenCC && (el->elem == NULL || el->elem->ntype==nRuleRef) && GenAST) {
+ /* MR10 */ err("You can no longer use attributes returned by rules when also using ASTs");
+ /* MR10 */ err(" Use upward inheritance (\"rule >[Attrib a] : ... <<$a=...\>\>\")");
+ /* MR10 */ };
+ /* MR10 */
+ /* MR10 */ /* keep track of <<... $label ...>> for semantic predicates in guess mode */
+ /* MR10 */ /* element labels contain pointer to the owners node */
+ /* MR10 */
+ /* MR10 */ if (el->elem != NULL && el->elem->ntype == nToken) {
+ /* MR10 */ list_add(&CurActionLabels,el);
+ /* MR10 */ };
+}
+else
+warn(eMsg1("$%s not parameter, return value, (defined) element label",&zzbegexpr[1]));
+}
+zzmore();
+ >>
+
+#0
+ <<
+ NLA = 49;
+ zzreplstr("(*_root)"); zzmore(); chkGTFlag();
+ >>
+
+#\[\]
+ <<
+ NLA = 50;
+ if ( GenCC ) {
+ if (NewAST) zzreplstr("(newAST)");
+ else zzreplstr("(new AST)");}
+ else {zzreplstr("zzastnew()");} zzmore();
+ chkGTFlag();
+ >>
+
+#\(\)
+ <<
+ NLA = 51;
+ zzreplstr("NULL"); zzmore(); chkGTFlag();
+ >>
+
+#[0-9]+
+ <<
+ NLA = 52;
+ {
+ static char buf[100];
+ if ( strlen(zzbegexpr)>(size_t)85 )
+ fatal("#i AST ref too big");
+ if ( GenCC ) sprintf(buf,"_ast%d%s",BlkLevel-1,zzbegexpr+1);
+ else sprintf(buf,"zzastArg(%s)",zzbegexpr+1);
+ zzreplstr(buf);
+ zzmore();
+ set_orel(atoi(zzbegexpr+1), &AST_nodes_refd_in_actions);
+ chkGTFlag();
+ }
+ >>
+
+#line[\ \t]* [0-9]+ {[\ \t]* \"~[\"]+\" ([\ \t]* [0-9]*)* } (\n|\r|\r\n)
+ <<
+ NLA = 53;
+
+ zzline = atoi(zzbegexpr+5) - 1; zzline++; zzmore();
+ getFileNameFromTheLineInfo(FileStr[CurFile], zzbegexpr);
+ >>
+
+#line ~[\n\r]* (\n|\r|\r\n)
+ <<
+ NLA = 54;
+
+ zzline++; zzmore();
+ >>
+
+#[_a-zA-Z][_a-zA-Z0-9]*
+ <<
+ NLA = 55;
+
+ if ( !(strcmp(zzbegexpr, "#ifdef")==0 ||
+ strcmp(zzbegexpr, "#if")==0 ||
+ strcmp(zzbegexpr, "#else")==0 ||
+ strcmp(zzbegexpr, "#endif")==0 ||
+ strcmp(zzbegexpr, "#ifndef")==0 ||
+ strcmp(zzbegexpr, "#define")==0 ||
+ strcmp(zzbegexpr, "#pragma")==0 ||
+ strcmp(zzbegexpr, "#undef")==0 ||
+ strcmp(zzbegexpr, "#import")==0 ||
+ strcmp(zzbegexpr, "#line")==0 ||
+ strcmp(zzbegexpr, "#include")==0 ||
+ strcmp(zzbegexpr, "#error")==0) )
+ {
+ static char buf[100];
+ sprintf(buf, "%s_ast", zzbegexpr+1);
+ /* MR27 */ list_add(&CurAstLabelsInActions, mystrdup(zzbegexpr+1));
+ zzreplstr(buf);
+ chkGTFlag();
+ }
+ zzmore();
+ >>
+
+#\[
+ <<
+ NLA = 56;
+
+ pushint(']');
+ if ( GenCC ) {
+ if (NewAST) zzreplstr("(newAST(");
+ else zzreplstr("(new AST("); }
+ else zzreplstr("zzmk_ast(zzastnew(),");
+ zzmore();
+ chkGTFlag();
+ >>
+
+#\(
+ <<
+ NLA = 57;
+
+ pushint('}');
+ if ( GenCC ) {
+ if (tmakeInParser) {
+ zzreplstr("tmake(");
+ }
+ else {
+ zzreplstr("ASTBase::tmake(");
+ }
+ }
+ else {
+ zzreplstr("zztmake(");
+ }
+ zzmore();
+ chkGTFlag();
+ >>
+
+#
+ <<
+ NLA = 58;
+ zzmore();
+ >>
+
+\)
+ <<
+ NLA = 59;
+
+ if ( istackempty() )
+ zzmore();
+ else if ( topint()==')' ) {
+ popint();
+ }
+ else if ( topint()=='}' ) {
+ popint();
+ /* terminate #(..) */
+ zzreplstr(", NULL)");
+ }
+ zzmore();
+ >>
+
+\[
+ <<
+ NLA = 60;
+
+ pushint('|'); /* look for '|' to terminate simple [...] */
+ zzmore();
+ >>
+
+\(
+ <<
+ NLA = 61;
+
+ pushint(')');
+ zzmore();
+ >>
+
+\\\]
+ <<
+ NLA = 62;
+ zzreplstr("]"); zzmore();
+ >>
+
+\\\)
+ <<
+ NLA = 63;
+ zzreplstr(")"); zzmore();
+ >>
+
+\\>
+ <<
+ NLA = 64;
+ if (! tokenActionActive) zzreplstr(">"); /* MR1 */
+ zzmore(); /* MR1 */
+ >>
+
+'
+ <<
+ NLA = 65;
+ zzmode(ACTION_CHARS); zzmore();
+ >>
+
+\"
+ <<
+ NLA = 66;
+ zzmode(ACTION_STRINGS); zzmore();
+ >>
+
+\\$
+ <<
+ NLA = 67;
+ zzreplstr("$"); zzmore();
+ >>
+
+\\#
+ <<
+ NLA = 68;
+ zzreplstr("#"); zzmore();
+ >>
+
+\\(\n|\r|\r\n)
+ <<
+ NLA = 69;
+ zzline++; zzmore();
+ >>
+
+\\~[\]\)>$#]
+ <<
+ NLA = 70;
+ zzmore();
+ >>
+
+/
+ <<
+ NLA = 71;
+ zzmore();
+ >>
+
+/\*
+ <<
+ NLA = 72;
+ zzmode(ACTION_COMMENTS); zzmore();
+ >>
+
+\*/
+ <<
+ NLA = 73;
+ warn("Missing /*; found dangling */ in action"); zzmore();
+ >>
+
+//
+ <<
+ NLA = 74;
+ zzmode(ACTION_CPP_COMMENTS); zzmore();
+ >>
+
+~[\n\r\)\(\\$#\>\]\[\"'/]+
+ <<
+ NLA = 75;
+ zzmore();
+ >>
+
+
+%%PARSE_ENUM_FILE
+
+@
+ <<
+ NLA = Eof;
+ ;
+ >>
+
+[\t\ ]+
+ <<
+ NLA = 137;
+ zzskip();
+ >>
+
+\n|\r|\r\n
+ <<
+ NLA = 138;
+ zzline++; zzskip();
+ >>
+
+//
+ <<
+ NLA = 139;
+ zzmode(TOK_DEF_CPP_COMMENTS); zzmore();
+ >>
+
+/\*
+ <<
+ NLA = 140;
+ zzmode(TOK_DEF_COMMENTS); zzskip();
+ >>
+
+#ifdef
+ <<
+ NLA = 141;
+ zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
+ >>
+
+#if
+ <<
+ NLA = 142;
+ zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
+ >>
+
+#ifndef
+ <<
+ NLA = 143;
+ ;
+ >>
+
+#else
+ <<
+ NLA = 144;
+ zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
+ >>
+
+#endif
+ <<
+ NLA = 145;
+ zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
+ >>
+
+#undef
+ <<
+ NLA = 146;
+ zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
+ >>
+
+#import
+ <<
+ NLA = 147;
+ zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
+ >>
+
+#define
+ <<
+ NLA = 149;
+ >>
+
+enum
+ <<
+ NLA = 151;
+ >>
+
+\{
+ <<
+ NLA = 152;
+ >>
+
+=
+ <<
+ NLA = 153;
+ >>
+
+,
+ <<
+ NLA = 154;
+ >>
+
+\}
+ <<
+ NLA = 155;
+ >>
+
+;
+ <<
+ NLA = 156;
+ >>
+
+[0-9]+
+ <<
+ NLA = INT;
+ >>
+
+[a-zA-Z_][_a-zA-Z0-9]*
+ <<
+ NLA = ID;
+ >>
+
+%%
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/pred.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/pred.c new file mode 100644 index 0000000000..eb11c4d950 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/pred.c @@ -0,0 +1,821 @@ +/*
+ * pred.c -- source for predicate detection, manipulation
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2001
+ */
+
+#include <stdio.h>
+#include "pcctscfg.h"
+#include "set.h"
+#include "syn.h"
+#include "hash.h"
+#include "generic.h"
+#include "dlgdef.h"
+#include <ctype.h>
+
+#ifdef __USE_PROTOS
+static void complete_context_sets(RuleRefNode *, Predicate *);
+static void complete_context_trees(RuleRefNode *, Predicate *);
+#else
+static void complete_context_sets();
+static void complete_context_trees();
+#endif
+
+char *PRED_AND_LIST = "AND";
+char *PRED_OR_LIST = "OR";
+
+/*
+ * In C mode, return the largest constant integer found as the
+ * sole argument to LATEXT(i).
+ *
+ * In C++ mode, return the largest constant integer found as the
+ * sole argument to LT(i) given that the char before is nonalpha.
+ */
+
+int
+#ifdef __USE_PROTOS
+predicateLookaheadDepth(ActionNode *a)
+#else
+predicateLookaheadDepth(a)
+ActionNode *a;
+#endif
+{
+ int max_k=0;
+
+ if (a->predEntry != NULL) {
+ MR_pred_depth(a->predEntry->pred,&max_k);
+ goto PREDENTRY_EXIT;
+ }
+
+ if ( GenCC )
+ {
+ /* scan for LT(i) */
+ int k = 0;
+ char *p = a->action;
+ while ( p!=NULL )
+ {
+ p = strstr(p, "LT(");
+ if ( p!=NULL )
+ {
+ if ( p>=a->action && !isalpha(*(p-1)) )
+ {
+ k = atoi(p+strlen("LT("));
+ if ( k>max_k ) max_k=k;
+ }
+ p += strlen("LT(");
+ }
+ }
+ }
+ else {
+ /* scan for LATEXT(i) */
+ int k = 0;
+ char *p = a->action;
+ while ( p!=NULL )
+ {
+ p = strstr(p, "LATEXT(");
+ if ( p!=NULL )
+ {
+ p += strlen("LATEXT(");
+ k = atoi(p);
+ if ( k>max_k ) max_k=k;
+ }
+ }
+ }
+
+ if (max_k==0) {
+ max_k = 1; /* MR33 Badly designed if didn't set max_k when CLL_k = 1 */
+ if (CLL_k > 1) /* MR27 Don't warn if max(k,ck) == 1 */
+ {
+ if ( !a->frmwarned )
+ {
+ a->frmwarned = 1;
+ warnFL(eMsg1("predicate: %s missing, bad, or with i=0; assuming i=1",
+ GenCC?"LT(i)":"LATEXT(i)"),
+ FileStr[a->file], a->line);
+ }
+ }
+ }
+
+/* MR10 */ if ( max_k > CLL_k) {
+/* MR10 */ if ( !a->frmwarned )
+/* MR10 */ {
+/* MR10 */ a->frmwarned = 1;
+/* MR11 */ errFL(eMsgd2("predicate refers to lookahead token %d. Semantic lookahead is limited to max(k,ck)==%d",
+/* MR10 */ max_k,CLL_k),
+/* MR10 */ FileStr[a->file],a->line);
+/* MR10 */ if (max_k >= OutputLL_k) {
+/* MR10 */ if (!GenCC) {
+/* MR10 */ errFL(eMsgd(" the lookahead buffer size in C mode is %d token(s) (including the one just recognized)",
+/* MR10 */ OutputLL_k),
+/* MR10 */ FileStr[a->file],a->line);
+/* MR10 */ };
+/* MR10 */ };
+/* MR10 */ };
+/* MR10 */ max_k= CLL_k;
+/* MR10 */ };
+
+PREDENTRY_EXIT:
+ return max_k;
+}
+
+/* Find all predicates in a block of alternatives. DO NOT find predicates
+ * behind the block because that predicate could depend on things set in
+ * one of the nonoptional blocks
+ */
+
+Predicate *
+#ifdef __USE_PROTOS
+find_in_aSubBlk( Junction *alt )
+#else
+find_in_aSubBlk( alt )
+Junction *alt;
+#endif
+{
+ Predicate *a, *head=NULL, *tail=NULL, *root=NULL;
+ Junction *p = alt;
+
+ if (MRhoisting) {
+ return MR_find_in_aSubBlk(alt);
+ };
+ for (; p!=NULL; p=(Junction *)p->p2)
+ {
+ /* ignore empty alts */
+ if ( p->p1->ntype != nJunction ||
+ ((Junction *)p->p1)->jtype != EndBlk )
+ {
+ a = find_predicates(p->p1); /* get preds for this alt */
+ if ( a==NULL ) continue;
+
+ /* make an OR list of predicates */
+ if ( head==NULL )
+ {
+ root = new_pred();
+ root->expr = PRED_OR_LIST;
+ head = tail = a;
+ root->down = head;
+ }
+ else {
+ tail->right = a;
+ a->left = tail;
+ a->up = tail->up;
+ tail = a;
+ }
+ }
+ }
+
+ /* if just one pred, remove OR root */
+ if ( root!=NULL && root->down->right == NULL )
+ {
+ Predicate *d = root->down;
+ free( (char *) root);
+ return d;
+ }
+
+ return root;
+}
+
+Predicate *
+#ifdef __USE_PROTOS
+find_in_aOptBlk( Junction *alt )
+#else
+find_in_aOptBlk( alt )
+Junction *alt;
+#endif
+{
+ return find_in_aSubBlk( alt );
+}
+
+Predicate *
+#ifdef __USE_PROTOS
+find_in_aLoopBegin( Junction *alt )
+#else
+find_in_aLoopBegin( alt )
+Junction *alt;
+#endif
+{
+ return find_in_aSubBlk( (Junction *) alt->p1 ); /* get preds in alts */
+}
+
+Predicate *
+#ifdef __USE_PROTOS
+find_in_aPlusBlk( Junction *alt )
+#else
+find_in_aPlusBlk( alt )
+Junction *alt;
+#endif
+{
+ require(alt!=NULL&&alt->p2!=NULL, "invalid aPlusBlk");
+ return find_in_aSubBlk( alt );
+}
+
+/* Look for a predicate;
+ *
+ * Do not pass anything but Junction nodes; no Actions, Tokens, RuleRefs.
+ * This means that a "hoisting distance" of zero is the only distance
+ * allowable. Init actions are ignored.
+ *
+ * WARNING:
+ * Assumes no (..)? block after predicate for the moment.
+ * Does not check to see if pred is in production that can generate
+ * a sequence contained in the set of ambiguous tuples.
+ *
+ * Return the predicate found if any.
+ */
+
+
+Predicate *
+#ifdef __USE_PROTOS
+find_predicates( Node *alt )
+#else
+find_predicates( alt )
+Node *alt;
+#endif
+{
+#ifdef DBG_PRED
+ Junction *j;
+ RuleRefNode *r;
+ TokNode *t;
+#endif
+ Predicate *pred;
+
+ if ( alt==NULL ) return NULL;
+
+#ifdef DBG_PRED
+ switch ( alt->ntype )
+ {
+ case nJunction :
+ j = (Junction *) alt;
+ fprintf(stderr, "Junction(in %s)", j->rname);
+ switch ( j->jtype )
+ {
+ case aSubBlk :
+ fprintf(stderr,"aSubBlk\n");
+ break;
+ case aOptBlk :
+ fprintf(stderr,"aOptBlk\n");
+ break;
+ case aLoopBegin :
+ fprintf(stderr,"aLoopBeginBlk\n");
+ break;
+ case aLoopBlk :
+ fprintf(stderr,"aLoopBlk\n");
+ break;
+ case aPlusBlk :
+ fprintf(stderr,"aPlusBlk\n");
+ break;
+ case EndBlk :
+ fprintf(stderr,"EndBlk\n");
+ break;
+ case RuleBlk :
+ fprintf(stderr,"RuleBlk\n");
+ break;
+ case Generic :
+ fprintf(stderr,"Generic\n");
+ break;
+ case EndRule :
+ fprintf(stderr,"EndRule\n");
+ break;
+ }
+ break;
+ case nRuleRef :
+ r = (RuleRefNode *) alt;
+ fprintf(stderr, "RuleRef(in %s)\n", r->rname);
+ break;
+ case nToken :
+ t = (TokNode *) alt;
+ fprintf(stderr, "TokenNode(in %s)%s\n", t->rname, TokenString(t->token));
+ break;
+ case nAction :
+ fprintf(stderr, "Action\n");
+ break;
+ }
+#endif
+
+ switch ( alt->ntype )
+ {
+ case nJunction :
+ {
+ Predicate *a, *b;
+ Junction *p = (Junction *) alt;
+
+ /* lock nodes */
+ if ( p->jtype==aLoopBlk || p->jtype==RuleBlk ||
+ p->jtype==aPlusBlk || p->jtype==EndRule )
+ {
+ require(p->pred_lock!=NULL, "rJunc: lock array is NULL");
+ if ( p->pred_lock[1] )
+ {
+ return NULL;
+ }
+ p->pred_lock[1] = TRUE;
+ }
+
+ switch ( p->jtype )
+ {
+ case aSubBlk :
+ a = find_in_aSubBlk(p);
+ return a; /* nothing is visible past this guy */
+ case aOptBlk :
+ a = find_in_aOptBlk(p);
+ return a;
+ case aLoopBegin :
+ a = find_in_aLoopBegin(p);
+ return a;
+ case aLoopBlk :
+ a = find_in_aSubBlk(p);
+ p->pred_lock[1] = FALSE;
+ return a;
+ case aPlusBlk :
+ a = find_in_aPlusBlk(p);
+ p->pred_lock[1] = FALSE;
+ return a; /* nothing is visible past this guy */
+ case RuleBlk :
+ a = find_predicates(p->p1);
+ p->pred_lock[1] = FALSE;
+ return a;
+ case Generic :
+ a = find_predicates(p->p1);
+ b = find_predicates(p->p2);
+ if ( p->pred_lock!=NULL ) p->pred_lock[1] = FALSE;
+ if ( a==NULL ) return b;
+ if ( b==NULL ) return a;
+ /* otherwise OR the two preds together */
+ {
+ fatal_internal("hit unknown situation during predicate hoisting");
+ }
+ case EndBlk :
+ case EndRule : /* Find no predicates after a rule ref */
+ return NULL;
+ default:
+ fatal_internal("this cannot be printed\n");
+ break;
+ }
+ }
+ case nAction :
+ {
+ ActionNode *p = (ActionNode *) alt;
+ if ( p->noHoist) return NULL; /* MR12c */
+ if ( p->init_action ) return find_predicates(p->next);
+ if ( p->is_predicate )
+ {
+ Tree *t=NULL;
+#ifdef DBG_PRED
+ fprintf(stderr, "predicate: <<%s>>?\n", p->action);
+#endif
+ if ( p->guardpred!=NULL )
+ {
+ pred = predicate_dup(p->guardpred);
+ MR_guardPred_plainSet(p,pred); /* MR12c */
+ }
+ else
+ {
+ pred = new_pred();
+ pred->k = predicateLookaheadDepth(p);
+ pred->source = p;
+ pred->expr = p->action;
+ if ( HoistPredicateContext && pred->k > 1 )
+ {
+ /* MR30 No need to use first_item_is_guess_block_extra
+ since we know this is an action, not a (...)* or
+ (...)+ block.
+ */
+
+ if ( first_item_is_guess_block((Junction *)p->next) )
+ {
+ warnFL("cannot compute context of predicate in front of (..)? block",
+ FileStr[p->file], p->line);
+ }
+ else
+ {
+ ConstrainSearch = 0;
+/* MR11 */ if (p->ampersandPred != NULL) {
+/* MR11 */ TRAV(p,
+/* MR11 */ pred->k,
+/* MR11 */ &(pred->completionTree), t);
+/* MR11 */ } else {
+ TRAV(p->next,
+ pred->k,
+ &(pred->completionTree), t);
+ };
+ pred->tcontext = t;
+ MR_check_pred_too_long(pred,pred->completionTree);
+#ifdef DBG_PRED
+ fprintf(stderr, "LL(%d) context:", pred->k);
+ preorder(t);
+ fprintf(stderr, "\n");
+#endif
+ }
+ }
+ else if ( HoistPredicateContext && pred->k == 1 )
+ {
+ pred->scontext[1] = empty;
+ /* MR30 No need to use first_item_is_guess_block_extra
+ since we know this is an action.
+ */
+ if ( first_item_is_guess_block((Junction *)p->next) )
+ {
+ warnFL("cannot compute context of predicate in front of (..)? block",
+ FileStr[p->file], p->line);
+ }
+ else
+ {
+ REACH((Junction *)p->next,
+ 1,
+ &(pred->completionSet),
+ pred->scontext[1]);
+ MR_check_pred_too_long(pred,pred->completionSet);
+#ifdef DBG_PRED
+ fprintf(stderr, "LL(1) context:");
+ s_fprT(stderr, pred->scontext[1]);
+ fprintf(stderr, "\n");
+#endif
+ }
+ }
+ }
+ {
+ Predicate *d = find_predicates(p->next);
+ Predicate *root;
+
+/* Warning: Doesn't seem like the up pointers will all be set correctly;
+ * TJP: that's ok, we're not using them now.
+ */
+ if ( d!=NULL )
+ {
+ root = new_pred();
+ root->expr = PRED_AND_LIST;
+ root->down = pred;
+ pred->right = d;
+ pred->up = root;
+ d->left = pred;
+ d->up = pred->up;
+ return root;
+ }
+ }
+ return pred;
+ }
+ return NULL;
+ }
+ case nRuleRef :
+ {
+ Predicate *a;
+ RuleRefNode *p = (RuleRefNode *) alt;
+ Junction *r;
+ Junction *save_MR_RuleBlkWithHalt;
+
+ RuleEntry *q = (RuleEntry *) hash_get(Rname, p->text);
+ if ( q == NULL )
+ {
+ warnFL( eMsg1("rule %s not defined",p->text), FileStr[p->file], p->line );
+ return NULL;
+ }
+ r = RulePtr[q->rulenum];
+ if ( r->pred_lock[1] )
+ {
+ /* infinite left-recursion; ignore 'cause LL sup 1 (k) analysis
+ * must have seen it earlier.
+ */
+ return NULL;
+ }
+
+ /* MR10 There should only be one halt set at a time. */
+ /* MR10 Life would have been easier with a global variable */
+ /* MR10 (at least for this particular need) */
+ /* MR10 Unset the old one and set the new one, later undo. */
+
+ require(r->end->halt == FALSE,"should only have one halt at a time");
+
+/* MR10 */ require(MR_RuleBlkWithHalt == NULL ||
+/* MR10 */ (MR_RuleBlkWithHalt->jtype == RuleBlk && MR_RuleBlkWithHalt->end->halt == TRUE),
+/* MR10 */ "RuleBlkWithHalt->end not RuleBlk or does not have halt set");
+/* MR10 */ if (MR_RuleBlkWithHalt != NULL) {
+/* MR10 */ MR_RuleBlkWithHalt->end->halt=FALSE;
+/* MR10 */ };
+
+/*** fprintf(stderr,"\nSetting halt on junction #%d\n",r->end->seq); ***/
+
+ require(r->end->halt == FALSE,"rule->end->halt already set");
+
+ save_MR_RuleBlkWithHalt=MR_RuleBlkWithHalt;
+
+/* MR10 */ MR_pointerStackPush(&MR_RuleBlkWithHaltStack,MR_RuleBlkWithHalt);
+/* MR10 */ MR_pointerStackPush(&MR_PredRuleRefStack,p);
+
+ r->end->halt = TRUE;
+/* MR10 */ MR_RuleBlkWithHalt=r;
+
+ a = find_predicates((Node *)r);
+
+ require(r->end->halt == TRUE,"rule->end->halt not set");
+ r->end->halt = FALSE;
+
+/* MR10 */ MR_pointerStackPop(&MR_PredRuleRefStack);
+/* MR10 */ MR_RuleBlkWithHalt=(Junction *) MR_pointerStackPop(&MR_RuleBlkWithHaltStack);
+
+ require (MR_RuleBlkWithHalt==save_MR_RuleBlkWithHalt,
+ "RuleBlkWithHaltStack not consistent");
+
+/* MR10 */ require(MR_RuleBlkWithHalt == NULL ||
+/* MR10 */ (MR_RuleBlkWithHalt->jtype == RuleBlk && MR_RuleBlkWithHalt->end->halt == FALSE),
+/* MR10 */ "RuleBlkWithHalt->end not RuleBlk or has no halt set");
+/* MR10 */ if (MR_RuleBlkWithHalt != NULL) {
+/* MR10 */ MR_RuleBlkWithHalt->end->halt=TRUE;
+/* MR10 */ };
+
+/*** fprintf(stderr,"\nRestoring halt on junction #%d\n",r->end->seq); ***/
+
+ if ( a==NULL ) return NULL;
+
+ /* attempt to compute the "local" FOLLOW just like in normal lookahead
+ * computation if needed
+ */
+
+ complete_context_sets(p,a);
+ complete_context_trees(p,a);
+
+/* MR10 */ MR_cleanup_pred_trees(a);
+
+ return a;
+ }
+ case nToken :
+ break;
+ }
+
+ return NULL;
+}
+
+#ifdef __USE_PROTOS
+Predicate *MR_find_predicates_and_supp(Node *alt)
+#else
+Predicate *MR_find_predicates_and_supp(alt)
+ Node *alt;
+#endif
+{
+ Predicate *p;
+
+ p=find_predicates(alt);
+ p=MR_suppressK(alt,p);
+ return p;
+}
+
+Predicate *
+#ifdef __USE_PROTOS
+new_pred( void )
+#else
+new_pred( )
+#endif
+{
+ Predicate *p = (Predicate *) calloc(1,sizeof(Predicate)); /* MR10 */
+ require(p!=NULL, "new_pred: cannot alloc predicate");
+ p->scontext[0]=empty;
+ p->scontext[1]=empty;
+ p->completionTree=empty;
+ p->completionSet=empty;
+ p->plainSet=empty;
+ return p;
+}
+
+static void
+#ifdef __USE_PROTOS
+complete_context_sets( RuleRefNode *p, Predicate *a )
+#else
+complete_context_sets( p, a )
+RuleRefNode *p;
+Predicate *a;
+#endif
+{
+ set rk2, b;
+ int k2;
+
+#ifdef DBG_PRED
+ fprintf(stderr, "enter complete_context_sets\n");
+#endif
+ for (; a!=NULL; a=a->right)
+ {
+ if ( a->expr == PRED_AND_LIST || a->expr == PRED_OR_LIST )
+ {
+ complete_context_sets(p,a->down);
+ continue;
+ }
+ rk2 = b = empty;
+ while ( !set_nil(a->completionSet) )
+ {
+ k2 = set_int(a->completionSet);
+ set_rm(k2, a->completionSet);
+
+ REACH(p->next, k2, &rk2, b);
+ set_orin(&(a->scontext[1]), b);
+ set_free(b);
+ }
+
+ set_orin(&(a->completionSet), rk2);/* remember what we couldn't do */
+ set_free(rk2);
+#ifdef DBG_PRED
+ fprintf(stderr, "LL(1) context for %s(addr 0x%x) after ruleref:", a->expr, a);
+ s_fprT(stderr, a->scontext[1]);
+ fprintf(stderr, "\n");
+#endif
+/* complete_context_sets(p, a->down);*/
+ }
+#ifdef DBG_PRED
+ fprintf(stderr, "exit complete_context_sets\n");
+#endif
+}
+
+static void
+#ifdef __USE_PROTOS
+complete_context_trees( RuleRefNode *p, Predicate *a )
+#else
+complete_context_trees( p, a )
+RuleRefNode *p;
+Predicate *a;
+#endif
+{
+ set rk2;
+ int k2;
+ Tree *u;
+
+#ifdef DBG_PRED
+ fprintf(stderr, "enter complete_context_trees\n");
+#endif
+ for (; a!=NULL; a=a->right)
+ {
+ if ( a->expr == PRED_AND_LIST || a->expr == PRED_OR_LIST )
+ {
+ complete_context_trees(p, a->down);
+ continue;
+ }
+ rk2 = empty;
+
+ /* any k left to do? if so, link onto tree */
+ while ( !set_nil(a->completionTree) )
+ {
+ k2 = set_int(a->completionTree);
+ set_rm(k2, a->completionTree);
+ u = NULL;
+
+ TRAV(p->next, k2, &rk2, u);
+
+ /* any subtrees missing k2 tokens, add u onto end */
+ a->tcontext = tlink(a->tcontext, u, k2);
+ Tfree(u); /* MR10 */
+ }
+ set_orin(&(a->completionTree), rk2);/* remember what we couldn't do */
+ set_free(rk2);
+#ifdef DBG_PRED
+ fprintf(stderr, "LL(i<%d) context after ruleref:", LL_k);
+ preorder(a->tcontext);
+ fprintf(stderr, "\n");
+#endif
+/* complete_context_trees(p, a->down);*/
+ }
+#ifdef DBG_PRED
+ fprintf(stderr, "exit complete_context_trees\n");
+#endif
+}
+
+/* Walk a list of predicates and return the set of all tokens in scontext[1]'s */
+set
+#ifdef __USE_PROTOS
+covered_set( Predicate *p )
+#else
+covered_set( p )
+Predicate *p;
+#endif
+{
+ set a;
+
+ a = empty;
+ for (; p!=NULL; p=p->right)
+ {
+ if ( p->expr == PRED_AND_LIST || p->expr == PRED_OR_LIST )
+ {
+ set_orin(&a, covered_set(p->down));
+ continue;
+ }
+ set_orin(&a, p->scontext[1]);
+ set_orin(&a, covered_set(p->down));
+ }
+ return a;
+}
+
+/* MR10 predicate_free()
+ MR10 Don't free the leaf nodes since they are part of the action node
+*/
+
+#ifdef __USE_PROTOS
+void predicate_free(Predicate *p)
+#else
+void predicate_free(p)
+ Predicate *p;
+#endif
+{
+ if (p == NULL) return;
+ predicate_free(p->right);
+ predicate_free(p->down);
+ if (p->cloned ||
+ p->source == NULL ||
+ p->source->guardpred == NULL ||
+ p->expr == PRED_AND_LIST ||
+ p->expr == PRED_OR_LIST) {
+ set_free(p->scontext[1]);
+ set_free(p->completionSet);
+ set_free(p->completionTree);
+ set_free(p->plainSet);
+ Tfree(p->tcontext);
+ free( (char *) p);
+ } else {
+ p->right=NULL;
+ p->down=NULL; /* MR13 *** debug */
+ };
+}
+
+/* MR10 predicate_dup() */
+
+#ifdef __USE_PROTOS
+Predicate * predicate_dup_xxx(Predicate *p,int contextToo)
+#else
+Predicate * predicate_dup_xxx(p,contextToo)
+ Predicate *p;
+ int contextToo;
+#endif
+{
+ Predicate *q;
+
+ if (p == NULL) return NULL;
+ q=new_pred();
+ q->down=predicate_dup(p->down);
+ q->right=predicate_dup(p->right);
+
+ /*
+ don't replicate expr - it is read-only
+ and address comparison is used to look
+ for identical predicates.
+ */
+
+ q->expr=p->expr;
+ q->k=p->k;
+ q->source=p->source;
+ q->cloned=1;
+ q->ampersandStyle=p->ampersandStyle;
+ q->inverted=p->inverted;
+ q->predEntry=p->predEntry;
+ q->plainSet=set_dup(p->plainSet);
+
+ if (contextToo) {
+ q->tcontext=tdup(p->tcontext);
+ q->scontext[0]=set_dup(p->scontext[0]);
+ q->scontext[1]=set_dup(p->scontext[1]);
+ q->completionTree=set_dup(p->completionTree);
+ q->completionSet=set_dup(p->completionSet);
+ };
+
+ /* don't need to dup "redundant" */
+
+ return q;
+
+}
+
+#ifdef __USE_PROTOS
+Predicate * predicate_dup_without_context(Predicate *p)
+#else
+Predicate * predicate_dup_without_context(p)
+ Predicate *p;
+#endif
+{
+ return predicate_dup_xxx(p,0);
+}
+
+#ifdef __USE_PROTOS
+Predicate * predicate_dup(Predicate *p)
+#else
+Predicate * predicate_dup(p)
+ Predicate *p;
+#endif
+{
+ return predicate_dup_xxx(p,1);
+}
+
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/proto.h b/BaseTools/Source/C/VfrCompile/Pccts/antlr/proto.h new file mode 100644 index 0000000000..53035e720e --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/proto.h @@ -0,0 +1,852 @@ +/*
+ * proto.h -- function prototypes
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2001
+ */
+
+ /* V a r i a b l e s */
+
+extern int tp;
+extern Junction *SynDiag;
+extern char Version[];
+extern char VersionDef[];
+#ifdef __cplusplus
+extern void (*fpPrint[])(...);
+#else
+extern void (*fpPrint[])();
+#endif
+#ifdef __cplusplus
+extern struct _set (*fpReach[])(...);
+#else
+extern struct _set (*fpReach[])();
+#endif
+#ifdef __cplusplus
+extern struct _tree *(*fpTraverse[])(...);
+#else
+extern struct _tree *(*fpTraverse[])();
+#endif
+#ifdef __cplusplus
+extern void (**fpTrans)(...);
+#else
+extern void (**fpTrans)();
+#endif
+#ifdef __cplusplus
+extern void (**fpJTrans)(...);
+#else
+extern void (**fpJTrans)();
+#endif
+#ifdef __cplusplus
+extern void (*C_Trans[NumNodeTypes+1])(...);
+#else
+extern void (*C_Trans[])();
+#endif
+#ifdef __cplusplus
+extern void (*C_JTrans[NumJuncTypes+1])(...);
+#else
+extern void (*C_JTrans[])();
+#endif
+extern int BlkLevel;
+extern int CurFile;
+extern char *CurPredName;
+extern char *CurRule;
+extern int CurRuleDebug; /* MR13 */
+extern Junction *CurRuleBlk;
+extern RuleEntry *CurRuleNode;
+extern ListNode *CurElementLabels;
+extern ListNode *CurAstLabelsInActions; /* MR27 */
+extern ListNode *ContextGuardPredicateList; /* MR13 */
+extern ListNode *CurActionLabels;
+extern int numericActionLabel; /* MR10 << ... $1 ... >> or << ... $1 ... >>? */
+extern ListNode *NumericPredLabels; /* MR10 << ... $1 ... >>? ONLY */
+extern char *FileStr[];
+extern int NumFiles;
+extern int EpToken;
+extern int WildCardToken;
+extern Entry **Tname,
+ **Texpr,
+ **Rname,
+ **Fcache,
+ **Tcache,
+ **Elabel,
+ **Sname,
+ **Pname; /* MR11 */
+extern ListNode *ExprOrder;
+extern ListNode **Cycles;
+extern int TokenNum;
+extern int LastTokenCounted;
+extern ListNode *BeforeActions, *AfterActions, *LexActions;
+
+/* MR1 */
+/* MR1 11-Apr-97 Provide mechanism for inserting code into DLG class */
+/* MR1 via #lexmember <<....>> & #lexprefix <<...>> */
+/* MR1 */
+
+extern ListNode *LexMemberActions; /* MR1 */
+extern ListNode *LexPrefixActions; /* MR1 */
+
+extern set *fset; /* for constrained search */ /* MR11 */
+extern int maxk; /* for constrained search */ /* MR11 */
+extern int Save_argc; /* MR10 */
+extern char **Save_argv; /* MR10 */
+extern ListNode *eclasses, *tclasses;
+extern char *HdrAction;
+extern char *FirstAction; /* MR11 */
+extern FILE *ErrFile;
+extern char *RemapFileName;
+extern char *ErrFileName;
+extern char *DlgFileName;
+extern char *DefFileName;
+extern char *ModeFileName;
+extern char *StdMsgName;
+extern int NumRules;
+extern Junction **RulePtr;
+extern int LL_k;
+extern int CLL_k;
+extern char *decodeJType[];
+extern int PrintOut;
+extern int PrintAnnotate;
+extern int CodeGen;
+extern int LexGen;
+extern int esetnum;
+extern int setnum;
+extern int wordnum;
+extern int GenAST;
+extern int GenANSI;
+extern int **FoStack;
+extern int **FoTOS;
+extern int GenExprSetsOpt;
+extern FILE *DefFile;
+extern int CannotContinue;
+extern int GenCR;
+extern int GenLineInfo;
+extern int GenLineInfoMS;
+extern int action_file, action_line;
+extern int TraceGen;
+extern int CurAmbigAlt1, CurAmbigAlt2, CurAmbigline, CurAmbigfile;
+extern char *CurAmbigbtype;
+extern int elevel;
+extern int GenEClasseForRules;
+extern FILE *input, *output;
+extern char **TokenStr, **ExprStr;
+extern int CurrentLexClass, NumLexClasses;
+extern LClass lclass[];
+extern char LexStartSymbol[];
+extern char *CurRetDef;
+extern char *CurParmDef;
+extern int OutputLL_k;
+extern int TreeResourceLimit;
+extern int DemandLookahead;
+extern char *RulePrefix;
+extern int GenStdPccts;
+extern char *stdpccts;
+extern int ParseWithPredicates;
+extern int ConstrainSearch;
+extern int PURIFY; /* MR23 */
+
+extern set MR_CompromisedRules; /* MR14 */
+extern int MR_AmbSourceSearch; /* MR11 */
+extern int MR_SuppressSearch; /* MR13 */
+extern int MR_AmbSourceSearchGroup; /* MR11 */
+extern int MR_AmbSourceSearchChoice; /* MR11 */
+extern int MR_AmbSourceSearchLimit; /* MR11 */
+extern int MR_usingPredNames; /* MR11 */
+extern int MR_ErrorSetComputationActive; /* MR14 */
+extern char *MR_AmbAidRule; /* MR11 */
+extern int MR_AmbAidLine; /* MR11 */
+extern int MR_AmbAidMultiple; /* MR11 */
+extern int MR_AmbAidDepth; /* MR11 */
+extern int MR_skipped_e3_report; /* MR11 */
+extern int MR_matched_AmbAidRule; /* MR11 */
+extern int MR_Inhibit_Tokens_h_Gen; /* MR13 */
+extern int NewAST; /* MR13 */
+extern int tmakeInParser; /* MR23 */
+extern int AlphaBetaTrace; /* MR14 */
+extern int MR_BlkErr; /* MR21 */
+extern int MR_AlphaBetaWarning; /* MR14 */
+extern int MR_AlphaBetaMessageCount; /* MR14 */
+extern int MR_MaintainBackTrace; /* MR14 */
+extern int MR_BadExprSets; /* MR13 */
+extern int FoundGuessBlk;
+extern int FoundException;
+extern int FoundAtOperator; /* MR6 */
+extern int FoundExceptionGroup; /* MR6 */
+extern int WarningLevel;
+extern int UseStdout; /* MR6 */
+extern int TabWidth; /* MR6 */
+extern int pLevel;
+extern int pAlt1;
+extern int pAlt2;
+extern int AImode;
+extern int HoistPredicateContext;
+extern int MRhoisting; /* MR9 */
+extern int MRhoistingk; /* MR13 */
+extern int MR_debugGenRule; /* MR11 */
+extern int GenCC;
+extern char *ParserName;
+extern char *StandardSymbols[];
+extern char *ASTSymbols[];
+extern set reserved_positions;
+extern set all_tokens;
+extern set imag_tokens;
+extern set tokclasses;
+extern ListNode *ForcedTokens;
+extern int *TokenInd;
+extern FILE *Parser_h, *Parser_c;
+extern char CurrentClassName[];
+extern int no_classes_found;
+extern char Parser_h_Name[];
+extern char Parser_c_Name[];
+extern char MRinfoFile_Name[]; /* MR10 */
+extern FILE *MRinfoFile; /* MR10 */
+extern int MRinfo; /* MR10 */
+extern int MRinfoSeq; /* MR10 */
+extern int InfoP; /* MR10 */
+extern int InfoT; /* MR10 */
+extern int InfoF; /* MR10 */
+extern int InfoM; /* MR10 */
+extern int InfoO; /* MR12 */
+extern int PotentialSuppression; /* MR10 */
+extern int PotentialDummy; /* MR10 */
+extern int TnodesInUse; /* MR10 */
+extern int TnodesPeak; /* MR10 */
+extern int TnodesReportThreshold; /* MR11 */
+extern int TnodesAllocated; /* MR10 */
+extern char *ClassDeclStuff; /* MR10 */
+extern char *BaseClassName; /* MR22 */
+extern ListNode *class_before_actions, *class_after_actions;
+extern char *UserTokenDefsFile;
+extern int UserDefdTokens;
+extern ListNode *MetaTokenNodes;
+extern char *OutputDirectory;
+extern int DontCopyTokens;
+extern int LTinTokenAction; /* MR23 */
+extern set AST_nodes_refd_in_actions;
+extern ListNode *CurExGroups;
+extern int CurBlockID;
+extern int CurAltNum;
+extern Junction *CurAltStart;
+extern Junction *OuterAltStart; /* chain exception groups MR7 */
+extern ExceptionGroup *DefaultExGroup;
+extern int NumSignals;
+extern int ContextGuardTRAV;
+extern Junction *MR_RuleBlkWithHalt; /* MR10 */
+extern PointerStack MR_BackTraceStack; /* MR10 */
+extern PointerStack MR_PredRuleRefStack; /* MR10 */
+extern PointerStack MR_RuleBlkWithHaltStack; /* MR10 */
+
+/* */
+/* MR1 10-Apr-97 MR1 Previously unable to put right shift operator */
+/* MR1 in DLG action */
+/* */
+extern int tokenActionActive; /* MR1 */
+
+extern char *PRED_OR_LIST; /* MR10 */
+extern char *PRED_AND_LIST; /* MR10 */
+
+#ifdef __VMS
+#define STRICMP strcasecmp /* MR21 */
+#else
+#define STRICMP stricmp /* MR21 */
+#endif
+
+/* MR26 */
+#ifdef PCCTS_USE_STDARG
+extern Tree *tmake(Tree *root, ...);
+#else
+extern Tree *tmake();
+#endif
+
+#ifdef __USE_PROTOS
+extern int STRICMP(const char*, const char*);
+extern void istackreset(void);
+extern int istacksize(void);
+extern void pushint(int);
+extern int popint( void );
+extern int istackempty( void );
+extern int topint( void );
+extern void NewSetWd( void );
+extern void DumpSetWd( void );
+extern void DumpSetWdForC( void );
+extern void DumpSetWdForCC( void );
+extern void NewSet( void );
+extern void FillSet( set );
+extern void ComputeErrorSets( void );
+extern void ComputeTokSets( void );
+extern void SubstErrorClass( set * );
+extern int DefErrSet( set *, int, char * );
+extern int DefErrSetForC( set *, int, char * );
+extern int DefErrSetForCC( set *, int, char * );
+extern int DefErrSet1(int, set *, int, char *); /* MR21 */
+extern int DefErrSetForC1(int, set *, int, char *, const char* ); /* MR21 */
+extern int DefErrSetForCC1(int, set *, int, char *, const char* ); /* MR21 */
+extern int DefErrSetWithSuffix(int, set *, int, char *, const char *); /* MR21 */
+extern void GenErrHdr( void );
+extern void dumpExpr( FILE *, char * );
+extern void addParm( Node *, char * );
+extern Graph buildAction( char *, int, int, int );
+extern Graph buildToken( char * );
+extern Graph buildWildCard( char * );
+extern Graph buildRuleRef( char * );
+extern Graph Or( Graph, Graph );
+extern Graph Cat( Graph, Graph );
+extern Graph makeOpt( Graph, int, char *);
+extern Graph makeBlk( Graph, int, char *);
+extern Graph makeLoop( Graph, int, char *);
+extern Graph makePlus( Graph, int, char *);
+extern Graph emptyAlt( void );
+extern Graph emptyAlt3( void );
+extern TokNode * newTokNode( void );
+extern RuleRefNode * newRNode( void );
+extern Junction * newJunction( void );
+extern ActionNode * newActionNode( void );
+extern char * makelocks( void );
+extern void preorder( Tree * );
+extern Tree * tnode( int );
+extern void _Tfree( Tree * );
+extern Tree * tdup( Tree * );
+extern int is_single_tuple( Tree * );
+extern Tree * tappend( Tree *, Tree * );
+extern void Tfree( Tree * );
+extern Tree * tlink( Tree *, Tree *, int );
+extern Tree * tshrink( Tree * );
+extern Tree * tflatten( Tree * );
+extern Tree * tJunc( Junction *, int, set * );
+extern Tree * tRuleRef( RuleRefNode *, int, set * );
+extern Tree * tToken( TokNode *, int, set * );
+extern Tree * tAction( ActionNode *, int, set * );
+extern int tmember( Tree *, Tree * );
+extern int tmember_constrained( Tree *, Tree * );
+extern Tree * tleft_factor( Tree * );
+extern Tree * trm_perm( Tree *, Tree * );
+extern void tcvt( set *, Tree * );
+extern Tree * permute( int, int );
+extern Tree * VerifyAmbig( Junction *, Junction *, unsigned **, set *, Tree **, Tree **, int * );
+extern set rJunc( Junction *, int, set * );
+extern set rRuleRef( RuleRefNode *, int, set * );
+extern set rToken( TokNode *, int, set * );
+extern set rAction( ActionNode *, int, set * );
+extern void HandleAmbiguity( Junction *, Junction *, Junction *, int );
+extern set First( Junction *, int, int, int * );
+extern void freeBlkFsets( Junction * );
+extern void genAction( ActionNode * );
+extern void genRuleRef( RuleRefNode * );
+extern void genToken( TokNode * );
+extern void genOptBlk( Junction * );
+extern void genLoopBlk( Junction *, Junction *, Junction *, int );
+extern void genLoopBegin( Junction * );
+extern void genPlusBlk( Junction * );
+extern void genSubBlk( Junction * );
+extern void genRule( Junction * );
+extern void genJunction( Junction * );
+extern void genEndBlk( Junction * );
+extern void genEndRule( Junction * );
+extern void genHdr( int );
+extern void genHdr1( int );
+extern void dumpAction( char *, FILE *, int, int, int, int );
+extern void dumpActionPlus(ActionNode*, char *, FILE *, int, int, int, int ); /* MR21 */
+extern Entry ** newHashTable( void );
+extern Entry * hash_add( Entry **, char *, Entry * );
+extern Entry * hash_get( Entry **, char * );
+extern void hashStat( Entry ** );
+extern char * mystrdup( char * );
+extern void genLexDescr( void );
+extern void dumpLexClasses( FILE * );
+extern void genDefFile( void );
+extern void DumpListOfParmNames( char *, FILE *, int ); /* MR5 janm 26-May-97 */
+extern int DumpNextNameInDef( char **, FILE * );
+extern void DumpOldStyleParms( char *, FILE * );
+extern void DumpType( char *, FILE * );
+extern int strmember( char *, char * );
+/* extern int HasComma( char * ); MR23 Replaced by hasMultipleOperands() */
+extern void DumpRetValStruct( FILE *, char *, int );
+extern char * StripQuotes( char * );
+extern int main( int, char *[] );
+extern void readDescr( void );
+extern FILE * NextFile( void );
+extern char * outnameX( char *, char *);
+extern char * outname( char * );
+extern void fatalFL( char *, char *, int );
+extern void fatal_intern( char *, char *, int );
+extern void cleanUp( void );
+extern char * eMsg3( char *, char *, char *, char * );
+extern char * eMsgd( char *, int );
+extern char * eMsgd2( char *, int, int );
+extern void s_fprT( FILE *, set );
+extern char * TerminalString( int );
+extern void lexclass( char * );
+extern void lexmode( int );
+extern int LexClassIndex( char * );
+extern int hasAction( char * );
+extern void setHasAction( char *, char * );
+extern int addTname( char * );
+extern int addTexpr( char * );
+extern int Tnum( char * );
+extern void Tklink( char *, char * );
+extern Entry * newEntry( char *, int );
+extern void list_add( ListNode **, void * );
+extern void list_free( ListNode **, int freeData ); /* MR10 */
+extern void list_apply( ListNode *, void (*)(void *) );
+extern int list_search_cstring (ListNode *, char *); /* MR27 */
+extern char * Fkey( char *, int, int );
+extern void FoPush( char *, int );
+extern void FoPop( int );
+extern void RegisterCycle( char *, int );
+extern void ResolveFoCycles( int );
+extern void pJunc( Junction * );
+extern void pRuleRef( RuleRefNode * );
+extern void pToken( TokNode * );
+extern void pAction( ActionNode * );
+extern void FoLink( Node * );
+extern void addFoLink( Node *, char *, Junction * );
+extern void GenCrossRef( Junction * );
+extern void defErr( char *, long, long, long, long, long, long );
+extern void genStdPCCTSIncludeFile(FILE *,char *); /* MR10 */
+extern char * pcctsBaseName(char *); /* MR32 */
+extern Predicate *find_predicates(Node *); /* MR10 */
+extern Predicate *MR_find_predicates_and_supp(Node *); /* MR13 */
+extern int predicateLookaheadDepth(ActionNode *); /* MR10 */
+extern void predicate_free(Predicate *); /* MR10 */
+extern Predicate * predicate_dup(Predicate *); /* MR10 */
+extern Predicate * predicate_dup_without_context(Predicate *); /* MR11 */
+extern void GenRulePrototypes(FILE *, Junction *);
+extern Junction *first_item_is_guess_block(Junction *);
+extern Junction *first_item_is_guess_block_extra(Junction * q); /* MR30 */
+extern Junction *analysis_point(Junction *);
+extern Tree *make_tree_from_sets(set *, set *);
+extern Tree *tdup_chain(Tree *);
+extern Tree *tdif(Tree *, Predicate *, set *, set *);
+extern set covered_set(Predicate *);
+extern void AmbiguityDialog(Junction *, int, Junction *, Junction *, int *, int *);
+extern void dumpAmbigMsg(set *, FILE *, int);
+extern void GenRuleFuncRedefs(FILE *, Junction *);
+extern void GenPredefinedSymbolRedefs(FILE *);
+extern void GenASTSymbolRedefs(FILE *);
+extern void GenRemapFile(void);
+extern void GenSetRedefs(FILE *);
+extern ForcedToken *newForcedToken(char *, int);
+extern void RemapForcedTokens(void);
+extern char *TokenOrExpr(int);
+extern void setUpperRange(TokNode *, char *);
+extern void GenParser_c_Hdr(void);
+extern void GenParser_h_Hdr(void);
+extern void GenRuleMemberDeclarationsForCC(FILE *, Junction *);
+extern int addForcedTname( char *, int );
+extern char *OutMetaName(char *);
+extern void OutFirstSetSymbol(Junction *q, char *); /* MR21 */
+extern void warnNoFL(char *err);
+extern void warnFL(char *err,char *f,int l);
+extern void warn(char *err);
+extern void warnNoCR( char *err );
+extern void errNoFL(char *err);
+extern void errFL(char *err,char *f,int l);
+extern void err(char *err);
+extern void errNoCR( char *err );
+extern void genPredTree( Predicate *p, Node *j, int ,int);
+extern UserAction *newUserAction(char *);
+extern char *gate_symbol(char *name);
+extern char *makeAltID(int blockid, int altnum);
+extern void DumpRemainingTokSets(void);
+extern void DumpANSIFunctionArgDef(FILE *f, Junction *q, int bInit); /* MR23 */
+extern void DumpFormals(FILE *, char *, int bInit); /* MR23 */
+extern char* hideDefaultArgs(const char* pdecl); /* MR22 VHS */
+extern Predicate *computePredFromContextGuard(Graph,int *msgDone); /* MR21 */
+extern void recomputeContextGuard(Predicate *); /* MR13 */
+extern Predicate *new_pred(void);
+extern void chkGTFlag(void);
+extern void leAdd(LabelEntry *); /* MR7 */
+extern void leFixup(void); /* MR7 */
+extern void egAdd(ExceptionGroup *); /* MR7 */
+extern void egFixup(void); /* MR7 */
+extern void altAdd(Junction *); /* MR7 */
+extern void altFixup(void); /* MR7 */
+extern Predicate * MR_find_in_aSubBlk(Junction *alt); /* MR10 */
+extern Predicate * MR_predFlatten(Predicate *p); /* MR10 */
+extern Predicate * MR_predSimplifyALL(Predicate *p); /* MR10 */
+extern Predicate * MR_predSimplifyALLX(Predicate *p,int skipPass3); /* MR10 */
+extern int MR_allPredLeaves(Predicate *p); /* MR10 */
+extern void MR_cleanup_pred_trees(Predicate *p); /* MR10 */
+extern int MR_predicate_context_completed(Predicate *p); /* MR10 */
+extern void MR_check_pred_too_long(Predicate *p,set completion); /* MR10 */
+extern Tree * MR_remove_epsilon_from_tree(Tree *t); /* MR10 */
+extern Tree * MR_computeTreeAND(Tree *l,Tree *r); /* MR10 */
+extern int MR_tree_equ(Tree *big, Tree *small); /* MR10 */
+extern set MR_First(int ck,Junction *j,set *incomplete); /* MR10 */
+extern set MR_compute_pred_set(Predicate *p); /* MR10 */
+extern Tree * MR_compute_pred_tree_context(Predicate *p); /* MR10 */
+extern int MR_pointerStackPush(PointerStack *,void *); /* MR10 */
+extern void * MR_pointerStackPop(PointerStack *); /* MR10 */
+extern void * MR_pointerStackTop(PointerStack *); /* MR10 */
+extern void MR_pointerStackReset(PointerStack *); /* MR10 */
+extern void MR_backTraceReport(void); /* MR10 */
+extern void MR_alphaBetaTraceReport(void); /* MR14 */
+extern void MR_dumpRuleSet(set); /* MR14 */
+extern void MR_predContextPresent(Predicate *p,int *,int *); /* MR10 */
+extern void MR_dumpPred(Predicate *p,int withContext); /* MR10 */
+extern void MR_dumpPred1(int,Predicate *p,int withContext); /* MR10 */
+extern void MR_xxxIndent(FILE *f,int depth); /* MR11 */
+extern void MR_outputIndent(int depth); /* MR11 */
+extern void MR_stderrIndent(int depth); /* MR11 */
+extern Junction * MR_ruleReferenced(RuleRefNode *rrn); /* MR10 */
+extern Junction * MR_nameToRuleBlk(char *); /* MR10 */
+extern void MR_releaseResourcesUsedInRule(Node *); /* MR10 */
+extern void MR_dumpTreeX(int depth,Tree *t,int across); /* MR10 */
+extern void MR_dumpTreeF(FILE *f,int depth,Tree *t,int across); /* MR10 */
+extern void DumpFcache(void); /* MR10 */
+extern void MR_dumpTokenSet(FILE *f,int depth,set s); /* MR10 */
+extern void MR_traceAmbSource(set *,Junction *,Junction *); /* MR11 */
+extern void MR_traceAmbSourceK(Tree *,Junction *a1,Junction *a2); /* MR11 */
+extern void MR_traceAmbSourceKclient(void); /* MR20 */
+extern Node *MR_advance(Node *); /* MR11 */
+extern int MR_offsetFromRule(Node *); /* MR11 */
+extern char *MR_ruleNamePlusOffset(Node *); /* MR11 */
+extern int MR_max_height_of_tree(Tree *); /* MR11 */
+extern int MR_all_leaves_same_height(Tree *,int); /* MR11 */
+extern void MR_projectTreeOntoSet(Tree *t,int k,set *); /* MR11 */
+extern Tree *MR_make_tree_from_set(set); /* MR11 */
+extern Predicate *MR_removeRedundantPredPass3(Predicate *); /* MR11 */
+extern void MR_pred_depth(Predicate *,int *); /* MR11 */
+extern int MR_comparePredicates(Predicate *,Predicate *); /* MR11 */
+extern Predicate * MR_unfold(Predicate *); /* MR11 */
+extern void MR_simplifyInverted(Predicate *,int); /* MR11 */
+extern int MR_secondPredicateUnreachable /* MR11 */
+ (Predicate *first,Predicate *second); /* MR11 */
+extern void MR_clearPredEntry(Predicate *); /* MR11 */
+extern void MR_orphanRules(FILE *); /* MR12 */
+extern void MR_merge_contexts(Tree *); /* MR12 */
+extern int ci_strequ(char *,char *); /* MR12 */
+extern void MR_guardPred_plainSet(ActionNode *anode,Predicate *); /* MR12c */
+extern void MR_suppressSearchReport(void); /* MR12c */
+extern Predicate * MR_suppressK(Node *,Predicate *); /* MR13 */
+extern void MR_backTraceDumpItem(FILE *,int skip,Node *n); /* MR13 */
+extern void MR_backTraceDumpItemReset(void); /* MR13 */
+extern Junction * MR_junctionWithoutP2(Junction *); /* MR13 */
+extern void MR_setConstrainPointer(set *); /* MR18 */
+extern void BlockPreambleOption(Junction *q, char * pSymbol); /* MR23 */
+extern char* getInitializer(char *); /* MR23 */
+extern char *endFormal(char *pStart, /* MR23 */
+ char **ppDataType, /* MR23 */
+ char **ppSymbol, /* MR23 */
+ char **ppEqualSign, /* MR23 */
+ char **ppValue, /* MR23 */
+ char **ppSeparator, /* MR23 */
+ int *pNext); /* MR23 */
+extern char *strBetween(char *pStart, /* MR23 */
+ char *pNext, /* MR23 */
+ char *pStop); /* MR23 */
+extern int hasMultipleOperands(char *); /* MR23 */
+extern void DumpInitializers(FILE*, RuleEntry*, char*); /* MR23 */
+extern int isTermEntryTokClass(TermEntry *); /* MR23 */
+extern int isEmptyAlt(Node *, Node *); /* MR23 */
+#else
+extern int STRICMP();
+extern void istackreset();
+extern int istacksize();
+extern void pushint();
+extern int popint();
+extern int istackempty();
+extern int topint();
+extern void NewSetWd();
+extern void DumpSetWd();
+extern void DumpSetWdForC();
+extern void DumpSetWdForCC();
+extern void NewSet();
+extern void FillSet();
+extern void ComputeErrorSets();
+extern void ComputeTokSets();
+extern void SubstErrorClass();
+extern int DefErrSet();
+extern int DefErrSetForC();
+extern int DefErrSetForCC();
+extern int DefErrSet1();
+extern int DefErrSetForC1();
+extern int DefErrSetForCC1();
+extern int DefErrSetWithSuffix(); /* MR21 */
+extern void GenErrHdr();
+extern void dumpExpr();
+extern void addParm();
+extern Graph buildAction();
+extern Graph buildToken();
+extern Graph buildWildCard();
+extern Graph buildRuleRef();
+extern Graph Or();
+extern Graph Cat();
+extern Graph makeOpt();
+extern Graph makeBlk();
+extern Graph makeLoop();
+extern Graph makePlus();
+extern Graph emptyAlt();
+extern Graph emptyAlt3();
+extern TokNode * newTokNode();
+extern RuleRefNode * newRNode();
+extern Junction * newJunction();
+extern ActionNode * newActionNode();
+extern char * makelocks();
+extern void preorder();
+extern Tree * tnode();
+extern void _Tfree();
+extern Tree * tdup();
+extern int is_single_tuple();
+extern Tree * tappend();
+extern void Tfree();
+extern Tree * tlink();
+extern Tree * tshrink();
+extern Tree * tflatten();
+extern Tree * tJunc();
+extern Tree * tRuleRef();
+extern Tree * tToken();
+extern Tree * tAction();
+extern int tmember();
+extern int tmember_constrained();
+extern Tree * tleft_factor();
+extern Tree * trm_perm();
+extern void tcvt();
+extern Tree * permute();
+extern Tree * VerifyAmbig();
+extern set rJunc();
+extern set rRuleRef();
+extern set rToken();
+extern set rAction();
+extern void HandleAmbiguity();
+extern set First();
+extern void freeBlkFsets();
+extern void genAction();
+extern void genRuleRef();
+extern void genToken();
+extern void genOptBlk();
+extern void genLoopBlk();
+extern void genLoopBegin();
+extern void genPlusBlk();
+extern void genSubBlk();
+extern void genRule();
+extern void genJunction();
+extern void genEndBlk();
+extern void genEndRule();
+extern void genHdr();
+extern void genHdr1();
+extern void dumpAction();
+extern void dumpActionPlus(); /* MR21 */
+extern Entry ** newHashTable();
+extern Entry * hash_add();
+extern Entry * hash_get();
+extern void hashStat();
+extern char * mystrdup();
+extern void genLexDescr();
+extern void dumpLexClasses();
+extern void genDefFile();
+extern void DumpListOfParmNames(); /* MR5 janm 26-May-97 */
+extern int DumpNextNameInDef();
+extern void DumpOldStyleParms();
+extern void DumpType();
+extern int strmember();
+/* extern int HasComma(); MR23 Replaced by hasMultipleOperands() */
+extern void DumpRetValStruct();
+extern char * StripQuotes();
+extern int main();
+extern void readDescr();
+extern FILE * NextFile();
+extern char * outnameX();
+extern char * outname();
+extern void fatalFL();
+extern void fatal_intern();
+extern void cleanUp();
+extern char * eMsg3();
+extern char * eMsgd();
+extern char * eMsgd2();
+extern void s_fprT();
+extern char * TerminalString();
+extern void lexclass();
+extern void lexmode();
+extern int LexClassIndex();
+extern int hasAction();
+extern void setHasAction();
+extern int addTname();
+extern int addTexpr();
+extern int Tnum();
+extern void Tklink();
+extern Entry * newEntry();
+extern void list_add();
+extern void list_free(); /* MR10 */
+extern void list_apply();
+extern int list_search_cstring (); /* MR27 */
+extern char * Fkey();
+extern void FoPush();
+extern void FoPop();
+extern void RegisterCycle();
+extern void ResolveFoCycles();
+extern void pJunc();
+extern void pRuleRef();
+extern void pToken();
+extern void pAction();
+extern void FoLink();
+extern void addFoLink();
+extern void GenCrossRef();
+extern void defErr();
+extern void genStdPCCTSIncludeFile();
+extern char * pcctsBaseName(); /* MR32 */
+extern Predicate *find_predicates();
+extern Predicate *MR_find_predicates_and_supp(); /* MR13 */
+extern int predicateLookaheadDepth(); /* MR10 */
+extern void predicate_free(); /* MR10 */
+extern Predicate * predicate_dup(); /* MR10 */
+extern Predicate * predicate_dup_without_context(); /* MR11 */
+extern void GenRulePrototypes();
+extern Junction *first_item_is_guess_block();
+extern Junction *first_item_is_guess_block_extra(); /* MR30 */
+extern Junction *analysis_point();
+extern Tree *make_tree_from_sets();
+extern Tree *tdup_chain();
+extern Tree *tdif();
+extern set covered_set();
+extern void AmbiguityDialog();
+extern void dumpAmbigMsg();
+extern void GenRuleFuncRedefs();
+extern void GenPredefinedSymbolRedefs();
+extern void GenASTSymbolRedefs();
+extern void GenRemapFile();
+extern void GenSetRedefs();
+extern ForcedToken *newForcedToken();
+extern void RemapForcedTokens();
+extern char *TokenOrExpr();
+extern void setUpperRange();
+extern void GenParser_c_Hdr();
+extern void GenParser_h_Hdr();
+extern void GenRuleMemberDeclarationsForCC();
+extern int addForcedTname();
+extern char *OutMetaName();
+extern void OutFirstSetSymbol(); /* MR21 */
+extern void warnNoFL();
+extern void warnFL();
+extern void warn();
+extern void warnNoCR();
+extern void errNoFL();
+extern void errFL();
+extern void err();
+extern void errNoCR();
+extern void genPredTree();
+extern UserAction *newUserAction();
+extern char *gate_symbol();
+extern char *makeAltID();
+extern void DumpRemainingTokSets();
+extern void DumpANSIFunctionArgDef();
+extern void DumpFormals(); /* MR23 */
+extern char* hideDefaultArgs(); /* MR22 VHS */
+extern Predicate *computePredFromContextGuard();
+extern void recomputeContextGuard(); /* MR13 */
+extern Predicate *new_pred();
+extern void chkGTFlag();
+extern void leAdd(); /* MR7 */
+extern void leFixup(); /* MR7 */
+extern void egAdd(); /* MR7 */
+extern void egFixup(); /* MR7 */
+extern void altAdd(); /* MR7 */
+extern void altFixup(); /* MR7 */
+extern Predicate * MR_find_in_aSubBlk(); /* MR10 */
+extern Predicate * MR_predFlatten(); /* MR10 */
+extern Predicate * MR_predSimplifyALL(); /* MR10 */
+extern Predicate * MR_predSimplifyALLX(); /* MR10 */
+extern void MR_cleanup_pred_trees(); /* MR10 */
+extern int MR_allPredLeaves(); /* MR10 */
+extern int MR_predicate_context_completed(); /* MR10 */
+extern void MR_check_pred_too_long(); /* MR10 */
+extern Tree * MR_remove_epsilon_from_tree(); /* MR10 */
+extern Tree * MR_computeTreeAND(); /* MR10 */
+extern int MR_tree_equ(); /* MR10 */
+extern set MR_First(); /* MR10 */
+extern set MR_compute_pred_set(); /* MR10 */
+extern Tree * MR_compute_pred_tree_context(); /* MR10 */
+extern int MR_pointerStackPush(); /* MR10 */
+extern void * MR_pointerStackPop(); /* MR10 */
+extern void * MR_pointerStackTop(); /* MR10 */
+extern void MR_pointerStackReset(); /* MR10 */
+extern void MR_backTraceReport(); /* MR10 */
+extern void MR_alphaBetaTraceReport(); /* MR14 */
+extern void MR_dumpRuleSet(); /* MR14 */
+extern void MR_predContextPresent(); /* MR10 */
+extern void MR_dumpPred(); /* MR10 */
+extern void MR_dumpPred1(); /* MR10 */
+extern void MR_xxxIndent(); /* MR11 */
+extern void MR_stderrIndent(); /* MR11 */
+extern void MR_outputIndent(); /* MR11 */
+extern Junction * MR_ruleReferenced(); /* MR10 */
+extern void MR_releaseResourcesUsedInRule(); /* MR10 */
+extern void MR_dumpTreeX(); /* MR10 */
+extern void MR_dumpTreeF(); /* MR10 */
+extern void DumpFcache(); /* MR10 */
+extern void MR_dumpTokenSet(); /* MR10 */
+extern void MR_traceAmbSource(); /* MR11 */
+extern Node *MR_advance(); /* MR11 */
+extern int MR_offsetFromRule(); /* MR11 */
+extern char *MR_ruleNamePlusOffset(); /* MR11 */
+extern void MR_traceAmbSourceK(); /* MR11 */
+extern void MR_traceAmbSourceKclient(); /* [i_a] added */
+extern int MR_max_height_of_tree(); /* MR11 */
+extern int MR_all_leaves_same_height(); /* MR11 */
+extern void MR_projectTreeOntoSet(); /* MR11 */
+extern Tree *MR_make_tree_from_set(); /* MR11 */
+extern Predicate *MR_removeRedundantPredPass3(); /* MR11 */
+extern void MR_pred_depth(); /* MR11 */
+extern int MR_comparePredicates(); /* MR11 */
+extern Predicate * MR_unfold(); /* MR11 */
+extern void MR_simplifyInverted(); /* MR11 */
+extern int MR_secondPredicateUnreachable(); /* MR11 */
+extern Junction * MR_nameToRuleBlk(); /* MR10 */
+extern void MR_clearPredEntry(); /* MR11 */
+extern void MR_orphanRules(); /* MR12 */
+extern void MR_merge_contexts(); /* MR12 */
+extern int ci_strequ(); /* MR12 */
+extern void MR_guardPred_plainSet(); /* MR12c */
+extern void MR_suppressSearchReport(); /* MR12c */
+extern Predicate * MR_suppressK(); /* MR13 */
+extern void MR_backTraceDumpItem(); /* MR13 */
+extern void MR_backTraceDumpItemReset(); /* MR13 */
+extern Junction * MR_junctionWithoutP2(); /* MR13 */
+extern void MR_setConstrainPointer(); /* MR18 */
+extern void BlockPreambleOption(); /* MR23 */
+extern char* getInitializer(); /* MR23 */
+extern int hasMultipleOperands(); /* MR23 */
+extern char *endFormal(); /* MR23 */
+extern char *strBetween(); /* MR23 */
+extern void DumpInitializers(); /* MR23 */
+extern int isTermEntryTokClass(); /* MR23 */
+extern int isEmptyAlt();
+
+#endif
+
+#ifdef __USE_PROTOS
+#include <stdlib.h>
+#endif
+
+/* MR20 G. Hobbelt Create proper externs for dlg variables */
+
+extern set attribsRefdFromAction;
+extern int inAlt;
+extern int UsedOldStyleAttrib;
+extern int UsedNewStyleLabel;
+
+#define MAX_BLK_LEVEL 100 /* MR23 */
+extern int CurBlockID_array[MAX_BLK_LEVEL]; /* MR23 */
+extern int CurAltNum_array[MAX_BLK_LEVEL]; /* MR23 */
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/scan.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/scan.c new file mode 100644 index 0000000000..9b4bde08e6 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/scan.c @@ -0,0 +1,5735 @@ +
+/* parser.dlg -- DLG Description of scanner
+ *
+ * Generated from: antlr.g
+ *
+ * Terence Parr, Will Cohen, and Hank Dietz: 1989-2001
+ * Purdue University Electrical Engineering
+ * With AHPCRC, University of Minnesota
+ * ANTLR Version 1.33MR33
+ */
+
+#define ANTLR_VERSION 13333
+#include "pcctscfg.h"
+#include "pccts_stdio.h"
+
+#include "pcctscfg.h"
+#include "set.h"
+#include <ctype.h>
+#include "syn.h"
+#include "hash.h"
+#include "generic.h"
+#define zzcr_attr(attr,tok,t)
+#include "antlr.h"
+#include "tokens.h"
+#include "dlgdef.h"
+LOOKAHEAD
+
+void
+#ifdef __USE_PROTOS
+zzerraction(void)
+#else
+zzerraction()
+#endif
+{
+ (*zzerr)("invalid token");
+ zzadvance();
+ zzskip();
+}
+/*
+ * D L G tables
+ *
+ * Generated from: parser.dlg
+ *
+ * 1989-2001 by Will Cohen, Terence Parr, and Hank Dietz
+ * Purdue University Electrical Engineering
+ * DLG Version 1.33MR33
+ */
+
+#include "mode.h"
+
+
+
+
+/* maintained, but not used for now */
+set AST_nodes_refd_in_actions = set_init;
+int inAlt = 0;
+set attribsRefdFromAction = set_init; /* MR20 */
+int UsedOldStyleAttrib = 0;
+int UsedNewStyleLabel = 0;
+#ifdef __USE_PROTOS
+char *inline_set(char *);
+#else
+char *inline_set();
+#endif
+
+/* MR1 10-Apr-97 MR1 Previously unable to put right shift operator */
+/* MR1 in DLG action */
+
+int tokenActionActive=0; /* MR1 */
+
+
+
+
+
+static char *
+#ifdef __USE_PROTOS
+getFileNameFromTheLineInfo(char *toStr, char *fromStr)
+#else
+getFileNameFromTheLineInfo(toStr, fromStr)
+char *toStr, *fromStr;
+#endif
+{
+ int i, j, k;
+
+ if (!fromStr || !toStr) return toStr;
+
+ /* find the first " */
+
+ for (i=0;
+ (i<MaxFileName) &&
+ (fromStr[i] != '\n') &&
+ (fromStr[i] != '\r') &&
+ (fromStr[i] != '\"');
+ i++) /* nothing */ ;
+
+ if ( (i == MaxFileName) ||
+ (fromStr[i] == '\n') ||
+ (fromStr[i] == '\r') ) {
+ return toStr;
+}
+
+ /* find the second " */
+
+ for (j=i+1;
+(j<MaxFileName) &&
+(fromStr[j] != '\n') &&
+(fromStr[j] != '\r') &&
+(fromStr[j] != '\"');
+j++) /* nothing */ ;
+
+ if ((j == MaxFileName) ||
+(fromStr[j] == '\n') ||
+(fromStr[j] == '\r') ) {
+ return toStr;
+}
+
+ /* go back until the last / or \ */
+
+ for (k=j-1;
+(fromStr[k] != '\"') &&
+(fromStr[k] != '/') &&
+(fromStr[k] != '\\');
+k--) /* nothing */ ;
+
+ /* copy the string after " / or \ into toStr */
+
+ for (i=k+1; fromStr[i] != '\"'; i++) {
+toStr[i-k-1] = fromStr[i];
+}
+
+ toStr[i-k-1] = '\0';
+
+ return toStr;
+}
+
+/* MR14 end of a block to support #line in antlr source code */
+
+
+
+
+#ifdef __USE_PROTOS
+void mark_label_used_in_sem_pred(LabelEntry *le) /* MR10 */
+#else
+void mark_label_used_in_sem_pred(le) /* MR10 */
+LabelEntry *le;
+#endif
+{
+ TokNode *tn;
+ require (le->elem->ntype == nToken,"mark_label_used... ntype != nToken");
+ tn=(TokNode *)le->elem;
+ require (tn->label != 0,"mark_label_used... TokNode has no label");
+ tn->label_used_in_semantic_pred=1;
+}
+
+static void act1()
+{
+ NLA = Eof;
+ /* L o o k F o r A n o t h e r F i l e */
+ {
+ FILE *new_input;
+ new_input = NextFile();
+ if ( new_input == NULL ) { NLA=Eof; return; }
+ fclose( input );
+ input = new_input;
+ zzrdstream( input );
+ zzskip(); /* Skip the Eof (@) char i.e continue */
+ }
+ }
+
+
+static void act2()
+{
+ NLA = 76;
+ zzskip();
+ }
+
+
+static void act3()
+{
+ NLA = 77;
+ zzline++; zzskip();
+ }
+
+
+static void act4()
+{
+ NLA = 78;
+ zzmode(ACTIONS); zzmore();
+ istackreset();
+ pushint(']');
+ }
+
+
+static void act5()
+{
+ NLA = 79;
+ action_file=CurFile; action_line=zzline;
+ zzmode(ACTIONS); zzmore();
+ list_free(&CurActionLabels,0); /* MR10 */
+ numericActionLabel=0; /* MR10 */
+ istackreset();
+ pushint('>');
+ }
+
+
+static void act6()
+{
+ NLA = 80;
+ zzmode(STRINGS); zzmore();
+ }
+
+
+static void act7()
+{
+ NLA = 81;
+ zzmode(COMMENTS); zzskip();
+ }
+
+
+static void act8()
+{
+ NLA = 82;
+ warn("Missing /*; found dangling */"); zzskip();
+ }
+
+
+static void act9()
+{
+ NLA = 83;
+ zzmode(CPP_COMMENTS); zzskip();
+ }
+
+
+static void act10()
+{
+ NLA = 84;
+
+ zzline = atoi(zzbegexpr+5) - 1; zzline++; zzmore();
+ getFileNameFromTheLineInfo(FileStr[CurFile], zzbegexpr);
+ }
+
+
+static void act11()
+{
+ NLA = 85;
+
+ zzline++; zzmore();
+ }
+
+
+static void act12()
+{
+ NLA = 86;
+ warn("Missing <<; found dangling >>"); zzskip();
+ }
+
+
+static void act13()
+{
+ NLA = WildCard;
+ }
+
+
+static void act14()
+{
+ NLA = 88;
+ FoundException = 1; /* MR6 */
+ FoundAtOperator = 1;
+ }
+
+
+static void act15()
+{
+ NLA = Pragma;
+ }
+
+
+static void act16()
+{
+ NLA = FirstSetSymbol;
+ }
+
+
+static void act17()
+{
+ NLA = 94;
+ }
+
+
+static void act18()
+{
+ NLA = 95;
+ }
+
+
+static void act19()
+{
+ NLA = 96;
+ }
+
+
+static void act20()
+{
+ NLA = 97;
+ }
+
+
+static void act21()
+{
+ NLA = 98;
+ }
+
+
+static void act22()
+{
+ NLA = 99;
+ }
+
+
+static void act23()
+{
+ NLA = 102;
+ }
+
+
+static void act24()
+{
+ NLA = 103;
+ }
+
+
+static void act25()
+{
+ NLA = 104;
+ }
+
+
+static void act26()
+{
+ NLA = 105;
+ }
+
+
+static void act27()
+{
+ NLA = 106;
+ }
+
+
+static void act28()
+{
+ NLA = 107;
+ }
+
+
+static void act29()
+{
+ NLA = 108;
+ }
+
+
+static void act30()
+{
+ NLA = 109;
+ }
+
+
+static void act31()
+{
+ NLA = 110;
+ }
+
+
+static void act32()
+{
+ NLA = 111;
+ }
+
+
+static void act33()
+{
+ NLA = 112;
+ }
+
+
+static void act34()
+{
+ NLA = 113;
+ }
+
+
+static void act35()
+{
+ NLA = 114;
+ }
+
+
+static void act36()
+{
+ NLA = 115;
+ }
+
+
+static void act37()
+{
+ NLA = 116;
+ }
+
+
+static void act38()
+{
+ NLA = 117;
+ }
+
+
+static void act39()
+{
+ NLA = 118;
+ }
+
+
+static void act40()
+{
+ NLA = 119;
+ }
+
+
+static void act41()
+{
+ NLA = 120;
+ }
+
+
+static void act42()
+{
+ NLA = 121;
+ }
+
+
+static void act43()
+{
+ NLA = 122;
+ }
+
+
+static void act44()
+{
+ NLA = 123;
+ }
+
+
+static void act45()
+{
+ NLA = 124;
+ }
+
+
+static void act46()
+{
+ NLA = 125;
+ }
+
+
+static void act47()
+{
+ NLA = 126;
+ }
+
+
+static void act48()
+{
+ NLA = 127;
+ }
+
+
+static void act49()
+{
+ NLA = 128;
+ }
+
+
+static void act50()
+{
+ NLA = 129;
+ }
+
+
+static void act51()
+{
+ NLA = 130;
+ }
+
+
+static void act52()
+{
+ NLA = 131;
+ }
+
+
+static void act53()
+{
+ NLA = 132;
+ }
+
+
+static void act54()
+{
+ NLA = 133;
+ }
+
+
+static void act55()
+{
+ NLA = 134;
+ }
+
+
+static void act56()
+{
+ NLA = 135;
+ }
+
+
+static void act57()
+{
+ NLA = NonTerminal;
+
+ while ( zzchar==' ' || zzchar=='\t' ) {
+ zzadvance();
+ }
+ if ( zzchar == ':' && inAlt ) NLA = LABEL;
+ }
+
+
+static void act58()
+{
+ NLA = TokenTerm;
+
+ while ( zzchar==' ' || zzchar=='\t' ) {
+ zzadvance();
+ }
+ if ( zzchar == ':' && inAlt ) NLA = LABEL;
+ }
+
+
+static void act59()
+{
+ NLA = 136;
+ warn(eMsg1("unknown meta-op: %s",LATEXT(1))); zzskip();
+ }
+
+static unsigned char shift0[257] = {
+ 0, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 1, 2, 58, 58, 3, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 1, 40, 6, 9, 58, 58, 45,
+ 58, 46, 47, 8, 52, 58, 58, 18, 7, 16,
+ 14, 15, 16, 16, 16, 16, 16, 16, 16, 41,
+ 42, 5, 48, 17, 53, 19, 56, 56, 56, 56,
+ 56, 26, 56, 56, 56, 56, 56, 51, 56, 56,
+ 56, 56, 56, 56, 29, 56, 56, 56, 56, 56,
+ 56, 56, 4, 20, 58, 50, 57, 58, 23, 31,
+ 38, 34, 13, 35, 24, 33, 11, 55, 36, 10,
+ 25, 12, 32, 21, 55, 22, 27, 28, 54, 55,
+ 55, 43, 30, 55, 39, 44, 37, 49, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58
+};
+
+
+static void act60()
+{
+ NLA = Eof;
+ }
+
+
+static void act61()
+{
+ NLA = QuotedTerm;
+ zzmode(START);
+ }
+
+
+static void act62()
+{
+ NLA = 3;
+
+ zzline++;
+ warn("eoln found in string");
+ zzskip();
+ }
+
+
+static void act63()
+{
+ NLA = 4;
+ zzline++; zzmore();
+ }
+
+
+static void act64()
+{
+ NLA = 5;
+ zzmore();
+ }
+
+
+static void act65()
+{
+ NLA = 6;
+ zzmore();
+ }
+
+static unsigned char shift1[257] = {
+ 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 2, 5, 5, 3, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 1, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 4, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5
+};
+
+
+static void act66()
+{
+ NLA = Eof;
+ }
+
+
+static void act67()
+{
+ NLA = 7;
+ zzmode(ACTIONS); zzmore();
+ }
+
+
+static void act68()
+{
+ NLA = 8;
+
+ zzline++;
+ warn("eoln found in string (in user action)");
+ zzskip();
+ }
+
+
+static void act69()
+{
+ NLA = 9;
+ zzline++; zzmore();
+ }
+
+
+static void act70()
+{
+ NLA = 10;
+ zzmore();
+ }
+
+
+static void act71()
+{
+ NLA = 11;
+ zzmore();
+ }
+
+static unsigned char shift2[257] = {
+ 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 2, 5, 5, 3, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 1, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 4, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5
+};
+
+
+static void act72()
+{
+ NLA = Eof;
+ }
+
+
+static void act73()
+{
+ NLA = 12;
+ zzmode(ACTIONS); zzmore();
+ }
+
+
+static void act74()
+{
+ NLA = 13;
+
+ zzline++;
+ warn("eoln found in char literal (in user action)");
+ zzskip();
+ }
+
+
+static void act75()
+{
+ NLA = 14;
+ zzmore();
+ }
+
+
+static void act76()
+{
+ NLA = 15;
+ zzmore();
+ }
+
+static unsigned char shift3[257] = {
+ 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 2, 5, 5, 3, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 1, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 4, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5
+};
+
+
+static void act77()
+{
+ NLA = Eof;
+ }
+
+
+static void act78()
+{
+ NLA = 16;
+ zzmode(ACTIONS); zzmore();
+ }
+
+
+static void act79()
+{
+ NLA = 17;
+ zzmore();
+ }
+
+
+static void act80()
+{
+ NLA = 18;
+ zzline++; zzmore(); DAWDLE;
+ }
+
+
+static void act81()
+{
+ NLA = 19;
+ zzmore();
+ }
+
+static unsigned char shift4[257] = {
+ 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 3, 5, 5, 4, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 1, 5, 5, 5, 5, 2, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5
+};
+
+
+static void act82()
+{
+ NLA = Eof;
+ }
+
+
+static void act83()
+{
+ NLA = 20;
+ zzmode(PARSE_ENUM_FILE);
+ zzmore();
+ }
+
+
+static void act84()
+{
+ NLA = 21;
+ zzmore();
+ }
+
+
+static void act85()
+{
+ NLA = 22;
+ zzline++; zzmore(); DAWDLE;
+ }
+
+
+static void act86()
+{
+ NLA = 23;
+ zzmore();
+ }
+
+static unsigned char shift5[257] = {
+ 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 3, 5, 5, 4, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 1, 5, 5, 5, 5, 2, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5
+};
+
+
+static void act87()
+{
+ NLA = Eof;
+ }
+
+
+static void act88()
+{
+ NLA = 24;
+ zzline++; zzmode(PARSE_ENUM_FILE); zzskip(); DAWDLE;
+ }
+
+
+static void act89()
+{
+ NLA = 25;
+ zzskip();
+ }
+
+static unsigned char shift6[257] = {
+ 0, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 1, 3, 3, 2, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3
+};
+
+
+static void act90()
+{
+ NLA = Eof;
+ }
+
+
+static void act91()
+{
+ NLA = 26;
+ zzline++; zzmode(ACTIONS); zzmore(); DAWDLE;
+ }
+
+
+static void act92()
+{
+ NLA = 27;
+ zzmore();
+ }
+
+static unsigned char shift7[257] = {
+ 0, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 1, 3, 3, 2, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3
+};
+
+
+static void act93()
+{
+ NLA = Eof;
+ }
+
+
+static void act94()
+{
+ NLA = 28;
+ zzline++; zzmode(START); zzskip(); DAWDLE;
+ }
+
+
+static void act95()
+{
+ NLA = 29;
+ zzskip();
+ }
+
+static unsigned char shift8[257] = {
+ 0, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 1, 3, 3, 2, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3
+};
+
+
+static void act96()
+{
+ NLA = Eof;
+ }
+
+
+static void act97()
+{
+ NLA = 30;
+ zzmode(START); zzskip();
+ }
+
+
+static void act98()
+{
+ NLA = 31;
+ zzskip();
+ }
+
+
+static void act99()
+{
+ NLA = 32;
+ zzline++; zzskip(); DAWDLE;
+ }
+
+
+static void act100()
+{
+ NLA = 33;
+ zzskip();
+ }
+
+static unsigned char shift9[257] = {
+ 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 3, 5, 5, 4, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 1, 5, 5, 5, 5, 2, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5
+};
+
+
+static void act101()
+{
+ NLA = Eof;
+ }
+
+
+static void act102()
+{
+ NLA = Action;
+ /* these do not nest */
+ zzmode(START);
+ NLATEXT[0] = ' ';
+ NLATEXT[1] = ' ';
+ zzbegexpr[0] = ' ';
+ zzbegexpr[1] = ' ';
+ if ( zzbufovf ) {
+ err( eMsgd("action buffer overflow; size %d",ZZLEXBUFSIZE));
+ }
+
+/* MR1 10-Apr-97 MR1 Previously unable to put right shift operator */
+ /* MR1 in DLG action */
+ /* MR1 Doesn't matter what kind of action it is - reset*/
+
+ tokenActionActive=0; /* MR1 */
+ }
+
+
+static void act103()
+{
+ NLA = Pred;
+ /* these do not nest */
+ zzmode(START);
+ NLATEXT[0] = ' ';
+ NLATEXT[1] = ' ';
+ zzbegexpr[0] = '\0';
+ if ( zzbufovf ) {
+ err( eMsgd("predicate buffer overflow; size %d",ZZLEXBUFSIZE));
+ };
+#ifdef __cplusplus__
+ /* MR10 */ list_apply(CurActionLabels, (void (*)(void *))mark_label_used_in_sem_pred);
+#else
+#ifdef __STDC__
+ /* MR10 */ list_apply(CurActionLabels, (void (*)(void *))mark_label_used_in_sem_pred);
+#else
+#ifdef __USE_PROTOS
+ /* MRxx */ list_apply(CurActionLabels, (void (*)(void *))mark_label_used_in_sem_pred);
+#else
+ /* MR10 */ list_apply(CurActionLabels,mark_label_used_in_sem_pred);
+#endif
+#endif
+#endif
+ }
+
+
+static void act104()
+{
+ NLA = PassAction;
+ if ( topint() == ']' ) {
+ popint();
+ if ( istackempty() ) /* terminate action */
+ {
+ zzmode(START);
+ NLATEXT[0] = ' ';
+ zzbegexpr[0] = ' ';
+ if ( zzbufovf ) {
+ err( eMsgd("parameter buffer overflow; size %d",ZZLEXBUFSIZE));
+ }
+ }
+ else {
+ /* terminate $[..] and #[..] */
+ if ( GenCC ) zzreplstr("))");
+ else zzreplstr(")");
+ zzmore();
+ }
+ }
+ else if ( topint() == '|' ) { /* end of simple [...] */
+ popint();
+ zzmore();
+ }
+ else zzmore();
+ }
+
+
+static void act105()
+{
+ NLA = 37;
+
+ zzmore();
+ zzreplstr(inline_set(zzbegexpr+
+ strlen("consumeUntil(")));
+ }
+
+
+static void act106()
+{
+ NLA = 38;
+ zzmore();
+ }
+
+
+static void act107()
+{
+ NLA = 39;
+ zzline++; zzmore(); DAWDLE;
+ }
+
+
+static void act108()
+{
+ NLA = 40;
+ zzmore();
+ }
+
+
+static void act109()
+{
+ NLA = 41;
+ zzmore();
+ }
+
+
+static void act110()
+{
+ NLA = 42;
+ if ( !GenCC ) {zzreplstr("zzaRet"); zzmore();}
+ else err("$$ use invalid in C++ mode");
+ }
+
+
+static void act111()
+{
+ NLA = 43;
+ if ( !GenCC ) {zzreplstr("zzempty_attr"); zzmore();}
+ else err("$[] use invalid in C++ mode");
+ }
+
+
+static void act112()
+{
+ NLA = 44;
+
+ pushint(']');
+ if ( !GenCC ) zzreplstr("zzconstr_attr(");
+ else err("$[..] use invalid in C++ mode");
+ zzmore();
+ }
+
+
+static void act113()
+{
+ NLA = 45;
+ {
+ static char buf[100];
+ numericActionLabel=1; /* MR10 */
+ if ( strlen(zzbegexpr)>(size_t)85 )
+ fatal("$i attrib ref too big");
+ set_orel(atoi(zzbegexpr+1), &attribsRefdFromAction);
+ if ( !GenCC ) sprintf(buf,"zzaArg(zztasp%d,%s)",
+ BlkLevel-1,zzbegexpr+1);
+ else sprintf(buf,"_t%d%s",
+ BlkLevel-1,zzbegexpr+1);
+ zzreplstr(buf);
+ zzmore();
+ UsedOldStyleAttrib = 1;
+ if ( UsedNewStyleLabel )
+ err("cannot mix old-style $i with new-style labels");
+ }
+ }
+
+
+static void act114()
+{
+ NLA = 46;
+ {
+ static char buf[100];
+ numericActionLabel=1; /* MR10 */
+ if ( strlen(zzbegexpr)>(size_t)85 )
+ fatal("$i.field attrib ref too big");
+ zzbegexpr[strlen(zzbegexpr)-1] = ' ';
+ set_orel(atoi(zzbegexpr+1), &attribsRefdFromAction);
+ if ( !GenCC ) sprintf(buf,"zzaArg(zztasp%d,%s).",
+ BlkLevel-1,zzbegexpr+1);
+ else sprintf(buf,"_t%d%s.",
+ BlkLevel-1,zzbegexpr+1);
+ zzreplstr(buf);
+ zzmore();
+ UsedOldStyleAttrib = 1;
+ if ( UsedNewStyleLabel )
+ err("cannot mix old-style $i with new-style labels");
+ }
+ }
+
+
+static void act115()
+{
+ NLA = 47;
+ {
+ static char buf[100];
+ static char i[20], j[20];
+ char *p,*q;
+ numericActionLabel=1; /* MR10 */
+ if (strlen(zzbegexpr)>(size_t)85) fatal("$i.j attrib ref too big");
+ for (p=zzbegexpr+1,q= &i[0]; *p!='.'; p++) {
+ if ( q == &i[20] )
+ fatalFL("i of $i.j attrib ref too big",
+ FileStr[CurFile], zzline );
+ *q++ = *p;
+ }
+ *q = '\0';
+ for (p++, q= &j[0]; *p!='\0'; p++) {
+ if ( q == &j[20] )
+ fatalFL("j of $i.j attrib ref too big",
+ FileStr[CurFile], zzline );
+ *q++ = *p;
+ }
+ *q = '\0';
+ if ( !GenCC ) sprintf(buf,"zzaArg(zztasp%s,%s)",i,j);
+ else sprintf(buf,"_t%s%s",i,j);
+ zzreplstr(buf);
+ zzmore();
+ UsedOldStyleAttrib = 1;
+ if ( UsedNewStyleLabel )
+ err("cannot mix old-style $i with new-style labels");
+ }
+ }
+
+
+static void act116()
+{
+ NLA = 48;
+ { static char buf[300]; LabelEntry *el;
+ zzbegexpr[0] = ' ';
+ if ( CurRule != NULL &&
+ strcmp(CurRule, &zzbegexpr[1])==0 ) {
+ if ( !GenCC ) zzreplstr("zzaRet");
+ }
+ else if ( CurRetDef != NULL &&
+ strmember(CurRetDef, &zzbegexpr[1])) {
+ if ( hasMultipleOperands( CurRetDef ) ) {
+ require (strlen(zzbegexpr)<=(size_t)285,
+ "$retval attrib ref too big");
+ sprintf(buf,"_retv.%s",&zzbegexpr[1]);
+ zzreplstr(buf);
+ }
+ else zzreplstr("_retv");
+ }
+ else if ( CurParmDef != NULL &&
+ strmember(CurParmDef, &zzbegexpr[1])) {
+ ;
+ }
+ else if ( Elabel==NULL ) {
+ { err("$-variables in actions outside of rules are not allowed"); }
+ } else if ( (el=(LabelEntry *)hash_get(Elabel, &zzbegexpr[1]))!=NULL ) {
+ /* MR10 */
+ /* MR10 */ /* element labels might exist without an elem when */
+ /* MR10 */ /* it is a forward reference (to a rule) */
+ /* MR10 */
+ /* MR10 */ if ( GenCC && (el->elem == NULL || el->elem->ntype==nRuleRef) )
+ /* MR10 */ { err(eMsg1("There are no token ptrs for rule references: '$%s'",&zzbegexpr[1])); }
+ /* MR10 */
+ /* MR10 */ if ( !GenCC && (el->elem == NULL || el->elem->ntype==nRuleRef) && GenAST) {
+ /* MR10 */ err("You can no longer use attributes returned by rules when also using ASTs");
+ /* MR10 */ err(" Use upward inheritance (\"rule >[Attrib a] : ... <<$a=...>>\")");
+ /* MR10 */ };
+ /* MR10 */
+ /* MR10 */ /* keep track of <<... $label ...>> for semantic predicates in guess mode */
+ /* MR10 */ /* element labels contain pointer to the owners node */
+ /* MR10 */
+ /* MR10 */ if (el->elem != NULL && el->elem->ntype == nToken) {
+ /* MR10 */ list_add(&CurActionLabels,el);
+ /* MR10 */ };
+}
+else
+warn(eMsg1("$%s not parameter, return value, (defined) element label",&zzbegexpr[1]));
+}
+zzmore();
+ }
+
+
+static void act117()
+{
+ NLA = 49;
+ zzreplstr("(*_root)"); zzmore(); chkGTFlag();
+ }
+
+
+static void act118()
+{
+ NLA = 50;
+ if ( GenCC ) {
+ if (NewAST) zzreplstr("(newAST)");
+ else zzreplstr("(new AST)");}
+ else {zzreplstr("zzastnew()");} zzmore();
+ chkGTFlag();
+ }
+
+
+static void act119()
+{
+ NLA = 51;
+ zzreplstr("NULL"); zzmore(); chkGTFlag();
+ }
+
+
+static void act120()
+{
+ NLA = 52;
+ {
+ static char buf[100];
+ if ( strlen(zzbegexpr)>(size_t)85 )
+ fatal("#i AST ref too big");
+ if ( GenCC ) sprintf(buf,"_ast%d%s",BlkLevel-1,zzbegexpr+1);
+ else sprintf(buf,"zzastArg(%s)",zzbegexpr+1);
+ zzreplstr(buf);
+ zzmore();
+ set_orel(atoi(zzbegexpr+1), &AST_nodes_refd_in_actions);
+ chkGTFlag();
+ }
+ }
+
+
+static void act121()
+{
+ NLA = 53;
+
+ zzline = atoi(zzbegexpr+5) - 1; zzline++; zzmore();
+ getFileNameFromTheLineInfo(FileStr[CurFile], zzbegexpr);
+ }
+
+
+static void act122()
+{
+ NLA = 54;
+
+ zzline++; zzmore();
+ }
+
+
+static void act123()
+{
+ NLA = 55;
+
+ if ( !(strcmp(zzbegexpr, "#ifdef")==0 ||
+ strcmp(zzbegexpr, "#if")==0 ||
+ strcmp(zzbegexpr, "#else")==0 ||
+ strcmp(zzbegexpr, "#endif")==0 ||
+ strcmp(zzbegexpr, "#ifndef")==0 ||
+ strcmp(zzbegexpr, "#define")==0 ||
+ strcmp(zzbegexpr, "#pragma")==0 ||
+ strcmp(zzbegexpr, "#undef")==0 ||
+ strcmp(zzbegexpr, "#import")==0 ||
+ strcmp(zzbegexpr, "#line")==0 ||
+ strcmp(zzbegexpr, "#include")==0 ||
+ strcmp(zzbegexpr, "#error")==0) )
+ {
+ static char buf[100];
+ sprintf(buf, "%s_ast", zzbegexpr+1);
+ /* MR27 */ list_add(&CurAstLabelsInActions, mystrdup(zzbegexpr+1));
+ zzreplstr(buf);
+ chkGTFlag();
+ }
+ zzmore();
+ }
+
+
+static void act124()
+{
+ NLA = 56;
+
+ pushint(']');
+ if ( GenCC ) {
+ if (NewAST) zzreplstr("(newAST(");
+ else zzreplstr("(new AST("); }
+ else zzreplstr("zzmk_ast(zzastnew(),");
+ zzmore();
+ chkGTFlag();
+ }
+
+
+static void act125()
+{
+ NLA = 57;
+
+ pushint('}');
+ if ( GenCC ) {
+ if (tmakeInParser) {
+ zzreplstr("tmake(");
+ }
+ else {
+ zzreplstr("ASTBase::tmake(");
+ }
+ }
+ else {
+ zzreplstr("zztmake(");
+ }
+ zzmore();
+ chkGTFlag();
+ }
+
+
+static void act126()
+{
+ NLA = 58;
+ zzmore();
+ }
+
+
+static void act127()
+{
+ NLA = 59;
+
+ if ( istackempty() )
+ zzmore();
+ else if ( topint()==')' ) {
+ popint();
+ }
+ else if ( topint()=='}' ) {
+ popint();
+ /* terminate #(..) */
+ zzreplstr(", NULL)");
+ }
+ zzmore();
+ }
+
+
+static void act128()
+{
+ NLA = 60;
+
+ pushint('|'); /* look for '|' to terminate simple [...] */
+ zzmore();
+ }
+
+
+static void act129()
+{
+ NLA = 61;
+
+ pushint(')');
+ zzmore();
+ }
+
+
+static void act130()
+{
+ NLA = 62;
+ zzreplstr("]"); zzmore();
+ }
+
+
+static void act131()
+{
+ NLA = 63;
+ zzreplstr(")"); zzmore();
+ }
+
+
+static void act132()
+{
+ NLA = 64;
+ if (! tokenActionActive) zzreplstr(">"); /* MR1 */
+ zzmore(); /* MR1 */
+ }
+
+
+static void act133()
+{
+ NLA = 65;
+ zzmode(ACTION_CHARS); zzmore();
+ }
+
+
+static void act134()
+{
+ NLA = 66;
+ zzmode(ACTION_STRINGS); zzmore();
+ }
+
+
+static void act135()
+{
+ NLA = 67;
+ zzreplstr("$"); zzmore();
+ }
+
+
+static void act136()
+{
+ NLA = 68;
+ zzreplstr("#"); zzmore();
+ }
+
+
+static void act137()
+{
+ NLA = 69;
+ zzline++; zzmore();
+ }
+
+
+static void act138()
+{
+ NLA = 70;
+ zzmore();
+ }
+
+
+static void act139()
+{
+ NLA = 71;
+ zzmore();
+ }
+
+
+static void act140()
+{
+ NLA = 72;
+ zzmode(ACTION_COMMENTS); zzmore();
+ }
+
+
+static void act141()
+{
+ NLA = 73;
+ warn("Missing /*; found dangling */ in action"); zzmore();
+ }
+
+
+static void act142()
+{
+ NLA = 74;
+ zzmode(ACTION_CPP_COMMENTS); zzmore();
+ }
+
+
+static void act143()
+{
+ NLA = 75;
+ zzmore();
+ }
+
+static unsigned char shift10[257] = {
+ 0, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 16, 19, 33, 33, 20, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 16, 33, 28, 27, 21, 33, 33,
+ 30, 15, 18, 32, 33, 33, 33, 25, 31, 23,
+ 24, 24, 24, 24, 24, 24, 24, 24, 24, 33,
+ 33, 33, 33, 1, 2, 33, 26, 26, 26, 26,
+ 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+ 26, 26, 26, 26, 26, 26, 11, 26, 26, 26,
+ 26, 26, 22, 29, 3, 33, 26, 33, 26, 26,
+ 4, 26, 10, 26, 26, 26, 13, 26, 26, 14,
+ 9, 6, 5, 26, 26, 26, 7, 12, 8, 26,
+ 26, 26, 26, 26, 17, 33, 34, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33
+};
+
+
+static void act144()
+{
+ NLA = Eof;
+ ;
+ }
+
+
+static void act145()
+{
+ NLA = 137;
+ zzskip();
+ }
+
+
+static void act146()
+{
+ NLA = 138;
+ zzline++; zzskip();
+ }
+
+
+static void act147()
+{
+ NLA = 139;
+ zzmode(TOK_DEF_CPP_COMMENTS); zzmore();
+ }
+
+
+static void act148()
+{
+ NLA = 140;
+ zzmode(TOK_DEF_COMMENTS); zzskip();
+ }
+
+
+static void act149()
+{
+ NLA = 141;
+ zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
+ }
+
+
+static void act150()
+{
+ NLA = 142;
+ zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
+ }
+
+
+static void act151()
+{
+ NLA = 143;
+ ;
+ }
+
+
+static void act152()
+{
+ NLA = 144;
+ zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
+ }
+
+
+static void act153()
+{
+ NLA = 145;
+ zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
+ }
+
+
+static void act154()
+{
+ NLA = 146;
+ zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
+ }
+
+
+static void act155()
+{
+ NLA = 147;
+ zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
+ }
+
+
+static void act156()
+{
+ NLA = 149;
+ }
+
+
+static void act157()
+{
+ NLA = 151;
+ }
+
+
+static void act158()
+{
+ NLA = 152;
+ }
+
+
+static void act159()
+{
+ NLA = 153;
+ }
+
+
+static void act160()
+{
+ NLA = 154;
+ }
+
+
+static void act161()
+{
+ NLA = 155;
+ }
+
+
+static void act162()
+{
+ NLA = 156;
+ }
+
+
+static void act163()
+{
+ NLA = INT;
+ }
+
+
+static void act164()
+{
+ NLA = ID;
+ }
+
+static unsigned char shift11[257] = {
+ 0, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 1, 2, 27, 27, 3, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 1, 27, 27, 6, 27, 27, 27,
+ 27, 27, 27, 5, 27, 22, 27, 27, 4, 25,
+ 25, 25, 25, 25, 25, 25, 25, 25, 25, 27,
+ 24, 27, 21, 27, 27, 27, 26, 26, 26, 26,
+ 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+ 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+ 26, 26, 27, 27, 27, 27, 26, 27, 26, 26,
+ 26, 9, 10, 8, 26, 26, 7, 26, 26, 12,
+ 15, 11, 17, 16, 26, 18, 13, 19, 14, 26,
+ 26, 26, 26, 26, 20, 27, 23, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27
+};
+
+#define DfaStates 436
+typedef unsigned short DfaState;
+
+static DfaState st0[60] = {
+ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+ 11, 11, 11, 12, 13, 13, 13, 14, 15, 16,
+ 17, 11, 11, 18, 11, 11, 19, 11, 11, 19,
+ 11, 11, 11, 11, 20, 11, 11, 21, 22, 23,
+ 24, 25, 26, 11, 27, 28, 29, 30, 31, 32,
+ 33, 34, 35, 36, 11, 11, 19, 436, 436, 436
+};
+
+static DfaState st1[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st2[60] = {
+ 436, 2, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st3[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st4[60] = {
+ 436, 436, 37, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st5[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st6[60] = {
+ 436, 436, 436, 436, 436, 38, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st7[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st8[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 39, 40, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st9[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 41, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st10[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 42, 43, 43, 44, 43, 43, 43, 436, 436, 436,
+ 436, 45, 43, 43, 43, 43, 46, 43, 47, 43,
+ 43, 43, 43, 48, 43, 49, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st11[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st12[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 51, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st13[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 13, 13, 13, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st14[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 52, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st15[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 53, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st16[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st17[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 54,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st18[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 55, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st19[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 56, 56, 56, 56, 56, 56, 56, 436, 436, 436,
+ 436, 56, 56, 56, 56, 56, 56, 56, 56, 56,
+ 56, 56, 56, 56, 56, 56, 56, 436, 56, 436,
+ 436, 436, 436, 56, 436, 436, 436, 436, 436, 436,
+ 436, 56, 436, 436, 56, 56, 56, 56, 436, 436
+};
+
+static DfaState st20[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 57, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st21[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st22[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 58, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 59, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st23[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st24[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st25[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st26[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st27[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 60, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st28[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 61, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st29[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st30[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st31[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 62, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st32[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st33[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st34[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 56, 56, 56, 56, 56, 56, 56, 436, 436, 436,
+ 436, 56, 56, 56, 56, 56, 56, 56, 56, 56,
+ 56, 56, 56, 56, 56, 56, 56, 436, 56, 436,
+ 436, 436, 436, 56, 436, 436, 436, 436, 436, 436,
+ 436, 63, 436, 436, 56, 56, 56, 56, 436, 436
+};
+
+static DfaState st35[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st36[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st37[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st38[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st39[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st40[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st41[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st42[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 64, 43, 65, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st43[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st44[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 66, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st45[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 67, 68, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st46[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 69, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st47[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 70, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st48[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 71, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st49[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 72, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st50[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st51[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 73, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st52[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st53[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st54[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 74, 43, 43, 44, 43, 43, 43, 436, 436, 436,
+ 436, 45, 43, 43, 43, 43, 46, 43, 47, 43,
+ 43, 43, 43, 48, 43, 49, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st55[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 75, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st56[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 56, 56, 56, 56, 56, 56, 56, 436, 436, 436,
+ 436, 56, 56, 56, 56, 56, 56, 56, 56, 56,
+ 56, 56, 56, 56, 56, 56, 56, 436, 56, 436,
+ 436, 436, 436, 56, 436, 436, 436, 436, 436, 436,
+ 436, 56, 436, 436, 56, 56, 56, 56, 436, 436
+};
+
+static DfaState st57[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 76, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st58[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 77, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st59[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 78, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st60[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st61[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st62[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st63[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 56, 56, 56, 56, 56, 56, 56, 436, 436, 436,
+ 436, 56, 56, 56, 56, 56, 56, 56, 56, 56,
+ 56, 56, 56, 56, 56, 56, 56, 436, 56, 436,
+ 436, 436, 436, 56, 436, 436, 79, 436, 436, 436,
+ 436, 56, 436, 436, 56, 56, 56, 56, 436, 436
+};
+
+static DfaState st64[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 80, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st65[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 81, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st66[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 82, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st67[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 83, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 84, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st68[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 85, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st69[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 86, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st70[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 87, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st71[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 88, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st72[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 89, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st73[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 90, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st74[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 65, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st75[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 91, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st76[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 92, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st77[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 93, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st78[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 94, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st79[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 95, 96, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st80[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 97, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st81[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 98, 43, 99, 43, 100, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 101, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st82[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 102, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st83[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 103, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st84[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 104, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st85[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 105, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st86[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 106, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st87[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 107, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 108, 43, 43, 436, 109, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st88[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 110, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st89[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 111, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st90[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 112, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st91[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 113, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st92[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 114, 50, 50, 50, 436, 436
+};
+
+static DfaState st93[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 115, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st94[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 116, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st95[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 117, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st96[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 118, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st97[60] = {
+ 436, 119, 120, 121, 122, 122, 122, 122, 122, 122,
+ 123, 123, 123, 123, 124, 124, 124, 122, 122, 122,
+ 122, 123, 123, 123, 123, 123, 123, 123, 123, 123,
+ 123, 123, 123, 123, 123, 123, 123, 122, 123, 122,
+ 122, 122, 122, 123, 122, 122, 122, 122, 122, 122,
+ 122, 123, 122, 122, 123, 123, 123, 123, 122, 436
+};
+
+static DfaState st98[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 125, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st99[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 126, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st100[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 127, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st101[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 128, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st102[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 129, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st103[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st104[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 130, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st105[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 131, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st106[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 132, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st107[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 133, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st108[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 134, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st109[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 135, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st110[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 136, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st111[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 137, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st112[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 138, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st113[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 139, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st114[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 140, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st115[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st116[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st117[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st118[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st119[60] = {
+ 436, 119, 120, 121, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 141, 141, 141, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 436
+};
+
+static DfaState st120[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st121[60] = {
+ 436, 436, 142, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st122[60] = {
+ 436, 122, 120, 121, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 436
+};
+
+static DfaState st123[60] = {
+ 436, 122, 120, 121, 122, 122, 122, 122, 122, 122,
+ 123, 123, 123, 123, 123, 123, 123, 122, 122, 122,
+ 122, 123, 123, 123, 123, 123, 123, 123, 123, 123,
+ 123, 123, 123, 123, 123, 123, 123, 122, 123, 122,
+ 122, 122, 122, 123, 122, 122, 122, 122, 122, 122,
+ 122, 123, 122, 122, 123, 123, 123, 123, 122, 436
+};
+
+static DfaState st124[60] = {
+ 436, 143, 144, 145, 122, 122, 146, 122, 122, 122,
+ 123, 123, 123, 123, 124, 124, 124, 122, 122, 122,
+ 122, 123, 123, 123, 123, 123, 123, 123, 123, 123,
+ 123, 123, 123, 123, 123, 123, 123, 122, 123, 122,
+ 122, 122, 122, 123, 122, 122, 122, 122, 122, 122,
+ 122, 123, 122, 122, 123, 123, 123, 123, 122, 436
+};
+
+static DfaState st125[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 147, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st126[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 148, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st127[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 149, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st128[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 150, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st129[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 151, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st130[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 152, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st131[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 153, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st132[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 154,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st133[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st134[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 155, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st135[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 156, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st136[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 157, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st137[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st138[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 158, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st139[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st140[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 159, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st141[60] = {
+ 436, 143, 144, 145, 122, 122, 146, 122, 122, 122,
+ 122, 122, 122, 122, 141, 141, 141, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 436
+};
+
+static DfaState st142[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st143[60] = {
+ 436, 143, 120, 121, 122, 122, 146, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 436
+};
+
+static DfaState st144[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st145[60] = {
+ 436, 436, 160, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st146[60] = {
+ 436, 161, 162, 163, 161, 161, 122, 161, 161, 161,
+ 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
+ 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
+ 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
+ 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
+ 161, 161, 161, 161, 161, 161, 161, 161, 161, 436
+};
+
+static DfaState st147[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 164, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st148[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 165, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st149[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 166, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st150[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 167, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st151[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 168, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st152[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st153[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st154[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 169, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st155[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 170, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st156[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 171, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st157[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st158[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 172, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st159[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st160[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st161[60] = {
+ 436, 161, 162, 163, 161, 161, 173, 161, 161, 161,
+ 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
+ 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
+ 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
+ 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
+ 161, 161, 161, 161, 161, 161, 161, 161, 161, 436
+};
+
+static DfaState st162[60] = {
+ 436, 174, 174, 174, 174, 174, 175, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 436
+};
+
+static DfaState st163[60] = {
+ 436, 174, 176, 174, 174, 174, 175, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 436
+};
+
+static DfaState st164[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 177, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st165[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 178, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st166[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 179, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st167[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 180, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st168[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 181, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st169[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 182, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st170[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st171[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 183, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st172[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 184, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st173[60] = {
+ 436, 185, 144, 145, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 186, 186, 186, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 436
+};
+
+static DfaState st174[60] = {
+ 436, 174, 174, 174, 174, 174, 175, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 436
+};
+
+static DfaState st175[60] = {
+ 436, 187, 188, 189, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 190, 190, 190, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st176[60] = {
+ 436, 174, 174, 174, 174, 174, 175, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 436
+};
+
+static DfaState st177[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 191, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st178[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 192, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st179[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 193, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st180[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st181[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st182[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 194,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st183[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st184[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
+};
+
+static DfaState st185[60] = {
+ 436, 185, 144, 145, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 186, 186, 186, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 436
+};
+
+static DfaState st186[60] = {
+ 436, 185, 144, 145, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 186, 186, 186, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 436
+};
+
+static DfaState st187[60] = {
+ 436, 187, 188, 189, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 190, 190, 190, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st188[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st189[60] = {
+ 436, 436, 195, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st190[60] = {
+ 436, 187, 188, 189, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 190, 190, 190, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st191[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st192[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st193[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st194[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 196, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st195[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st196[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 197, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st197[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 198, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st198[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 199, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st199[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 200, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st200[60] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
+};
+
+static DfaState st201[7] = {
+ 202, 203, 204, 205, 206, 207, 436
+};
+
+static DfaState st202[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st203[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st204[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st205[7] = {
+ 436, 436, 208, 436, 436, 436, 436
+};
+
+static DfaState st206[7] = {
+ 436, 209, 210, 211, 209, 209, 436
+};
+
+static DfaState st207[7] = {
+ 436, 436, 436, 436, 436, 207, 436
+};
+
+static DfaState st208[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st209[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st210[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st211[7] = {
+ 436, 436, 212, 436, 436, 436, 436
+};
+
+static DfaState st212[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st213[7] = {
+ 214, 215, 216, 217, 218, 219, 436
+};
+
+static DfaState st214[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st215[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st216[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st217[7] = {
+ 436, 436, 220, 436, 436, 436, 436
+};
+
+static DfaState st218[7] = {
+ 436, 221, 222, 223, 221, 221, 436
+};
+
+static DfaState st219[7] = {
+ 436, 436, 436, 436, 436, 219, 436
+};
+
+static DfaState st220[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st221[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st222[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st223[7] = {
+ 436, 436, 224, 436, 436, 436, 436
+};
+
+static DfaState st224[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st225[7] = {
+ 226, 227, 228, 229, 230, 231, 436
+};
+
+static DfaState st226[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st227[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st228[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st229[7] = {
+ 436, 436, 232, 436, 436, 436, 436
+};
+
+static DfaState st230[7] = {
+ 436, 233, 233, 233, 233, 233, 436
+};
+
+static DfaState st231[7] = {
+ 436, 436, 436, 436, 436, 231, 436
+};
+
+static DfaState st232[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st233[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st234[7] = {
+ 235, 236, 237, 238, 239, 237, 436
+};
+
+static DfaState st235[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st236[7] = {
+ 436, 436, 240, 436, 436, 436, 436
+};
+
+static DfaState st237[7] = {
+ 436, 436, 237, 436, 436, 237, 436
+};
+
+static DfaState st238[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st239[7] = {
+ 436, 436, 436, 241, 436, 436, 436
+};
+
+static DfaState st240[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st241[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st242[7] = {
+ 243, 244, 245, 246, 247, 245, 436
+};
+
+static DfaState st243[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st244[7] = {
+ 436, 436, 248, 436, 436, 436, 436
+};
+
+static DfaState st245[7] = {
+ 436, 436, 245, 436, 436, 245, 436
+};
+
+static DfaState st246[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st247[7] = {
+ 436, 436, 436, 249, 436, 436, 436
+};
+
+static DfaState st248[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st249[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st250[5] = {
+ 251, 252, 253, 254, 436
+};
+
+static DfaState st251[5] = {
+ 436, 436, 436, 436, 436
+};
+
+static DfaState st252[5] = {
+ 436, 436, 436, 436, 436
+};
+
+static DfaState st253[5] = {
+ 436, 255, 436, 436, 436
+};
+
+static DfaState st254[5] = {
+ 436, 436, 436, 254, 436
+};
+
+static DfaState st255[5] = {
+ 436, 436, 436, 436, 436
+};
+
+static DfaState st256[5] = {
+ 257, 258, 259, 260, 436
+};
+
+static DfaState st257[5] = {
+ 436, 436, 436, 436, 436
+};
+
+static DfaState st258[5] = {
+ 436, 436, 436, 436, 436
+};
+
+static DfaState st259[5] = {
+ 436, 261, 436, 436, 436
+};
+
+static DfaState st260[5] = {
+ 436, 436, 436, 260, 436
+};
+
+static DfaState st261[5] = {
+ 436, 436, 436, 436, 436
+};
+
+static DfaState st262[5] = {
+ 263, 264, 265, 266, 436
+};
+
+static DfaState st263[5] = {
+ 436, 436, 436, 436, 436
+};
+
+static DfaState st264[5] = {
+ 436, 436, 436, 436, 436
+};
+
+static DfaState st265[5] = {
+ 436, 267, 436, 436, 436
+};
+
+static DfaState st266[5] = {
+ 436, 436, 436, 266, 436
+};
+
+static DfaState st267[5] = {
+ 436, 436, 436, 436, 436
+};
+
+static DfaState st268[7] = {
+ 269, 270, 271, 272, 273, 271, 436
+};
+
+static DfaState st269[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st270[7] = {
+ 436, 436, 274, 436, 436, 436, 436
+};
+
+static DfaState st271[7] = {
+ 436, 436, 271, 436, 436, 271, 436
+};
+
+static DfaState st272[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st273[7] = {
+ 436, 436, 436, 275, 436, 436, 436
+};
+
+static DfaState st274[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st275[7] = {
+ 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st276[36] = {
+ 277, 278, 279, 280, 281, 279, 279, 279, 279, 279,
+ 279, 279, 279, 279, 279, 282, 279, 279, 283, 284,
+ 285, 286, 287, 279, 279, 279, 279, 288, 289, 290,
+ 291, 292, 293, 279, 279, 436
+};
+
+static DfaState st277[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st278[36] = {
+ 436, 294, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st279[36] = {
+ 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
+ 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 279, 279, 436
+};
+
+static DfaState st280[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st281[36] = {
+ 436, 436, 279, 436, 279, 295, 279, 279, 279, 279,
+ 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 279, 279, 436
+};
+
+static DfaState st282[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st283[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st284[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st285[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 296,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st286[36] = {
+ 436, 436, 436, 436, 297, 297, 297, 297, 297, 297,
+ 297, 297, 297, 297, 297, 436, 436, 436, 436, 436,
+ 436, 298, 299, 300, 300, 436, 297, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st287[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st288[36] = {
+ 436, 436, 436, 436, 301, 301, 301, 301, 301, 301,
+ 301, 301, 301, 301, 302, 303, 436, 436, 436, 436,
+ 436, 436, 304, 305, 306, 436, 301, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st289[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st290[36] = {
+ 436, 307, 308, 309, 308, 308, 308, 308, 308, 308,
+ 308, 308, 308, 308, 308, 308, 308, 308, 310, 311,
+ 312, 313, 308, 308, 308, 308, 308, 314, 308, 308,
+ 308, 308, 308, 308, 308, 436
+};
+
+static DfaState st291[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st292[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 315, 316, 436, 436, 436
+};
+
+static DfaState st293[36] = {
+ 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
+ 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 317, 279, 279, 279, 436
+};
+
+static DfaState st294[36] = {
+ 436, 436, 318, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st295[36] = {
+ 436, 436, 279, 436, 279, 279, 319, 279, 279, 279,
+ 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 279, 279, 436
+};
+
+static DfaState st296[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st297[36] = {
+ 436, 436, 436, 436, 320, 320, 320, 320, 320, 320,
+ 320, 320, 320, 320, 320, 436, 436, 436, 436, 436,
+ 436, 436, 436, 320, 320, 436, 320, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st298[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st299[36] = {
+ 436, 436, 436, 321, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st300[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 300, 300, 322, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st301[36] = {
+ 436, 436, 436, 436, 323, 323, 323, 323, 323, 323,
+ 323, 323, 323, 323, 323, 436, 436, 436, 436, 436,
+ 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st302[36] = {
+ 436, 436, 436, 436, 323, 323, 323, 323, 323, 323,
+ 323, 323, 323, 324, 323, 436, 436, 436, 436, 436,
+ 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st303[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 325, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st304[36] = {
+ 436, 436, 436, 326, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st305[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 306, 306, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st306[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 306, 306, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st307[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st308[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st309[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st310[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st311[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st312[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 327,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st313[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st314[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st315[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st316[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st317[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st318[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st319[36] = {
+ 436, 436, 279, 436, 279, 279, 279, 328, 279, 279,
+ 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 279, 279, 436
+};
+
+static DfaState st320[36] = {
+ 436, 436, 436, 436, 320, 320, 320, 320, 320, 320,
+ 320, 320, 320, 320, 320, 436, 436, 436, 436, 436,
+ 436, 436, 436, 320, 320, 436, 320, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st321[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st322[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 329, 329, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st323[36] = {
+ 436, 436, 436, 436, 323, 323, 323, 323, 323, 323,
+ 323, 323, 323, 323, 323, 436, 436, 436, 436, 436,
+ 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st324[36] = {
+ 436, 436, 436, 436, 323, 323, 330, 323, 323, 323,
+ 323, 323, 323, 323, 323, 436, 436, 436, 436, 436,
+ 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st325[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st326[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st327[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st328[36] = {
+ 436, 436, 279, 436, 279, 279, 279, 279, 331, 279,
+ 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 279, 279, 436
+};
+
+static DfaState st329[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 329, 329, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st330[36] = {
+ 436, 436, 436, 436, 323, 323, 323, 323, 323, 323,
+ 332, 323, 323, 323, 323, 436, 436, 436, 436, 436,
+ 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st331[36] = {
+ 436, 436, 279, 436, 279, 279, 279, 279, 279, 333,
+ 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 279, 279, 436
+};
+
+static DfaState st332[36] = {
+ 436, 334, 334, 334, 335, 335, 335, 335, 335, 335,
+ 335, 335, 335, 335, 335, 334, 336, 334, 334, 337,
+ 338, 334, 334, 339, 339, 334, 335, 334, 334, 334,
+ 334, 334, 334, 334, 334, 436
+};
+
+static DfaState st333[36] = {
+ 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
+ 340, 279, 279, 279, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 279, 279, 436
+};
+
+static DfaState st334[36] = {
+ 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
+ 334, 334, 334, 334, 334, 334, 334, 334, 334, 337,
+ 338, 334, 334, 334, 334, 334, 334, 334, 334, 334,
+ 334, 334, 334, 334, 334, 436
+};
+
+static DfaState st335[36] = {
+ 436, 334, 334, 334, 335, 335, 335, 335, 335, 335,
+ 335, 335, 335, 335, 335, 334, 334, 334, 334, 337,
+ 338, 334, 334, 335, 335, 334, 335, 334, 334, 334,
+ 334, 334, 334, 334, 334, 436
+};
+
+static DfaState st336[36] = {
+ 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
+ 334, 334, 334, 334, 334, 334, 336, 334, 334, 337,
+ 338, 334, 334, 341, 341, 334, 334, 334, 334, 334,
+ 334, 334, 334, 334, 334, 436
+};
+
+static DfaState st337[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st338[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 342,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st339[36] = {
+ 436, 334, 334, 334, 335, 335, 335, 335, 335, 335,
+ 335, 335, 335, 335, 335, 334, 343, 334, 334, 344,
+ 345, 334, 334, 339, 339, 334, 335, 334, 346, 334,
+ 334, 334, 334, 334, 334, 436
+};
+
+static DfaState st340[36] = {
+ 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
+ 279, 347, 279, 279, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 279, 279, 436
+};
+
+static DfaState st341[36] = {
+ 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
+ 334, 334, 334, 334, 334, 334, 343, 334, 334, 344,
+ 345, 334, 334, 341, 341, 334, 334, 334, 346, 334,
+ 334, 334, 334, 334, 334, 436
+};
+
+static DfaState st342[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st343[36] = {
+ 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
+ 334, 334, 334, 334, 334, 334, 343, 334, 334, 337,
+ 338, 334, 334, 334, 334, 334, 334, 334, 346, 334,
+ 334, 334, 334, 334, 334, 436
+};
+
+static DfaState st344[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st345[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 348,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st346[36] = {
+ 436, 349, 349, 349, 349, 349, 349, 349, 349, 349,
+ 349, 349, 349, 349, 349, 349, 349, 349, 349, 350,
+ 351, 349, 349, 349, 349, 349, 349, 349, 334, 349,
+ 349, 349, 349, 349, 349, 436
+};
+
+static DfaState st347[36] = {
+ 436, 436, 279, 436, 279, 279, 352, 279, 279, 279,
+ 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 279, 279, 436
+};
+
+static DfaState st348[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st349[36] = {
+ 436, 349, 349, 349, 349, 349, 349, 349, 349, 349,
+ 349, 349, 349, 349, 349, 349, 349, 349, 349, 350,
+ 351, 349, 349, 349, 349, 349, 349, 349, 353, 349,
+ 349, 349, 349, 349, 349, 436
+};
+
+static DfaState st350[36] = {
+ 436, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 355, 354,
+ 354, 354, 354, 354, 354, 436
+};
+
+static DfaState st351[36] = {
+ 436, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 354, 356,
+ 354, 354, 354, 354, 354, 354, 354, 354, 355, 354,
+ 354, 354, 354, 354, 354, 436
+};
+
+static DfaState st352[36] = {
+ 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
+ 279, 279, 357, 279, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 279, 279, 436
+};
+
+static DfaState st353[36] = {
+ 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
+ 334, 334, 334, 334, 334, 334, 358, 334, 334, 344,
+ 345, 334, 334, 359, 359, 334, 334, 334, 334, 334,
+ 334, 334, 334, 334, 334, 436
+};
+
+static DfaState st354[36] = {
+ 436, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 355, 354,
+ 354, 354, 354, 354, 354, 436
+};
+
+static DfaState st355[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 360, 436, 436, 361,
+ 362, 436, 436, 363, 363, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st356[36] = {
+ 436, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 355, 354,
+ 354, 354, 354, 354, 354, 436
+};
+
+static DfaState st357[36] = {
+ 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
+ 279, 279, 279, 364, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 279, 279, 436
+};
+
+static DfaState st358[36] = {
+ 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
+ 334, 334, 334, 334, 334, 334, 358, 334, 334, 344,
+ 345, 334, 334, 359, 359, 334, 334, 334, 334, 334,
+ 334, 334, 334, 334, 334, 436
+};
+
+static DfaState st359[36] = {
+ 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
+ 334, 334, 334, 334, 334, 334, 358, 334, 334, 344,
+ 345, 334, 334, 359, 359, 334, 334, 334, 334, 334,
+ 334, 334, 334, 334, 334, 436
+};
+
+static DfaState st360[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 360, 436, 436, 361,
+ 362, 436, 436, 363, 363, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st361[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st362[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 365,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st363[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 360, 436, 436, 361,
+ 362, 436, 436, 363, 363, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st364[36] = {
+ 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
+ 279, 279, 279, 279, 366, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 279, 279, 436
+};
+
+static DfaState st365[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st366[36] = {
+ 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
+ 279, 279, 279, 279, 279, 367, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 279, 279, 436
+};
+
+static DfaState st367[36] = {
+ 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
+ 368, 368, 368, 368, 368, 368, 369, 370, 436, 368,
+ 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
+ 368, 368, 368, 368, 368, 436
+};
+
+static DfaState st368[36] = {
+ 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
+ 368, 368, 368, 368, 368, 368, 368, 368, 371, 368,
+ 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
+ 368, 368, 368, 368, 368, 436
+};
+
+static DfaState st369[36] = {
+ 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
+ 368, 368, 368, 368, 368, 368, 369, 370, 371, 368,
+ 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
+ 368, 368, 368, 368, 368, 436
+};
+
+static DfaState st370[36] = {
+ 436, 372, 372, 372, 372, 372, 372, 372, 372, 372,
+ 372, 372, 372, 372, 372, 372, 372, 372, 373, 372,
+ 372, 372, 372, 372, 372, 372, 372, 372, 372, 372,
+ 372, 372, 372, 372, 368, 436
+};
+
+static DfaState st371[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st372[36] = {
+ 436, 372, 372, 372, 372, 372, 372, 372, 372, 372,
+ 372, 372, 372, 372, 372, 372, 372, 372, 373, 372,
+ 372, 372, 372, 372, 372, 372, 372, 372, 372, 372,
+ 372, 372, 372, 372, 374, 436
+};
+
+static DfaState st373[36] = {
+ 436, 375, 375, 375, 375, 375, 375, 375, 375, 375,
+ 375, 375, 375, 375, 375, 375, 375, 375, 375, 375,
+ 375, 375, 375, 375, 375, 375, 375, 375, 375, 375,
+ 375, 375, 375, 375, 376, 436
+};
+
+static DfaState st374[36] = {
+ 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
+ 368, 368, 368, 368, 368, 368, 377, 368, 378, 368,
+ 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
+ 368, 368, 368, 368, 368, 436
+};
+
+static DfaState st375[36] = {
+ 436, 375, 375, 375, 375, 375, 375, 375, 375, 375,
+ 375, 375, 375, 375, 375, 375, 375, 375, 375, 375,
+ 375, 375, 375, 375, 375, 375, 375, 375, 375, 375,
+ 375, 375, 375, 375, 376, 436
+};
+
+static DfaState st376[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 379, 436, 380, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st377[36] = {
+ 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
+ 368, 368, 368, 368, 368, 368, 377, 368, 378, 368,
+ 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
+ 368, 368, 368, 368, 368, 436
+};
+
+static DfaState st378[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st379[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 379, 436, 380, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st380[36] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st381[28] = {
+ 382, 383, 384, 385, 386, 436, 387, 388, 388, 388,
+ 389, 388, 388, 388, 388, 388, 388, 388, 388, 388,
+ 390, 391, 392, 393, 394, 395, 388, 436
+};
+
+static DfaState st382[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st383[28] = {
+ 436, 383, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st384[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st385[28] = {
+ 436, 436, 396, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st386[28] = {
+ 436, 436, 436, 436, 397, 398, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st387[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 399, 436, 400,
+ 401, 436, 436, 436, 402, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st388[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
+ 403, 403, 403, 403, 403, 403, 403, 403, 403, 403,
+ 436, 436, 436, 436, 436, 403, 403, 436
+};
+
+static DfaState st389[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
+ 403, 404, 403, 403, 403, 403, 403, 403, 403, 403,
+ 436, 436, 436, 436, 436, 403, 403, 436
+};
+
+static DfaState st390[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st391[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st392[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st393[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st394[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st395[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 395, 436, 436
+};
+
+static DfaState st396[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st397[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st398[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st399[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 405, 436,
+ 436, 436, 436, 436, 436, 406, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st400[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 407, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st401[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 408, 409, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st402[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 410, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st403[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
+ 403, 403, 403, 403, 403, 403, 403, 403, 403, 403,
+ 436, 436, 436, 436, 436, 403, 403, 436
+};
+
+static DfaState st404[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
+ 403, 403, 403, 403, 411, 403, 403, 403, 403, 403,
+ 436, 436, 436, 436, 436, 403, 403, 436
+};
+
+static DfaState st405[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 412,
+ 436, 413, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st406[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 414, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st407[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 415, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st408[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 416,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st409[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 417, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st410[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 418,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st411[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
+ 403, 403, 403, 403, 403, 419, 403, 403, 403, 403,
+ 436, 436, 436, 436, 436, 403, 403, 436
+};
+
+static DfaState st412[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 420, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st413[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 421,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st414[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 422, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st415[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 423, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st416[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 424, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st417[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 425, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st418[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 426, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st419[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
+ 403, 403, 403, 403, 403, 403, 403, 403, 403, 403,
+ 436, 436, 436, 436, 436, 403, 403, 436
+};
+
+static DfaState st420[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 427, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st421[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 428, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st422[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 429, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st423[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 430, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st424[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 431, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st425[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st426[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 432, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st427[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st428[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 433, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st429[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 434,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st430[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 435, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st431[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st432[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st433[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st434[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+static DfaState st435[28] = {
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436
+};
+
+
+DfaState *dfa[436] = {
+ st0,
+ st1,
+ st2,
+ st3,
+ st4,
+ st5,
+ st6,
+ st7,
+ st8,
+ st9,
+ st10,
+ st11,
+ st12,
+ st13,
+ st14,
+ st15,
+ st16,
+ st17,
+ st18,
+ st19,
+ st20,
+ st21,
+ st22,
+ st23,
+ st24,
+ st25,
+ st26,
+ st27,
+ st28,
+ st29,
+ st30,
+ st31,
+ st32,
+ st33,
+ st34,
+ st35,
+ st36,
+ st37,
+ st38,
+ st39,
+ st40,
+ st41,
+ st42,
+ st43,
+ st44,
+ st45,
+ st46,
+ st47,
+ st48,
+ st49,
+ st50,
+ st51,
+ st52,
+ st53,
+ st54,
+ st55,
+ st56,
+ st57,
+ st58,
+ st59,
+ st60,
+ st61,
+ st62,
+ st63,
+ st64,
+ st65,
+ st66,
+ st67,
+ st68,
+ st69,
+ st70,
+ st71,
+ st72,
+ st73,
+ st74,
+ st75,
+ st76,
+ st77,
+ st78,
+ st79,
+ st80,
+ st81,
+ st82,
+ st83,
+ st84,
+ st85,
+ st86,
+ st87,
+ st88,
+ st89,
+ st90,
+ st91,
+ st92,
+ st93,
+ st94,
+ st95,
+ st96,
+ st97,
+ st98,
+ st99,
+ st100,
+ st101,
+ st102,
+ st103,
+ st104,
+ st105,
+ st106,
+ st107,
+ st108,
+ st109,
+ st110,
+ st111,
+ st112,
+ st113,
+ st114,
+ st115,
+ st116,
+ st117,
+ st118,
+ st119,
+ st120,
+ st121,
+ st122,
+ st123,
+ st124,
+ st125,
+ st126,
+ st127,
+ st128,
+ st129,
+ st130,
+ st131,
+ st132,
+ st133,
+ st134,
+ st135,
+ st136,
+ st137,
+ st138,
+ st139,
+ st140,
+ st141,
+ st142,
+ st143,
+ st144,
+ st145,
+ st146,
+ st147,
+ st148,
+ st149,
+ st150,
+ st151,
+ st152,
+ st153,
+ st154,
+ st155,
+ st156,
+ st157,
+ st158,
+ st159,
+ st160,
+ st161,
+ st162,
+ st163,
+ st164,
+ st165,
+ st166,
+ st167,
+ st168,
+ st169,
+ st170,
+ st171,
+ st172,
+ st173,
+ st174,
+ st175,
+ st176,
+ st177,
+ st178,
+ st179,
+ st180,
+ st181,
+ st182,
+ st183,
+ st184,
+ st185,
+ st186,
+ st187,
+ st188,
+ st189,
+ st190,
+ st191,
+ st192,
+ st193,
+ st194,
+ st195,
+ st196,
+ st197,
+ st198,
+ st199,
+ st200,
+ st201,
+ st202,
+ st203,
+ st204,
+ st205,
+ st206,
+ st207,
+ st208,
+ st209,
+ st210,
+ st211,
+ st212,
+ st213,
+ st214,
+ st215,
+ st216,
+ st217,
+ st218,
+ st219,
+ st220,
+ st221,
+ st222,
+ st223,
+ st224,
+ st225,
+ st226,
+ st227,
+ st228,
+ st229,
+ st230,
+ st231,
+ st232,
+ st233,
+ st234,
+ st235,
+ st236,
+ st237,
+ st238,
+ st239,
+ st240,
+ st241,
+ st242,
+ st243,
+ st244,
+ st245,
+ st246,
+ st247,
+ st248,
+ st249,
+ st250,
+ st251,
+ st252,
+ st253,
+ st254,
+ st255,
+ st256,
+ st257,
+ st258,
+ st259,
+ st260,
+ st261,
+ st262,
+ st263,
+ st264,
+ st265,
+ st266,
+ st267,
+ st268,
+ st269,
+ st270,
+ st271,
+ st272,
+ st273,
+ st274,
+ st275,
+ st276,
+ st277,
+ st278,
+ st279,
+ st280,
+ st281,
+ st282,
+ st283,
+ st284,
+ st285,
+ st286,
+ st287,
+ st288,
+ st289,
+ st290,
+ st291,
+ st292,
+ st293,
+ st294,
+ st295,
+ st296,
+ st297,
+ st298,
+ st299,
+ st300,
+ st301,
+ st302,
+ st303,
+ st304,
+ st305,
+ st306,
+ st307,
+ st308,
+ st309,
+ st310,
+ st311,
+ st312,
+ st313,
+ st314,
+ st315,
+ st316,
+ st317,
+ st318,
+ st319,
+ st320,
+ st321,
+ st322,
+ st323,
+ st324,
+ st325,
+ st326,
+ st327,
+ st328,
+ st329,
+ st330,
+ st331,
+ st332,
+ st333,
+ st334,
+ st335,
+ st336,
+ st337,
+ st338,
+ st339,
+ st340,
+ st341,
+ st342,
+ st343,
+ st344,
+ st345,
+ st346,
+ st347,
+ st348,
+ st349,
+ st350,
+ st351,
+ st352,
+ st353,
+ st354,
+ st355,
+ st356,
+ st357,
+ st358,
+ st359,
+ st360,
+ st361,
+ st362,
+ st363,
+ st364,
+ st365,
+ st366,
+ st367,
+ st368,
+ st369,
+ st370,
+ st371,
+ st372,
+ st373,
+ st374,
+ st375,
+ st376,
+ st377,
+ st378,
+ st379,
+ st380,
+ st381,
+ st382,
+ st383,
+ st384,
+ st385,
+ st386,
+ st387,
+ st388,
+ st389,
+ st390,
+ st391,
+ st392,
+ st393,
+ st394,
+ st395,
+ st396,
+ st397,
+ st398,
+ st399,
+ st400,
+ st401,
+ st402,
+ st403,
+ st404,
+ st405,
+ st406,
+ st407,
+ st408,
+ st409,
+ st410,
+ st411,
+ st412,
+ st413,
+ st414,
+ st415,
+ st416,
+ st417,
+ st418,
+ st419,
+ st420,
+ st421,
+ st422,
+ st423,
+ st424,
+ st425,
+ st426,
+ st427,
+ st428,
+ st429,
+ st430,
+ st431,
+ st432,
+ st433,
+ st434,
+ st435
+};
+
+
+DfaState accepts[437] = {
+ 0, 1, 2, 3, 3, 4, 25, 6, 0, 50,
+ 59, 57, 57, 43, 26, 13, 14, 0, 57, 58,
+ 57, 21, 57, 23, 24, 27, 28, 44, 0, 35,
+ 36, 42, 45, 46, 58, 51, 52, 3, 5, 9,
+ 7, 8, 59, 59, 59, 59, 59, 59, 59, 59,
+ 57, 57, 12, 40, 59, 57, 58, 57, 57, 57,
+ 33, 34, 53, 58, 59, 59, 59, 59, 59, 59,
+ 59, 59, 59, 57, 59, 57, 57, 57, 57, 0,
+ 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
+ 57, 57, 57, 57, 57, 0, 0, 59, 59, 59,
+ 59, 59, 59, 32, 59, 59, 59, 59, 59, 59,
+ 59, 59, 57, 57, 57, 22, 56, 48, 49, 0,
+ 11, 11, 0, 59, 59, 59, 59, 59, 59, 59,
+ 59, 59, 59, 41, 59, 59, 59, 18, 57, 47,
+ 57, 0, 11, 0, 10, 10, 0, 59, 59, 59,
+ 59, 59, 15, 19, 59, 59, 59, 17, 57, 55,
+ 10, 0, 11, 11, 59, 59, 59, 59, 59, 59,
+ 20, 59, 57, 0, 0, 0, 11, 59, 59, 59,
+ 37, 38, 59, 39, 54, 0, 0, 0, 10, 10,
+ 0, 31, 29, 30, 59, 10, 59, 59, 59, 59,
+ 16, 0, 60, 61, 62, 62, 0, 65, 62, 64,
+ 63, 63, 63, 0, 66, 67, 68, 68, 0, 71,
+ 68, 70, 69, 69, 69, 0, 72, 73, 74, 74,
+ 0, 76, 74, 75, 0, 77, 79, 81, 80, 80,
+ 78, 80, 0, 82, 84, 86, 85, 85, 83, 85,
+ 0, 87, 88, 88, 89, 88, 0, 90, 91, 91,
+ 92, 91, 0, 93, 94, 94, 95, 94, 0, 96,
+ 98, 100, 99, 99, 97, 99, 0, 101, 108, 143,
+ 104, 143, 129, 127, 107, 107, 109, 128, 126, 134,
+ 0, 133, 139, 143, 102, 143, 107, 116, 110, 112,
+ 113, 123, 123, 125, 124, 117, 120, 132, 138, 130,
+ 131, 137, 137, 135, 136, 142, 140, 141, 103, 143,
+ 116, 111, 114, 123, 123, 119, 118, 137, 143, 115,
+ 123, 143, 123, 143, 0, 123, 0, 122, 122, 123,
+ 143, 0, 122, 0, 121, 121, 0, 143, 121, 0,
+ 122, 122, 143, 0, 0, 0, 122, 143, 0, 0,
+ 0, 121, 121, 0, 143, 121, 143, 0, 0, 0,
+ 0, 106, 0, 106, 0, 0, 0, 0, 105, 0,
+ 105, 0, 144, 145, 146, 146, 0, 0, 164, 164,
+ 158, 159, 160, 161, 162, 163, 146, 147, 148, 0,
+ 0, 0, 0, 164, 164, 150, 0, 0, 0, 0,
+ 0, 164, 0, 0, 0, 0, 0, 0, 0, 157,
+ 0, 0, 0, 0, 0, 152, 0, 149, 0, 0,
+ 0, 153, 154, 151, 155, 156, 0
+};
+
+void (*actions[165])() = {
+ zzerraction,
+ act1,
+ act2,
+ act3,
+ act4,
+ act5,
+ act6,
+ act7,
+ act8,
+ act9,
+ act10,
+ act11,
+ act12,
+ act13,
+ act14,
+ act15,
+ act16,
+ act17,
+ act18,
+ act19,
+ act20,
+ act21,
+ act22,
+ act23,
+ act24,
+ act25,
+ act26,
+ act27,
+ act28,
+ act29,
+ act30,
+ act31,
+ act32,
+ act33,
+ act34,
+ act35,
+ act36,
+ act37,
+ act38,
+ act39,
+ act40,
+ act41,
+ act42,
+ act43,
+ act44,
+ act45,
+ act46,
+ act47,
+ act48,
+ act49,
+ act50,
+ act51,
+ act52,
+ act53,
+ act54,
+ act55,
+ act56,
+ act57,
+ act58,
+ act59,
+ act60,
+ act61,
+ act62,
+ act63,
+ act64,
+ act65,
+ act66,
+ act67,
+ act68,
+ act69,
+ act70,
+ act71,
+ act72,
+ act73,
+ act74,
+ act75,
+ act76,
+ act77,
+ act78,
+ act79,
+ act80,
+ act81,
+ act82,
+ act83,
+ act84,
+ act85,
+ act86,
+ act87,
+ act88,
+ act89,
+ act90,
+ act91,
+ act92,
+ act93,
+ act94,
+ act95,
+ act96,
+ act97,
+ act98,
+ act99,
+ act100,
+ act101,
+ act102,
+ act103,
+ act104,
+ act105,
+ act106,
+ act107,
+ act108,
+ act109,
+ act110,
+ act111,
+ act112,
+ act113,
+ act114,
+ act115,
+ act116,
+ act117,
+ act118,
+ act119,
+ act120,
+ act121,
+ act122,
+ act123,
+ act124,
+ act125,
+ act126,
+ act127,
+ act128,
+ act129,
+ act130,
+ act131,
+ act132,
+ act133,
+ act134,
+ act135,
+ act136,
+ act137,
+ act138,
+ act139,
+ act140,
+ act141,
+ act142,
+ act143,
+ act144,
+ act145,
+ act146,
+ act147,
+ act148,
+ act149,
+ act150,
+ act151,
+ act152,
+ act153,
+ act154,
+ act155,
+ act156,
+ act157,
+ act158,
+ act159,
+ act160,
+ act161,
+ act162,
+ act163,
+ act164
+};
+
+static DfaState dfa_base[] = {
+ 0,
+ 201,
+ 213,
+ 225,
+ 234,
+ 242,
+ 250,
+ 256,
+ 262,
+ 268,
+ 276,
+ 381
+};
+
+static unsigned char *b_class_no[] = {
+ shift0,
+ shift1,
+ shift2,
+ shift3,
+ shift4,
+ shift5,
+ shift6,
+ shift7,
+ shift8,
+ shift9,
+ shift10,
+ shift11
+};
+
+
+
+#define ZZSHIFT(c) (b_class_no[zzauto][1+c])
+#define MAX_MODE 12
+#include "dlgauto.h"
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/stdpccts.h b/BaseTools/Source/C/VfrCompile/Pccts/antlr/stdpccts.h new file mode 100644 index 0000000000..ccdc21c3c9 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/stdpccts.h @@ -0,0 +1,31 @@ +#ifndef STDPCCTS_H
+#define STDPCCTS_H
+/*
+ * stdpccts.h -- P C C T S I n c l u d e
+ *
+ * Terence Parr, Will Cohen, and Hank Dietz: 1989-2001
+ * Purdue University Electrical Engineering
+ * With AHPCRC, University of Minnesota
+ * ANTLR Version 1.33MR33
+ */
+
+#ifndef ANTLR_VERSION
+#define ANTLR_VERSION 13333
+#endif
+
+#include "pcctscfg.h"
+#include "pccts_stdio.h"
+
+#include "pcctscfg.h"
+#include "set.h"
+#include <ctype.h>
+#include "syn.h"
+#include "hash.h"
+#include "generic.h"
+#define zzcr_attr(attr,tok,t)
+#define zzSET_SIZE 20
+#include "antlr.h"
+#include "tokens.h"
+#include "dlgdef.h"
+#include "mode.h"
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/syn.h b/BaseTools/Source/C/VfrCompile/Pccts/antlr/syn.h new file mode 100644 index 0000000000..a23d196d77 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/syn.h @@ -0,0 +1,390 @@ +/*
+ * syn.h
+ *
+ * This file includes definitions and macros associated with syntax diagrams
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2001
+ */
+
+#include "set.h"
+
+#define NumNodeTypes 4
+#define NumJuncTypes 9
+
+/* List the different node types */
+#define nJunction 1
+#define nRuleRef 2
+#define nToken 3
+#define nAction 4
+
+/* Different types of junctions */
+#define aSubBlk 1
+#define aOptBlk 2
+#define aLoopBlk 3
+#define EndBlk 4
+#define RuleBlk 5
+#define Generic 6 /* just a junction--no unusual characteristics */
+#define EndRule 7
+#define aPlusBlk 8
+#define aLoopBegin 9
+
+typedef int NodeType;
+
+#define TreeBlockAllocSize 500
+#define JunctionBlockAllocSize 200
+#define ActionBlockAllocSize 50
+#define RRefBlockAllocSize 100
+#define TokenBlockAllocSize 100
+
+#ifdef __cplusplus
+class ActionNode;
+class Junction;
+#endif
+
+/* note that 'right' is used by the tree node allocator as a ptr for linked list */
+typedef struct _tree {
+ struct _tree *down, *right;
+ int token;
+ union {
+ int rk; /* if token==EpToken, => how many more tokens req'd */
+ struct _tree *tref; /* if token==TREE_REF */
+ set sref; /* if token==SET */
+ } v;
+#ifdef TREE_DEBUG
+ int in_use;
+ int seq;
+#endif
+ } Tree;
+
+
+/* a predicate is defined to be a predicate action and a token tree with
+ * context info (if used); later, this struct may include the
+ * "hoisting distance" when we hoist past tokens.
+ *
+ * A tree is used to indicate && vs ||
+ *
+ * p
+ * |
+ * q--r
+ *
+ * indicates p && (q||r).
+ *
+ * If expr is PRED_AND_LIST or PRED_OR_LIST, then it's an operation node
+ * and indicates the start of an && or || list.
+ */
+
+typedef struct _Predicate {
+ struct _Predicate *down, *right; /* these have to be first */
+ struct _Predicate *up, *left; /* doubly-link me */
+ char *expr;
+ Tree *tcontext; /* used if lookahead depth of > one is needed (tree) */
+ int k; /* lookahead depth for this tcontext */
+ set scontext[2];/* used if lookahead depth of one is needed (set) */
+ /* scontext[0] is not used; only needed so genExprSets()
+ routine works (it expects an array)
+ */
+ set completionTree; /* which lookahead depths are required to complete tcontext? */
+ set completionSet; /* MR10 separate completion set for sets and trees */
+ struct _PredEntry *predEntry; /* MR11 */
+
+#ifdef __cplusplus
+ ActionNode *source; /* where did this predicate come from? */
+#else
+ struct _anode *source; /* where did this predicate come from? */
+#endif
+
+ char cloned; /* MR10 don't want to free original guard pred */
+ char redundant; /* MR10 predicate tree simplification */
+ char ampersandStyle; /* MR10 (g)? && <<p>>? */
+ char inverted; /* MR11 ! predName */
+ char isConst; /* MR11 */
+ char constValue; /* MR11 */
+ char conflictReported; /* MR11 */
+
+ set plainSet; /* MR12b */
+
+ /*** remember to change new_predicate() and predicate_dup() when changing this ***/
+
+} Predicate;
+
+typedef struct _ExceptionHandler {
+ char *signalname;
+ char *action;
+ } ExceptionHandler;
+
+typedef struct _ExceptionGroup {
+ struct _ListNode *handlers; /* list of ExceptionHandler's */
+ char *label; /* label==""; implies not attached to any
+ * particular rule ref.
+ */
+ char *altID; /* which alt did it come from (blk#:alt#) */
+
+ struct _ExceptionGroup *pendingLink; /* for alternative EG MR7 */
+ struct _ExceptionGroup *outerEG; /* for alternative EG MR7 */
+ struct _LabelEntry *labelEntry; /* for alternative EG MR7 */
+ int forRule; /* MR7 */
+ int used; /* MR7 */
+ } ExceptionGroup ;
+
+
+#define TokenString(_i) ((TokenInd!=NULL)?TokenStr[TokenInd[_i]]:TokenStr[_i])
+#define ExprString(_i) ((TokenInd!=NULL)?ExprStr[TokenInd[_i]]:ExprStr[_i])
+
+
+ /* M e s s a g e P a s s i n g T o N o d e s */
+
+/*
+ * assumes a 'Junction *r' exists. This macro calls a function with
+ * the pointer to the node to operate on and a pointer to the rule
+ * in which it is enclosed.
+ */
+#define TRANS(p) {if ( (p)==NULL ) fatal("TRANS: NULL object"); \
+ if ( (p)->ntype == nJunction ) (*(fpJTrans[((Junction *)(p))->jtype]))( p );\
+ else (*(fpTrans[(p)->ntype]))( p );}
+
+#define PRINT(p) {if ( (p)==NULL ) fatal("PRINT: NULL object");\
+ (*(fpPrint[(p)->ntype]))( p );}
+
+#define REACH(p,k,rk,a) {if ( (p)==NULL ) fatal("REACH: NULL object");\
+ (a) = (*(fpReach[(p)->ntype]))( p, k, rk );}
+
+#define TRAV(p,k,rk,a) {if ( (p)==NULL ) {\
+ if ( ContextGuardTRAV ) (a)=NULL; \
+ else fatal("TRAV: NULL object");\
+ } \
+ else (a) = (*(fpTraverse[(p)->ntype]))( p, k, rk );}
+
+/**
+*** #define TRAV(p,k,rk,a) {if ( (p)==NULL ) fatal("TRAV: NULL object");\
+*** (a) = (*(fpTraverse[(p)->ntype]))( p, k, rk );}
+**/
+
+/* All syntax diagram nodes derive from Node -- superclass
+ */
+#ifdef __cplusplus
+class Node {
+public:
+ NodeType ntype;
+ char *rname; /* what rule does this element live in? */
+ int file; /* index in FileStr */
+ int line; /* line number that element occurs on */
+ };
+#else
+typedef struct _node {
+ NodeType ntype;
+ char *rname; /* what rule does this element live in? */
+ int file; /* index in FileStr */
+ int line; /* line number that element occurs on */
+ } Node;
+#endif
+
+#ifdef __cplusplus
+class ActionNode : public Node {
+public:
+#else
+typedef struct _anode {
+ NodeType ntype;
+ char *rname; /* what rule does this action live in? */
+ int file; /* index in FileStr (name of file with action) */
+ int line; /* line number that action occurs on */
+#endif
+ Node *next;
+ char *action;
+ int is_predicate; /* true if action is a <<...>>? predicate action */
+ int done; /* don't dump if action dumped (used for predicates) */
+ int init_action; /* is this the 1st action of 1st prod of block? */
+ char *pred_fail; /* what to do/print when predicate fails */
+ Predicate *guardpred; /* if '(context)? =>' was present, already done */
+ unsigned char frmwarned;/* have we dumped a warning for pred yet? */
+ unsigned char ctxwarned;/* have we dumped a warning for pred yet? */
+ unsigned char predTooLong; /* MR10 have we dumped warning for pred yet */
+ unsigned char noHoist; /* MR12 literally "noHoist" */
+ Predicate *ampersandPred; /* MR10 (g)? && <<p>>? expr */
+#ifdef __cplusplus
+ Junction *guardNodes; /* MR11 */
+#else
+ struct _junct *guardNodes; /* MR11 */
+#endif
+ struct _PredEntry *predEntry; /* MR11 */
+ int inverted; /* MR11 <<!predSymbol>>? */
+#ifdef __cplusplus
+ };
+#else
+ } ActionNode;
+#endif
+
+#ifdef __cplusplus
+class TokNode : public Node {
+public:
+#else
+typedef struct _toknode {
+ NodeType ntype;
+ char *rname; /* name of rule it's in */
+ int file; /* index in FileStr (name of file with rule) */
+ int line; /* line number that token occurs on */
+#endif
+ Node *next;
+ int token;
+ int astnode; /* leaf/root/excluded (used to build AST's) */
+ unsigned char label;/* token label or expression ? */
+ unsigned char remapped;
+ /* used if token id's are forced to certain positions;
+ * a function walks the tree reassigning token numbers */
+ int upper_range; /* MR13 - was char */
+ /* used only if Token is of type T1..T2; in this case,
+ * use token..upper_range as the range; else
+ * upper_range must be 0 */
+ unsigned char wild_card;
+ /* indicates that the token is the "." wild-card;
+ * field token is ignored if wild_card is set
+ */
+ unsigned int elnum; /* element number within the alternative */
+#ifdef __cplusplus
+ Junction *altstart; /* pointer to node that starts alt */
+#else
+ struct _junct *altstart; /* pointer to node that starts alt */
+#endif
+ struct _TCnode *tclass; /* token class if tokclass ref */
+ set tset; /* set of tokens represented by meta token */
+ char *el_label; /* el_label:toknode */
+ unsigned char complement; /* complement the set? */
+ ExceptionGroup *ex_group; /* any exception[el_label] attached? */
+ unsigned char use_def_MT_handler;
+ unsigned char label_used_in_semantic_pred; /* MR10 */
+#ifdef __cplusplus
+ };
+#else
+ } TokNode;
+#endif
+
+#ifdef __cplusplus
+class RuleRefNode : public Node {
+public:
+#else
+typedef struct _rrnode {
+ NodeType ntype;
+ char *rname; /* name of rule it's in */
+ int file; /* index in FileStr (name of file with rule)
+ it's in */
+ int line; /* line number that rule ref occurs on */
+#endif
+ Node *next;
+ char *text; /* reference to which rule */
+ char *parms; /* point to parameters of rule invocation
+ (if present) */
+ char *assign; /* point to left-hand-side of assignment
+ (if any) */
+ int linked; /* Has a FoLink already been established? */
+ int astnode; /* excluded? (used to build AST's) */
+ unsigned int elnum; /* element number within the alternative */
+#ifdef __cplusplus
+ Junction *altstart;
+#else
+ struct _junct *altstart;
+#endif
+ char *el_label; /* el_label:rrnode */
+ ExceptionGroup *ex_group; /* any exception[el_label] attached? */
+#ifdef __cplusplus
+ };
+#else
+ } RuleRefNode;
+#endif
+
+#ifdef __cplusplus
+class Junction : public Node {
+public:
+#else
+typedef struct _junct {
+ NodeType ntype;
+ char *rname; /* name of rule junction is in */
+ int file; /* index in FileStr (name of file with rule)
+ if blk == RuleBlk */
+ int line; /* line number that rule occurs on */
+#endif
+ int seq; /* MR10 sequence number */
+ char ignore; /* used by FIRST computation to ignore
+ empty alt added for the (...)+ blks */
+ char visited; /* used by recursive routines to avoid
+ infinite recursion */
+ char pvisited; /* used by print routines to avoid
+ infinite recursion */
+ char fvisited; /* used by FoLink() to avoid
+ infinite recursion */
+ char *lock; /* used by REACH to track infinite recursion */
+ char *pred_lock; /* used by find_predicates to track infinite recursion */
+ int altnum; /* used in subblocks. altnum==0 means not an
+ alt of subrule */
+ int jtype; /* annotation for code-gen/FIRST/FOLLOW.
+ Junction type */
+#ifdef __cplusplus
+ Junction *end; /* pointer to node with EndBlk in it
+ if blk == a block type */
+#else
+ struct _junct *end; /* pointer to node with EndBlk in it
+ if blk == a block type */
+#endif
+ Node *p1, *p2;
+ char halt; /* never move past a junction with halt==TRUE */ /* MR10 was int */
+ char *pdecl; /* point to declaration of parameters on rule
+ (if present) */
+ char *parm; /* point to parameter of block invocation
+ (if present) */
+ char predparm; /* indicates that the 'parm' is a predicate
+ * to be used in the while loop generated
+ * for blocks */ /* MR10 was int */
+ char *ret; /* point to return type of rule (if present) */
+ char *erraction; /* point to error action (if present) */
+ int blockid; /* this is a unique ID */
+ char *exception_label; /* goto label for this alt */
+ set *fset; /* used for code generation */
+ Tree *ftree; /* used for code generation */
+ Predicate *predicate;/* predicate that can be used to disambiguate */
+ char guess; /* true if (...)? block */
+ char alpha_beta_guess_end; /* MR14 1 => end block of guess sub block */
+ Node *guess_analysis_point; /* MR14 */
+ char approx; /* limit block to use linear approx lookahead? */
+ set tokrefs; /* if ith element of alt is tokref then i is member */
+ set rulerefs; /* if ith element of alt is rule ref then i is member */
+ struct _ListNode *exceptions; /* list of exceptions groups for rule */
+ struct _ListNode *el_labels; /* list of element labels for rule */
+ ExceptionGroup *outerEG; /* MR7 */
+ int curAltNum; /* MR7 */
+ char* pFirstSetSymbol; /* #pragma FirstSetSymbol(Foo) MR21 */
+#ifdef __cplusplus
+ Junction *pendingLink; /* MR7 */
+#else
+ struct _junct *pendingLink; /* MR7 */
+#endif
+ char overlap_warning; /* MR10 */
+#ifdef __cplusplus
+ };
+#else
+ } Junction;
+#endif
+
+typedef struct { Node *left, *right;} Graph;
+
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/tokens.h b/BaseTools/Source/C/VfrCompile/Pccts/antlr/tokens.h new file mode 100644 index 0000000000..91a53a8471 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/tokens.h @@ -0,0 +1,246 @@ +#ifndef tokens_h
+#define tokens_h
+/* tokens.h -- List of labelled tokens and stuff
+ *
+ * Generated from: antlr.g
+ *
+ * Terence Parr, Will Cohen, and Hank Dietz: 1989-2001
+ * Purdue University Electrical Engineering
+ * ANTLR Version 1.33MR33
+ */
+#define zzEOF_TOKEN 1
+#define Eof 1
+#define QuotedTerm 2
+#define Action 34
+#define Pred 35
+#define PassAction 36
+#define WildCard 87
+#define LABEL 89
+#define Pragma 92
+#define FirstSetSymbol 93
+#define NonTerminal 100
+#define TokenTerm 101
+#define ID 148
+#define INT 150
+
+#ifdef __USE_PROTOS
+void grammar(void);
+#else
+extern void grammar();
+#endif
+
+#ifdef __USE_PROTOS
+void class_def(void);
+#else
+extern void class_def();
+#endif
+
+#ifdef __USE_PROTOS
+void rule(void);
+#else
+extern void rule();
+#endif
+
+#ifdef __USE_PROTOS
+void laction(void);
+#else
+extern void laction();
+#endif
+
+#ifdef __USE_PROTOS
+void lmember(void);
+#else
+extern void lmember();
+#endif
+
+#ifdef __USE_PROTOS
+void lprefix(void);
+#else
+extern void lprefix();
+#endif
+
+#ifdef __USE_PROTOS
+void aPred(void);
+#else
+extern void aPred();
+#endif
+
+#ifdef __USE_PROTOS
+extern Predicate * predOrExpr(void);
+#else
+extern Predicate * predOrExpr();
+#endif
+
+#ifdef __USE_PROTOS
+extern Predicate * predAndExpr(void);
+#else
+extern Predicate * predAndExpr();
+#endif
+
+#ifdef __USE_PROTOS
+extern Predicate * predPrimary(void);
+#else
+extern Predicate * predPrimary();
+#endif
+
+#ifdef __USE_PROTOS
+void aLexclass(void);
+#else
+extern void aLexclass();
+#endif
+
+#ifdef __USE_PROTOS
+void error(void);
+#else
+extern void error();
+#endif
+
+#ifdef __USE_PROTOS
+void tclass(void);
+#else
+extern void tclass();
+#endif
+
+#ifdef __USE_PROTOS
+void token(void);
+#else
+extern void token();
+#endif
+
+#ifdef __USE_PROTOS
+void block(set * toksrefd,set * rulesrefd);
+#else
+extern void block();
+#endif
+
+#ifdef __USE_PROTOS
+void alt(set * toksrefd,set * rulesrefd);
+#else
+extern void alt();
+#endif
+
+#ifdef __USE_PROTOS
+extern LabelEntry * element_label(void);
+#else
+extern LabelEntry * element_label();
+#endif
+
+#ifdef __USE_PROTOS
+extern Node * element(int old_not,int first_on_line,int use_def_MT_handler);
+#else
+extern Node * element();
+#endif
+
+#ifdef __USE_PROTOS
+void default_exception_handler(void);
+#else
+extern void default_exception_handler();
+#endif
+
+#ifdef __USE_PROTOS
+extern ExceptionGroup * exception_group(void);
+#else
+extern ExceptionGroup * exception_group();
+#endif
+
+#ifdef __USE_PROTOS
+extern ExceptionHandler * exception_handler(void);
+#else
+extern ExceptionHandler * exception_handler();
+#endif
+
+#ifdef __USE_PROTOS
+void enum_file(char * fname);
+#else
+extern void enum_file();
+#endif
+
+#ifdef __USE_PROTOS
+void defines(char * fname);
+#else
+extern void defines();
+#endif
+
+#ifdef __USE_PROTOS
+void enum_def(char * fname);
+#else
+extern void enum_def();
+#endif
+
+#endif
+extern SetWordType zzerr1[];
+extern SetWordType zzerr2[];
+extern SetWordType zzerr3[];
+extern SetWordType zzerr4[];
+extern SetWordType setwd1[];
+extern SetWordType zzerr5[];
+extern SetWordType zzerr6[];
+extern SetWordType zzerr7[];
+extern SetWordType zzerr8[];
+extern SetWordType zzerr9[];
+extern SetWordType setwd2[];
+extern SetWordType zzerr10[];
+extern SetWordType zzerr11[];
+extern SetWordType zzerr12[];
+extern SetWordType zzerr13[];
+extern SetWordType setwd3[];
+extern SetWordType zzerr14[];
+extern SetWordType zzerr15[];
+extern SetWordType zzerr16[];
+extern SetWordType zzerr17[];
+extern SetWordType zzerr18[];
+extern SetWordType zzerr19[];
+extern SetWordType zzerr20[];
+extern SetWordType zzerr21[];
+extern SetWordType setwd4[];
+extern SetWordType zzerr22[];
+extern SetWordType zzerr23[];
+extern SetWordType zzerr24[];
+extern SetWordType zzerr25[];
+extern SetWordType zzerr26[];
+extern SetWordType setwd5[];
+extern SetWordType zzerr27[];
+extern SetWordType zzerr28[];
+extern SetWordType zzerr29[];
+extern SetWordType zzerr30[];
+extern SetWordType zzerr31[];
+extern SetWordType zzerr32[];
+extern SetWordType zzerr33[];
+extern SetWordType setwd6[];
+extern SetWordType zzerr34[];
+extern SetWordType zzerr35[];
+extern SetWordType zzerr36[];
+extern SetWordType zzerr37[];
+extern SetWordType zzerr38[];
+extern SetWordType zzerr39[];
+extern SetWordType zzerr40[];
+extern SetWordType zzerr41[];
+extern SetWordType zzerr42[];
+extern SetWordType setwd7[];
+extern SetWordType zzerr43[];
+extern SetWordType zzerr44[];
+extern SetWordType zzerr45[];
+extern SetWordType zzerr46[];
+extern SetWordType zzerr47[];
+extern SetWordType zzerr48[];
+extern SetWordType zzerr49[];
+extern SetWordType zzerr50[];
+extern SetWordType zzerr51[];
+extern SetWordType zzerr52[];
+extern SetWordType zzerr53[];
+extern SetWordType setwd8[];
+extern SetWordType zzerr54[];
+extern SetWordType zzerr55[];
+extern SetWordType zzerr56[];
+extern SetWordType zzerr57[];
+extern SetWordType setwd9[];
+extern SetWordType zzerr58[];
+extern SetWordType zzerr59[];
+extern SetWordType zzerr60[];
+extern SetWordType zzerr61[];
+extern SetWordType zzerr62[];
+extern SetWordType zzerr63[];
+extern SetWordType zzerr64[];
+extern SetWordType zzerr65[];
+extern SetWordType setwd10[];
+extern SetWordType setwd11[];
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/DlgDDK.mak b/BaseTools/Source/C/VfrCompile/Pccts/dlg/DlgDDK.mak new file mode 100644 index 0000000000..156d524acc --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/DlgDDK.mak @@ -0,0 +1,121 @@ +# PCCTS directory
+
+# You will need to set the LIB variable similar to this.
+# LIB="C:/Program Files/Microsoft Visual Studio .NET 2003/Vc7/lib;c:/Microsoft Visual Studio .NET 2003/Vc7/PlatformSDK/Lib"
+
+# PCCTS_HOME=<your PCCTS_HOME>
+PCCTS_HOME=$(WORKSPACE)\Tools\CCode\Source\Pccts
+DLG_SRC=$(PCCTS_HOME)\dlg
+PCCTS_H=$(PCCTS_HOME)\h
+
+
+# Support directories
+SET=$(PCCTS_HOME)\support\set
+
+
+# Compiler stuff
+CC = cl
+CFLAGS = /nologo -I "." -I "$(PCCTS_H)" -I "$(SET)" -D "USER_ZZSYN" -D "PC" \
+ -D "ZZLEXBUFSIZE=65536" /D "LONGFILENAMES" /W3 /Zi
+
+DLG_OBJS = dlg_p.obj dlg_a.obj main.obj err.obj support.obj \
+ output.obj relabel.obj automata.obj
+
+SUPPORT_OBJS = set.obj
+
+# Dependencies
+
+dlg.exe: $(DLG_OBJS) $(SUPPORT_OBJS)
+ $(CC) $(CFLAGS) -o dlg.exe bufferoverflowu.lib $(DLG_OBJS) $(SUPPORT_OBJS)
+ del *.obj
+ del *.ilk
+ del *.pdb
+ move dlg.exe $(WORKSPACE)\Tools\bin\.
+
+dlg_p.obj: $(DLG_SRC)\dlg_p.c \
+ $(PCCTS_H)\antlr.h \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(DLG_SRC)\dlg.h \
+ $(DLG_SRC)\mode.h \
+ $(DLG_SRC)\tokens.h \
+
+ $(CC) -c $(CFLAGS) $(DLG_SRC)\dlg_p.c
+
+dlg_a.obj: $(DLG_SRC)\dlg_a.c \
+ $(PCCTS_H)\antlr.h \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgauto.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(DLG_SRC)\dlg.h \
+ $(DLG_SRC)\mode.h \
+ $(DLG_SRC)\tokens.h \
+
+ $(CC) -c $(CFLAGS) $(DLG_SRC)\dlg_a.c
+
+main.obj: $(DLG_SRC)\main.c \
+ $(PCCTS_H)\antlr.h \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(DLG_SRC)\dlg.h \
+ $(DLG_SRC)\mode.h \
+ $(DLG_SRC)\stdpccts.h \
+ $(DLG_SRC)\tokens.h \
+
+ $(CC) -c $(CFLAGS) $(DLG_SRC)\main.c
+
+err.obj: $(DLG_SRC)\err.c \
+ $(PCCTS_H)\antlr.h \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(PCCTS_H)\err.h \
+ $(SET)\set.h \
+ $(DLG_SRC)\dlg.h \
+ $(DLG_SRC)\tokens.h \
+
+ $(CC) -c $(CFLAGS) $(DLG_SRC)\err.c
+
+support.obj: $(DLG_SRC)\support.c \
+ $(PCCTS_H)\config.h \
+ $(SET)\set.h \
+ $(DLG_SRC)\dlg.h \
+
+ $(CC) -c $(CFLAGS) $(DLG_SRC)\support.c
+
+output.obj: $(DLG_SRC)\output.c \
+ $(PCCTS_H)\config.h \
+ $(SET)\set.h \
+ $(DLG_SRC)\dlg.h \
+
+ $(CC) -c $(CFLAGS) $(DLG_SRC)\output.c
+
+relabel.obj: $(DLG_SRC)\relabel.c \
+ $(PCCTS_H)\config.h \
+ $(SET)\set.h \
+ $(DLG_SRC)\dlg.h \
+
+ $(CC) -c $(CFLAGS) $(DLG_SRC)\relabel.c
+
+automata.obj: $(DLG_SRC)\automata.c \
+ $(PCCTS_H)\config.h \
+ $(SET)\set.h \
+ $(DLG_SRC)\dlg.h \
+
+ $(CC) -c $(CFLAGS) $(DLG_SRC)\automata.c
+
+
+set.obj: $(SET)\set.c \
+ $(PCCTS_H)\config.h \
+ $(SET)\set.h \
+
+ $(CC) -c $(CFLAGS) $(SET)\set.c
+
+clean:
+ del *.obj
+
+distclean:
+ del *.obj
+ del $(WORKSPACE)\Tools\bin\dlg.exe
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/DlgMS.mak b/BaseTools/Source/C/VfrCompile/Pccts/dlg/DlgMS.mak new file mode 100644 index 0000000000..18c37d3656 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/DlgMS.mak @@ -0,0 +1,125 @@ +# PCCTS directory
+
+# You will need to set the LIB variable similar to this.
+# LIB="C:/Program Files/Microsoft Visual Studio .NET 2003/Vc7/lib;c:/Microsoft Visual Studio .NET 2003/Vc7/PlatformSDK/Lib"
+
+# PCCTS_HOME=<your PCCTS_HOME>
+PCCTS_HOME=$(BASE_TOOLS_PATH)\Source\C\VfrCompile\Pccts
+DLG_SRC=$(PCCTS_HOME)\dlg
+PCCTS_H=$(PCCTS_HOME)\h
+
+
+# Support directories
+SET=$(PCCTS_HOME)\support\set
+
+
+# Compiler stuff
+CC = cl
+CFLAGS = /nologo -I "." -I "$(PCCTS_H)" -I "$(SET)" -D "USER_ZZSYN" -D "PC" \
+ -D "ZZLEXBUFSIZE=65536" /D "LONGFILENAMES" /W3 /Zi \
+ /D _CRT_SECURE_NO_DEPRECATE /D _CRT_NONSTDC_NO_DEPRECATE
+
+DLG_OBJS = dlg_p.obj dlg_a.obj main.obj err.obj support.obj \
+ output.obj relabel.obj automata.obj
+
+SUPPORT_OBJS = set.obj
+
+# Dependencies
+
+dlg.exe: $(DLG_OBJS) $(SUPPORT_OBJS)
+ $(CC) $(CFLAGS) -Fedlg.exe $(DLG_OBJS) $(SUPPORT_OBJS)
+ copy dlg.exe $(EDK_TOOLS_PATH)\Bin\Win32
+
+dlg_p.obj: $(DLG_SRC)\dlg_p.c \
+ $(PCCTS_H)\antlr.h \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(DLG_SRC)\dlg.h \
+ $(DLG_SRC)\mode.h \
+ $(DLG_SRC)\tokens.h \
+
+ $(CC) -c $(CFLAGS) $(DLG_SRC)\dlg_p.c
+
+dlg_a.obj: $(DLG_SRC)\dlg_a.c \
+ $(PCCTS_H)\antlr.h \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgauto.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(DLG_SRC)\dlg.h \
+ $(DLG_SRC)\mode.h \
+ $(DLG_SRC)\tokens.h \
+
+ $(CC) -c $(CFLAGS) $(DLG_SRC)\dlg_a.c
+
+main.obj: $(DLG_SRC)\main.c \
+ $(PCCTS_H)\antlr.h \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(SET)\set.h \
+ $(DLG_SRC)\dlg.h \
+ $(DLG_SRC)\mode.h \
+ $(DLG_SRC)\stdpccts.h \
+ $(DLG_SRC)\tokens.h \
+
+ $(CC) -c $(CFLAGS) $(DLG_SRC)\main.c
+
+err.obj: $(DLG_SRC)\err.c \
+ $(PCCTS_H)\antlr.h \
+ $(PCCTS_H)\config.h \
+ $(PCCTS_H)\dlgdef.h \
+ $(PCCTS_H)\err.h \
+ $(SET)\set.h \
+ $(DLG_SRC)\dlg.h \
+ $(DLG_SRC)\tokens.h \
+
+ $(CC) -c $(CFLAGS) $(DLG_SRC)\err.c
+
+support.obj: $(DLG_SRC)\support.c \
+ $(PCCTS_H)\config.h \
+ $(SET)\set.h \
+ $(DLG_SRC)\dlg.h \
+
+ $(CC) -c $(CFLAGS) $(DLG_SRC)\support.c
+
+output.obj: $(DLG_SRC)\output.c \
+ $(PCCTS_H)\config.h \
+ $(SET)\set.h \
+ $(DLG_SRC)\dlg.h \
+
+ $(CC) -c $(CFLAGS) $(DLG_SRC)\output.c
+
+relabel.obj: $(DLG_SRC)\relabel.c \
+ $(PCCTS_H)\config.h \
+ $(SET)\set.h \
+ $(DLG_SRC)\dlg.h \
+
+ $(CC) -c $(CFLAGS) $(DLG_SRC)\relabel.c
+
+automata.obj: $(DLG_SRC)\automata.c \
+ $(PCCTS_H)\config.h \
+ $(SET)\set.h \
+ $(DLG_SRC)\dlg.h \
+
+ $(CC) -c $(CFLAGS) $(DLG_SRC)\automata.c
+
+
+set.obj: $(SET)\set.c \
+ $(PCCTS_H)\config.h \
+ $(SET)\set.h \
+
+ $(CC) -c $(CFLAGS) $(SET)\set.c
+
+clean:
+ -del *.obj
+ -del *.ilk
+ -del *.pdb
+
+cleanall:
+ -del *.obj
+ -del *.ilk
+ -del *.pdb
+ -del *.exe
+ -del $(EDK_TOOLS_PATH)\Bin\Win32\dlg.exe
+
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/DlgPPC.mak b/BaseTools/Source/C/VfrCompile/Pccts/dlg/DlgPPC.mak new file mode 100644 index 0000000000..55b643ad88 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/DlgPPC.mak @@ -0,0 +1,84 @@ +# File: dlgPPC.make
+# Target: dlgPPC
+# Sources: automata.c
+# dlg_a.c
+# dlg_p.c
+# err.c
+# main.c
+# output.c
+# relabel.c
+# support.c
+# ::support:set:set.c
+# Created: Sunday, May 17, 1998 11:34:20 PM
+# Author: Kenji Tanaka
+
+
+MAKEFILE = dlgPPC.make
+¥MondoBuild¥ = {MAKEFILE} # Make blank to avoid rebuilds when makefile is modified
+Includes = ¶
+ -i "::h:" ¶
+ -i "::support:set:"
+Sym¥PPC =
+ObjDir¥PPC = ":Obj:"
+
+PPCCOptions = {Includes} {Sym¥PPC} -w off -d MPW -d __STDC__=1 -d USER_ZZSYN
+
+Objects¥PPC = ¶
+ "{ObjDir¥PPC}automata.c.x" ¶
+ "{ObjDir¥PPC}dlg_a.c.x" ¶
+ "{ObjDir¥PPC}dlg_p.c.x" ¶
+ "{ObjDir¥PPC}err.c.x" ¶
+ "{ObjDir¥PPC}main.c.x" ¶
+ "{ObjDir¥PPC}output.c.x" ¶
+ "{ObjDir¥PPC}relabel.c.x" ¶
+ "{ObjDir¥PPC}support.c.x" ¶
+ "{ObjDir¥PPC}set.c.x"
+
+
+dlgPPC ÄÄ {¥MondoBuild¥} {Objects¥PPC}
+ PPCLink ¶
+ -o {Targ} {Sym¥PPC} ¶
+ {Objects¥PPC} ¶
+ -t 'MPST' ¶
+ -c 'MPS ' ¶
+ "{SharedLibraries}InterfaceLib" ¶
+ "{SharedLibraries}StdCLib" ¶
+ "{SharedLibraries}MathLib" ¶
+ "{PPCLibraries}StdCRuntime.o" ¶
+ "{PPCLibraries}PPCCRuntime.o" ¶
+ "{PPCLibraries}PPCToolLibs.o"
+
+
+"{ObjDir¥PPC}automata.c.x" Ä {¥MondoBuild¥} automata.c
+ {PPCC} automata.c -o {Targ} {PPCCOptions}
+
+"{ObjDir¥PPC}dlg_a.c.x" Ä {¥MondoBuild¥} dlg_a.c
+ {PPCC} dlg_a.c -o {Targ} {PPCCOptions}
+
+"{ObjDir¥PPC}dlg_p.c.x" Ä {¥MondoBuild¥} dlg_p.c
+ {PPCC} dlg_p.c -o {Targ} {PPCCOptions}
+
+"{ObjDir¥PPC}err.c.x" Ä {¥MondoBuild¥} err.c
+ {PPCC} err.c -o {Targ} {PPCCOptions}
+
+"{ObjDir¥PPC}main.c.x" Ä {¥MondoBuild¥} main.c
+ {PPCC} main.c -o {Targ} {PPCCOptions}
+
+"{ObjDir¥PPC}output.c.x" Ä {¥MondoBuild¥} output.c
+ {PPCC} output.c -o {Targ} {PPCCOptions}
+
+"{ObjDir¥PPC}relabel.c.x" Ä {¥MondoBuild¥} relabel.c
+ {PPCC} relabel.c -o {Targ} {PPCCOptions}
+
+"{ObjDir¥PPC}support.c.x" Ä {¥MondoBuild¥} support.c
+ {PPCC} support.c -o {Targ} {PPCCOptions}
+
+"{ObjDir¥PPC}set.c.x" Ä {¥MondoBuild¥} "::support:set:set.c"
+ {PPCC} "::support:set:set.c" -o {Targ} {PPCCOptions}
+
+
+dlgPPC ÄÄ dlg.r
+ Rez dlg.r -o dlgPPC -a
+
+Install Ä dlgPPC
+ Duplicate -y dlgPPC "{MPW}"Tools:dlg
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/automata.c b/BaseTools/Source/C/VfrCompile/Pccts/dlg/automata.c new file mode 100644 index 0000000000..d6d5d7809d --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/automata.c @@ -0,0 +1,353 @@ +/* Automata conversion functions for DLG
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * DLG 1.33
+ * Will Cohen
+ * With mods by Terence Parr; AHPCRC, University of Minnesota
+ * 1989-2001
+ */
+
+#include <stdio.h>
+#include "pcctscfg.h"
+#include "dlg.h"
+#ifdef MEMCHK
+#include "trax.h"
+#else
+#ifdef __STDC__
+#include <stdlib.h>
+#else
+#include <malloc.h>
+#endif /* __STDC__ */
+#endif
+
+#define hash_list struct _hash_list_
+hash_list{
+ hash_list *next; /* next thing in list */
+ dfa_node *node;
+ };
+
+int dfa_allocated = 0; /* keeps track of number of dfa nodes */
+dfa_node **dfa_array; /* root of binary tree that stores dfa array */
+dfa_node *dfa_model_node;
+hash_list *dfa_hash[HASH_SIZE]; /* used to quickly find */
+ /* desired dfa node */
+
+void
+#ifdef __USE_PROTOS
+make_dfa_model_node(int width)
+#else
+make_dfa_model_node(width)
+int width;
+#endif
+{
+ register int i;
+ dfa_model_node = (dfa_node*) malloc(sizeof(dfa_node)
+ + sizeof(int)*width);
+ dfa_model_node->node_no = -1; /* impossible value for real dfa node */
+ dfa_model_node->dfa_set = 0;
+ dfa_model_node->alternatives = FALSE;
+ dfa_model_node->done = FALSE;
+ dfa_model_node->nfa_states = empty;
+ for(i = 0; i<width; i++){
+ dfa_model_node->trans[i] = NIL_INDEX;
+ }
+}
+
+
+/* adds a new nfa to the binary tree and returns a pointer to it */
+dfa_node *
+#ifdef __USE_PROTOS
+new_dfa_node(set nfa_states)
+#else
+new_dfa_node(nfa_states)
+set nfa_states;
+#endif
+{
+ register int j;
+ register dfa_node *t;
+ static int dfa_size=0; /* elements dfa_array[] can hold */
+
+ ++dfa_allocated;
+ if (dfa_size<=dfa_allocated){
+ /* need to redo array */
+ if (!dfa_array){
+ /* need some to do inital allocation */
+ dfa_size=dfa_allocated+DFA_MIN;
+ dfa_array=(dfa_node **) malloc(sizeof(dfa_node*)*
+ dfa_size);
+ }else{
+ /* need more space */
+ dfa_size=2*(dfa_allocated+1);
+ dfa_array=(dfa_node **) realloc(dfa_array,
+ sizeof(dfa_node*)*dfa_size);
+ }
+ }
+ /* fill out entry in array */
+ t = (dfa_node*) malloc(sizeof(nfa_node)+sizeof(int)*class_no);
+ *t = *dfa_model_node;
+ for (j=0; j<class_no; ++j)
+ t->trans[j] = NIL_INDEX;
+ t->node_no = dfa_allocated;
+ t->nfa_states = set_dup(nfa_states);
+ dfa_array[dfa_allocated] = t;
+ return t;
+}
+
+
+/* past a pointer to the start start of the nfa graph
+ * nfa_to_dfa convers this graph to dfa. The function returns
+ * a pointer to the first dfa state.
+ * NOTE: The function that prints out the table will have to figure out how
+ * to find the other dfa states given the first dfa_state and the number of dfa
+ * nodes allocated
+ */
+dfa_node **
+#ifdef __USE_PROTOS
+nfa_to_dfa(nfa_node *start)
+#else
+nfa_to_dfa(start)
+nfa_node *start;
+#endif
+{
+ register dfa_node *d_state, *trans_d_state;
+ register int a;
+ set t;
+ int last_done;
+ unsigned *nfa_list;
+ unsigned *reach_list;
+
+ reach_list = (unsigned *) malloc((2+nfa_allocated)*sizeof(unsigned));
+ if (!start) return NULL;
+ t = set_of(NFA_NO(start));
+ _set_pdq(t,reach_list);
+ closure(&t,reach_list);
+ /* Make t a dfa state */
+ d_state = dfastate(t);
+ last_done = DFA_NO(d_state);
+
+ do {
+ /* Mark dfa state x as "done" */
+ d_state->done = TRUE;
+ nfa_list = set_pdq(d_state->nfa_states);
+ for (a = 0; a<class_no; ++a) {
+ /* Add NFA states reached by a from d_state */
+ reach(nfa_list,a,reach_list);
+ /* Were any states found? */
+ if ((*reach_list)!=nil) {
+ /* was t=empty; */
+ set_free(t);
+ /* yes, compute closure */
+ closure(&t,reach_list);
+ /* Make DFA state of it ... */
+ trans_d_state = dfastate(t);
+ /* And make transition x->t, labeled with a */
+ d_state->trans[a] = DFA_NO(trans_d_state);
+ d_state->alternatives = TRUE;
+ }
+ }
+ free(nfa_list);
+ ++last_done; /* move forward in queue */
+ /* And so forth until nothing isn't done */
+ d_state = DFA(last_done);
+ } while (last_done<=dfa_allocated);
+
+ free(reach_list);
+ set_free(t);
+
+ /* returns pointer to the array that holds the automaton */
+ return dfa_array;
+}
+
+void
+#ifdef __USE_PROTOS
+clear_hash(void)
+#else
+clear_hash()
+#endif
+{
+ register int i;
+
+ for(i=0; i<HASH_SIZE; ++i)
+ dfa_hash[i] = 0;
+}
+
+#if HASH_STAT
+void
+#ifdef __USE_PROTOS
+fprint_hash_stats(FILE *f)
+#else
+fprint_hash_stats(f)
+FILE *f;
+#endif
+{
+ register hash_list *p;
+ register int i,j;
+ register total;
+
+ total=0;
+ for(i=0; i<HASH_SIZE; ++i){
+ j=0;
+ p = dfa_hash[i];
+ while(p){
+ ++j;
+ p = p->next;
+ }
+ total+=j;
+ fprintf(f,"bin[%d] has %d\n",i,j);
+ }
+ fprintf(f,"total = %d\n",total);
+}
+#endif
+
+/* Returns a pointer to a dfa node that has the same nfa nodes in it.
+ * This may or maynot be a newly created node.
+ */
+dfa_node *
+#ifdef __USE_PROTOS
+dfastate(set nfa_states)
+#else
+dfastate(nfa_states)
+set nfa_states;
+#endif
+{
+ register hash_list *p;
+ int bin;
+
+ /* hash using set and see if it exists */
+ bin = set_hash(nfa_states,HASH_SIZE);
+ p = dfa_hash[bin];
+ while(p && !set_equ(nfa_states,(p->node)->nfa_states)){
+ p = p->next;
+ }
+ if(!p){
+ /* next state to add to hash table */
+ p = (hash_list*)malloc(sizeof(hash_list));
+ p->node = new_dfa_node(nfa_states);
+ p->next = dfa_hash[bin];
+ dfa_hash[bin] = p;
+ }
+ return (p->node);
+}
+
+
+/* this reach assumes the closure has been done already on set */
+int
+#ifdef __USE_PROTOS
+reach(unsigned *nfa_list, register int a, unsigned *reach_list)
+#else
+reach(nfa_list, a, reach_list)
+unsigned *nfa_list;
+register int a;
+unsigned *reach_list;
+#endif
+{
+ register unsigned *e;
+ register nfa_node *node;
+ int t=0;
+
+ e = nfa_list;
+ if (e){
+ while (*e != nil){
+ node = NFA(*e);
+ if (set_el(a,node->label)){
+ t=1;
+ *reach_list=NFA_NO(node->trans[0]);
+ ++reach_list;
+ }
+ ++e;
+ }
+ }
+ *reach_list=nil;
+ return t;
+}
+
+/* finds all the nodes that can be reached by epsilon transitions
+ from the set of a nodes and returns puts them back in set b */
+set
+#ifdef __USE_PROTOS
+closure(set *b, unsigned *reach_list)
+#else
+closure(b, reach_list)
+set *b;
+unsigned *reach_list;
+#endif
+{
+ register nfa_node *node,*n; /* current node being examined */
+ register unsigned *e;
+
+ ++operation_no;
+#if 0
+ t = e = set_pdq(*b);
+#else
+ e=reach_list;
+#endif
+ while (*e != nil){
+ node = NFA(*e);
+ set_orel(NFA_NO(node),b);
+ /* mark it done */
+ node->nfa_set = operation_no;
+ if ((n=node->trans[0]) != NIL_INDEX && set_nil(node->label) &&
+ (n->nfa_set != operation_no)){
+ /* put in b */
+ set_orel(NFA_NO(n),b);
+ close1(n,operation_no,b);
+ }
+ if ((n=node->trans[1]) != NIL_INDEX &&
+ (n->nfa_set != operation_no)){
+ /* put in b */
+ set_orel(NFA_NO(node->trans[1]),b);
+ close1(n,operation_no,b);
+ }
+ ++e;
+ }
+#if 0
+ free(t);
+#endif
+ return *b;
+}
+
+#ifdef __USE_PROTOS
+void close1(nfa_node *node, int o, set *b)
+#else
+void close1(node,o,b)
+nfa_node *node;
+int o; /* marker to avoid cycles */
+set *b;
+#endif
+{
+ register nfa_node *n; /* current node being examined */
+
+ /* mark it done */
+ node->nfa_set = o;
+ if ((n=node->trans[0]) != NIL_INDEX && set_nil(node->label) &&
+ (n->nfa_set != o)){
+ /* put in b */
+ set_orel(NFA_NO(n),b);
+ close1(n,o,b);
+ }
+ if ((n=node->trans[1]) != NIL_INDEX &&
+ (n->nfa_set != o)){
+ /* put in b */
+ set_orel(NFA_NO(node->trans[1]),b);
+ close1(n,o,b);
+ }
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg.1 b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg.1 new file mode 100644 index 0000000000..f68e3ae8a7 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg.1 @@ -0,0 +1,79 @@ +.TH dlg 1 "April 1994" "DLG" "PCCTS Manual Pages"
+.SH NAME
+dlg \- DFA Lexical Analyzer Generator
+.SH SYNTAX
+.LP
+\fBdlg\fR [\fIoptions\fR] \fIlexical_spec\fR [\fIoutput_file\fR]
+.SH DESCRIPTION
+.B dlg
+is a tool that produces fast deterministic finite automata for recognizing
+regular expressions in input.
+.SH OPTIONS
+.IP "\fB-CC\fR"
+Generate C++ output. The \fIoutput_file\fP is not specified in this
+case.
+.IP "\fB-C\fR[\fP level\fR]
+Where \fPlevel\fR is the compression level used. 0 indications no
+compression, 1 removes all unused characters from the transition from table,
+and 2 maps equivalent characters into the same character classes. It is
+suggested that level -C2 is used, since it will significantly reduce the size
+of the dfa produced for lexical analyzer.
+.IP "\fB-m\fP
+Produces the header file for the lexical mode with a name other than
+the default name of "mode.h".
+.IP \fB-i\fP
+An interactive, or as interactive as possible, parser is produced. A character
+is only obtained when required to decide which state to go to. Some care
+must be taken to obtain accept states that do not require look ahead at the
+next character to determine if that is the stop state. Any regular expression
+with a Kleene closure at the end is guaranteed to require another character
+of look ahead.
+.IP "\fB-cl\fP class
+Specify a class name for DLG to generate. The default is DLGLexer.
+'class' will be a subclass of DLGLexerBase; only used for -CC.
+.IP \fB-ci\fP
+The automaton will treat upper and lower case characters identically.
+This is accomplished in the automaton; the characters in the lexical
+buffer are unmodified.
+.IP \fB-cs\fP
+Upper and lower case characters are treated as distinct. This is the
+default.
+.IP "\fB-o\fP dir
+Directory where output files should go (default="."). This is very
+nice for keeping the source directory clear of ANTLR and DLG spawn.
+.IP \fB-Wambiguity\fP
+Warns if more than one regular expression could match the same character
+sequence. The warnings give the numbers of the expressions in the dlg
+lexical specification file. The numbering of the expressions starts at one.
+Multiple warnings may be print for the same expressions.
+.IP \-
+Used in place of file names to get input from standard in or send output
+to standard out.
+.SH "SPECIAL CONSIDERATIONS"
+.PP
+\fIDlg\fP works... we think. There is no implicit guarantee of
+anything. We reserve no \fBlegal\fP rights to the software known as
+the Purdue Compiler Construction Tool Set (PCCTS) \(em PCCTS is in the
+public domain. An individual or company may do whatever they wish
+with source code distributed with PCCTS or the code generated by
+PCCTS, including the incorporation of PCCTS, or its output, into
+commercial software. We encourage users to develop software with
+PCCTS. However, we do ask that credit is given to us for developing
+PCCTS. By "credit", we mean that if you incorporate our source code
+into one of your programs (commercial product, research project, or
+otherwise) that you acknowledge this fact somewhere in the
+documentation, research report, etc... If you like PCCTS and have
+developed a nice tool with the output, please mention that you
+developed it using PCCTS. As long as these guidelines are followed, we
+expect to continue enhancing this system and expect to make other
+tools available as they are completed.
+.SH FILES
+.B mode.h
+,
+.B dlgauto.h
+,
+.B dlgdef.h
+.SH SEE ALSO
+.BR antlr (1),
+.BR pccts (1)
+.SH BUGS
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg.h b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg.h new file mode 100644 index 0000000000..9f387c0a1c --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg.h @@ -0,0 +1,250 @@ +/* dlg header file
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * DLG 1.33
+ * Will Cohen
+ * With mods by Terence Parr; AHPCRC, University of Minnesota
+ * 1989-2001
+ */
+
+/* MR1 Move pcctscfg.h to top of file */
+
+#include "pcctscfg.h"
+
+/* turn off warnings for unreferenced labels */
+
+#ifdef _MSC_VER
+#pragma warning(disable:4102)
+#endif
+
+#include "set.h"
+
+#define TRUE 1
+#define FALSE 0
+
+/***** output related stuff *******************/
+#define IN input_stream
+#define OUT output_stream
+
+#define MAX_MODES 50 /* number of %%names allowed */
+#define MAX_ON_LINE 10
+
+#define NFA_MIN 64 /* minimum nfa_array size */
+#define DFA_MIN 64 /* minimum dfa_array size */
+
+#define DEFAULT_CLASSNAME "DLGLexer"
+
+/* these macros allow the size of the character set to be easily changed */
+/* NOTE: do NOT change MIN_CHAR since EOF is the lowest char, -1 */
+#define MIN_CHAR (-1) /* lowest possible character possible on input */
+#define MAX_CHAR 255 /* highest possible character possible on input */
+#define CHAR_RANGE (1+(MAX_CHAR) - (MIN_CHAR))
+
+/* indicates that the not an "array" reference */
+#define NIL_INDEX 0
+
+/* size of hash table used to find dfa_states quickly */
+#define HASH_SIZE 211
+
+#define nfa_node struct _nfa_node
+nfa_node {
+ int node_no;
+ int nfa_set;
+ int accept; /* what case to use */
+ nfa_node *trans[2];
+ set label; /* one arc always labelled with epsilon */
+};
+
+#define dfa_node struct _dfa_node
+dfa_node {
+ int node_no;
+ int dfa_set;
+ int alternatives; /* used for interactive mode */
+ /* are more characters needed */
+ int done;
+ set nfa_states;
+ int trans[1];/* size of transition table depends on
+ * number of classes required for automata.
+ */
+
+
+};
+
+/******** macros for accessing the NFA and DFA nodes ****/
+#define NFA(x) (nfa_array[x])
+#define DFA(x) (dfa_array[x])
+#define DFA_NO(x) ( (x) ? (x)->node_no : NIL_INDEX)
+#define NFA_NO(x) ( (x) ? (x)->node_no : NIL_INDEX)
+
+/******** wrapper for memory checking ***/
+/*#define malloc(x) dlg_malloc((x),__FILE__,__LINE__)*/
+
+/*#define calloc(x,y) dlg_calloc((x),(y),__FILE__,__LINE__)*/
+
+/******** antlr attributes *************/
+typedef struct {
+ unsigned char letter;
+ nfa_node *l,*r;
+ set label;
+ } Attrib;
+
+#define zzcr_attr(attr, token, text) { \
+ (attr)->letter = text[0]; (attr)->l = NULL; \
+ (attr)->r = NULL; (attr)->label = empty; \
+}
+#define zzd_attr(a) set_free((a)->label);
+
+/******************** Variable ******************************/
+extern char program[]; /* tells what program this is */
+extern char version[]; /* tells what version this is */
+extern char *file_str[]; /* file names being used */
+extern int err_found; /* flag to indicate error occured */
+extern int action_no; /* last action function printed */
+extern int func_action; /* should actions be turned into functions?*/
+extern set used_chars; /* used to label trans. arcs */
+extern set used_classes; /* classes or chars used to label trans. arcs */
+extern int class_no; /* number of classes used */
+extern set class_sets[]; /* shows char. in each class */
+extern set normal_chars; /* mask off unused portion of set */
+extern int comp_level; /* what compression level to use */
+extern int interactive; /* interactive scanner (avoid lookahead)*/
+extern int mode_counter; /* keeps track of the number of %%name */
+extern int dfa_basep[]; /* start of each group of dfa */
+extern int dfa_class_nop[];/* number of transistion arcs in */
+ /* each dfa in each mode */
+extern int nfa_allocated;
+extern int dfa_allocated;
+extern nfa_node **nfa_array; /* start of nfa "array" */
+extern dfa_node **dfa_array; /* start of dfa "array" */
+extern int operation_no; /* unique number for each operation */
+extern FILE *input_stream; /* where description read from */
+extern FILE *output_stream; /* where to put the output */
+extern FILE *mode_stream; /* where to put the mode output */
+extern FILE *class_stream;
+extern char *mode_file; /* name of file for mode output */
+extern int gen_ansi; /* produce ansi compatible code */
+extern int case_insensitive;/* ignore case of input spec. */
+extern int warn_ambig; /* show if regular expressions ambiguous */
+extern int gen_cpp;
+extern char *cl_file_str;
+extern int firstLexMember; /* MR1 */
+extern char *OutputDirectory;
+extern char *class_name;
+
+/******************** Functions ******************************/
+#ifdef __USE_PROTOS
+extern char *dlg_malloc(int, char *, int); /* wrapper malloc */
+extern char *dlg_calloc(int, int, char *, int); /* wrapper calloc */
+extern int reach(unsigned *, register int, unsigned *);
+extern set closure(set *, unsigned *);
+extern dfa_node *new_dfa_node(set);
+extern nfa_node *new_nfa_node(void);
+extern dfa_node *dfastate(set);
+extern dfa_node **nfa_to_dfa(nfa_node *);
+extern void internal_error(char *, char *, int); /* MR9 23-Sep-97 */
+extern FILE *read_stream(char *); /* opens file for reading */
+extern FILE *write_stream(char *); /* opens file for writing */
+extern void make_nfa_model_node(void);
+extern void make_dfa_model_node(int);
+extern char *ClassName(char *);
+extern char *OutMetaName(char *);
+extern void error(char*, int);
+extern void warning(char*, int);
+extern void p_head(void);
+extern void p_class_hdr(void);
+extern void p_includes(void);
+extern void p_tables(void);
+extern void p_tail(void); /* MR1 */
+extern void p_class_def1(void); /* MR1 */
+extern void new_automaton_mode(void); /* MR1 */
+extern int relabel(nfa_node *,int); /* MR1 */
+extern void p_shift_table(int); /* MR1 */
+extern void p_bshift_table(void); /* MR1 */
+extern void p_class_table(void); /* MR1 */
+extern void p_mode_def(char *,int); /* MR1 */
+extern void init(void); /* MR1 */
+extern void p_class_def2(void); /* MR1 */
+extern void clear_hash(void); /* MR1 */
+extern void p_alternative_table(void); /* MR1 */
+extern void p_node_table(void); /* MR1 */
+extern void p_dfa_table(void); /* MR1 */
+extern void p_accept_table(void); /* MR1 */
+extern void p_action_table(void); /* MR1 */
+extern void p_base_table(void); /* MR1 */
+extern void p_single_node(int,int); /* MR1 */
+extern char * minsize(int); /* MR1 */
+extern void close1(nfa_node *,int,set *); /* MR1 */
+extern void partition(nfa_node *,int); /* MR1 */
+extern void intersect_nfa_labels(nfa_node *,set *); /* MR1 */
+extern void r_intersect(nfa_node *,set *); /* MR1 */
+extern void label_node(nfa_node *); /* MR1 */
+extern void label_with_classes(nfa_node *); /* MR1 */
+
+#else
+extern char *dlg_malloc(); /* wrapper malloc */
+extern char *dlg_calloc(); /* wrapper calloc */
+extern int reach();
+extern set closure();
+extern dfa_node *new_dfa_node();
+extern nfa_node *new_nfa_node();
+extern dfa_node *dfastate();
+extern dfa_node **nfa_to_dfa();
+extern void internal_error(); /* MR9 23-Sep-97 */
+extern FILE *read_stream(); /* opens file for reading */
+extern FILE *write_stream(); /* opens file for writing */
+extern void make_nfa_model_node();
+extern void make_dfa_model_node();
+extern char *ClassName();
+extern char *OutMetaName();
+extern void error();
+extern void warning();
+extern void p_head(); /* MR9 */
+extern void p_class_hdr(); /* MR9 */
+extern void p_includes(); /* MR9 */
+extern void p_tables(); /* MR9 */
+extern void p_tail(); /* MR1 */
+extern void p_class_def1(); /* MR1 */
+extern void new_automaton_mode(); /* MR1 */
+extern int relabel(); /* MR1 */
+extern void p_shift_table(); /* MR1 */
+extern void p_bshift_table(); /* MR1 */
+extern void p_class_table(); /* MR1 */
+extern void p_mode_def(); /* MR1 */
+extern void init(); /* MR1 */
+extern void p_class_def2(); /* MR1 */
+extern void clear_hash(); /* MR1 */
+extern void p_alternative_table(); /* MR1 */
+extern void p_node_table(); /* MR1 */
+extern void p_dfa_table(); /* MR1 */
+extern void p_accept_table(); /* MR1 */
+extern void p_action_table(); /* MR1 */
+extern void p_base_table(); /* MR1 */
+extern void p_single_node(); /* MR1 */
+extern char * minsize(); /* MR1 */
+extern void close1(); /* MR1 */
+extern void partition(); /* MR1 */
+extern void intersect_nfa_labels(); /* MR1 */
+extern void r_intersect(); /* MR1 */
+extern void label_node(); /* MR1 */
+extern void label_with_classes(); /* MR1 */
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg.r b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg.r new file mode 100644 index 0000000000..c5311fa1b8 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg.r @@ -0,0 +1,275 @@ +/*
+ File: dlgMPW.r
+ Target: dlg 133MR
+ Created: Monday, June 15, 1998 4:44:11 AM
+ Author: Kenji Tanaka (kentar@osa.att.ne.jp)
+*/
+
+#include "cmdo.r"
+
+resource 'cmdo' (128, "Dlg") {
+ { /* array dialogs: 1 elements */
+ /* [1] */
+ 295,
+ "DLG -- Purdue Compiler Construction Tool"
+ " Set (PCCTS) lexical analyzer generator.",
+ { /* array itemArray: 18 elements */
+ /* [1] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {35, 175, 50, 225},
+ "On",
+ "-CC",
+ "When this control is checked, DLG genera"
+ "tes a scanner using C++ classes rather t"
+ "han C functions."
+ },
+ /* [2] */
+ Or {
+ { /* array OrArray: 1 elements */
+ /* [1] */
+ 1
+ }
+ },
+ RegularEntry {
+ "Lexer Class Name:",
+ {35, 225, 50, 355},
+ {35, 355, 51, 450},
+ "DLGLexer",
+ keepCase,
+ "-cl",
+ "This entry specifies the name DLG uses f"
+ "or the C++ lexer class."
+ },
+ /* [3] */
+ NotDependent {
+
+ },
+ TextBox {
+ gray,
+ {25, 165, 60, 460},
+ "C++ Code Generation"
+ },
+ /* [4] */
+ NotDependent {
+
+ },
+ Files {
+ InputFile,
+ RequiredFile {
+ {37, 25, 56, 135},
+ "Input File",
+ "",
+ "Choose the lexical description file for "
+ "DLG to process."
+ },
+ Additional {
+ "",
+ "",
+ "",
+ "",
+ { /* array TypesArray: 1 elements */
+ /* [1] */
+ text
+ }
+ }
+ },
+ /* [5] */
+ Or {
+ { /* array OrArray: 1 elements */
+ /* [1] */
+ -1
+ }
+ },
+ Files {
+ OutputFile,
+ RequiredFile {
+ {66, 25, 85, 135},
+ "Output File",
+ "",
+ "Choose the name of the file that will ho"
+ "ld the DLG-produced scanner."
+ },
+ NoMore {
+
+ }
+ },
+ /* [6] */
+ Or {
+ { /* array OrArray: 2 elements */
+ /* [1] */
+ 1,
+ /* [2] */
+ 5
+ }
+ },
+ Dummy {
+
+ },
+ /* [7] */
+ NotDependent {
+
+ },
+ Redirection {
+ DiagnosticOutput,
+ {90, 25}
+ },
+ /* [8] */
+ NotDependent {
+
+ },
+ TextBox {
+ gray,
+ {25, 20, 132, 145},
+ "Files"
+ },
+ /* [9] */
+ NotDependent {
+
+ },
+ Files {
+ DirOnly,
+ OptionalFile {
+ {68, 175, 84, 305},
+ {88, 175, 107, 305},
+ "Output Directory",
+ ":",
+ "-o",
+ "",
+ "Choose the directory where DLG will put "
+ "its output.",
+ dim,
+ "Output DirectoryI",
+ "",
+ ""
+ },
+ NoMore {
+
+ }
+ },
+ /* [10] */
+ NotDependent {
+
+ },
+ RegularEntry {
+ "Mode File Name:",
+ {68, 315, 83, 450},
+ {88, 315, 104, 450},
+ "mode.h",
+ keepCase,
+ "-m",
+ "This entry specifies the name DLG uses f"
+ "or its lexical mode output file."
+ },
+ /* [11] */
+ NotDependent {
+
+ },
+ RadioButtons {
+ { /* array radioArray: 3 elements */
+ /* [1] */
+ {134, 175, 149, 255}, "None", "", Set, "When this option is selected, DLG will n"
+ "ot compress its tables.",
+ /* [2] */
+ {134, 265, 149, 345}, "Level 1", "-C1", NotSet, "When this option is selected, DLG will r"
+ "emove all unused characters from the tra"
+ "nsition-from table.",
+ /* [3] */
+ {134, 360, 149, 450}, "Level 2", "-C2", NotSet, "When this option is selected, DLG will p"
+ "erform level 1 compression plus it will "
+ "map equivalent characters into the same "
+ "character classes."
+ }
+ },
+ /* [12] */
+ NotDependent {
+
+ },
+ TextBox {
+ gray,
+ {124, 165, 156, 460},
+ "Table Compression"
+ },
+ /* [13] */
+ NotDependent {
+
+ },
+ CheckOption {
+ Set,
+ {165, 20, 180, 145},
+ "Case Sensitive",
+ "-ci",
+ "When this control is checked, the DLG au"
+ "tomaton will treat upper and lower case "
+ "characters identically."
+ },
+ /* [14] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {165, 150, 180, 300},
+ "Interactive Scanner",
+ "-i",
+ "When this control is checked, DLG will g"
+ "enerate as interactive a scanner as poss"
+ "ible."
+ },
+ /* [15] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {165, 310, 180, 460},
+ "Ambiguity Warnings",
+ "-Wambiguity",
+ "When this control is checked, DLG warns "
+ "if more than one regular expression coul"
+ "d match the same character sequence."
+ },
+ /* [16] */
+ NotDependent {
+
+ },
+ VersionDialog {
+ VersionString {
+ "1.33MR"
+ },
+ "PCCTS was written by Terence Parr, Russe"
+ "ll Quong, Will Cohen, and Hank Dietz: 19"
+ "89-1998. MPW port by Scott Haney.",
+ noDialog
+ },
+ /* [17] */
+ And {
+ { /* array AndArray: 2 elements */
+ /* [1] */
+ 4,
+ /* [2] */
+ 6
+ }
+ },
+ DoItButton {
+
+ },
+ /* [18] */
+ NotDependent {
+
+ },
+ CheckOption {
+ NotSet,
+ {142, 20, 157, 148},
+ "Generate ANSI C",
+ "-ga",
+ "When this control is checked, DLG genera"
+ "tes ANSI C compatible code."
+ }
+ }
+ }
+};
+
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg1.txt b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg1.txt new file mode 100644 index 0000000000..06b320de2a --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg1.txt @@ -0,0 +1,132 @@ +
+
+
+dlg(1) PCCTS Manual Pages dlg(1)
+
+
+
+NAME
+ dlg - DFA Lexical Analyzer Generator
+
+SYNTAX
+ dlg [_o_p_t_i_o_n_s] _l_e_x_i_c_a_l__s_p_e_c [_o_u_t_p_u_t__f_i_l_e]
+
+DESCRIPTION
+ dlg is a tool that produces fast deterministic finite auto-
+ mata for recognizing regular expressions in input.
+
+OPTIONS
+ -CC Generate C++ output. The _o_u_t_p_u_t__f_i_l_e is not specified
+ in this case.
+
+ -C[ level]
+ Where level is the compression level used. 0 indica-
+ tions no compression, 1 removes all unused characters
+ from the transition from table, and 2 maps equivalent
+ characters into the same character classes. It is sug-
+ gested that level -C2 is used, since it will signifi-
+ cantly reduce the size of the dfa produced for lexical
+ analyzer.
+
+ -m Produces the header file for the lexical mode with a
+ name other than the default name of "mode.h".
+
+ -i An interactive, or as interactive as possible, parser
+ is produced. A character is only obtained when
+ required to decide which state to go to. Some care
+ must be taken to obtain accept states that do not
+ require look ahead at the next character to determine
+ if that is the stop state. Any regular expression with
+ a Kleene closure at the end is guaranteed to require
+ another character of look ahead.
+
+ -cl class
+ Specify a class name for DLG to generate. The default
+ is DLGLexer.
+
+ -ci The automaton will treat upper and lower case charac-
+ ters identically. This is accomplished in the automa-
+ ton; the characters in the lexical buffer are unmodi-
+ fied.
+
+ -cs Upper and lower case characters are treated as dis-
+ tinct. This is the default.
+
+ -o dir
+ Directory where output files should go (default=".").
+ This is very nice for keeping the source directory
+ clear of ANTLR and DLG spawn.
+
+ -Wambiguity
+ Warns if more than one regular expression could match
+ the same character sequence. The warnings give the
+ numbers of the expressions in the dlg lexical specifi-
+ cation file. The numbering of the expressions starts
+ at one. Multiple warnings may be print for the same
+ expressions.
+
+ - Used in place of file names to get input from standard
+ in or send output to standard out.
+
+SPECIAL CONSIDERATIONS
+ _D_l_g works... we think. There is no implicit guarantee of
+ anything. We reserve no legal rights to the software known
+ as the Purdue Compiler Construction Tool Set (PCCTS) - PCCTS
+ is in the public domain. An individual or company may do
+ whatever they wish with source code distributed with PCCTS
+ or the code generated by PCCTS, including the incorporation
+ of PCCTS, or its output, into commercial software. We
+ encourage users to develop software with PCCTS. However, we
+ do ask that credit is given to us for developing PCCTS. By
+ "credit", we mean that if you incorporate our source code
+ into one of your programs (commercial product, research pro-
+ ject, or otherwise) that you acknowledge this fact somewhere
+ in the documentation, research report, etc... If you like
+ PCCTS and have developed a nice tool with the output, please
+ mention that you developed it using PCCTS. As long as these
+ guidelines are followed, we expect to continue enhancing
+ this system and expect to make other tools available as they
+ are completed.
+
+FILES
+ mode.h , dlgauto.h , dlgdef.h
+
+SEE ALSO
+ antlr(1), pccts(1)
+
+BUGS
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_a.c b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_a.c new file mode 100644 index 0000000000..0b8982cf2a --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_a.c @@ -0,0 +1,1414 @@ +
+/* parser.dlg -- DLG Description of scanner
+ *
+ * Generated from: dlg_p.g
+ *
+ * Terence Parr, Will Cohen, and Hank Dietz: 1989-2001
+ * Purdue University Electrical Engineering
+ * With AHPCRC, University of Minnesota
+ * ANTLR Version 1.33MR33
+ */
+
+#define ANTLR_VERSION 13333
+#include "pcctscfg.h"
+#include "pccts_stdio.h"
+
+#include <ctype.h>
+#include "dlg.h"
+#include "antlr.h"
+#include "tokens.h"
+#include "dlgdef.h"
+LOOKAHEAD
+
+void
+#ifdef __USE_PROTOS
+zzerraction(void)
+#else
+zzerraction()
+#endif
+{
+ (*zzerr)("invalid token");
+ zzadvance();
+ zzskip();
+}
+/*
+ * D L G tables
+ *
+ * Generated from: parser.dlg
+ *
+ * 1989-2001 by Will Cohen, Terence Parr, and Hank Dietz
+ * Purdue University Electrical Engineering
+ * DLG Version 1.33MR33
+ */
+
+#include "mode.h"
+
+
+
+
+int func_action; /* should actions be turned into functions?*/
+int lex_mode_counter = 0; /* keeps track of the number of %%names */
+/* MR1 */
+/* MR1 11-Apr-97 Provide mechanism for inserting code into DLG class */
+/* MR1 via <<%%lexmember...>> */
+/* MR1 */
+int lexMember = 0; /* <<%%lexmemeber ...>> MR1 */
+int lexAction = 0; /* <<%%lexaction ...>> MR1 */
+int parserClass = 0; /* <<%%parserclass ...>> MR1 */
+int lexPrefix = 0; /* <<%%lexprefix ...>> MR1 */
+char theClassName[100]; /* MR11 */
+char *pClassName=theClassName; /* MR11 */
+int firstLexMember=1; /* MR1 */
+
+#ifdef __USE_PROTOS
+void xxputc(int c) { /* MR1 */
+#else
+ void xxputc(c) /* MR1 */
+ int c; /* MR1 */
+ { /* MR1 */
+#endif
+ if (parserClass) { /* MR1 */
+ *pClassName++=c; /* MR1 */
+ *pClassName=0; /* MR1 */
+ } else if (lexMember || lexPrefix) { /* MR1 */
+ if (class_stream != NULL) fputc(c,class_stream); /* MR1 */
+ } else { /* MR1 */
+ fputc(c,OUT); /* MR1 */
+ }; /* MR1 */
+ } /* MR1 */
+
+#ifdef __USE_PROTOS
+ void xxprintf(char *format,char *string) { /* MR1 */
+#else
+ void xxprintf(format,string) /* MR1 */
+ char *format; /* MR1 */
+ char *string; /* MR1 */
+ { /* MR1 */
+#endif
+ if (lexMember || lexPrefix || parserClass) { /* MR1 */
+ if (class_stream != NULL) /* MR1 */
+ fprintf(class_stream,format,string); /* MR1 */
+ } else { /* MR1 */
+ fprintf(OUT,format,string); /* MR1 */
+ }; /* MR1 */
+ } /* MR1 */
+
+static void act1()
+{
+ NLA = 1;
+ }
+
+
+static void act2()
+{
+ NLA = 2;
+ zzskip();
+ }
+
+
+static void act3()
+{
+ NLA = 3;
+ zzline++; zzskip(); DAWDLE;
+ }
+
+
+static void act4()
+{
+ NLA = L_EOF;
+ }
+
+
+static void act5()
+{
+ NLA = PER_PER;
+ }
+
+
+static void act6()
+{
+ NLA = NAME_PER_PER;
+ p_mode_def(&zzlextext[2],lex_mode_counter++);
+ }
+
+
+static void act7()
+{
+ NLA = LEXMEMBER;
+ lexMember=1; /* MR1 */
+ if (firstLexMember != 0) { /* MR1 */
+ firstLexMember=0; /* MR1 */
+ p_class_def1(); /* MR1 */
+ }; /* MR1 */
+ zzmode(ACT); /* MR1 */
+ }
+
+
+static void act8()
+{
+ NLA = LEXACTION;
+ lexAction=1;zzmode(ACT);
+ }
+
+
+static void act9()
+{
+ NLA = PARSERCLASS;
+ parserClass=1; /* MR1 */
+ zzmode(ACT); /* MR1 */
+ }
+
+
+static void act10()
+{
+ NLA = LEXPREFIX;
+ lexPrefix=1;zzmode(ACT);
+ }
+
+
+static void act11()
+{
+ NLA = ACTION;
+ if (func_action)
+ fprintf(OUT,"\n%s %sact%d()\n{ ",
+ gen_cpp?"ANTLRTokenType":"static void",
+ gen_cpp?ClassName("::"):"", ++action_no);
+ zzmode(ACT); zzskip();
+ }
+
+
+static void act12()
+{
+ NLA = GREAT_GREAT;
+ }
+
+
+static void act13()
+{
+ NLA = L_BRACE;
+ }
+
+
+static void act14()
+{
+ NLA = R_BRACE;
+ }
+
+
+static void act15()
+{
+ NLA = L_PAR;
+ }
+
+
+static void act16()
+{
+ NLA = R_PAR;
+ }
+
+
+static void act17()
+{
+ NLA = L_BRACK;
+ }
+
+
+static void act18()
+{
+ NLA = R_BRACK;
+ }
+
+
+static void act19()
+{
+ NLA = ZERO_MORE;
+ }
+
+
+static void act20()
+{
+ NLA = ONE_MORE;
+ }
+
+
+static void act21()
+{
+ NLA = OR;
+ }
+
+
+static void act22()
+{
+ NLA = RANGE;
+ }
+
+
+static void act23()
+{
+ NLA = NOT;
+ }
+
+
+static void act24()
+{
+ NLA = OCTAL_VALUE;
+ {int t; sscanf(&zzlextext[1],"%o",&t); zzlextext[0] = t;}
+ }
+
+
+static void act25()
+{
+ NLA = HEX_VALUE;
+ {int t; sscanf(&zzlextext[3],"%x",&t); zzlextext[0] = t;}
+ }
+
+
+static void act26()
+{
+ NLA = DEC_VALUE;
+ {int t; sscanf(&zzlextext[1],"%d",&t); zzlextext[0] = t;}
+ }
+
+
+static void act27()
+{
+ NLA = TAB;
+ zzlextext[0] = '\t';
+ }
+
+
+static void act28()
+{
+ NLA = NL;
+ zzlextext[0] = '\n';
+ }
+
+
+static void act29()
+{
+ NLA = CR;
+ zzlextext[0] = '\r';
+ }
+
+
+static void act30()
+{
+ NLA = BS;
+ zzlextext[0] = '\b';
+ }
+
+
+static void act31()
+{
+ NLA = CONTINUATION;
+ zzline++; zzskip();
+ }
+
+
+static void act32()
+{
+ NLA = LIT;
+ zzlextext[0] = zzlextext[1];
+ }
+
+
+static void act33()
+{
+ NLA = REGCHAR;
+ }
+
+static unsigned char shift0[257] = {
+ 0, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 1, 2, 40, 40, 1, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 1, 40, 40, 40, 40, 4, 40,
+ 40, 30, 31, 34, 35, 40, 37, 40, 40, 23,
+ 24, 24, 24, 24, 24, 24, 24, 25, 25, 40,
+ 40, 26, 40, 27, 40, 3, 21, 21, 21, 21,
+ 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
+ 22, 22, 22, 22, 22, 22, 22, 22, 22, 20,
+ 22, 22, 32, 39, 33, 40, 22, 40, 11, 9,
+ 12, 21, 6, 19, 22, 22, 14, 22, 22, 5,
+ 8, 16, 15, 17, 22, 10, 18, 13, 22, 22,
+ 22, 7, 22, 22, 28, 36, 29, 38, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40
+};
+
+
+static void act34()
+{
+ NLA = 1;
+ error("unterminated action", zzline); zzmode(START);
+ }
+
+
+static void act35()
+{
+ NLA = ACTION;
+ if (func_action) fprintf(OUT,"}\n\n");
+ zzmode(START);
+ /* MR1 */
+ /* MR1 11-Apr-97 Provide mechanism for inserting code into DLG class */
+ /* MR1 via <<%%lexmember ...>> */
+ /* MR1 This is a consequence of not saving actions */
+ /* MR1 */
+ /* MR1 */ parserClass=0;
+ /* MR1 */ lexPrefix=0;
+ /* MR1 */ lexAction=0;
+ /* MR1 */ lexMember=0;
+ }
+
+
+static void act36()
+{
+ NLA = 34;
+ xxputc(zzlextext[0]); zzskip();
+ }
+
+
+static void act37()
+{
+ NLA = 35;
+ xxputc('>'); zzskip();
+ }
+
+
+static void act38()
+{
+ NLA = 36;
+ xxputc('\\'); zzskip();
+ }
+
+
+static void act39()
+{
+ NLA = 37;
+ xxputc(zzlextext[0]); ++zzline; zzskip();
+ }
+
+
+static void act40()
+{
+ NLA = 38;
+ zzmode(ACTION_COMMENTS); /* MR1 */
+ xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
+ }
+
+
+static void act41()
+{
+ NLA = 39;
+ zzmode(ACTION_CPP_COMMENTS); /* MR1 */
+ xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
+ }
+
+
+static void act42()
+{
+ NLA = 40;
+ xxputc(zzlextext[0]); zzskip();
+ }
+
+static unsigned char shift1[257] = {
+ 0, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 3, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 5, 6, 6, 6, 6, 4, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 1, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 2, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6
+};
+
+
+static void act43()
+{
+ NLA = 1;
+ }
+
+
+static void act44()
+{
+ NLA = 41;
+ zzmode(ACT); /* MR1 */
+ xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
+ }
+
+
+static void act45()
+{
+ NLA = 42;
+ zzline++; xxputc(zzlextext[0]); zzskip();
+ }
+
+
+static void act46()
+{
+ NLA = 43;
+ xxputc(zzlextext[0]); zzskip();
+ }
+
+static unsigned char shift2[257] = {
+ 0, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 3, 4, 4, 3, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 1, 4, 4, 4, 4, 2, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4
+};
+
+
+static void act47()
+{
+ NLA = 1;
+ }
+
+
+static void act48()
+{
+ NLA = 44;
+ zzmode(ACT); zzline++; /* MR1 */
+ xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
+ }
+
+
+static void act49()
+{
+ NLA = 45;
+ xxputc(zzlextext[0]); zzskip();
+ }
+
+static unsigned char shift3[257] = {
+ 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 1, 2, 2, 1, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2
+};
+
+#define DfaStates 94
+typedef unsigned char DfaState;
+
+static DfaState st0[42] = {
+ 1, 2, 3, 4, 5, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 7, 8, 9, 10,
+ 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+ 6, 94
+};
+
+static DfaState st1[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st2[42] = {
+ 94, 21, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st3[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st4[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st5[42] = {
+ 94, 94, 94, 94, 22, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st6[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st7[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 23, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st8[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 24, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st9[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st10[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st11[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st12[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st13[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st14[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st15[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st16[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st17[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st18[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st19[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st20[42] = {
+ 94, 25, 26, 25, 25, 25, 25, 25, 25, 27,
+ 28, 25, 25, 29, 25, 25, 30, 25, 25, 25,
+ 25, 25, 25, 31, 32, 32, 25, 25, 25, 25,
+ 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+ 25, 94
+};
+
+static DfaState st21[42] = {
+ 94, 21, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st22[42] = {
+ 94, 94, 94, 94, 94, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st23[42] = {
+ 94, 94, 94, 94, 34, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st24[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st25[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st26[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st27[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st28[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st29[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st30[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st31[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 35, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 35, 94, 94, 36, 36, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st32[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 37, 37, 37, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st33[42] = {
+ 94, 94, 94, 94, 94, 38, 38, 38, 38, 38,
+ 38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
+ 38, 38, 38, 38, 38, 38, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st34[42] = {
+ 94, 94, 94, 94, 39, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st35[42] = {
+ 94, 94, 94, 94, 94, 94, 40, 94, 94, 40,
+ 94, 40, 40, 94, 94, 94, 94, 94, 94, 40,
+ 94, 40, 94, 40, 40, 40, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st36[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 36, 36, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st37[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 37, 37, 37, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st38[42] = {
+ 94, 94, 94, 94, 94, 38, 38, 38, 38, 38,
+ 38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
+ 38, 38, 38, 38, 38, 38, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st39[42] = {
+ 94, 94, 94, 94, 94, 41, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 42, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st40[42] = {
+ 94, 94, 94, 94, 94, 94, 40, 94, 94, 40,
+ 94, 40, 40, 94, 94, 94, 94, 94, 94, 40,
+ 94, 40, 94, 40, 40, 40, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st41[42] = {
+ 94, 94, 94, 94, 94, 94, 43, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st42[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 44, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st43[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 45, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st44[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 46, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st45[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 47, 94,
+ 94, 48, 94, 94, 94, 94, 94, 49, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st46[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 50, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st47[42] = {
+ 94, 94, 94, 94, 94, 94, 51, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st48[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 52, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st49[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 53, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st50[42] = {
+ 94, 94, 94, 94, 94, 94, 54, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st51[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 55, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st52[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 56, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st53[42] = {
+ 94, 94, 94, 94, 94, 94, 57, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st54[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 58, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st55[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 59,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st56[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 60, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st57[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 61,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st58[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 62, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st59[42] = {
+ 94, 94, 94, 94, 94, 94, 63, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st60[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 64, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st61[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 65, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st62[42] = {
+ 94, 94, 94, 94, 94, 66, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st63[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 67, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st64[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 68, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st65[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 69, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st66[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 70, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st67[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st68[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st69[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st70[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 71, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st71[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 72, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st72[42] = {
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94
+};
+
+static DfaState st73[8] = {
+ 74, 75, 76, 77, 78, 79, 79, 94
+};
+
+static DfaState st74[8] = {
+ 94, 94, 94, 94, 94, 94, 94, 94
+};
+
+static DfaState st75[8] = {
+ 94, 80, 94, 94, 94, 94, 94, 94
+};
+
+static DfaState st76[8] = {
+ 94, 81, 94, 94, 94, 94, 94, 94
+};
+
+static DfaState st77[8] = {
+ 94, 94, 94, 94, 94, 94, 94, 94
+};
+
+static DfaState st78[8] = {
+ 94, 94, 94, 94, 82, 83, 94, 94
+};
+
+static DfaState st79[8] = {
+ 94, 94, 94, 94, 94, 94, 94, 94
+};
+
+static DfaState st80[8] = {
+ 94, 94, 94, 94, 94, 94, 94, 94
+};
+
+static DfaState st81[8] = {
+ 94, 94, 94, 94, 94, 94, 94, 94
+};
+
+static DfaState st82[8] = {
+ 94, 94, 94, 94, 94, 94, 94, 94
+};
+
+static DfaState st83[8] = {
+ 94, 94, 94, 94, 94, 94, 94, 94
+};
+
+static DfaState st84[6] = {
+ 85, 86, 87, 88, 87, 94
+};
+
+static DfaState st85[6] = {
+ 94, 94, 94, 94, 94, 94
+};
+
+static DfaState st86[6] = {
+ 94, 94, 89, 94, 94, 94
+};
+
+static DfaState st87[6] = {
+ 94, 94, 94, 94, 94, 94
+};
+
+static DfaState st88[6] = {
+ 94, 94, 94, 94, 94, 94
+};
+
+static DfaState st89[6] = {
+ 94, 94, 94, 94, 94, 94
+};
+
+static DfaState st90[4] = {
+ 91, 92, 93, 94
+};
+
+static DfaState st91[4] = {
+ 94, 94, 94, 94
+};
+
+static DfaState st92[4] = {
+ 94, 94, 94, 94
+};
+
+static DfaState st93[4] = {
+ 94, 94, 94, 94
+};
+
+
+DfaState *dfa[94] = {
+ st0,
+ st1,
+ st2,
+ st3,
+ st4,
+ st5,
+ st6,
+ st7,
+ st8,
+ st9,
+ st10,
+ st11,
+ st12,
+ st13,
+ st14,
+ st15,
+ st16,
+ st17,
+ st18,
+ st19,
+ st20,
+ st21,
+ st22,
+ st23,
+ st24,
+ st25,
+ st26,
+ st27,
+ st28,
+ st29,
+ st30,
+ st31,
+ st32,
+ st33,
+ st34,
+ st35,
+ st36,
+ st37,
+ st38,
+ st39,
+ st40,
+ st41,
+ st42,
+ st43,
+ st44,
+ st45,
+ st46,
+ st47,
+ st48,
+ st49,
+ st50,
+ st51,
+ st52,
+ st53,
+ st54,
+ st55,
+ st56,
+ st57,
+ st58,
+ st59,
+ st60,
+ st61,
+ st62,
+ st63,
+ st64,
+ st65,
+ st66,
+ st67,
+ st68,
+ st69,
+ st70,
+ st71,
+ st72,
+ st73,
+ st74,
+ st75,
+ st76,
+ st77,
+ st78,
+ st79,
+ st80,
+ st81,
+ st82,
+ st83,
+ st84,
+ st85,
+ st86,
+ st87,
+ st88,
+ st89,
+ st90,
+ st91,
+ st92,
+ st93
+};
+
+
+DfaState accepts[95] = {
+ 0, 1, 2, 3, 4, 33, 33, 33, 33, 13,
+ 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
+ 0, 2, 5, 11, 12, 32, 31, 30, 29, 27,
+ 28, 24, 26, 6, 0, 0, 24, 26, 6, 0,
+ 25, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 7, 8, 10,
+ 0, 0, 9, 0, 34, 36, 38, 39, 42, 42,
+ 35, 37, 41, 40, 0, 43, 46, 46, 45, 44,
+ 0, 47, 48, 49, 0
+};
+
+void (*actions[50])() = {
+ zzerraction,
+ act1,
+ act2,
+ act3,
+ act4,
+ act5,
+ act6,
+ act7,
+ act8,
+ act9,
+ act10,
+ act11,
+ act12,
+ act13,
+ act14,
+ act15,
+ act16,
+ act17,
+ act18,
+ act19,
+ act20,
+ act21,
+ act22,
+ act23,
+ act24,
+ act25,
+ act26,
+ act27,
+ act28,
+ act29,
+ act30,
+ act31,
+ act32,
+ act33,
+ act34,
+ act35,
+ act36,
+ act37,
+ act38,
+ act39,
+ act40,
+ act41,
+ act42,
+ act43,
+ act44,
+ act45,
+ act46,
+ act47,
+ act48,
+ act49
+};
+
+static DfaState dfa_base[] = {
+ 0,
+ 73,
+ 84,
+ 90
+};
+
+static unsigned char *b_class_no[] = {
+ shift0,
+ shift1,
+ shift2,
+ shift3
+};
+
+
+
+#define ZZSHIFT(c) (b_class_no[zzauto][1+c])
+#define MAX_MODE 4
+#include "dlgauto.h"
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_p.c b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_p.c new file mode 100644 index 0000000000..e726ae3983 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_p.c @@ -0,0 +1,959 @@ +/*
+ * A n t l r T r a n s l a t i o n H e a d e r
+ *
+ * Terence Parr, Will Cohen, and Hank Dietz: 1989-2001
+ * Purdue University Electrical Engineering
+ * With AHPCRC, University of Minnesota
+ * ANTLR Version 1.33MR33
+ *
+ * ..\bin\antlr dlg_p.g -gh
+ *
+ */
+
+#define ANTLR_VERSION 13333
+#include "pcctscfg.h"
+#include "pccts_stdio.h"
+
+#include <ctype.h>
+#include "dlg.h"
+#define zzSET_SIZE 8
+#include "antlr.h"
+#include "tokens.h"
+#include "dlgdef.h"
+#include "mode.h"
+
+/* MR23 In order to remove calls to PURIFY use the antlr -nopurify option */
+
+#ifndef PCCTS_PURIFY
+#define PCCTS_PURIFY(r,s) memset((char *) &(r),'\0',(s));
+#endif
+
+ANTLR_INFO
+
+
+/* MR20 G. Hobbelt
+Fix for Borland C++ 4.x & 5.x compiling with ALL warnings enabled
+*/
+
+#ifdef __TURBOC__
+#pragma warn -aus /* unused assignment of 'xxx' */
+#endif
+
+int action_no = 0; /* keep track of actions outputed */
+int nfa_allocated = 0; /* keeps track of number of nfa nodes */
+nfa_node **nfa_array = NULL;/* root of binary tree that stores nfa array */
+nfa_node nfa_model_node; /* model to initialize new nodes */
+set used_chars; /* used to label trans. arcs */
+set used_classes; /* classes or chars used to label trans. arcs */
+set normal_chars; /* mask to get rid elements that aren't used
+in set */
+int flag_paren = FALSE;
+int flag_brace = FALSE;
+int mode_counter = 0; /* keep track of number of %%names */
+
+
+
+void
+#ifdef __USE_PROTOS
+grammar(void)
+#else
+grammar()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ p_head(); p_class_hdr(); func_action = FALSE;
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ while ( (setwd1[LA(1)]&0x1) ) {
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ if ( (LA(1)==LEXACTION) ) {
+ zzmatch(LEXACTION); zzCONSUME;
+ }
+ else {
+ if ( (LA(1)==LEXMEMBER) ) {
+ zzmatch(LEXMEMBER); zzCONSUME;
+ }
+ else {
+ if ( (LA(1)==LEXPREFIX) ) {
+ zzmatch(LEXPREFIX); zzCONSUME;
+ }
+ else {
+ if ( (LA(1)==PARSERCLASS) ) {
+ zzmatch(PARSERCLASS); zzCONSUME;
+ }
+ else {
+ if ( (LA(1)==ACTION) ) {
+ }
+ else {zzFAIL(1,zzerr1,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ }
+ }
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+ zzmatch(ACTION); zzCONSUME;
+ zzLOOP(zztasp2);
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ if ( gen_cpp ) p_includes();
+ start_states();
+ func_action = FALSE; p_tables(); p_tail();
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ while ( (LA(1)==ACTION) ) {
+ zzmatch(ACTION); zzCONSUME;
+ zzLOOP(zztasp2);
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ zzmatch(1);
+ if (firstLexMember != 0) p_class_def1();
+ zzCONSUME;
+
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd1, 0x2);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+start_states(void)
+#else
+start_states()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==PER_PER) ) {
+ zzmatch(PER_PER); zzCONSUME;
+ do_conversion();
+ }
+ else {
+ if ( (LA(1)==NAME_PER_PER) ) {
+ zzmatch(NAME_PER_PER); zzCONSUME;
+ do_conversion();
+ {
+ zzBLOCK(zztasp3);
+ zzMake0;
+ {
+ while ( (LA(1)==NAME_PER_PER) ) {
+ zzmatch(NAME_PER_PER); zzCONSUME;
+ do_conversion();
+ zzLOOP(zztasp3);
+ }
+ zzEXIT(zztasp3);
+ }
+ }
+ }
+ else {zzFAIL(1,zzerr2,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ zzmatch(PER_PER); zzCONSUME;
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd1, 0x4);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+do_conversion(void)
+#else
+do_conversion()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ new_automaton_mode(); func_action = TRUE;
+ rule_list();
+
+ dfa_class_nop[mode_counter] =
+ relabel(zzaArg(zztasp1,1 ).l,comp_level);
+ if (comp_level)
+ p_shift_table(mode_counter);
+ dfa_basep[mode_counter] = dfa_allocated+1;
+ make_dfa_model_node(dfa_class_nop[mode_counter]);
+ nfa_to_dfa(zzaArg(zztasp1,1 ).l);
+ ++mode_counter;
+ func_action = FALSE;
+#ifdef HASH_STAT
+ fprint_hash_stats(stderr);
+#endif
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd1, 0x8);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+rule_list(void)
+#else
+rule_list()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ if ( (setwd1[LA(1)]&0x10) ) {
+ rule();
+ zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ while ( (setwd1[LA(1)]&0x20) ) {
+ rule();
+ {nfa_node *t1;
+ t1 = new_nfa_node();
+ (t1)->trans[0]=zzaRet.l;
+ (t1)->trans[1]=zzaArg(zztasp2,1 ).l;
+ /* all accept nodes "dead ends" */
+ zzaRet.l=t1; zzaRet.r=NULL;
+ }
+ zzLOOP(zztasp2);
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ }
+ else {
+ if ( (setwd1[LA(1)]&0x40) ) {
+ zzaRet.l = new_nfa_node(); zzaRet.r = NULL;
+ warning("no regular expressions", zzline);
+ }
+ else {zzFAIL(1,zzerr3,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd1, 0x80);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+rule(void)
+#else
+rule()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ if ( (setwd2[LA(1)]&0x1) ) {
+ reg_expr();
+ zzmatch(ACTION);
+ if (zzaArg(zztasp1,1 ).r != NULL) {
+ zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r; (zzaArg(zztasp1,1 ).r)->accept=action_no;
+ }
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==ACTION) ) {
+ zzmatch(ACTION);
+ zzaRet.l = NULL; zzaRet.r = NULL;
+ error("no expression for action ", zzline);
+ zzCONSUME;
+
+ }
+ else {zzFAIL(1,zzerr4,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd2, 0x2);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+reg_expr(void)
+#else
+reg_expr()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ and_expr();
+ zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ while ( (LA(1)==OR) ) {
+ zzmatch(OR); zzCONSUME;
+ and_expr();
+ {nfa_node *t1, *t2;
+ t1 = new_nfa_node(); t2 = new_nfa_node();
+ (t1)->trans[0]=zzaRet.l;
+ (t1)->trans[1]=zzaArg(zztasp2,2 ).l;
+ /* MR23 */ if (zzaRet.r != NULL) (zzaRet.r)->trans[1]=t2;
+ if (zzaArg(zztasp2,2 ).r) {
+ (zzaArg(zztasp2,2 ).r)->trans[1]=t2; /* MR20 */
+ }
+ zzaRet.l=t1; zzaRet.r=t2;
+ }
+ zzLOOP(zztasp2);
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd2, 0x4);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+and_expr(void)
+#else
+and_expr()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ repeat_expr();
+
+ zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ while ( (setwd2[LA(1)]&0x8) ) {
+ repeat_expr();
+ if (zzaRet.r != NULL) {
+ (zzaRet.r)->trans[1]=zzaArg(zztasp2,1 ).l;
+ zzaRet.r=zzaArg(zztasp2,1 ).r;
+ }
+ zzLOOP(zztasp2);
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd2, 0x10);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+repeat_expr(void)
+#else
+repeat_expr()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ if ( (setwd2[LA(1)]&0x20) ) {
+ expr();
+ zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==ZERO_MORE) ) {
+ zzmatch(ZERO_MORE);
+ { nfa_node *t1,*t2;
+ /* MR23 */ if (zzaRet.r != NULL) (zzaRet.r)->trans[0] = zzaRet.l;
+ t1 = new_nfa_node(); t2 = new_nfa_node();
+ t1->trans[0]=zzaRet.l;
+ t1->trans[1]=t2;
+ /* MR23 */ if (zzaRet.r != NULL) (zzaRet.r)->trans[1]=t2;
+ zzaRet.l=t1;zzaRet.r=t2;
+ }
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==ONE_MORE) ) {
+ zzmatch(ONE_MORE);
+ if (zzaRet.r != NULL) (zzaRet.r)->trans[0] = zzaRet.l;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd2[LA(1)]&0x40) ) {
+ }
+ else {zzFAIL(1,zzerr5,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ }
+ else {
+ if ( (LA(1)==ZERO_MORE) ) {
+ zzmatch(ZERO_MORE);
+ error("no expression for *", zzline);
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==ONE_MORE) ) {
+ zzmatch(ONE_MORE);
+ error("no expression for +", zzline);
+ zzCONSUME;
+
+ }
+ else {zzFAIL(1,zzerr6,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ }
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd2, 0x80);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+expr(void)
+#else
+expr()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ zzaRet.l = new_nfa_node();
+ zzaRet.r = new_nfa_node();
+ if ( (LA(1)==L_BRACK) ) {
+ zzmatch(L_BRACK); zzCONSUME;
+ atom_list();
+ zzmatch(R_BRACK);
+
+ /* MR23 */ if (zzaRet.l != NULL) {
+ (zzaRet.l)->trans[0] = zzaRet.r;
+ (zzaRet.l)->label = set_dup(zzaArg(zztasp1,2 ).label);
+ set_orin(&used_chars,(zzaRet.l)->label);
+ }
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==NOT) ) {
+ zzmatch(NOT); zzCONSUME;
+ zzmatch(L_BRACK); zzCONSUME;
+ atom_list();
+ zzmatch(R_BRACK);
+
+ /* MR23 */ if (zzaRet.l != NULL) {
+ (zzaRet.l)->trans[0] = zzaRet.r;
+ (zzaRet.l)->label = set_dif(normal_chars,zzaArg(zztasp1,3 ).label);
+ set_orin(&used_chars,(zzaRet.l)->label);
+ }
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==L_PAR) ) {
+ zzmatch(L_PAR); zzCONSUME;
+ reg_expr();
+ zzmatch(R_PAR);
+
+ /* MR23 */ if (zzaRet.l != NULL) {
+ (zzaRet.l)->trans[0] = zzaArg(zztasp1,2 ).l;
+ if (zzaArg(zztasp1,2 ).r) {
+ (zzaArg(zztasp1,2 ).r)->trans[1] = zzaRet.r; /* MR20 */
+ }
+ }
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==L_BRACE) ) {
+ zzmatch(L_BRACE); zzCONSUME;
+ reg_expr();
+ zzmatch(R_BRACE);
+
+ /* MR23 */ if (zzaRet.l != NULL) {
+ (zzaRet.l)->trans[0] = zzaArg(zztasp1,2 ).l;
+ (zzaRet.l)->trans[1] = zzaRet.r;
+ if (zzaArg(zztasp1,2 ).r) {
+ (zzaArg(zztasp1,2 ).r)->trans[1] = zzaRet.r; /* MR20 */
+ }
+ }
+ zzCONSUME;
+
+ }
+ else {
+ if ( (setwd3[LA(1)]&0x1) ) {
+ atom();
+
+ /* MR23 */ if (zzaRet.l != NULL) {
+ (zzaRet.l)->trans[0] = zzaRet.r;
+ (zzaRet.l)->label = set_dup(zzaArg(zztasp1,1 ).label);
+ set_orin(&used_chars,(zzaRet.l)->label);
+ }
+ }
+ else {zzFAIL(1,zzerr7,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ }
+ }
+ }
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd3, 0x2);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+atom_list(void)
+#else
+atom_list()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ set_free(zzaRet.label);
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ while ( (setwd3[LA(1)]&0x4) ) {
+ near_atom();
+ set_orin(&(zzaRet.label),zzaArg(zztasp2,1 ).label);
+ zzLOOP(zztasp2);
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd3, 0x8);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+near_atom(void)
+#else
+near_atom()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ register int i;
+ register int i_prime;
+ anychar();
+ zzaRet.letter=zzaArg(zztasp1,1 ).letter; zzaRet.label=set_of(zzaArg(zztasp1,1 ).letter);
+ i_prime = zzaArg(zztasp1,1 ).letter + MIN_CHAR;
+ if (case_insensitive && islower(i_prime))
+ set_orel(toupper(i_prime)-MIN_CHAR,
+ &(zzaRet.label));
+ if (case_insensitive && isupper(i_prime))
+ set_orel(tolower(i_prime)-MIN_CHAR,
+ &(zzaRet.label));
+ {
+ zzBLOCK(zztasp2);
+ zzMake0;
+ {
+ if ( (LA(1)==RANGE) ) {
+ zzmatch(RANGE); zzCONSUME;
+ anychar();
+ if (case_insensitive){
+ i_prime = zzaRet.letter+MIN_CHAR;
+ zzaRet.letter = (islower(i_prime) ?
+ toupper(i_prime) : i_prime)-MIN_CHAR;
+ i_prime = zzaArg(zztasp2,2 ).letter+MIN_CHAR;
+ zzaArg(zztasp2,2 ).letter = (islower(i_prime) ?
+ toupper(i_prime) : i_prime)-MIN_CHAR;
+ }
+ /* check to see if range okay */
+ {
+ int debugLetter1 = zzaRet.letter;
+ int debugLetter2 = zzaArg(zztasp2,2 ).letter;
+ }
+ if (zzaRet.letter > zzaArg(zztasp2,2 ).letter
+ && zzaArg(zztasp2,2 ).letter != 0xff){ /* MR16 */
+ error("invalid range ", zzline);
+ }
+ for (i=zzaRet.letter; i<= (int)zzaArg(zztasp2,2 ).letter; ++i){
+ set_orel(i,&(zzaRet.label));
+ i_prime = i+MIN_CHAR;
+ if (case_insensitive && islower(i_prime))
+ set_orel(toupper(i_prime)-MIN_CHAR,
+ &(zzaRet.label));
+ if (case_insensitive && isupper(i_prime))
+ set_orel(tolower(i_prime)-MIN_CHAR,
+ &(zzaRet.label));
+ }
+ }
+ else {
+ if ( (setwd3[LA(1)]&0x10) ) {
+ }
+ else {zzFAIL(1,zzerr8,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ zzEXIT(zztasp2);
+ }
+ }
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd3, 0x20);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+atom(void)
+#else
+atom()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ register int i_prime;
+ anychar();
+ zzaRet.label = set_of(zzaArg(zztasp1,1 ).letter);
+ i_prime = zzaArg(zztasp1,1 ).letter + MIN_CHAR;
+ if (case_insensitive && islower(i_prime))
+ set_orel(toupper(i_prime)-MIN_CHAR,
+ &(zzaRet.label));
+ if (case_insensitive && isupper(i_prime))
+ set_orel(tolower(i_prime)-MIN_CHAR,
+ &(zzaRet.label));
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd3, 0x40);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+anychar(void)
+#else
+anychar()
+#endif
+{
+ zzRULE;
+ zzBLOCK(zztasp1);
+ zzMake0;
+ {
+ if ( (LA(1)==REGCHAR) ) {
+ zzmatch(REGCHAR);
+ zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==OCTAL_VALUE) ) {
+ zzmatch(OCTAL_VALUE);
+ zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==HEX_VALUE) ) {
+ zzmatch(HEX_VALUE);
+ zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==DEC_VALUE) ) {
+ zzmatch(DEC_VALUE);
+ zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==TAB) ) {
+ zzmatch(TAB);
+ zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==NL) ) {
+ zzmatch(NL);
+ zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==CR) ) {
+ zzmatch(CR);
+ zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==BS) ) {
+ zzmatch(BS);
+ zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==LIT) ) {
+ zzmatch(LIT);
+ zzaRet.letter = zzaArg(zztasp1,1 ).letter - MIN_CHAR;
+ zzCONSUME;
+
+ }
+ else {
+ if ( (LA(1)==L_EOF) ) {
+ zzmatch(L_EOF);
+ zzaRet.letter = 0;
+ zzCONSUME;
+
+ }
+ else {zzFAIL(1,zzerr9,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ zzEXIT(zztasp1);
+ return;
+fail:
+ zzEXIT(zztasp1);
+ /* empty action */
+ zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
+ zzresynch(setwd3, 0x80);
+ }
+}
+
+/* adds a new nfa to the binary tree and returns a pointer to it */
+nfa_node *
+#ifdef __USE_PROTOS
+new_nfa_node(void)
+#else
+new_nfa_node()
+#endif
+{
+ register nfa_node *t;
+ static int nfa_size=0; /* elements nfa_array[] can hold */
+
+ ++nfa_allocated;
+ if (nfa_size<=nfa_allocated){
+ /* need to redo array */
+ if (!nfa_array){
+ /* need some to do inital allocation */
+ nfa_size=nfa_allocated+NFA_MIN;
+ nfa_array=(nfa_node **) malloc(sizeof(nfa_node*)*
+ nfa_size);
+ }else{
+ /* need more space */
+ nfa_size=2*(nfa_allocated+1);
+ nfa_array=(nfa_node **) realloc(nfa_array,
+ sizeof(nfa_node*)*nfa_size);
+ }
+ }
+ /* fill out entry in array */
+ t = (nfa_node*) malloc(sizeof(nfa_node));
+ nfa_array[nfa_allocated] = t;
+ *t = nfa_model_node;
+ t->node_no = nfa_allocated;
+ return t;
+}
+
+
+/* initialize the model node used to fill in newly made nfa_nodes */
+void
+#ifdef __USE_PROTOS
+make_nfa_model_node(void)
+#else
+make_nfa_model_node()
+#endif
+{
+ nfa_model_node.node_no = -1; /* impossible value for real nfa node */
+ nfa_model_node.nfa_set = 0;
+ nfa_model_node.accept = 0; /* error state default*/
+ nfa_model_node.trans[0] = NULL;
+ nfa_model_node.trans[1] = NULL;
+ nfa_model_node.label = empty;
+}
+
+#if defined(DEBUG) || defined(_DEBUG)
+
+/* print out the pointer value and the node_number */
+void
+#ifdef __USE_PROTOS
+fprint_dfa_pair(FILE *f, nfa_node *p)
+#else
+fprint_dfa_pair(f, p)
+FILE *f;
+nfa_node *p;
+#endif
+{
+ if (p){
+ fprintf(f, "%x (%d)", p, p->node_no);
+ }else{
+ fprintf(f, "(nil)");
+ }
+}
+
+/* print out interest information on a set */
+void
+#ifdef __USE_PROTOS
+fprint_set(FILE *f, set s)
+#else
+fprint_set(f,s)
+FILE *f;
+set s;
+#endif
+{
+ unsigned int *x;
+
+ fprintf(f, "n = %d,", s.n);
+ if (s.setword){
+ fprintf(f, "setword = %x, ", s.setword);
+ /* print out all the elements in the set */
+ x = set_pdq(s);
+ while (*x!=nil){
+ fprintf(f, "%d ", *x);
+ ++x;
+ }
+ }else{
+ fprintf(f, "setword = (nil)");
+ }
+}
+
+/* code to be able to dump out the nfas
+return 0 if okay dump
+return 1 if screwed up
+*/
+int
+#ifdef __USE_PROTOS
+dump_nfas(int first_node, int last_node)
+#else
+dump_nfas(first_node, last_node)
+int first_node;
+int last_node;
+#endif
+{
+ register int i;
+ nfa_node *t;
+
+ for (i=first_node; i<=last_node; ++i){
+ t = NFA(i);
+ if (!t) break;
+ fprintf(stderr, "nfa_node %d {\n", t->node_no);
+ fprintf(stderr, "\n\tnfa_set = %d\n", t->nfa_set);
+ fprintf(stderr, "\taccept\t=\t%d\n", t->accept);
+ fprintf(stderr, "\ttrans\t=\t(");
+ fprint_dfa_pair(stderr, t->trans[0]);
+ fprintf(stderr, ",");
+ fprint_dfa_pair(stderr, t->trans[1]);
+ fprintf(stderr, ")\n");
+ fprintf(stderr, "\tlabel\t=\t{ ");
+ fprint_set(stderr, t->label);
+ fprintf(stderr, "\t}\n");
+ fprintf(stderr, "}\n\n");
+ }
+ return 0;
+}
+#endif
+
+/* DLG-specific syntax error message generator
+* (define USER_ZZSYN when compiling so don't get 2 definitions)
+*/
+void
+#ifdef __USE_PROTOS
+zzsyn(char *text, int tok, char *egroup, SetWordType *eset, int etok, int k, char *bad_text)
+#else
+zzsyn(text, tok, egroup, eset, etok, k, bad_text)
+char *text, *egroup, *bad_text;
+int tok;
+int etok;
+int k;
+SetWordType *eset;
+#endif
+{
+fprintf(stderr, ErrHdr, file_str[0]!=NULL?file_str[0]:"stdin", zzline);
+fprintf(stderr, " syntax error at \"%s\"", (tok==zzEOF_TOKEN)?"EOF":text);
+if ( !etok && !eset ) {fprintf(stderr, "\n"); return;}
+if ( k==1 ) fprintf(stderr, " missing");
+else
+{
+fprintf(stderr, "; \"%s\" not", bad_text);
+if ( zzset_deg(eset)>1 ) fprintf(stderr, " in");
+}
+if ( zzset_deg(eset)>0 ) zzedecode(eset);
+else fprintf(stderr, " %s", zztokens[etok]);
+if ( strlen(egroup) > (size_t)0 ) fprintf(stderr, " in %s", egroup);
+fprintf(stderr, "\n");
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_p.g b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_p.g new file mode 100644 index 0000000000..58ca110693 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_p.g @@ -0,0 +1,614 @@ +/* This is the parser for the dlg
+ * This is a part of the Purdue Compiler Construction Tool Set
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * DLG 1.33
+ * Will Cohen
+ * With mods by Terence Parr; AHPCRC, University of Minnesota
+ * 1989-1995
+ */
+
+#header <<
+#include <ctype.h>
+#include "dlg.h"
+>>
+
+<<
+
+/* MR20 G. Hobbelt
+ Fix for Borland C++ 4.x & 5.x compiling with ALL warnings enabled
+*/
+
+#ifdef __TURBOC__
+#pragma warn -aus /* unused assignment of 'xxx' */
+#endif
+
+int action_no = 0; /* keep track of actions outputed */
+int nfa_allocated = 0; /* keeps track of number of nfa nodes */
+nfa_node **nfa_array = NULL;/* root of binary tree that stores nfa array */
+nfa_node nfa_model_node; /* model to initialize new nodes */
+set used_chars; /* used to label trans. arcs */
+set used_classes; /* classes or chars used to label trans. arcs */
+set normal_chars; /* mask to get rid elements that aren't used
+ in set */
+int flag_paren = FALSE;
+int flag_brace = FALSE;
+int mode_counter = 0; /* keep track of number of %%names */
+
+>>
+
+#lexaction <<
+int func_action; /* should actions be turned into functions?*/
+int lex_mode_counter = 0; /* keeps track of the number of %%names */
+/* MR1 */
+/* MR1 11-Apr-97 Provide mechanism for inserting code into DLG class */
+/* MR1 via <<%%lexmember...>> */
+/* MR1 */
+int lexMember = 0; /* <<%%lexmemeber ...>> MR1 */
+int lexAction = 0; /* <<%%lexaction ...>> MR1 */
+int parserClass = 0; /* <<%%parserclass ...>> MR1 */
+int lexPrefix = 0; /* <<%%lexprefix ...>> MR1 */
+char theClassName[100]; /* MR11 */
+char *pClassName=theClassName; /* MR11 */
+int firstLexMember=1; /* MR1 */
+
+#ifdef __USE_PROTOS
+void xxputc(int c) { /* MR1 */
+#else
+void xxputc(c) /* MR1 */
+ int c; /* MR1 */
+{ /* MR1 */
+#endif
+ if (parserClass) { /* MR1 */
+ *pClassName++=c; /* MR1 */
+ *pClassName=0; /* MR1 */
+ } else if (lexMember || lexPrefix) { /* MR1 */
+ if (class_stream != NULL) fputc(c,class_stream); /* MR1 */
+ } else { /* MR1 */
+ fputc(c,OUT); /* MR1 */
+ }; /* MR1 */
+} /* MR1 */
+
+#ifdef __USE_PROTOS
+void xxprintf(char *format,char *string) { /* MR1 */
+#else
+void xxprintf(format,string) /* MR1 */
+ char *format; /* MR1 */
+ char *string; /* MR1 */
+{ /* MR1 */
+#endif
+ if (lexMember || lexPrefix || parserClass) { /* MR1 */
+ if (class_stream != NULL) /* MR1 */
+ fprintf(class_stream,format,string); /* MR1 */
+ } else { /* MR1 */
+ fprintf(OUT,format,string); /* MR1 */
+ }; /* MR1 */
+} /* MR1 */
+>>
+
+#token "[\r\t\ ]+" << zzskip(); >> /* Ignore white */
+#token "\n" << zzline++; zzskip(); DAWDLE; >> /* Track Line # */
+#token L_EOF "\@"
+#token PER_PER "\%\%"
+#token NAME_PER_PER "\%\%[a-zA-Z_][a-zA-Z0-9_]*"
+ << p_mode_def(&zzlextext[2],lex_mode_counter++); >>
+
+#token LEXMEMBER "\<\<\%\%lexmember" /* MR1 */
+ <<lexMember=1; /* MR1 */
+ if (firstLexMember != 0) { /* MR1 */
+ firstLexMember=0; /* MR1 */
+ p_class_def1(); /* MR1 */
+ }; /* MR1 */
+ zzmode(ACT); /* MR1 */
+ >> /* MR1 */
+#token LEXACTION "\<\<\%\%lexaction" /* MR1 */
+ <<lexAction=1;zzmode(ACT);>> /* MR1 */
+#token PARSERCLASS "\<\<\%\%parserclass" /* MR1 */
+ <<parserClass=1; /* MR1 */
+ zzmode(ACT); /* MR1 */
+ >> /* MR1 */
+#token LEXPREFIX "\<\<\%\%lexprefix" /* MR1 */
+ <<lexPrefix=1;zzmode(ACT);>> /* MR1 */
+
+#token ACTION "\<\<"
+ << if (func_action)
+ fprintf(OUT,"\n%s %sact%d()\n{ ",
+ gen_cpp?"ANTLRTokenType":"static void",
+ gen_cpp?ClassName("::"):"", ++action_no);
+ zzmode(ACT); zzskip();
+ >>
+#token GREAT_GREAT "\>\>"
+#token L_BRACE "\{"
+#token R_BRACE "\}"
+#token L_PAR "\("
+#token R_PAR "\)"
+#token L_BRACK "\["
+#token R_BRACK "\]"
+#token ZERO_MORE "\*"
+#token ONE_MORE "\+"
+#token OR "\|"
+#token RANGE "\-"
+#token NOT "\~"
+#token OCTAL_VALUE "\\0[0-7]*"
+ << {int t; sscanf(&zzlextext[1],"%o",&t); zzlextext[0] = t;}>>
+#token HEX_VALUE "\\0[Xx][0-9a-fA-F]+"
+ << {int t; sscanf(&zzlextext[3],"%x",&t); zzlextext[0] = t;}>>
+#token DEC_VALUE "\\[1-9][0-9]*"
+ << {int t; sscanf(&zzlextext[1],"%d",&t); zzlextext[0] = t;}>>
+#token TAB "\\t" << zzlextext[0] = '\t';>>
+#token NL "\\n" << zzlextext[0] = '\n';>>
+#token CR "\\r" << zzlextext[0] = '\r';>>
+#token BS "\\b" << zzlextext[0] = '\b';>>
+
+/* MR1 */
+/* MR1 10-Apr-97 MR1 Allow #token regular expressions to cross lines */
+/* MR1 */
+#token CONTINUATION "\\ \n" << zzline++; zzskip();>> /* MR1 */
+
+/* NOTE: this takes ANYTHING after the \ */
+#token LIT "\\~[tnrb]" << zzlextext[0] = zzlextext[1];>>
+
+/* NOTE: this takes ANYTHING that doesn't match the other tokens */
+#token REGCHAR "~[\\]"
+
+
+grammar : << p_head(); p_class_hdr(); func_action = FALSE;>>
+ ( {LEXACTION | LEXMEMBER | LEXPREFIX | PARSERCLASS } ACTION)* /* MR1 */
+ <<if ( gen_cpp ) p_includes();>>
+ start_states
+ << func_action = FALSE; p_tables(); p_tail(); >>
+ (ACTION)* "@"
+ << if (firstLexMember != 0) p_class_def1(); >> /* MR1 */
+ ;
+
+start_states : ( PER_PER do_conversion
+ | NAME_PER_PER do_conversion (NAME_PER_PER do_conversion)*)
+ PER_PER
+ ;
+
+do_conversion : <<new_automaton_mode(); func_action = TRUE;>>
+ rule_list
+ <<
+ dfa_class_nop[mode_counter] =
+ relabel($1.l,comp_level);
+ if (comp_level)
+ p_shift_table(mode_counter);
+ dfa_basep[mode_counter] = dfa_allocated+1;
+ make_dfa_model_node(dfa_class_nop[mode_counter]);
+ nfa_to_dfa($1.l);
+ ++mode_counter;
+ func_action = FALSE;
+#ifdef HASH_STAT
+ fprint_hash_stats(stderr);
+#endif
+ >>
+ ;
+
+rule_list : rule <<$$.l=$1.l; $$.r=$1.r;>>
+ (rule
+ <<{nfa_node *t1;
+ t1 = new_nfa_node();
+ (t1)->trans[0]=$$.l;
+ (t1)->trans[1]=$1.l;
+ /* all accept nodes "dead ends" */
+ $$.l=t1; $$.r=NULL;
+ }
+ >>
+ )*
+ | /* empty */
+ <<$$.l = new_nfa_node(); $$.r = NULL;
+ warning("no regular expressions", zzline);
+ >>
+ ;
+
+rule : reg_expr ACTION
+/* MR23 */ << if ($1.r != NULL) {
+ $$.l=$1.l; $$.r=$1.r; ($1.r)->accept=action_no;
+ }
+ >>
+ | ACTION
+ <<$$.l = NULL; $$.r = NULL;
+ error("no expression for action ", zzline);
+ >>
+ ;
+
+reg_expr : and_expr <<$$.l=$1.l; $$.r=$1.r;>>
+ (OR and_expr
+ <<{nfa_node *t1, *t2;
+ t1 = new_nfa_node(); t2 = new_nfa_node();
+ (t1)->trans[0]=$$.l;
+ (t1)->trans[1]=$2.l;
+/* MR23 */ if ($$.r != NULL) ($$.r)->trans[1]=t2;
+ if ($2.r) {
+ ($2.r)->trans[1]=t2; /* MR20 */
+ }
+ $$.l=t1; $$.r=t2;
+ }
+ >>
+ )*
+ ;
+
+and_expr : repeat_expr
+ <<
+ $$.l=$1.l; $$.r=$1.r;
+ >>
+ (repeat_expr
+/* MR23 */ << if ($$.r != NULL) {
+ ($$.r)->trans[1]=$1.l;
+ $$.r=$1.r;
+ }
+ >>
+ )*
+ ;
+
+repeat_expr : expr <<$$.l=$1.l; $$.r=$1.r;>>
+ { ZERO_MORE
+ <<{ nfa_node *t1,*t2;
+/* MR23 */ if ($$.r != NULL) ($$.r)->trans[0] = $$.l;
+ t1 = new_nfa_node(); t2 = new_nfa_node();
+ t1->trans[0]=$$.l;
+ t1->trans[1]=t2;
+/* MR23 */ if ($$.r != NULL) ($$.r)->trans[1]=t2;
+ $$.l=t1;$$.r=t2;
+ }
+ >>
+ | ONE_MORE
+/* MR23 */ <<if ($$.r != NULL) ($$.r)->trans[0] = $$.l;>>
+ }
+ | ZERO_MORE
+ << error("no expression for *", zzline);>>
+ | ONE_MORE
+ << error("no expression for +", zzline);>>
+ ;
+
+expr : << $$.l = new_nfa_node();
+ $$.r = new_nfa_node();
+ >>
+ L_BRACK atom_list R_BRACK
+ <<
+/* MR23 */ if ($$.l != NULL) {
+ ($$.l)->trans[0] = $$.r;
+ ($$.l)->label = set_dup($2.label);
+ set_orin(&used_chars,($$.l)->label);
+ }
+ >>
+ | NOT L_BRACK atom_list R_BRACK
+ <<
+/* MR23 */ if ($$.l != NULL) {
+ ($$.l)->trans[0] = $$.r;
+ ($$.l)->label = set_dif(normal_chars,$3.label);
+ set_orin(&used_chars,($$.l)->label);
+ }
+ >>
+ | L_PAR reg_expr R_PAR
+ <<
+/* MR23 */ if ($$.l != NULL) {
+ ($$.l)->trans[0] = $2.l;
+ if ($2.r) {
+ ($2.r)->trans[1] = $$.r; /* MR20 */
+ }
+ }
+ >>
+ | L_BRACE reg_expr R_BRACE
+ <<
+/* MR23 */ if ($$.l != NULL) {
+ ($$.l)->trans[0] = $2.l;
+ ($$.l)->trans[1] = $$.r;
+ if ($2.r) {
+ ($2.r)->trans[1] = $$.r; /* MR20 */
+ }
+ }
+ >>
+ | atom
+ <<
+/* MR23 */ if ($$.l != NULL) {
+ ($$.l)->trans[0] = $$.r;
+ ($$.l)->label = set_dup($1.label);
+ set_orin(&used_chars,($$.l)->label);
+ }
+ >>
+ ;
+
+atom_list : << set_free($$.label); >>
+ (near_atom <<set_orin(&($$.label),$1.label);>>)*
+ ;
+
+near_atom : << register int i;
+ register int i_prime;
+ >>
+ anychar
+ <<$$.letter=$1.letter; $$.label=set_of($1.letter);
+ i_prime = $1.letter + MIN_CHAR;
+ if (case_insensitive && islower(i_prime))
+ set_orel(toupper(i_prime)-MIN_CHAR,
+ &($$.label));
+ if (case_insensitive && isupper(i_prime))
+ set_orel(tolower(i_prime)-MIN_CHAR,
+ &($$.label));
+ >>
+ { RANGE anychar
+ << if (case_insensitive){
+ i_prime = $$.letter+MIN_CHAR;
+ $$.letter = (islower(i_prime) ?
+ toupper(i_prime) : i_prime)-MIN_CHAR;
+ i_prime = $2.letter+MIN_CHAR;
+ $2.letter = (islower(i_prime) ?
+ toupper(i_prime) : i_prime)-MIN_CHAR;
+ }
+ /* check to see if range okay */
+ {
+ int debugLetter1 = $$.letter;
+ int debugLetter2 = $2.letter;
+ }
+ if ($$.letter > $2.letter
+ && $2.letter != 0xff){ /* MR16 */
+ error("invalid range ", zzline);
+ }
+ for (i=$$.letter; i<= (int)$2.letter; ++i){
+ set_orel(i,&($$.label));
+ i_prime = i+MIN_CHAR;
+ if (case_insensitive && islower(i_prime))
+ set_orel(toupper(i_prime)-MIN_CHAR,
+ &($$.label));
+ if (case_insensitive && isupper(i_prime))
+ set_orel(tolower(i_prime)-MIN_CHAR,
+ &($$.label));
+ }
+ >>
+ }
+ ;
+
+atom : << register int i_prime;>>
+ anychar
+ <<$$.label = set_of($1.letter);
+ i_prime = $1.letter + MIN_CHAR;
+ if (case_insensitive && islower(i_prime))
+ set_orel(toupper(i_prime)-MIN_CHAR,
+ &($$.label));
+ if (case_insensitive && isupper(i_prime))
+ set_orel(tolower(i_prime)-MIN_CHAR,
+ &($$.label));
+ >>
+ ;
+
+anychar : REGCHAR <<$$.letter = $1.letter - MIN_CHAR;>>
+ | OCTAL_VALUE <<$$.letter = $1.letter - MIN_CHAR;>>
+ | HEX_VALUE <<$$.letter = $1.letter - MIN_CHAR;>>
+ | DEC_VALUE <<$$.letter = $1.letter - MIN_CHAR;>>
+ | TAB <<$$.letter = $1.letter - MIN_CHAR;>>
+ | NL <<$$.letter = $1.letter - MIN_CHAR;>>
+ | CR <<$$.letter = $1.letter - MIN_CHAR;>>
+ | BS <<$$.letter = $1.letter - MIN_CHAR;>>
+ | LIT <<$$.letter = $1.letter - MIN_CHAR;>>
+ /* NOTE: LEX_EOF is ALWAYS shifted to 0 = MIN_CHAR - MIN_CHAR*/
+ | L_EOF <<$$.letter = 0;>>
+ ;
+
+<</* empty action */>>
+
+#lexclass ACT
+#token "@" << error("unterminated action", zzline); zzmode(START); >>
+#token ACTION "\>\>"
+ << if (func_action) fprintf(OUT,"}\n\n");
+ zzmode(START);
+/* MR1 */
+/* MR1 11-Apr-97 Provide mechanism for inserting code into DLG class */
+/* MR1 via <<%%lexmember ...>> */
+/* MR1 This is a consequence of not saving actions */
+/* MR1 */
+/* MR1 */ parserClass=0;
+/* MR1 */ lexPrefix=0;
+/* MR1 */ lexAction=0;
+/* MR1 */ lexMember=0;
+ >>
+#token "\>" << xxputc(zzlextext[0]); zzskip(); >> /* MR1 */
+#token "\\\>" << xxputc('>'); zzskip(); >> /* MR1 */
+#token "\\" << xxputc('\\'); zzskip(); >> /* MR1 */
+#token "\n" << xxputc(zzlextext[0]); ++zzline; zzskip(); >> /* MR1 */
+#token "/\*" << zzmode(ACTION_COMMENTS); /* MR1 */
+ xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
+ >> /* MR1 */
+#token "//" << zzmode(ACTION_CPP_COMMENTS); /* MR1 */
+ xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
+ >> /* MR1 */
+#token "~[]" << xxputc(zzlextext[0]); zzskip(); >> /* MR1 */
+ /* MR1 */
+#lexclass ACTION_COMMENTS /* MR1 */
+#token "\*/" << zzmode(ACT); /* MR1 */
+ xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
+ >> /* MR1 */
+#token "[\n\r]" << zzline++; xxputc(zzlextext[0]); zzskip();>> /* MR1 */
+#token "~[]" << xxputc(zzlextext[0]); zzskip();>> /* MR1 */
+ /* MR1 */
+#lexclass ACTION_CPP_COMMENTS /* MR1 */
+#token "[\n\r]" << zzmode(ACT); zzline++; /* MR1 */
+ xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
+ >> /* MR1 */
+#token "~[]" << xxputc(zzlextext[0]); zzskip();>> /* MR1 */
+
+<<
+/* adds a new nfa to the binary tree and returns a pointer to it */
+nfa_node *
+#ifdef __USE_PROTOS
+new_nfa_node(void)
+#else
+new_nfa_node()
+#endif
+{
+ register nfa_node *t;
+ static int nfa_size=0; /* elements nfa_array[] can hold */
+
+ ++nfa_allocated;
+ if (nfa_size<=nfa_allocated){
+ /* need to redo array */
+ if (!nfa_array){
+ /* need some to do inital allocation */
+ nfa_size=nfa_allocated+NFA_MIN;
+ nfa_array=(nfa_node **) malloc(sizeof(nfa_node*)*
+ nfa_size);
+ }else{
+ /* need more space */
+ nfa_size=2*(nfa_allocated+1);
+ nfa_array=(nfa_node **) realloc(nfa_array,
+ sizeof(nfa_node*)*nfa_size);
+ }
+ }
+ /* fill out entry in array */
+ t = (nfa_node*) malloc(sizeof(nfa_node));
+ nfa_array[nfa_allocated] = t;
+ *t = nfa_model_node;
+ t->node_no = nfa_allocated;
+ return t;
+}
+
+
+/* initialize the model node used to fill in newly made nfa_nodes */
+void
+#ifdef __USE_PROTOS
+make_nfa_model_node(void)
+#else
+make_nfa_model_node()
+#endif
+{
+ nfa_model_node.node_no = -1; /* impossible value for real nfa node */
+ nfa_model_node.nfa_set = 0;
+ nfa_model_node.accept = 0; /* error state default*/
+ nfa_model_node.trans[0] = NULL;
+ nfa_model_node.trans[1] = NULL;
+ nfa_model_node.label = empty;
+}
+>>
+
+<<
+#if defined(DEBUG) || defined(_DEBUG)
+
+/* print out the pointer value and the node_number */
+void
+#ifdef __USE_PROTOS
+fprint_dfa_pair(FILE *f, nfa_node *p)
+#else
+fprint_dfa_pair(f, p)
+FILE *f;
+nfa_node *p;
+#endif
+{
+ if (p){
+ fprintf(f, "%x (%d)", p, p->node_no);
+ }else{
+ fprintf(f, "(nil)");
+ }
+}
+
+/* print out interest information on a set */
+void
+#ifdef __USE_PROTOS
+fprint_set(FILE *f, set s)
+#else
+fprint_set(f,s)
+FILE *f;
+set s;
+#endif
+{
+ unsigned int *x;
+
+ fprintf(f, "n = %d,", s.n);
+ if (s.setword){
+ fprintf(f, "setword = %x, ", s.setword);
+ /* print out all the elements in the set */
+ x = set_pdq(s);
+ while (*x!=nil){
+ fprintf(f, "%d ", *x);
+ ++x;
+ }
+ }else{
+ fprintf(f, "setword = (nil)");
+ }
+}
+
+/* code to be able to dump out the nfas
+ return 0 if okay dump
+ return 1 if screwed up
+ */
+int
+#ifdef __USE_PROTOS
+dump_nfas(int first_node, int last_node)
+#else
+dump_nfas(first_node, last_node)
+int first_node;
+int last_node;
+#endif
+{
+ register int i;
+ nfa_node *t;
+
+ for (i=first_node; i<=last_node; ++i){
+ t = NFA(i);
+ if (!t) break;
+ fprintf(stderr, "nfa_node %d {\n", t->node_no);
+ fprintf(stderr, "\n\tnfa_set = %d\n", t->nfa_set);
+ fprintf(stderr, "\taccept\t=\t%d\n", t->accept);
+ fprintf(stderr, "\ttrans\t=\t(");
+ fprint_dfa_pair(stderr, t->trans[0]);
+ fprintf(stderr, ",");
+ fprint_dfa_pair(stderr, t->trans[1]);
+ fprintf(stderr, ")\n");
+ fprintf(stderr, "\tlabel\t=\t{ ");
+ fprint_set(stderr, t->label);
+ fprintf(stderr, "\t}\n");
+ fprintf(stderr, "}\n\n");
+ }
+ return 0;
+}
+#endif
+>>
+
+<<
+/* DLG-specific syntax error message generator
+ * (define USER_ZZSYN when compiling so don't get 2 definitions)
+ */
+void
+#ifdef __USE_PROTOS
+zzsyn(char *text, int tok, char *egroup, SetWordType *eset, int etok, int k, char *bad_text)
+#else
+zzsyn(text, tok, egroup, eset, etok, k, bad_text)
+char *text, *egroup, *bad_text;
+int tok;
+int etok;
+int k;
+SetWordType *eset;
+#endif
+{
+ fprintf(stderr, ErrHdr, file_str[0]!=NULL?file_str[0]:"stdin", zzline);
+ fprintf(stderr, " syntax error at \"%s\"", (tok==zzEOF_TOKEN)?"EOF":text);
+ if ( !etok && !eset ) {fprintf(stderr, "\n"); return;}
+ if ( k==1 ) fprintf(stderr, " missing");
+ else
+ {
+ fprintf(stderr, "; \"%s\" not", bad_text);
+ if ( zzset_deg(eset)>1 ) fprintf(stderr, " in");
+ }
+ if ( zzset_deg(eset)>0 ) zzedecode(eset);
+ else fprintf(stderr, " %s", zztokens[etok]);
+ if ( strlen(egroup) > (size_t)0 ) fprintf(stderr, " in %s", egroup);
+ fprintf(stderr, "\n");
+}
+>>
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/err.c b/BaseTools/Source/C/VfrCompile/Pccts/dlg/err.c new file mode 100644 index 0000000000..c3eaeae6d1 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/err.c @@ -0,0 +1,99 @@ +/*
+ * A n t l r S e t s / E r r o r F i l e H e a d e r
+ *
+ * Generated from: dlg_p.g
+ *
+ * Terence Parr, Russell Quong, Will Cohen, and Hank Dietz: 1989-2001
+ * Parr Research Corporation
+ * with Purdue University Electrical Engineering
+ * With AHPCRC, University of Minnesota
+ * ANTLR Version 1.33MR33
+ */
+
+#define ANTLR_VERSION 13333
+#include "pcctscfg.h"
+#include "pccts_stdio.h"
+
+#include <ctype.h>
+#include "dlg.h"
+#define zzSET_SIZE 8
+#include "antlr.h"
+#include "tokens.h"
+#include "dlgdef.h"
+#include "err.h"
+
+ANTLRChar *zztokens[46]={
+ /* 00 */ "Invalid",
+ /* 01 */ "@",
+ /* 02 */ "[\\r\\t\\ ]+",
+ /* 03 */ "\\n",
+ /* 04 */ "L_EOF",
+ /* 05 */ "PER_PER",
+ /* 06 */ "NAME_PER_PER",
+ /* 07 */ "LEXMEMBER",
+ /* 08 */ "LEXACTION",
+ /* 09 */ "PARSERCLASS",
+ /* 10 */ "LEXPREFIX",
+ /* 11 */ "ACTION",
+ /* 12 */ "GREAT_GREAT",
+ /* 13 */ "L_BRACE",
+ /* 14 */ "R_BRACE",
+ /* 15 */ "L_PAR",
+ /* 16 */ "R_PAR",
+ /* 17 */ "L_BRACK",
+ /* 18 */ "R_BRACK",
+ /* 19 */ "ZERO_MORE",
+ /* 20 */ "ONE_MORE",
+ /* 21 */ "OR",
+ /* 22 */ "RANGE",
+ /* 23 */ "NOT",
+ /* 24 */ "OCTAL_VALUE",
+ /* 25 */ "HEX_VALUE",
+ /* 26 */ "DEC_VALUE",
+ /* 27 */ "TAB",
+ /* 28 */ "NL",
+ /* 29 */ "CR",
+ /* 30 */ "BS",
+ /* 31 */ "CONTINUATION",
+ /* 32 */ "LIT",
+ /* 33 */ "REGCHAR",
+ /* 34 */ "\\>",
+ /* 35 */ "\\\\>",
+ /* 36 */ "\\",
+ /* 37 */ "\\n",
+ /* 38 */ "/\\*",
+ /* 39 */ "//",
+ /* 40 */ "~[]",
+ /* 41 */ "\\*/",
+ /* 42 */ "[\\n\\r]",
+ /* 43 */ "~[]",
+ /* 44 */ "[\\n\\r]",
+ /* 45 */ "~[]"
+};
+SetWordType zzerr1[8] = {0x80,0xf,0x0,0x0, 0x0,0x0,0x0,0x0};
+SetWordType zzerr2[8] = {0x60,0x0,0x0,0x0, 0x0,0x0,0x0,0x0};
+SetWordType zzerr3[8] = {0x70,0xa8,0x9a,0x7f, 0x3,0x0,0x0,0x0};
+SetWordType setwd1[46] = {0x0,0x6,0x0,0x0,0x30,0xc8,0xc8,
+ 0x1,0x1,0x1,0x1,0x35,0x0,0x30,0x0,
+ 0x30,0x0,0x30,0x0,0x30,0x30,0x0,0x0,
+ 0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
+ 0x0,0x30,0x30,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0};
+SetWordType zzerr4[8] = {0x10,0xa8,0x9a,0x7f, 0x3,0x0,0x0,0x0};
+SetWordType zzerr5[8] = {0x10,0xe8,0xbb,0x7f, 0x3,0x0,0x0,0x0};
+SetWordType zzerr6[8] = {0x10,0xa0,0x9a,0x7f, 0x3,0x0,0x0,0x0};
+SetWordType setwd2[46] = {0x0,0x0,0x0,0x0,0xeb,0x2,0x2,
+ 0x0,0x0,0x0,0x0,0xd6,0x0,0xeb,0xd4,
+ 0xeb,0xd4,0xeb,0x0,0xcb,0xcb,0xd0,0x0,
+ 0xeb,0xeb,0xeb,0xeb,0xeb,0xeb,0xeb,0xeb,
+ 0x0,0xeb,0xeb,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0};
+SetWordType zzerr7[8] = {0x10,0xa0,0x82,0x7f, 0x3,0x0,0x0,0x0};
+SetWordType zzerr8[8] = {0x10,0x0,0x44,0x7f, 0x3,0x0,0x0,0x0};
+SetWordType zzerr9[8] = {0x10,0x0,0x0,0x7f, 0x3,0x0,0x0,0x0};
+SetWordType setwd3[46] = {0x0,0x0,0x0,0x0,0xf7,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0xc2,0x0,0xc2,0xc2,
+ 0xc2,0xc2,0xc2,0xb8,0xc2,0xc2,0xc2,0x80,
+ 0xc2,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,
+ 0x0,0xf7,0xf7,0x0,0x0,0x0,0x0,0x0,
+ 0x0,0x0,0x0,0x0,0x0,0x0,0x0};
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/main.c b/BaseTools/Source/C/VfrCompile/Pccts/dlg/main.c new file mode 100644 index 0000000000..35bd827f8c --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/main.c @@ -0,0 +1,281 @@ +/* Main function for dlg version
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * DLG 1.33
+ * Will Cohen
+ * With mods by Terence Parr; AHPCRC, University of Minnesota
+ * 1989-2001
+ */
+
+#include <stdio.h>
+#include "stdpccts.h"
+
+char program[] = "dlg";
+char version[] = "1.33MR33"; /* MRXXX */
+int numfiles = 0;
+char *file_str[2] = {NULL, NULL};
+char *mode_file = "mode.h";
+char *class_name = DEFAULT_CLASSNAME;
+char *OutputDirectory = TopDirectory;
+
+/* Option variables */
+int comp_level = 0;
+int interactive = FALSE;
+int case_insensitive = FALSE;
+int warn_ambig = FALSE;
+int gen_cpp = FALSE;
+
+#ifdef __USE_PROTOS
+static int ci_strequ(char *a,char *b)
+#else
+static int ci_strequ(a,b)
+ char *a;
+ char *b;
+#endif
+{
+ for ( ;*a != 0 && *b != 0; a++, b++) {
+ if (toupper(*a) != toupper(*b)) return 0;
+ }
+ return (*a == *b);
+}
+
+/* Option List Stuff */
+#ifdef __USE_PROTOS
+void p_comp0(void) {comp_level = 0;}
+void p_comp1(void) {comp_level = 1;}
+void p_comp2(void) {comp_level = 2;}
+void p_stdio(void) { file_str[numfiles++] = NULL;}
+void p_file(char *s) { file_str[numfiles++] = s;}
+void p_cl_name(char *s, char *t)
+ {
+ if ( gen_cpp ) {
+ class_name = t;
+ }
+ else {
+ warning("-cl only valid in C++ mode; -cl ignored...",0);
+ }
+ }
+void p_mode_file(char *s, char *t){mode_file=t;}
+void p_outdir(char *s,char *t) {OutputDirectory=t;}
+void p_ansi(void) {gen_ansi = TRUE;}
+void p_interactive(void) {interactive = TRUE;}
+void p_case_s(void) { case_insensitive = FALSE; }
+void p_case_i(void) { case_insensitive = TRUE; }
+void p_warn_ambig(void) { warn_ambig = TRUE; }
+void p_cpp(void) { gen_cpp = TRUE; }
+#else
+void p_comp0() {comp_level = 0;}
+void p_comp1() {comp_level = 1;}
+void p_comp2() {comp_level = 2;}
+void p_stdio() { file_str[numfiles++] = NULL;}
+void p_file(s) char *s; { file_str[numfiles++] = s;}
+void p_cl_name(s,t)
+ char *s, *t;
+ {
+ if ( gen_cpp ) {
+ class_name = t;
+ }
+ else {
+ warning("-cl only valid in C++ mode; -cl ignored...",0);
+ }
+ }
+void p_mode_file(s,t) char *s,*t;{mode_file=t;}
+void p_outdir(s,t) char *s,*t;{OutputDirectory=t;}
+void p_ansi() {gen_ansi = TRUE;}
+void p_interactive() {interactive = TRUE;}
+void p_case_s() { case_insensitive = FALSE; }
+void p_case_i() { case_insensitive = TRUE; }
+void p_warn_ambig() { warn_ambig = TRUE; }
+void p_cpp() { gen_cpp = TRUE; }
+#endif
+
+#ifdef __cplusplus
+typedef void (*WildFunc)(...);
+#else
+typedef void (*WildFunc)();
+#endif
+
+typedef struct {
+ char *option;
+ int arg;
+ WildFunc process;
+ char *descr;
+ } Opt;
+
+Opt options[] = {
+ { "-CC", 0, (WildFunc)p_cpp, "Generate C++ output" },
+ { "-C0", 0, (WildFunc)p_comp0, "No compression (default)" },
+ { "-C1", 0, (WildFunc)p_comp1, "Compression level 1" },
+ { "-C2", 0, (WildFunc)p_comp2, "Compression level 2" },
+ { "-ga", 0, (WildFunc)p_ansi, "Generate ansi C"},
+ { "-Wambiguity", 0, (WildFunc)p_warn_ambig, "Warn if expressions ambiguous"},
+ { "-m", 1, (WildFunc)p_mode_file, "Rename lexical mode output file"},
+ { "-i", 0, (WildFunc)p_interactive, "Build interactive scanner (not valid for C++ mode)"},
+ { "-ci", 0, (WildFunc)p_case_i, "Make lexical analyzer case insensitive"},
+ { "-cl", 1, (WildFunc)p_cl_name, "Rename lexer class (DLGLexer); only used for -CC"},
+ { "-cs", 0, (WildFunc)p_case_s, "Make lexical analyzer case sensitive (default)"},
+ { "-o", 1, (WildFunc)p_outdir, OutputDirectoryOption},
+ { "-", 0, (WildFunc)p_stdio, "Use standard i/o rather than file"},
+ { "*", 0, (WildFunc)p_file, ""}, /* anything else is a file */
+ { NULL, 0, NULL }
+ };
+
+#ifdef __USE_PROTOS
+void ProcessArgs(int argc, char **argv, Opt *options)
+#else
+void ProcessArgs(argc, argv, options)
+int argc;
+char **argv;
+Opt *options;
+#endif
+{
+ Opt *p;
+
+ while ( argc-- > 0 )
+ {
+ p = options;
+ while ( p->option != NULL )
+ {
+ if ( strcmp(p->option, "*") == 0 ||
+ ci_strequ(p->option,*argv) )
+ {
+ if ( p->arg )
+ {
+ (*p->process)( *argv, *(argv+1) );
+ argv++;
+ argc--;
+ }
+ else
+ (*p->process)( *argv );
+ break;
+ }
+ p++;
+ }
+ argv++;
+ }
+}
+
+#ifdef __USE_PROTOS
+int main(int argc, char *argv[])
+#else
+int main(argc, argv)
+int argc;
+char *argv[];
+#endif
+{
+ init();
+ fprintf(stderr, "%s Version %s 1989-2001\n", &(program[0]),
+ &(version[0]));
+ if ( argc == 1 )
+ {
+ Opt *p = options;
+ fprintf(stderr, "%s [options] f1 f2 ... fn\n",argv[0]);
+ while ( *(p->option) != '*' )
+ {
+ fprintf(stderr, "\t%s %s\t%s\n",
+ p->option,
+ (p->arg)?"___":" ",
+ p->descr);
+ p++;
+ }
+ }else{
+ ProcessArgs(argc-1, &(argv[1]), options);
+ if (interactive && gen_cpp) {
+ fprintf(stderr,"\n");
+/*** MR21a This statement is wrong ! ***/
+#if 0
+*** fprintf(stderr,"Interactive lexer option (\"-i\") has no effect when in C++ mode\n");
+*** fprintf(stderr,"because of extra buffering provided by ANTLRTokenBuffer class.\n");
+*** fprintf(stderr,"\n");
+#endif
+ }
+ input_stream = read_stream(file_str[0]);
+ if (input_stream) {
+ /* don't overwrite unless input okay */
+ if ( gen_cpp ) {
+ output_stream = write_stream(ClassName(CPP_FILE_SUFFIX));
+ if ( file_str[1]!=NULL ) {
+ warning("output file implicit in C++ mode; ignored...",0);
+ }
+ class_stream = write_stream(ClassName(".h"));
+ mode_stream = class_stream;
+ }
+ else {
+ output_stream = write_stream(file_str[1]);
+ mode_stream = write_stream(mode_file);
+ }
+ }
+ /* make sure that error reporting routines in grammar
+ know what the file really is */
+ /* make sure that reading and writing somewhere */
+ if (input_stream && output_stream && mode_stream){
+ ANTLR(grammar(), input_stream);
+ }
+ p_class_def2(); /* MR1 */
+ }
+ if ( output_stream!=NULL ) fclose(output_stream);
+ if ( !gen_cpp && mode_stream!=NULL ) fclose(mode_stream);
+ if ( class_stream!=NULL ) fclose(class_stream);
+ exit(PCCTS_EXIT_SUCCESS);
+ return 0; /* get rid of warning message MR1 */
+}
+
+/* initialize all the variables */
+void
+#ifdef __USE_PROTOS
+init(void)
+#else
+init()
+#endif
+{
+ register int i;
+
+#ifdef SPECIAL_INITS
+ special_inits(); /* MR1 */
+#endif
+ used_chars = empty;
+ used_classes = empty;
+ /* make the valid character set */
+ normal_chars = empty;
+ /* NOTE: MIN_CHAR is EOF */
+ /* NOTE: EOF is not quite a valid char, it is special. Skip it*/
+ for (i = 1; i<CHAR_RANGE; ++i){
+ set_orel(i,&normal_chars);
+ }
+ make_nfa_model_node();
+ clear_hash();
+ /* NOTE: need to set this flag before the lexer starts getting */
+ /* tokens */
+ func_action = FALSE;
+}
+
+/* stuff that needs to be reset when a new automaton is being built */
+void
+#ifdef __USE_PROTOS
+new_automaton_mode(void) /* MR1 */
+#else
+new_automaton_mode() /* MR1 */
+#endif
+{
+ set_free(used_chars);
+ clear_hash();
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/makefile b/BaseTools/Source/C/VfrCompile/Pccts/dlg/makefile new file mode 100644 index 0000000000..406725d195 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/makefile @@ -0,0 +1,156 @@ +#
+# Makefile for DLG 1.33
+# Terence Parr
+# Purdue University, U of MN, Parr Research Corporation
+# 1989-1994
+#
+# Ported to IBM C-Set/2 and Microsoft 6.0 by
+# Ed Harfmann
+# Micro Data Base Systems
+# Lafayette, Indiana
+#
+SET=../support/set
+PCCTS_H=../h
+
+##
+## Uncomment the appropriate section to build
+##
+
+#
+# OS/2 & DOS 16 bit using MSC 6.0
+#
+#CC=cl
+#ANTLR=..\bin\antlr
+#DLG=..\bin\dlg
+#CFLAGS= -I. -I$(SET) -I$(PCCTS_H) /AL /Za /W3 -DPC -DUSER_ZZSYN
+#OUT_OBJ = -Fo
+#LIBS=/NOD:LLIBCE LLIBCEP
+#OBJ_EXT = obj
+#
+#dlg.exe : dlg_p.obj dlg_a.obj main.obj err.obj set.obj support.obj \
+# output.obj relabel.obj automata.obj
+# link @<<
+#$** /NOI
+#$@ /STACK:16384
+#
+#$(LIBS: = +^
+#)
+#$(DEF_FILE) $(LFLAGS) ;
+#<<
+# bind $@ c:\os2\doscalls.lib
+# copy *.exe ..\bin
+#
+
+#
+# Borland C++ for DOS
+#
+#CC=bcc
+#ANTLR=..\bin\antlr
+#DLG=..\bin\dlg
+#CFLAGS= -I. -I$(SET) -I$(PCCTS_H) -ml -ff- -w- -DPC -DUSER_ZZSYN
+#OUT_OBJ = -o
+#LIBS= emu mathl cl
+#OBJ_EXT = obj
+#
+#dlg.exe : dlg_p.obj dlg_a.obj main.obj err.obj set.obj support.obj \
+# output.obj relabel.obj automata.obj
+# tlink @&&|
+#C0L $**
+#$@ /Tde /c
+#
+#$(LIBS)
+#$(DEF_FILE) $(LFLAGS) ;
+#|
+# copy *.exe ..\bin
+#
+
+#
+# C-Set/2 for OS/2
+#
+#CC=icc
+#CFLAGS= -I. -I$(SET) -I$(PCCTS_H) /Sa /W3 /DUSER_ZZSYN
+#OUT_OBJ = -Fo
+#LIBS=
+#ANTLR=..\bin\antlr
+#DLG=..\bin\dlg
+#OBJ_EXT=obj
+#
+#dlg.exe : dlg_p.obj dlg_a.obj main.obj err.obj set.obj support.obj \
+# output.obj relabel.obj automata.obj
+# link386 @<<
+#$** /NOI
+#$@ /STACK:32768
+#
+#$(LIBS: = +^
+#)
+#$(DEF_FILE) $(LFLAGS) ;
+#<<
+# copy *.exe ..\bin
+#
+
+#
+# Borland C++ for OS/2
+#
+#CC=bcc
+#CFLAGS= -I. -I$(SET) -I$(PCCTS_H) -w- -DUSER_ZZSYN
+#OUT_OBJ = -o
+#LIBS= c2 os2
+#
+#ANTLR=..\bin\antlr
+#DLG=..\bin\dlg
+#OBJ_EXT = obj
+#dlg.exe : dlg_p.obj dlg_a.obj main.obj err.obj set.obj support.obj \
+# output.obj relabel.obj automata.obj
+# tlink @&&|
+#c02 $** -c
+#dlg.exe
+#
+#C2 os2
+#
+#|
+# copy *.exe ..\bin
+#
+
+#
+# UNIX
+#
+CC=cc
+COPT=-O
+ANTLR=${BIN_DIR}/antlr
+DLG=${BIN_DIR}/dlg
+CFLAGS= $(COPT) -I. -I$(SET) -I$(PCCTS_H) -DUSER_ZZSYN -DZZLEXBUFSIZE=65536
+OBJ_EXT=o
+OUT_OBJ = -o
+OBJ = dlg_p.o dlg_a.o main.o err.o set.o support.o output.o \
+ relabel.o automata.o
+
+$(BIN_DIR)/dlg : $(OBJ) $(SRC)
+ $(CC) $(CFLAGS) -o $(BIN_DIR)/dlg $(OBJ)
+
+SRC = dlg_p.c dlg_a.c main.c err.c $(SET)/set.c support.c output.c \
+ relabel.c automata.c
+
+#dlg_p.c parser.dlg err.c tokens.h : dlg_p.g
+# $(ANTLR) dlg_p.g
+
+#dlg_a.c mode.h : parser.dlg
+# $(DLG) -C2 parser.dlg dlg_a.c
+
+dlg_p.$(OBJ_EXT) : dlg_p.c dlg.h tokens.h mode.h
+ $(CC) $(CFLAGS) -c dlg_p.c
+
+dlg_a.$(OBJ_EXT) : dlg_a.c dlg.h tokens.h mode.h
+ $(CC) $(CFLAGS) -c dlg_a.c
+
+main.$(OBJ_EXT) : main.c dlg.h
+ $(CC) $(CFLAGS) -c main.c
+
+set.$(OBJ_EXT) : $(SET)/set.c
+ $(CC) -c $(CFLAGS) $(SET)/set.c
+
+lint:
+ lint *.c
+
+#clean up all the intermediate files
+clean:
+ rm -f $(BIN_DIR)/dlg *.$(OBJ_EXT) core
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/makefile.cygwin b/BaseTools/Source/C/VfrCompile/Pccts/dlg/makefile.cygwin new file mode 100644 index 0000000000..bbba820d13 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/makefile.cygwin @@ -0,0 +1,157 @@ +#
+# Makefile for DLG 1.33
+# Terence Parr
+# Purdue University, U of MN, Parr Research Corporation
+# 1989-1994
+#
+# Ported to IBM C-Set/2 and Microsoft 6.0 by
+# Ed Harfmann
+# Micro Data Base Systems
+# Lafayette, Indiana
+#
+SET=../support/set
+PCCTS_H=../h
+
+##
+## Uncomment the appropriate section to build
+##
+
+#
+# OS/2 & DOS 16 bit using MSC 6.0
+#
+#CC=cl
+#ANTLR=..\bin\antlr
+#DLG=..\bin\dlg
+#CFLAGS= -I. -I$(SET) -I$(PCCTS_H) /AL /Za /W3 -DPC -DUSER_ZZSYN
+#OUT_OBJ = -Fo
+#LIBS=/NOD:LLIBCE LLIBCEP
+#OBJ_EXT = obj
+#
+#dlg.exe : dlg_p.obj dlg_a.obj main.obj err.obj set.obj support.obj \
+# output.obj relabel.obj automata.obj
+# link @<<
+#$** /NOI
+#$@ /STACK:16384
+#
+#$(LIBS: = +^
+#)
+#$(DEF_FILE) $(LFLAGS) ;
+#<<
+# bind $@ c:\os2\doscalls.lib
+# copy *.exe ..\bin
+#
+
+#
+# Borland C++ for DOS
+#
+#CC=bcc
+#ANTLR=..\bin\antlr
+#DLG=..\bin\dlg
+#CFLAGS= -I. -I$(SET) -I$(PCCTS_H) -ml -ff- -w- -DPC -DUSER_ZZSYN
+#OUT_OBJ = -o
+#LIBS= emu mathl cl
+#OBJ_EXT = obj
+#
+#dlg.exe : dlg_p.obj dlg_a.obj main.obj err.obj set.obj support.obj \
+# output.obj relabel.obj automata.obj
+# tlink @&&|
+#C0L $**
+#$@ /Tde /c
+#
+#$(LIBS)
+#$(DEF_FILE) $(LFLAGS) ;
+#|
+# copy *.exe ..\bin
+#
+
+#
+# C-Set/2 for OS/2
+#
+#CC=icc
+#CFLAGS= -I. -I$(SET) -I$(PCCTS_H) /Sa /W3 /DUSER_ZZSYN
+#OUT_OBJ = -Fo
+#LIBS=
+#ANTLR=..\bin\antlr
+#DLG=..\bin\dlg
+#OBJ_EXT=obj
+#
+#dlg.exe : dlg_p.obj dlg_a.obj main.obj err.obj set.obj support.obj \
+# output.obj relabel.obj automata.obj
+# link386 @<<
+#$** /NOI
+#$@ /STACK:32768
+#
+#$(LIBS: = +^
+#)
+#$(DEF_FILE) $(LFLAGS) ;
+#<<
+# copy *.exe ..\bin
+#
+
+#
+# Borland C++ for OS/2
+#
+#CC=bcc
+#CFLAGS= -I. -I$(SET) -I$(PCCTS_H) -w- -DUSER_ZZSYN
+#OUT_OBJ = -o
+#LIBS= c2 os2
+#
+#ANTLR=..\bin\antlr
+#DLG=..\bin\dlg
+#OBJ_EXT = obj
+#dlg.exe : dlg_p.obj dlg_a.obj main.obj err.obj set.obj support.obj \
+# output.obj relabel.obj automata.obj
+# tlink @&&|
+#c02 $** -c
+#dlg.exe
+#
+#C2 os2
+#
+#|
+# copy *.exe ..\bin
+#
+
+#
+# UNIX
+#
+BIN_DIR=../../../../bin
+CC=cc
+COPT=-O
+ANTLR=$(BIN_DIR)/antlr.exe
+DLG=${BIN_DIR}/dlg.exe
+CFLAGS= $(COPT) -I. -I$(SET) -I$(PCCTS_H) -DUSER_ZZSYN -DZZLEXBUFSIZE=65536
+OBJ_EXT=o
+OUT_OBJ = -o
+OBJ = dlg_p.o dlg_a.o main.o err.o set.o support.o output.o \
+ relabel.o automata.o
+
+dlg : $(OBJ) $(SRC)
+ $(CC) $(CFLAGS) -o $(BIN_DIR)/dlg.exe $(OBJ)
+
+SRC = dlg_p.c dlg_a.c main.c err.c $(SET)/set.c support.c output.c \
+ relabel.c automata.c
+
+#dlg_p.c parser.dlg err.c tokens.h : dlg_p.g
+# $(ANTLR) dlg_p.g
+
+#dlg_a.c mode.h : parser.dlg
+# $(DLG) -C2 parser.dlg dlg_a.c
+
+dlg_p.$(OBJ_EXT) : dlg_p.c dlg.h tokens.h mode.h
+ $(CC) $(CFLAGS) -c dlg_p.c
+
+dlg_a.$(OBJ_EXT) : dlg_a.c dlg.h tokens.h mode.h
+ $(CC) $(CFLAGS) -c dlg_a.c
+
+main.$(OBJ_EXT) : main.c dlg.h
+ $(CC) $(CFLAGS) -c main.c
+
+set.$(OBJ_EXT) : $(SET)/set.c
+ $(CC) -c $(CFLAGS) $(SET)/set.c
+
+lint:
+ lint *.c
+
+#clean up all the intermediate files
+clean:
+ rm -f *.$(OBJ_EXT) core
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/makefile1 b/BaseTools/Source/C/VfrCompile/Pccts/dlg/makefile1 new file mode 100644 index 0000000000..4d00f7966e --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/makefile1 @@ -0,0 +1,63 @@ +#
+# Makefile for DLG 1.33
+# Terence Parr
+# Purdue University, U of MN, Parr Research Corporation
+# 1989-1994
+#
+# Ported to IBM C-Set/2 and Microsoft 6.0 by
+# Ed Harfmann
+# Micro Data Base Systems
+# Lafayette, Indiana
+#
+SET=../support/set
+PCCTS_H=../h
+
+##
+## Uncomment the appropriate section to build
+##
+
+
+#
+# UNIX
+#
+CC=cc
+ANTLR=../bin/antlr
+DLG=../bin/dlg
+ANSI=-ansi
+CFLAGS= -O -I. -I$(SET) -I$(PCCTS_H) -DUSER_ZZSYN $(COTHER) $(ANSI) -DZZLEXBUFSIZE=32000
+OBJ_EXT=o
+OUT_OBJ = -o
+OBJ = dlg_p.o dlg_a.o main.o err.o set.o support.o output.o \
+ relabel.o automata.o
+
+dlg : $(OBJ) $(SRC)
+ $(CC) $(CFLAGS) -o dlg $(OBJ)
+ mv dlg ../bin
+
+SRC = dlg_p.c dlg_a.c main.c err.c $(SET)/set.c support.c output.c \
+ relabel.c automata.c
+
+dlg_p.c parser.dlg err.c tokens.h : dlg_p.g
+ $(ANTLR) dlg_p.g
+
+dlg_a.c mode.h : parser.dlg
+ $(DLG) -C2 parser.dlg dlg_a.c
+
+dlg_p.$(OBJ_EXT) : dlg_p.c dlg.h tokens.h mode.h
+ $(CC) $(CFLAGS) -c dlg_p.c
+
+dlg_a.$(OBJ_EXT) : dlg_a.c dlg.h tokens.h mode.h
+ $(CC) $(CFLAGS) -c dlg_a.c
+
+main.$(OBJ_EXT) : main.c dlg.h
+ $(CC) $(CFLAGS) -c main.c
+
+set.$(OBJ_EXT) : $(SET)/set.c
+ $(CC) -c $(CFLAGS) $(SET)/set.c
+
+lint:
+ lint *.c
+
+#clean up all the intermediate files
+clean:
+ rm -f *.$(OBJ_EXT) core
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/mode.h b/BaseTools/Source/C/VfrCompile/Pccts/dlg/mode.h new file mode 100644 index 0000000000..3f3279e52a --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/mode.h @@ -0,0 +1,4 @@ +#define START 0
+#define ACT 1
+#define ACTION_COMMENTS 2
+#define ACTION_CPP_COMMENTS 3
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/output.c b/BaseTools/Source/C/VfrCompile/Pccts/dlg/output.c new file mode 100644 index 0000000000..2e56a6d8c1 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/output.c @@ -0,0 +1,850 @@ +/* output.c, output generator for dlg
+ *
+ * Output Notes:
+ *
+ * DfaStates == number of dfa nodes in automaton (just a #define)
+ * DfaState == type large enough to index every node in automaton
+ * <256 unsigned char, <65536 unsigned short, etc.
+ *
+ * Thus, the elements in each of the automaton states (st%d) are type DfaState
+ * and are size appropriately, since they must be able to index the next
+ * automaton state.
+ *
+ * dfa[] == a linear array that points to all the automaton states (st%d)
+ * (dfa_base[] should be the same, but isn't right now)
+ *
+ * accepts[] == Taking a closer look at this one, it probably shouldn't be type
+ * DfaState because there is no real requirement that the number of
+ * accepts states is less than the number of dfa state. However, if
+ * the number of accept states was more than the number of DFA states
+ * then the lexical specification would be really ambiguous.
+ *
+ * Another note. Is that is should be possible to fold accepts[] and
+ * actions[] together. If this is done, I would suggest get rid of
+ * accept[] and make actions[] have an entry for each state (st%d) in
+ * the automaton.
+ *
+ * dfa_base[] == starting location for each lexical mode. This should be
+ * Dfastate type (but isn't right now), since it points to the states
+ * in the automaton.
+ *
+ * dfa_class_no[] == indicates the number of columns each lexical mode has.
+ *
+ * b_class_no[] == pointer to the start of the translation array used to
+ * convert from input character to character class. This could cause
+ * problems if there are more than 256 classes
+ *
+ * shift%d[] == the actual translation arrays that convert the input character
+ * into the character class. These will have to change if there are
+ * more than 256 character classes.
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * DLG 1.33
+ * Will Cohen
+ * With mods by Terence Parr; AHPCRC, University of Minnesota
+ * 1989-2001
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include "dlg.h"
+#ifdef MEMCHK
+#include "trax.h"
+#else
+#ifdef __STDC__
+#include <stdlib.h>
+#else
+#include <malloc.h>
+#endif /* __STDC__ */
+#endif
+
+static char *mode_name[MAX_MODES];
+static int mode_number[MAX_MODES];
+static int cur_mode=0;
+
+int operation_no = 0; /* used to mark nodes so that infinite loops avoided */
+int dfa_basep[MAX_MODES]; /* start of each group of states */
+int dfa_class_nop[MAX_MODES]; /* number of elements in each group of states*/
+
+int gen_ansi = FALSE; /* allows ansi code to be generated */
+
+FILE *input_stream; /* where to read description from */
+FILE *output_stream; /* where to put the output */
+FILE *mode_stream; /* where to put the mode.h stuff */
+FILE *class_stream; /* where to put the scan.h stuff (if gen_cpp) */
+
+/* NOTE: This section is MACHINE DEPENDENT */
+#define DIF_SIZE 4
+#if defined(PC) && !defined(PC32)
+unsigned long typesize[DIF_SIZE] = { 0x7f, 0x7fff, 0x7ffful, 0x7ffffffful }; /* MR20 */
+char t0[] = "unsigned char";
+char t1[] = "unsigned short";
+char t2[] = "unsigned int";
+char t3[] = "unsigned long";
+char *typevar[DIF_SIZE] = { t0, t1, t2, t3};
+#else
+unsigned long typesize[DIF_SIZE] = { 0x7f, 0x7fff, 0x7ffffffful, 0x7ffffffful }; /* MR20 */
+char t0[] = "unsigned char";
+char t1[] = "unsigned short";
+char t2[] = "unsigned int";
+char t3[] = "unsigned long";
+char *typevar[DIF_SIZE] = { t0, t1, t2, t3};
+#endif
+
+/* Added by TJP August 1994 */
+/* Take in MyLexer and return MyLexer_h */
+
+static char *
+#ifdef __USE_PROTOS
+gate_symbol(char *name)
+#else
+gate_symbol(name)
+char *name;
+#endif
+{
+ static char buf[100];
+ sprintf(buf, "%s_h", name);
+ return buf;
+}
+
+/* Added by TJP August 1994 */
+static char *
+#ifdef __USE_PROTOS
+mystrdup(char *s)
+#else
+mystrdup(s)
+char *s;
+#endif
+{
+ char *p = (char *)malloc(strlen(s)+1);
+ strcpy(p, s);
+ return p;
+}
+
+#ifdef __USE_PROTOS
+void p_class_hdr(void)
+#else
+void p_class_hdr()
+#endif
+{
+ if ( class_stream == NULL ) return;
+ fprintf(class_stream, "#ifndef %s\n", gate_symbol(ClassName("")));
+ fprintf(class_stream, "#define %s\n", gate_symbol(ClassName("")));
+ fprintf(class_stream, "/*\n");
+ fprintf(class_stream, " * D L G L e x e r C l a s s D e f i n i t i o n\n");
+ fprintf(class_stream, " *\n");
+ fprintf(class_stream, " * Generated from:");
+ fprintf(class_stream, " %s", file_str[0]);
+ fprintf(class_stream, "\n");
+ fprintf(class_stream, " *\n");
+ fprintf(class_stream, " * 1989-2001 by Will Cohen, Terence Parr, and Hank Dietz\n");
+ fprintf(class_stream, " * Purdue University Electrical Engineering\n");
+ fprintf(class_stream, " * DLG Version %s\n", version);
+ fprintf(class_stream, " */\n\n");
+ fprintf(class_stream, "\n");
+ fprintf(class_stream, "#include \"%s\"\n", DLEXERBASE_H);
+}
+
+/* MR1 */
+/* MR1 16-Apr-97 Split printing of class header up into several parts */
+/* MR1 so that #lexprefix <<...>>and #lexmember <<...>> */
+/* MR1 can be inserted in the appropriate spots */
+/* MR1 */
+
+#ifdef __USE_PROTOS
+void p_class_def1(void)
+#else
+void p_class_def1()
+#endif
+{
+ if ( class_stream == NULL ) return;
+ fprintf(class_stream, "\nclass %s : public DLGLexerBase {\n", ClassName(""));
+ fprintf(class_stream, "public:\n");
+}
+
+#ifdef __USE_PROTOS
+void p_class_def2(void)
+#else
+void p_class_def2()
+#endif
+{
+ int i, m;
+ if ( class_stream == NULL ) return;
+ fprintf(class_stream, "public:\n");
+ fprintf(class_stream, "\tstatic const int MAX_MODE;\n");
+ fprintf(class_stream, "\tstatic const int DfaStates;\n");
+ for (i=0; i<cur_mode; i++) {
+ fprintf(class_stream, "\tstatic const int %s;\n", mode_name[i]);
+ }
+
+ fprintf(class_stream, "\ttypedef %s DfaState;\n\n", minsize(dfa_allocated));
+ fprintf(class_stream, "\t%s(DLGInputStream *in,\n",ClassName(""));
+ fprintf(class_stream, "\t\tunsigned bufsize=2000)\n");
+ fprintf(class_stream, "\t\t: DLGLexerBase(in, bufsize, %d)\n", interactive);
+ fprintf(class_stream, "\t{\n");
+ fprintf(class_stream, "\t;\n");
+ fprintf(class_stream, "\t}\n");
+ fprintf(class_stream, "\tvoid mode(int);\n");
+ fprintf(class_stream, "\tANTLRTokenType nextTokenType(void);\n");
+ fprintf(class_stream, "\tvoid advance(void);\n");
+ fprintf(class_stream, "protected:\n");
+ for (i=1; i<=action_no; ++i) {
+ fprintf(class_stream, "\tANTLRTokenType act%d();\n", i);
+ }
+
+ for(m=0; m<(mode_counter-1); ++m){
+ for(i=dfa_basep[m]; i<dfa_basep[m+1]; ++i)
+ fprintf(class_stream, "\tstatic DfaState st%d[%d];\n", i-1, dfa_class_nop[m]+1);
+ }
+ for(i=dfa_basep[m]; i<=dfa_allocated; ++i)
+ fprintf(class_stream, "\tstatic DfaState st%d[%d];\n", i-1, dfa_class_nop[m]+1);
+
+ fprintf(class_stream, "\tstatic DfaState *dfa[%d];\n", dfa_allocated);
+ fprintf(class_stream, "\tstatic DfaState dfa_base[];\n");
+/* fprintf(class_stream, "\tstatic int dfa_base_no[];\n"); */
+ fprintf(class_stream, "\tstatic unsigned char *b_class_no[];\n");
+ fprintf(class_stream, "\tstatic DfaState accepts[%d];\n",dfa_allocated+1);
+ fprintf(class_stream, "\tstatic DLGChar alternatives[%d];\n",dfa_allocated+1);
+ /* WARNING: should be ANTLRTokenType for action table, but g++ 2.5.6 is hosed */
+ fprintf(class_stream, "\tstatic ANTLRTokenType (%s::*actions[%d])();\n", ClassName(""), action_no+1);
+ for(m=0; m<mode_counter; ++m) {
+ fprintf(class_stream, "\tstatic unsigned char shift%d[%d];\n",
+ m, CHAR_RANGE);
+ }
+ if (comp_level)
+ fprintf(class_stream, "\tint ZZSHIFT(int c) { return b_class_no[automaton][1+c]; }\n");
+ else
+ fprintf(class_stream, "\tint ZZSHIFT(int c) { return 1+c; }\n");
+
+/* MR1 */
+/* MR1 11-APr-97 Kludge to allow inclusion of user-defined code in */
+/* MR1 DLGLexer class header */
+/* MR1 Deprecated in favor of 133MR1 addition #lexmember <<>> */
+/* MR1 */
+/* MR1 */ fprintf(class_stream,"//\n");
+/* MR1 */ fprintf(class_stream,
+/* MR1 */ "// 133MR1 Deprecated feature to allow inclusion of ");
+/* MR1 */ fprintf(class_stream,
+/* MR1 */ "user-defined code in DLG class header\n");
+/* MR1 */ fprintf(class_stream,"//\n");
+/* MR1 */
+/* MR1 */ fprintf(class_stream,"#ifdef DLGLexerIncludeFile\n");
+/* MR1 */ fprintf(class_stream,"#include DLGLexerIncludeFile\n");
+/* MR1 */ fprintf(class_stream,"#endif\n");
+
+ fprintf(class_stream, "};\n");
+
+ fprintf(class_stream, "typedef ANTLRTokenType (%s::*Ptr%sMemberFunc)();\n",
+ ClassName(""), ClassName(""));
+
+ fprintf(class_stream, "#endif\n");
+}
+
+/* generate required header on output */
+
+#ifdef __USE_PROTOS
+void p_head(void)
+#else
+void p_head()
+#endif
+{
+ fprintf(OUT, "/*\n");
+ fprintf(OUT, " * D L G tables\n");
+ fprintf(OUT, " *\n");
+ fprintf(OUT, " * Generated from:");
+ fprintf(OUT, " %s", file_str[0]);
+ fprintf(OUT, "\n");
+ fprintf(OUT, " *\n");
+ fprintf(OUT, " * 1989-2001 by Will Cohen, Terence Parr, and Hank Dietz\n");
+ fprintf(OUT, " * Purdue University Electrical Engineering\n");
+ fprintf(OUT, " * DLG Version %s\n", version);
+ fprintf(OUT, " */\n\n");
+ if ( gen_cpp) fprintf(OUT, "#include \"pcctscfg.h\"\n");
+ if ( gen_cpp ) fprintf(OUT, "#include \"pccts_stdio.h\"\n");
+ if ( !gen_cpp ) fprintf(OUT, "#include \"%s\"\n\n", mode_file);
+ fprintf(OUT,"\n");
+}
+
+#ifdef __USE_PROTOS
+void p_includes(void)
+#else
+void p_includes()
+#endif
+{
+ fprintf(OUT, "#include \"%s\"\n", APARSER_H);
+ fprintf(OUT, "#include \"%s\"\n", DLEXERBASE_H);
+ fprintf(OUT, "#include \"%s\"\n", ClassName(".h"));
+}
+
+/* generate code to tie up any loose ends */
+
+#ifdef __USE_PROTOS
+void p_tail(void) /* MR1 */
+#else
+void p_tail() /* MR1 */
+#endif
+{
+ if ( gen_cpp ) {
+ if ( strcmp(ClassName(""), DEFAULT_CLASSNAME)!=0 )
+ fprintf(OUT, "#define DLGLexer %s\n", ClassName(""));
+ fprintf(OUT, "#include \"%s\"\n", DLEXER_H); /* MR23 Rename DLexer.cpp to DLexer.h */
+ return;
+ }
+ fprintf(OUT, "\n");
+ fprintf(OUT, "\n");
+ if (comp_level)
+ fprintf(OUT, "#define ZZSHIFT(c) (b_class_no[zzauto][1+c])\n");
+ else
+ fprintf(OUT, "#define ZZSHIFT(c) (1+c)\n");
+ if ( !gen_cpp ) fprintf(OUT, "#define MAX_MODE %d\n",mode_counter);
+ fprintf(OUT, "#include \"dlgauto.h\"\n");
+}
+
+
+/* output the table of DFA for general use */
+
+#ifdef __USE_PROTOS
+void p_tables()
+#else
+void p_tables()
+#endif
+{
+ if ( !gen_cpp ) {
+ fprintf(OUT, "#define DfaStates\t%d\n", dfa_allocated);
+ fprintf(OUT, "typedef %s DfaState;\n\n", minsize(dfa_allocated));
+ }
+
+ if ( gen_cpp ) {
+ int i;
+ fprintf(OUT, "\n");
+ fprintf(OUT, "const int %s::MAX_MODE=%d;\n",
+ ClassName(""),
+ mode_counter);
+ fprintf(OUT, "const int %s::DfaStates=%d;\n",
+ ClassName(""),
+ dfa_allocated);
+ for (i=0; i<cur_mode; i++) {
+ fprintf(OUT, "const int %s::%s=%d;\n",
+ ClassName(""), mode_name[i], mode_number[i]);
+ }
+ fprintf(OUT, "\n");
+ }
+
+ p_node_table();
+ p_dfa_table();
+ p_accept_table();
+ p_action_table();
+ p_base_table();
+ p_class_table();
+ if (comp_level)
+ p_bshift_table();
+ if (interactive || gen_cpp )
+ p_alternative_table();
+}
+
+
+/* figures out the smallest variable type that will hold the transitions
+ */
+
+#ifdef __USE_PROTOS
+char *minsize(int elements)
+#else
+char *minsize(elements)
+int elements;
+#endif
+{
+ int i = 0;
+
+ while ((unsigned long) elements > typesize[i]) /* MR20 */
+ ++i;
+ return typevar[i];
+}
+
+
+#ifdef __USE_PROTOS
+void p_node_table(void)
+#else
+void p_node_table()
+#endif
+{
+ register int i;
+ register int m = 0;
+
+ for(m=0; m<(mode_counter-1); ++m){
+ for(i=dfa_basep[m]; i<dfa_basep[m+1]; ++i)
+ p_single_node(i,dfa_class_nop[m]);
+ }
+ for(i=dfa_basep[m]; i<=dfa_allocated; ++i)
+ p_single_node(i,dfa_class_nop[m]);
+}
+
+
+#ifdef __USE_PROTOS
+void p_single_node(int i,int classes)
+#else
+void p_single_node(i,classes)
+int i,classes;
+#endif
+{
+ register int j;
+ register int trans, items_on_line;
+
+#if 1
+ /* extra state (classes+1) for invalid characters */
+ fprintf(OUT, "%sDfaState %sst%d[%d] = {\n ",
+ gen_cpp?ClassName("::"):"static ",
+ gen_cpp?ClassName("::"):"",(i-1), (classes+1));
+#else
+ fprintf(OUT, "static DfaState st%d[%d] = {\n ", (i-1), classes);
+#endif
+ items_on_line = MAX_ON_LINE;
+ for(j=0; j<classes; ++j){
+ DAWDLE;
+ trans = DFA(i)->trans[j];
+ if (trans == NIL_INDEX)
+ trans = dfa_allocated+1;
+ /* all of DFA moved down one in array */
+ fprintf(OUT, "%d", trans-1);
+ fprintf(OUT, ", ");
+ if (!(--items_on_line)){
+ fprintf(OUT, "\n ");
+ items_on_line = MAX_ON_LINE;
+ }
+ }
+#if 1
+ /* put in jump to error state */
+ fprintf(OUT, "%d\n};\n\n", dfa_allocated);
+#else
+ fprintf(OUT, "\n};\n\n");
+#endif
+}
+
+
+#ifdef __USE_PROTOS
+void p_dfa_table(void)
+#else
+void p_dfa_table()
+#endif
+{
+ register int i;
+
+ fprintf(OUT, "\n%sDfaState *%sdfa[%d] = {\n",
+ gen_cpp?ClassName("::"):"",gen_cpp?ClassName("::"):"", dfa_allocated);
+ for (i=0; i<(dfa_allocated-1); ++i){
+ fprintf(OUT, "\tst%d,\n", i);
+ }
+ fprintf(OUT, "\tst%d\n", i);
+ fprintf(OUT, "};\n\n");
+}
+
+
+#ifdef __USE_PROTOS
+void p_accept_table(void)
+#else
+void p_accept_table()
+#endif
+{
+ register int i = 1;
+ register int items_on_line = 0;
+ int true_interactive = TRUE;
+
+ /* make sure element for one past (zzerraction) -WEC 12/16/92 */
+ fprintf(OUT,"\n%sDfaState %saccepts[%d] = {\n ",
+ gen_cpp?ClassName("::"):"",
+ gen_cpp?ClassName("::"):"",
+ dfa_allocated+1);
+ /* don't do anything if no dfa nodes */
+ if (i>dfa_allocated) goto skip_accepts;
+ for (;;) {
+ int accept=0; /* MR14a - Manuel Kessler (mlkessle@cip.physik.uni-wuerzburg.de) */
+ set accept_set;
+ set nfa_states;
+ unsigned int *t, *nfa_i;
+ unsigned int *q, *regular_expr;
+
+ accept_set = empty;
+ nfa_states = DFA(i)->nfa_states;
+ t = nfa_i = set_pdq(nfa_states);
+ /* NOTE: picks lowest accept because accepts monotonic */
+ /* with respect to nfa node numbers and set_pdq */
+ /* returns in that order */
+ while((*nfa_i != nil) && (!(accept = NFA(*nfa_i)->accept))){
+ nfa_i++;
+ }
+
+ /* figure out if more than one accept state there */
+ if (warn_ambig ){
+ set_orel(accept, &accept_set);
+ while(*nfa_i != nil){
+ set_orel(NFA(*nfa_i)->accept, &accept_set);
+ nfa_i++;
+ }
+ /* remove error action from consideration */
+ set_rm(0, accept_set);
+
+ if( set_deg(accept_set)>1){
+ fprintf(stderr, "dlg warning: ambiguous regular expression ");
+ q = regular_expr = set_pdq(accept_set);
+ while(*regular_expr != nil){
+ fprintf(stderr," %d ", *regular_expr);
+ ++regular_expr;
+ }
+ fprintf(stderr, "\n");
+ free(q);
+ }
+ }
+
+ if ((DFA(i)->alternatives) && (accept != 0)){
+ true_interactive = FALSE;
+ }
+ fprintf(OUT, "%d, ", accept);
+
+ /* free up memory before we "break" below -ATG 4/6/95 */
+ free(t);
+ set_free(accept_set);
+
+ if ((++i)>dfa_allocated)
+ break;
+ if ((++items_on_line)>=MAX_ON_LINE){
+ fprintf(OUT,"\n ");
+ items_on_line = 0;
+ }
+/*
+ free(t);
+ set_free(accept_set);
+*/
+ }
+ /* make sure element for one past (zzerraction) -WEC 12/16/92 */
+skip_accepts:
+ fprintf(OUT, "0\n};\n\n");
+}
+
+
+#ifdef __USE_PROTOS
+void p_action_table(void)
+#else
+void p_action_table()
+#endif
+{
+ register int i;
+ char* theClassName = ClassName("");
+
+ if ( gen_cpp )
+ fprintf(OUT, "Ptr%sMemberFunc %s::actions[%d] = {\n", theClassName,
+ theClassName, action_no+1);
+ else
+ fprintf(OUT, "void (*actions[%d])() = {\n", action_no+1);
+ if ( gen_cpp )
+/* fprintf(OUT, "\t(Ptr%sMemberFunc)&%s::erraction,\n", theClassName, theClassName);*/
+ fprintf(OUT, "\t&%s::erraction,\n", theClassName);
+ else
+ fprintf(OUT, "\tzzerraction,\n");
+ for (i=1; i<action_no; ++i) {
+ if ( gen_cpp )
+/* fprintf(OUT,"\t(Ptr%sMemberFunc)&%s::act%d,\n", theClassName, theClassName, i);*/
+ fprintf(OUT,"\t&%s::act%d,\n", theClassName, i);
+ else
+ fprintf(OUT,"\tact%d,\n", i);
+ DAWDLE;
+ }
+ if ( gen_cpp )
+/* fprintf(OUT,"\t(Ptr%sMemberFunc)&%s::act%d\n", theClassName, theClassName, i);*/
+ fprintf(OUT,"\t&%s::act%d\n", theClassName, i);
+ else
+ fprintf(OUT,"\tact%d\n", i);
+ fprintf(OUT, "};\n\n");
+}
+
+
+#ifdef __USE_PROTOS
+void p_shift_table(int m) /* MR1 */
+#else
+void p_shift_table(m) /* MR1 */
+int m;
+#endif
+{
+ register int i = 0, j;
+ register int items_on_line = 0;
+
+ fprintf(OUT, "%s unsigned char %sshift%d[%d] = {\n ",
+ gen_cpp?"":"static",
+ gen_cpp?ClassName("::"):"", m, CHAR_RANGE);
+ for (;;) {
+ /* find which partition character i is in */
+ for (j=0; j<dfa_class_nop[mode_counter]; ++j){
+ if (set_el(i,class_sets[j]))
+ break;
+ }
+ fprintf(OUT,"%d",j);
+ if ((++i)>=CHAR_RANGE)
+ break;
+ fprintf(OUT,", ");
+ if ((++items_on_line)>=MAX_ON_LINE){
+ fprintf(OUT,"\n ");
+ items_on_line = 0;
+ }
+ }
+ fprintf(OUT, "\n};\n\n");
+}
+
+
+#ifdef __USE_PROTOS
+void p_base_table(void)
+#else
+void p_base_table()
+#endif
+{
+ register int m;
+
+ fprintf(OUT, "%sDfaState %sdfa_base[] = {\n",
+ gen_cpp?ClassName("::"):"static ",
+ gen_cpp?ClassName("::"):"");
+ for(m=0; m<(mode_counter-1); ++m)
+ fprintf(OUT, "\t%d,\n", dfa_basep[m]-1);
+ fprintf(OUT, "\t%d\n};\n\n", dfa_basep[m]-1);
+}
+
+
+#ifdef __USE_PROTOS
+void p_class_table(void) /* MR1 */
+#else
+void p_class_table() /* MR1 */
+#endif
+{
+#if 0
+ register int m;
+
+ fprintf(OUT,"%s int %sdfa_class_no[] = {\n",
+ gen_cpp?"":"static",
+ gen_cpp?ClassName("::"):"");
+ for(m=0; m<(mode_counter-1); ++m)
+ fprintf(OUT,"\t%d,\n", dfa_class_nop[m]);
+ fprintf(OUT,"\t%d\n};\n\n", dfa_class_nop[m]);
+#endif
+}
+
+
+#ifdef __USE_PROTOS
+void p_bshift_table(void) /* MR1 */
+#else
+void p_bshift_table() /* MR1 */
+#endif
+{
+ register int m;
+
+ fprintf(OUT,"%s unsigned char *%sb_class_no[] = {\n",
+ gen_cpp?"":"static",
+ gen_cpp?ClassName("::"):"");
+ for(m=0; m<(mode_counter-1); ++m)
+ fprintf(OUT, "\tshift%d,\n", m);
+ fprintf(OUT, "\tshift%d\n};\n\n", m);
+}
+
+
+#ifdef __USE_PROTOS
+void p_alternative_table(void) /* MR1 */
+#else
+void p_alternative_table() /* MR1 */
+#endif
+{
+ register int i;
+
+ if ( !gen_cpp ) fprintf(OUT, "#define ZZINTERACTIVE\n\n");
+ if ( gen_cpp )
+ fprintf(OUT, "DLGChar %salternatives[%d] = {\n", /* mr23 vhs %sDfaStates+1 */
+ ClassName("::"),
+ dfa_allocated+1); /* vhs ClassName("::")); */
+ else
+ fprintf(OUT, "static %s zzalternatives[DfaStates+1] = {\n",
+ minsize(dfa_allocated));
+
+ for(i=1; i<=dfa_allocated; ++i)
+ fprintf(OUT, "\t%d,\n", DFA(i)->alternatives);
+ fprintf(OUT, "/* must have 0 for zzalternatives[DfaStates] */\n");
+ fprintf(OUT, "\t0\n};\n\n");
+}
+
+
+#ifdef __USE_PROTOS
+void p_mode_def(char *s,int m) /* MR1 */
+#else
+void p_mode_def(s,m) /* MR1 */
+char *s;
+int m;
+#endif
+{
+ if ( gen_cpp )
+ {
+ mode_name[cur_mode] = mystrdup(s);
+ mode_number[cur_mode] = m;
+ cur_mode++;
+ }
+ else
+ fprintf(mode_stream, "#define %s %d\n", s, m);
+}
+
+#ifdef __USE_PROTOS
+char * ClassName(char *suffix)
+#else
+char * ClassName(suffix)
+char *suffix;
+#endif
+{
+ static char buf[200];
+ extern char *class_name;
+
+ sprintf(buf, "%s%s", class_name, suffix);
+ return buf;
+}
+
+#ifdef DEBUG
+
+/* print out a particular nfa node that is pointed to by p */
+
+#ifdef __USE_PROTOS
+void p_nfa_node(nfa_node *p)
+#else
+void p_nfa_node(p)
+nfa_node *p;
+#endif
+{
+ register nfa_node *t;
+
+ if (p != NIL_INDEX){
+ printf("NFA state : %d\naccept state : %d\n",
+ NFA_NO(p),p->accept);
+ if (p->trans[0] != NIL_INDEX){
+ printf("trans[0] => %d on ", NFA_NO(p->trans[0]));
+ p_set(p->label);
+ printf("\n");
+ }
+ else
+ printf("trans[0] => nil\n");
+ if (p->trans[1] != NIL_INDEX)
+ printf("trans[1] => %d on epsilon\n",
+ NFA_NO(p->trans[1]));
+ else
+ printf("trans[1] => nil\n");
+ printf("\n");
+ }
+}
+#endif
+
+#ifdef DEBUG
+
+/* code to print out special structures when using a debugger */
+
+#ifdef __USE_PROTOS
+void p_nfa(p)
+#else
+void p_nfa(nfa_node *p)
+nfa_node *p; /* state number also index into array */
+#endif
+{
+/* each node has a marker on it so it only gets printed once */
+
+ operation_no++; /* get new number */
+ s_p_nfa(p);
+}
+
+#ifdef __USE_PROTOS
+void s_p_nfa(nfa_node *p)
+#else
+void s_p_nfa(p)
+nfa_node *p; /* state number also index into array */
+#endif
+{
+ if ((p != NIL_INDEX) && (p->nfa_set != operation_no)){
+ /* so it is only printed once */
+ p->nfa_set = operation_no;
+ p_nfa_node(p);
+ s_p_nfa(p->trans[0]);
+ s_p_nfa(p->trans[1]);
+ }
+}
+
+#ifdef __USE_PROTOS
+void p_dfa_node(dfa_node *p)
+#else
+void p_dfa_node(p)
+dfa_node *p;
+#endif
+{
+ int i;
+
+ if (p != NIL_INDEX){
+ printf("DFA state :%d\n",NFA_NO(p));
+ if (p->done)
+ printf("done\n");
+ else
+ printf("undone\n");
+ printf("from nfa states : ");
+ p_set(p->nfa_states);
+ printf("\n");
+ /* NOTE: trans arcs stored as ints rather than pointer*/
+ for (i=0; i<class_no; i++){
+ printf("%d ",p->trans[i]);
+ }
+ printf("\n\n");
+ }
+}
+
+#ifdef __USE_PROTOS
+void p_dfa(void)
+#else
+void p_dfa()
+#endif
+{
+/* prints out all the dfa nodes actually allocated */
+
+ int i;
+
+ for (i = 1; i<=dfa_allocated; i++)
+ p_dfa_node(NFA(i));
+}
+
+
+/* print out numbers in the set label */
+
+#ifdef __USE_PROTOS
+void p_set(set label)
+#else
+void p_set(label)
+set label;
+#endif
+{
+ unsigned *t, *e;
+
+ if (set_nil(label)){
+ printf("epsilon\n");
+ }else{
+ t = e = set_pdq(label);
+ while(*e != nil){
+ printf("%d ", (*e+MIN_CHAR));
+ e++;
+ }
+ printf("\n");
+ free(t);
+ }
+
+}
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/parser.dlg b/BaseTools/Source/C/VfrCompile/Pccts/dlg/parser.dlg new file mode 100644 index 0000000000..df9a637f9e --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/parser.dlg @@ -0,0 +1,398 @@ +<<
+/* parser.dlg -- DLG Description of scanner
+ *
+ * Generated from: dlg_p.g
+ *
+ * Terence Parr, Will Cohen, and Hank Dietz: 1989-2001
+ * Purdue University Electrical Engineering
+ * With AHPCRC, University of Minnesota
+ * ANTLR Version 1.33MR33
+ */
+
+#define ANTLR_VERSION 13333
+#include "pcctscfg.h"
+#include "pccts_stdio.h"
+
+#include <ctype.h>
+#include "dlg.h"
+#include "antlr.h"
+#include "tokens.h"
+#include "dlgdef.h"
+LOOKAHEAD
+
+void
+#ifdef __USE_PROTOS
+zzerraction(void)
+#else
+zzerraction()
+#endif
+{
+ (*zzerr)("invalid token");
+ zzadvance();
+ zzskip();
+}
+>>
+
+<<%%lexaction
+
+int func_action; /* should actions be turned into functions?*/
+int lex_mode_counter = 0; /* keeps track of the number of %%names */
+/* MR1 */
+/* MR1 11-Apr-97 Provide mechanism for inserting code into DLG class */
+/* MR1 via <<%%lexmember...>> */
+/* MR1 */
+int lexMember = 0; /* <<%%lexmemeber ...>> MR1 */
+int lexAction = 0; /* <<%%lexaction ...>> MR1 */
+int parserClass = 0; /* <<%%parserclass ...>> MR1 */
+int lexPrefix = 0; /* <<%%lexprefix ...>> MR1 */
+char theClassName[100]; /* MR11 */
+char *pClassName=theClassName; /* MR11 */
+int firstLexMember=1; /* MR1 */
+
+#ifdef __USE_PROTOS
+void xxputc(int c) { /* MR1 */
+#else
+ void xxputc(c) /* MR1 */
+ int c; /* MR1 */
+ { /* MR1 */
+#endif
+ if (parserClass) { /* MR1 */
+ *pClassName++=c; /* MR1 */
+ *pClassName=0; /* MR1 */
+ } else if (lexMember || lexPrefix) { /* MR1 */
+ if (class_stream != NULL) fputc(c,class_stream); /* MR1 */
+ } else { /* MR1 */
+ fputc(c,OUT); /* MR1 */
+ }; /* MR1 */
+ } /* MR1 */
+
+#ifdef __USE_PROTOS
+ void xxprintf(char *format,char *string) { /* MR1 */
+#else
+ void xxprintf(format,string) /* MR1 */
+ char *format; /* MR1 */
+ char *string; /* MR1 */
+ { /* MR1 */
+#endif
+ if (lexMember || lexPrefix || parserClass) { /* MR1 */
+ if (class_stream != NULL) /* MR1 */
+ fprintf(class_stream,format,string); /* MR1 */
+ } else { /* MR1 */
+ fprintf(OUT,format,string); /* MR1 */
+ }; /* MR1 */
+ } /* MR1 */
+>>
+
+
+%%START
+
+@
+ <<
+ NLA = 1;
+ >>
+
+[\r\t\ ]+
+ <<
+ NLA = 2;
+ zzskip();
+ >>
+
+\n
+ <<
+ NLA = 3;
+ zzline++; zzskip(); DAWDLE;
+ >>
+
+\@
+ <<
+ NLA = L_EOF;
+ >>
+
+\%\%
+ <<
+ NLA = PER_PER;
+ >>
+
+\%\%[a-zA-Z_][a-zA-Z0-9_]*
+ <<
+ NLA = NAME_PER_PER;
+ p_mode_def(&zzlextext[2],lex_mode_counter++);
+ >>
+
+\<\<\%\%lexmember
+ <<
+ NLA = LEXMEMBER;
+ lexMember=1; /* MR1 */
+ if (firstLexMember != 0) { /* MR1 */
+ firstLexMember=0; /* MR1 */
+ p_class_def1(); /* MR1 */
+ }; /* MR1 */
+ zzmode(ACT); /* MR1 */
+ >>
+
+\<\<\%\%lexaction
+ <<
+ NLA = LEXACTION;
+ lexAction=1;zzmode(ACT);
+ >>
+
+\<\<\%\%parserclass
+ <<
+ NLA = PARSERCLASS;
+ parserClass=1; /* MR1 */
+ zzmode(ACT); /* MR1 */
+ >>
+
+\<\<\%\%lexprefix
+ <<
+ NLA = LEXPREFIX;
+ lexPrefix=1;zzmode(ACT);
+ >>
+
+\<\<
+ <<
+ NLA = ACTION;
+ if (func_action)
+ fprintf(OUT,"\n%s %sact%d()\n{ ",
+ gen_cpp?"ANTLRTokenType":"static void",
+ gen_cpp?ClassName("::"):"", ++action_no);
+ zzmode(ACT); zzskip();
+ >>
+
+\>\>
+ <<
+ NLA = GREAT_GREAT;
+ >>
+
+\{
+ <<
+ NLA = L_BRACE;
+ >>
+
+\}
+ <<
+ NLA = R_BRACE;
+ >>
+
+\(
+ <<
+ NLA = L_PAR;
+ >>
+
+\)
+ <<
+ NLA = R_PAR;
+ >>
+
+\[
+ <<
+ NLA = L_BRACK;
+ >>
+
+\]
+ <<
+ NLA = R_BRACK;
+ >>
+
+\*
+ <<
+ NLA = ZERO_MORE;
+ >>
+
+\+
+ <<
+ NLA = ONE_MORE;
+ >>
+
+\|
+ <<
+ NLA = OR;
+ >>
+
+\-
+ <<
+ NLA = RANGE;
+ >>
+
+\~
+ <<
+ NLA = NOT;
+ >>
+
+\\0[0-7]*
+ <<
+ NLA = OCTAL_VALUE;
+ {int t; sscanf(&zzlextext[1],"%o",&t); zzlextext[0] = t;}
+ >>
+
+\\0[Xx][0-9a-fA-F]+
+ <<
+ NLA = HEX_VALUE;
+ {int t; sscanf(&zzlextext[3],"%x",&t); zzlextext[0] = t;}
+ >>
+
+\\[1-9][0-9]*
+ <<
+ NLA = DEC_VALUE;
+ {int t; sscanf(&zzlextext[1],"%d",&t); zzlextext[0] = t;}
+ >>
+
+\\t
+ <<
+ NLA = TAB;
+ zzlextext[0] = '\t';
+ >>
+
+\\n
+ <<
+ NLA = NL;
+ zzlextext[0] = '\n';
+ >>
+
+\\r
+ <<
+ NLA = CR;
+ zzlextext[0] = '\r';
+ >>
+
+\\b
+ <<
+ NLA = BS;
+ zzlextext[0] = '\b';
+ >>
+
+\\ \n
+ <<
+ NLA = CONTINUATION;
+ zzline++; zzskip();
+ >>
+
+\\~[tnrb]
+ <<
+ NLA = LIT;
+ zzlextext[0] = zzlextext[1];
+ >>
+
+~[\\]
+ <<
+ NLA = REGCHAR;
+ >>
+
+
+%%ACT
+
+@
+ <<
+ NLA = 1;
+ error("unterminated action", zzline); zzmode(START);
+ >>
+
+\>\>
+ <<
+ NLA = ACTION;
+ if (func_action) fprintf(OUT,"}\n\n");
+ zzmode(START);
+ /* MR1 */
+ /* MR1 11-Apr-97 Provide mechanism for inserting code into DLG class */
+ /* MR1 via <<%%lexmember ...>> */
+ /* MR1 This is a consequence of not saving actions */
+ /* MR1 */
+ /* MR1 */ parserClass=0;
+ /* MR1 */ lexPrefix=0;
+ /* MR1 */ lexAction=0;
+ /* MR1 */ lexMember=0;
+ >>
+
+\>
+ <<
+ NLA = 34;
+ xxputc(zzlextext[0]); zzskip();
+ >>
+
+\\\>
+ <<
+ NLA = 35;
+ xxputc('>'); zzskip();
+ >>
+
+\\
+ <<
+ NLA = 36;
+ xxputc('\\'); zzskip();
+ >>
+
+\n
+ <<
+ NLA = 37;
+ xxputc(zzlextext[0]); ++zzline; zzskip();
+ >>
+
+/\*
+ <<
+ NLA = 38;
+ zzmode(ACTION_COMMENTS); /* MR1 */
+ xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
+ >>
+
+//
+ <<
+ NLA = 39;
+ zzmode(ACTION_CPP_COMMENTS); /* MR1 */
+ xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
+ >>
+
+~[]
+ <<
+ NLA = 40;
+ xxputc(zzlextext[0]); zzskip();
+ >>
+
+
+%%ACTION_COMMENTS
+
+@
+ <<
+ NLA = 1;
+ >>
+
+\*/
+ <<
+ NLA = 41;
+ zzmode(ACT); /* MR1 */
+ xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
+ >>
+
+[\n\r]
+ <<
+ NLA = 42;
+ zzline++; xxputc(zzlextext[0]); zzskip();
+ >>
+
+~[]
+ <<
+ NLA = 43;
+ xxputc(zzlextext[0]); zzskip();
+ >>
+
+
+%%ACTION_CPP_COMMENTS
+
+@
+ <<
+ NLA = 1;
+ >>
+
+[\n\r]
+ <<
+ NLA = 44;
+ zzmode(ACT); zzline++; /* MR1 */
+ xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
+ >>
+
+~[]
+ <<
+ NLA = 45;
+ xxputc(zzlextext[0]); zzskip();
+ >>
+
+%%
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/relabel.c b/BaseTools/Source/C/VfrCompile/Pccts/dlg/relabel.c new file mode 100644 index 0000000000..0b8bc163d1 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/relabel.c @@ -0,0 +1,217 @@ +/* This group of functions does the character class compression.
+ It goes over the dfa and relabels the arcs with the partitions
+ of characters in the NFA. The partitions are stored in the
+ array class.
+
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * DLG 1.33
+ * Will Cohen
+ * With mods by Terence Parr; AHPCRC, University of Minnesota
+ * 1989-2001
+ */
+
+#include <stdio.h>
+#include "dlg.h"
+#ifdef MEMCHK
+#include "trax.h"
+#else
+#ifdef __STDC__
+#include <stdlib.h>
+#else
+#include <malloc.h>
+#endif /* __STDC__ */
+#endif
+
+int class_no = CHAR_RANGE; /* number of classes for labels */
+int first_el[CHAR_RANGE]; /* first element in each class partition */
+set class_sets[CHAR_RANGE]; /* array holds partitions from class */
+ /* compression */
+
+/* goes through labels on NFA graph and partitions the characters into
+ * character classes. This reduces the amount of space required for each
+ * dfa node, since only one arc is required each class instead of one arc
+ * for each character
+ * level:
+ * 0 no compression done
+ * 1 remove unused characters from classes
+ * 2 compress equivalent characters into same class
+ *
+ * returns the number of character classes required
+ */
+#ifdef __USE_PROTOS
+int relabel(nfa_node* start,int level)
+#else
+int relabel(start,level)
+int level;
+nfa_node *start;
+#endif
+{
+ if (level){
+ set_free(used_classes);
+ partition(start,level);
+ label_with_classes(start);
+ }else{
+ /* classes equivalent to all characters in alphabet */
+ class_no = CHAR_RANGE;
+ }
+ return class_no;
+}
+
+/* makes character class sets for new labels */
+#ifdef __USE_PROTOS
+void partition(nfa_node* start,int level)
+#else
+void partition(start,level)
+nfa_node *start; /* beginning of nfa graph */
+int level; /* compression level to uses */
+#endif
+{
+ set current_class;
+ set unpart_chars;
+ set temp;
+
+ unpart_chars = set_dup(used_chars);
+#if 0
+ /* EOF (-1+1) alway in class 0 */
+ class_sets[0] = set_of(0);
+ first_el[0] = 0;
+ used_classes = set_of(0);
+ temp = set_dif(unpart_chars, class_sets[0]);
+ set_free(unpart_chars);
+ unpart_chars = temp;
+ class_no = 1;
+#else
+ class_no = 0;
+#endif
+ while (!set_nil(unpart_chars)){
+ /* don't look for equivalent labels if c <= 1 */
+ if (level <= 1){
+ current_class = set_of(set_int(unpart_chars));
+ }else{
+ current_class = set_dup(unpart_chars);
+ intersect_nfa_labels(start,¤t_class);
+ }
+ set_orel(class_no,&used_classes);
+ first_el[class_no] = set_int(current_class);
+ class_sets[class_no] = current_class;
+ temp = set_dif(unpart_chars,current_class);
+ set_free(unpart_chars);
+ unpart_chars = temp;
+ ++class_no;
+ }
+
+ /* free unpart_chars -ATG 5/6/95 */
+ set_free(unpart_chars);
+
+#if 0
+ /* group all the other unused characters into a class */
+ set_orel(class_no,&used_classes);
+ first_el[class_no] = set_int(current_class);
+ class_sets[class_no] = set_dif(normal_chars,used_chars);
+ ++class_no;
+#endif
+}
+
+
+/* given pointer to beginning of graph and recursively walks it trying
+ * to find a maximal partition. This partion in returned in maximal_class
+ */
+#ifdef __USE_PROTOS
+void intersect_nfa_labels(nfa_node* start,set* maximal_class)
+#else
+void intersect_nfa_labels(start,maximal_class)
+nfa_node *start;
+set *maximal_class;
+#endif
+{
+ /* pick a new operation number */
+ ++operation_no;
+ r_intersect(start,maximal_class);
+}
+
+#ifdef __USE_PROTOS
+void r_intersect(nfa_node* start,set* maximal_class)
+#else
+void r_intersect(start,maximal_class)
+nfa_node *start;
+set * maximal_class;
+#endif
+{
+ set temp;
+
+ if(start && start->nfa_set != operation_no)
+ {
+ start->nfa_set = operation_no;
+ temp = set_and(*maximal_class,start->label);
+ if (!set_nil(temp))
+ {
+ set_free(*maximal_class);
+ *maximal_class = temp;
+ }else{
+ set_free(temp);
+ }
+ r_intersect(start->trans[0],maximal_class);
+ r_intersect(start->trans[1],maximal_class);
+ }
+}
+
+
+/* puts class labels in place of old character labels */
+#ifdef __USE_PROTOS
+void label_with_classes(nfa_node* start)
+#else
+void label_with_classes(start)
+nfa_node *start;
+#endif
+{
+ ++operation_no;
+ label_node(start);
+}
+
+#ifdef __USE_PROTOS
+void label_node(nfa_node *start)
+#else
+void label_node(start)
+nfa_node *start;
+#endif
+{
+ set new_label;
+ register int i;
+
+ /* only do node if it hasn't been done before */
+ if (start && start->nfa_set != operation_no){
+ start->nfa_set = operation_no;
+ new_label = empty;
+ for (i = 0; i<class_no; ++i){
+ /* if one element of class in old_label,
+ all elements are. */
+ if (set_el(first_el[i],start->label))
+ set_orel(i,&new_label);
+ }
+ set_free(start->label);
+ start->label = new_label;
+ /* do any nodes that can be reached from this one */
+ label_node(start->trans[0]);
+ label_node(start->trans[1]);
+ }
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/stdpccts.h b/BaseTools/Source/C/VfrCompile/Pccts/dlg/stdpccts.h new file mode 100644 index 0000000000..06ec67e44d --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/stdpccts.h @@ -0,0 +1,26 @@ +#ifndef STDPCCTS_H
+#define STDPCCTS_H
+/*
+ * stdpccts.h -- P C C T S I n c l u d e
+ *
+ * Terence Parr, Will Cohen, and Hank Dietz: 1989-2001
+ * Purdue University Electrical Engineering
+ * With AHPCRC, University of Minnesota
+ * ANTLR Version 1.33MR33
+ */
+
+#ifndef ANTLR_VERSION
+#define ANTLR_VERSION 13333
+#endif
+
+#include "pcctscfg.h"
+#include "pccts_stdio.h"
+
+#include <ctype.h>
+#include "dlg.h"
+#define zzSET_SIZE 8
+#include "antlr.h"
+#include "tokens.h"
+#include "dlgdef.h"
+#include "mode.h"
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/support.c b/BaseTools/Source/C/VfrCompile/Pccts/dlg/support.c new file mode 100644 index 0000000000..84fe99d69c --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/support.c @@ -0,0 +1,240 @@ +/*
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * DLG 1.33
+ * Will Cohen
+ * With mods by Terence Parr; AHPCRC, University of Minnesota
+ * 1989-2001
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include "dlg.h"
+#ifdef MEMCHK
+#include "trax.h"
+#else
+#ifdef __STDC__
+#include <stdlib.h>
+#else
+#include <malloc.h>
+#endif /* __STDC__ */
+#endif
+
+int err_found = 0; /* indicates whether problem found */
+
+#ifdef __USE_PROTOS
+void internal_error(char *s, char *file,int line) /* MR9 23-Sep-97 */
+#else
+void internal_error(s,file,line) /* MR9 23-Sep-97 */
+char *s,*file;
+int line;
+#endif
+{
+ fprintf(stderr,s,file,line);
+ exit(PCCTS_EXIT_FAILURE);
+}
+
+#ifdef __USE_PROTOS
+char *dlg_malloc(int bytes,char *file,int line)
+#else
+char *dlg_malloc(bytes,file,line)
+int bytes;
+char *file;
+int line;
+#endif
+{
+ char *t;
+
+ t = (char *) malloc(bytes);
+ if (!t){
+ /* error */
+ internal_error("%s(%d): unable to allocate memory\n",
+ file,line);
+ }
+ return t;
+}
+
+
+#ifdef __USE_PROTOS
+char *dlg_calloc(int n,int bytes,char *file,int line)
+#else
+char *dlg_calloc(n,bytes,file,line)
+int n,bytes;
+char *file;
+int line;
+#endif
+{
+ char *t;
+
+ t = (char *) calloc(n,bytes);
+ if (!t){
+ /* error */
+ internal_error("%s(%d): unable to allocate memory\n",
+ file,line);
+ }
+ return t;
+}
+
+
+#ifdef __USE_PROTOS
+FILE *read_stream(char *name)
+#else
+FILE *read_stream(name)
+char *name;
+#endif
+{
+ FILE *f;
+
+ if (name){
+ if (name[0] == '-') {
+ fprintf(stderr, "dlg: invalid option: '%s'\n", name);
+ f = NULL;
+ }else{
+ f = fopen(name, "r");
+ if (f == NULL){
+ /* couldn't open file */
+ fprintf(stderr,
+ "dlg: Warning: Can't read file %s.\n",
+ name);
+ }
+ }
+ }else{
+ /* open stdin if nothing there */
+ f = stdin;
+ }
+ return f;
+}
+
+#ifdef __USE_PROTOS
+FILE *write_stream(char *name)
+#else
+FILE *write_stream(name)
+char *name;
+#endif
+{
+ FILE *f;
+
+ if (name){
+ if (name[0] == '-') {
+ fprintf(stderr, "dlg: invalid option: '%s'\n", name);
+ f = NULL;
+ }else{
+ f = fopen(OutMetaName(name), "w");
+ if (f == NULL){
+ /* couldn't open file */
+ fprintf(stderr,
+ "dlg: Warning: Can't write to file %s.\n",
+ name);
+ }
+ else
+#ifdef SPECIAL_FOPEN
+ special_fopen_actions(OutMetaName(name)); /* MR1 */
+#else
+ ; /* MR1 */
+#endif
+ }
+ }else{
+ /* open stdout if nothing there */
+ f = stdout;
+ }
+ return f;
+}
+
+
+#ifdef __USE_PROTOS
+void fatal(char *message,int line_no)
+#else
+void fatal(message,line_no)
+char *message;
+int line_no;
+#endif
+{
+ fprintf(stderr,ErrHdr,
+ (file_str[0] ? file_str[0] : "stdin"), line_no);
+ fprintf(stderr, " Fatal: %s\n", message);
+ exit(PCCTS_EXIT_FAILURE);
+}
+
+#ifdef __USE_PROTOS
+void error(char *message,int line_no)
+#else
+void error(message,line_no)
+char *message;
+int line_no;
+#endif
+{
+ fprintf(stderr,ErrHdr,
+ (file_str[0] ? file_str[0] : "stdin"), line_no);
+ fprintf(stderr, " Error: %s\n", message);
+ err_found = 1;
+}
+
+#ifdef __USE_PROTOS
+void warning(char *message,int line_no)
+#else
+void warning(message,line_no)
+char *message;
+int line_no;
+#endif
+{
+ fprintf(stderr,ErrHdr,
+ (file_str[0] ? file_str[0] : "stdin"), line_no);
+ fprintf(stderr, " Warning: %s\n", message);
+}
+
+/* MR10: Jeff Vincent
+ MR10: Changed to remove directory information from n only if
+ MR10: if OutputDirectory was changed by user (-o option)
+*/
+
+#ifdef __USE_PROTOS
+char *OutMetaName(char *n)
+#else
+char *OutMetaName(n)
+char *n;
+#endif
+{
+ static char *dir_sym = DirectorySymbol;
+ static char newname[MaxFileName+1];
+ char *p;
+
+ /* If OutputDirectory is same as TopDirectory (platform default) then leave n alone. */
+ if (strcmp(OutputDirectory, TopDirectory) == 0)
+ return n;
+
+ /* p will point to filename without path information */
+ if ((p = strrchr(n, *dir_sym)) != NULL)
+ p++;
+ else
+ p = n;
+
+ /* Copy new output directory into newname[] */
+ strcpy(newname, OutputDirectory);
+
+ /* if new output directory does not have trailing dir_sym, add it! */
+ if (newname[strlen(newname)-1] != *dir_sym)
+ strcat(newname, dir_sym);
+
+ /* contatenate FILE NAME ONLY to new output directory */
+ strcat(newname, p);
+
+ return newname;
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/tokens.h b/BaseTools/Source/C/VfrCompile/Pccts/dlg/tokens.h new file mode 100644 index 0000000000..73e502b7e1 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/tokens.h @@ -0,0 +1,133 @@ +#ifndef tokens_h
+#define tokens_h
+/* tokens.h -- List of labelled tokens and stuff
+ *
+ * Generated from: dlg_p.g
+ *
+ * Terence Parr, Will Cohen, and Hank Dietz: 1989-2001
+ * Purdue University Electrical Engineering
+ * ANTLR Version 1.33MR33
+ */
+#define zzEOF_TOKEN 1
+#define L_EOF 4
+#define PER_PER 5
+#define NAME_PER_PER 6
+#define LEXMEMBER 7
+#define LEXACTION 8
+#define PARSERCLASS 9
+#define LEXPREFIX 10
+#define ACTION 11
+#define GREAT_GREAT 12
+#define L_BRACE 13
+#define R_BRACE 14
+#define L_PAR 15
+#define R_PAR 16
+#define L_BRACK 17
+#define R_BRACK 18
+#define ZERO_MORE 19
+#define ONE_MORE 20
+#define OR 21
+#define RANGE 22
+#define NOT 23
+#define OCTAL_VALUE 24
+#define HEX_VALUE 25
+#define DEC_VALUE 26
+#define TAB 27
+#define NL 28
+#define CR 29
+#define BS 30
+#define CONTINUATION 31
+#define LIT 32
+#define REGCHAR 33
+
+#ifdef __USE_PROTOS
+void grammar(void);
+#else
+extern void grammar();
+#endif
+
+#ifdef __USE_PROTOS
+void start_states(void);
+#else
+extern void start_states();
+#endif
+
+#ifdef __USE_PROTOS
+void do_conversion(void);
+#else
+extern void do_conversion();
+#endif
+
+#ifdef __USE_PROTOS
+void rule_list(void);
+#else
+extern void rule_list();
+#endif
+
+#ifdef __USE_PROTOS
+void rule(void);
+#else
+extern void rule();
+#endif
+
+#ifdef __USE_PROTOS
+void reg_expr(void);
+#else
+extern void reg_expr();
+#endif
+
+#ifdef __USE_PROTOS
+void and_expr(void);
+#else
+extern void and_expr();
+#endif
+
+#ifdef __USE_PROTOS
+void repeat_expr(void);
+#else
+extern void repeat_expr();
+#endif
+
+#ifdef __USE_PROTOS
+void expr(void);
+#else
+extern void expr();
+#endif
+
+#ifdef __USE_PROTOS
+void atom_list(void);
+#else
+extern void atom_list();
+#endif
+
+#ifdef __USE_PROTOS
+void near_atom(void);
+#else
+extern void near_atom();
+#endif
+
+#ifdef __USE_PROTOS
+void atom(void);
+#else
+extern void atom();
+#endif
+
+#ifdef __USE_PROTOS
+void anychar(void);
+#else
+extern void anychar();
+#endif
+
+#endif
+extern SetWordType zzerr1[];
+extern SetWordType zzerr2[];
+extern SetWordType zzerr3[];
+extern SetWordType setwd1[];
+extern SetWordType zzerr4[];
+extern SetWordType zzerr5[];
+extern SetWordType zzerr6[];
+extern SetWordType setwd2[];
+extern SetWordType zzerr7[];
+extern SetWordType zzerr8[];
+extern SetWordType zzerr9[];
+extern SetWordType setwd3[];
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/AParser.cpp b/BaseTools/Source/C/VfrCompile/Pccts/h/AParser.cpp new file mode 100644 index 0000000000..720fe75af1 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/AParser.cpp @@ -0,0 +1,871 @@ +/* ANTLRParser.C
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+#include "pcctscfg.h"
+
+#include "pccts_stdlib.h"
+#include "pccts_stdarg.h"
+#include "pccts_string.h"
+#include "pccts_stdio.h"
+
+PCCTS_NAMESPACE_STD
+
+/* I have to put this here due to C++ limitation
+ * that you can't have a 'forward' decl for enums.
+ * I hate C++!!!!!!!!!!!!!!!
+ * Of course, if I could use real templates, this would go away.
+ */
+// MR1
+// MR1 10-Apr-97 133MR1 Prevent use of varying sizes for the
+// MR1 ANTLRTokenType enum
+// MR1
+
+enum ANTLRTokenType { TER_HATES_CPP=0, ITS_TOO_COMPLICATED=9999}; // MR1
+
+#define ANTLR_SUPPORT_CODE
+
+#include ATOKEN_H
+#include ATOKENBUFFER_H
+#include APARSER_H
+
+static const int zzINF_DEF_TOKEN_BUFFER_SIZE = 2000; /* MR14 */
+static const int zzINF_BUFFER_TOKEN_CHUNK_SIZE = 1000; /* MR14 */
+
+ /* L o o k a h e a d M a c r o s */
+
+/* maximum of 32 bits/unsigned int and must be 8 bits/byte;
+ * we only use 8 bits of it.
+ */
+SetWordType ANTLRParser::bitmask[sizeof(SetWordType)*8] = {
+ 0x00000001, 0x00000002, 0x00000004, 0x00000008,
+ 0x00000010, 0x00000020, 0x00000040, 0x00000080
+};
+
+char ANTLRParser::eMsgBuffer[500] = "";
+
+ANTLRParser::
+~ANTLRParser()
+{
+ delete [] token_type;
+ delete [] zzFAILtext; // MR16 Manfred Kogler
+}
+
+ANTLRParser::
+ANTLRParser(ANTLRTokenBuffer *_inputTokens,
+ int k,
+ int use_inf_look,
+ int dlook,
+ int ssize)
+{
+ LLk = k;
+ can_use_inf_look = use_inf_look;
+/* MR14 */ if (dlook != 0) {
+/* MR14 */ panic("ANTLRParser::ANTLRParser - Demand lookahead not supported in C++ mode");
+/* MR14 */
+/* MR14 */ };
+ demand_look = 0; /* demand_look = dlook; */
+ bsetsize = ssize;
+ guessing = 0;
+ token_tbl = NULL;
+ eofToken = (ANTLRTokenType)1;
+
+ // allocate lookahead buffer
+ token_type = new ANTLRTokenType[LLk];
+ lap = 0;
+ labase = 0;
+#ifdef ZZDEFER_FETCH
+ stillToFetch = 0; // MR19
+#endif
+ dirty = 0;
+ inf_labase = 0; // MR7
+ inf_last = 0; // MR7
+ /* prime lookahead buffer, point to inputTokens */
+ this->inputTokens = _inputTokens;
+ this->inputTokens->setMinTokens(k);
+ _inputTokens->setParser(this); // MR1
+ resynchConsumed=1; // MR8
+ zzFAILtext=NULL; // MR9
+ traceOptionValueDefault=0; // MR10
+ traceReset(); // MR10
+ zzGuessSeq=0; // MR10
+ syntaxErrCount=0; // MR11
+}
+
+void ANTLRParser::init()
+{
+ prime_lookahead();
+ resynchConsumed=1; // MR8
+ traceReset(); // MR10
+}
+
+void ANTLRParser::traceReset()
+{
+ traceOptionValue=traceOptionValueDefault;
+ traceGuessOptionValue=1;
+ traceCurrentRuleName=NULL;
+ traceDepth=0;
+}
+
+
+#ifdef _MSC_VER // MR23
+//Turn off warning:
+//interaction between '_setjmp' and C++ object destruction is non-portable
+#pragma warning(disable : 4611)
+#endif
+int ANTLRParser::
+guess(ANTLRParserState *st)
+{
+ saveState(st);
+ guessing = 1;
+ return setjmp(guess_start.state);
+}
+#ifdef _MSC_VER // MR23
+#pragma warning(default: 4611)
+#endif
+
+void ANTLRParser::
+saveState(ANTLRParserState *buf)
+{
+ buf->guess_start = guess_start;
+ buf->guessing = guessing;
+ buf->inf_labase = inf_labase;
+ buf->inf_last = inf_last;
+ buf->dirty = dirty;
+ buf->traceOptionValue=traceOptionValue; /* MR10 */
+ buf->traceGuessOptionValue=traceGuessOptionValue; /* MR10 */
+ buf->traceCurrentRuleName=traceCurrentRuleName; /* MR10 */
+ buf->traceDepth=traceDepth; /* MR10 */
+}
+
+void ANTLRParser::
+restoreState(ANTLRParserState *buf)
+{
+ int i;
+ int prevTraceOptionValue;
+
+ guess_start = buf->guess_start;
+ guessing = buf->guessing;
+ inf_labase = buf->inf_labase;
+ inf_last = buf->inf_last;
+ dirty = buf->dirty;
+
+ // restore lookahead buffer from k tokens before restored TokenBuffer position
+ // if demand_look, then I guess we don't look backwards for these tokens.
+ for (i=1; i<=LLk; i++) token_type[i-1] =
+ inputTokens->bufferedToken(i-LLk)->getType();
+ lap = 0;
+ labase = 0;
+
+ /* MR10 */
+
+ prevTraceOptionValue=traceOptionValue;
+ traceOptionValue=buf->traceOptionValue;
+ if ( (prevTraceOptionValue > 0) !=
+ (traceOptionValue > 0)) {
+ if (traceCurrentRuleName != NULL) { /* MR21 */
+ if (traceOptionValue > 0) {
+ /* MR23 */ printMessage(stderr,
+ "trace enable restored in rule %s depth %d\n",
+ traceCurrentRuleName,
+ traceDepth);
+ };
+ if (traceOptionValue <= 0) {
+ /* MR23 */ printMessage(stderr,
+ "trace disable restored in rule %s depth %d\n",
+ traceCurrentRuleName, /* MR21 */
+ traceDepth);
+ };
+ }
+ };
+ traceGuessOptionValue=buf->traceGuessOptionValue;
+ traceCurrentRuleName=buf->traceCurrentRuleName;
+ traceDepth=buf->traceDepth;
+ traceGuessDone(buf);
+}
+
+/* Get the next symbol from the input stream; put it into lookahead buffer;
+ * fill token_type[] fast reference cache also. NLA is the next place where
+ * a lookahead ANTLRAbstractToken should go.
+ */
+void ANTLRParser::
+consume()
+{
+
+#ifdef ZZDEBUG_CONSUME_ACTION
+ zzdebug_consume_action();
+#endif
+
+// MR19 V.H. Simonis
+// Defer Fetch feature
+// Moves action of consume() into LA() function
+
+#ifdef ZZDEFER_FETCH
+ stillToFetch++;
+#else
+ NLA = inputTokens->getToken()->getType();
+ dirty--;
+ lap = (lap+1)&(LLk-1);
+#endif
+
+}
+
+_ANTLRTokenPtr ANTLRParser::
+LT(int i)
+{
+
+// MR19 V.H. Simonis
+// Defer Fetch feature
+// Moves action of consume() into LA() function
+
+#ifdef ZZDEFER_FETCH
+ undeferFetch();
+#endif
+
+#ifdef DEBUG_TOKENBUFFER
+ if ( i >= inputTokens->bufferSize() || inputTokens->minTokens() < LLk ) /* MR20 Was "<=" */
+ {
+ char buf[2000]; /* MR20 Was "static" */
+ sprintf(buf, "The minimum number of tokens you requested that the\nANTLRTokenBuffer buffer is not enough to satisfy your\nLT(%d) request; increase 'k' argument to constructor for ANTLRTokenBuffer\n", i);
+ panic(buf);
+ }
+#endif
+ return inputTokens->bufferedToken(i-LLk);
+}
+
+void
+ANTLRParser::
+look(int k)
+{
+ int i, c = k - (LLk-dirty);
+ for (i=1; i<=c; i++) consume();
+}
+
+/* fill the lookahead buffer up with k symbols (even if DEMAND_LOOK);
+ */
+void
+ANTLRParser::
+prime_lookahead()
+{
+ int i;
+ for(i=1;i<=LLk; i++) consume();
+ dirty=0;
+ // lap = 0; // MR14 Sinan Karasu (sinan.karasu@boeing.com)
+ // labase = 0; // MR14
+ labase=lap; // MR14
+}
+
+/* check to see if the current input symbol matches '_t'.
+ * During NON demand lookahead mode, dirty will always be 0 and
+ * hence the extra code for consuming tokens in _match is never
+ * executed; the same routine can be used for both modes.
+ */
+int ANTLRParser::
+_match(ANTLRTokenType _t, ANTLRChar **MissText,
+ ANTLRTokenType *MissTok, _ANTLRTokenPtr *BadTok,
+ SetWordType **MissSet)
+{
+ if ( dirty==LLk ) {
+ consume();
+ }
+ if ( LA(1)!=_t ) {
+ *MissText=NULL;
+ *MissTok= _t;
+ *BadTok = LT(1);
+ *MissSet=NULL;
+ return 0;
+ }
+ dirty++;
+ labase = (labase+1)&(LLk-1); // labase maintained even if !demand look
+ return 1;
+}
+
+/* check to see if the current input symbol matches '_t'.
+ * Used during exception handling.
+ */
+int ANTLRParser::
+_match_wsig(ANTLRTokenType _t)
+{
+ if ( dirty==LLk ) {
+ consume();
+ }
+ if ( LA(1)!=_t ) return 0;
+ dirty++;
+ labase = (labase+1)&(LLk-1); // labase maintained even if !demand look
+ return 1;
+}
+
+/* check to see if the current input symbol matches any token in a set.
+ * During NON demand lookahead mode, dirty will always be 0 and
+ * hence the extra code for consuming tokens in _match is never
+ * executed; the same routine can be used for both modes.
+ */
+int ANTLRParser::
+_setmatch(SetWordType *tset, ANTLRChar **MissText,
+ ANTLRTokenType *MissTok, _ANTLRTokenPtr *BadTok,
+ SetWordType **MissSet, SetWordType *tokclassErrset)
+{
+ if ( dirty==LLk ) {
+ consume();
+ }
+ if ( !set_el(LA(1), tset) ) {
+ *MissText=NULL; /* MR23 */
+ *MissTok=(ANTLRTokenType) 0; /* MR23 */
+ *BadTok=LT(1); /* MR23 */
+ *MissSet=tokclassErrset; /* MR23 */
+ return 0;
+ }
+ dirty++;
+ labase = (labase+1)&(LLk-1); // labase maintained even if !demand look
+ return 1;
+}
+
+int ANTLRParser::
+_setmatch_wsig(SetWordType *tset)
+{
+ if ( dirty==LLk ) {
+ consume();
+ }
+ if ( !set_el(LA(1), tset) ) return 0;
+ dirty++;
+ labase = (labase+1)&(LLk-1); // labase maintained even if !demand look
+ return 1;
+}
+
+ /* Exception handling routines */
+//
+// 7-Apr-97 133MR1
+// Change suggested by Eli Sternheim (eli@interhdl.com)
+//
+void ANTLRParser::
+consumeUntil(SetWordType *st)
+{
+ ANTLRTokenType tmp; // MR1
+ const int Eof=1; // MR1
+ while ( !set_el( (tmp=LA(1)), st) && tmp!=Eof) { consume(); } // MR1
+}
+
+//
+// 7-Apr-97 133MR1
+// Change suggested by Eli Sternheim (eli@interhdl.com)
+//
+void ANTLRParser::
+consumeUntilToken(int t)
+{
+ int tmp; // MR1
+ const int Eof=1; // MR1
+ while ( (tmp=LA(1)) !=t && tmp!=Eof) { consume(); } // MR1
+}
+
+
+ /* Old error stuff */
+
+void ANTLRParser::
+resynch(SetWordType *wd,SetWordType mask)
+{
+
+/* MR8 S.Bochnak@microtool.com.pl */
+/* MR8 Change file scope static "consumed" to instance var */
+
+ /* if you enter here without having consumed a token from last resynch
+ * force a token consumption.
+ */
+/* MR8 */ if ( !resynchConsumed ) {consume(); resynchConsumed=1; return;}
+
+ /* if current token is in resynch set, we've got what we wanted */
+
+/* MR8 */ if ( wd[LA(1)]&mask || LA(1) == eofToken ) {resynchConsumed=0; return;}
+
+ /* scan until we find something in the resynch set */
+
+ while ( !(wd[LA(1)]&mask) && LA(1) != eofToken ) {consume();}
+
+/* MR8 */ resynchConsumed=1;
+}
+
+/* standard error reporting function that assumes DLG-based scanners;
+ * you should redefine in subclass to change it or if you use your
+ * own scanner.
+ */
+
+/* MR23 THM There appears to be a parameter "badText" passed to syn()
+ which is not present in the parameter list. This may be
+ because in C mode there is no attribute function which
+ returns the text, so the text representation of the token
+ must be passed explicitly. I think.
+*/
+
+void ANTLRParser::
+syn(_ANTLRTokenPtr /*tok MR23*/, ANTLRChar *egroup, SetWordType *eset,
+ ANTLRTokenType etok, int k)
+{
+ int line;
+
+ line = LT(1)->getLine();
+
+ syntaxErrCount++; /* MR11 */
+
+ /* MR23 If the token is not an EOF token, then use the ->getText() value.
+
+ If the token is the EOF token the text returned by ->getText()
+ may be garbage. If the text from the token table is "@" use
+ "<eof>" instead, because end-users don't know what "@" means.
+ If the text is not "@" then use that text, which must have been
+ supplied by the grammar writer.
+ */
+ const char * errorAt = LT(1)->getText();
+ if (LA(1) == eofToken) {
+ errorAt = parserTokenName(LA(1));
+ if (errorAt[0] == '@') errorAt = "<eof>";
+ }
+ /* MR23 */ printMessage(stderr, "line %d: syntax error at \"%s\"",
+ line, errorAt);
+ if ( !etok && !eset ) {/* MR23 */ printMessage(stderr, "\n"); return;}
+ if ( k==1 ) /* MR23 */ printMessage(stderr, " missing");
+ else
+ {
+ /* MR23 */ printMessage(stderr, "; \"%s\" not", LT(k)->getText()); // MR23 use LT(k) since k>1
+ if ( set_deg(eset)>1 ) /* MR23 */ printMessage(stderr, " in");
+ }
+ if ( set_deg(eset)>0 ) edecode(eset);
+ else /* MR23 */ printMessage(stderr, " %s", token_tbl[etok]);
+ if ( strlen(egroup) > 0 ) /* MR23 */ printMessage(stderr, " in %s", egroup);
+ /* MR23 */ printMessage(stderr, "\n");
+}
+
+/* is b an element of set p? */
+int ANTLRParser::
+set_el(ANTLRTokenType b, SetWordType *p)
+{
+ return( p[DIVWORD(b)] & bitmask[MODWORD(b)] );
+}
+
+int ANTLRParser::
+set_deg(SetWordType *a)
+{
+ /* Fast compute degree of a set... the number
+ of elements present in the set. Assumes
+ that all word bits are used in the set
+ */
+ register SetWordType *p = a;
+ register SetWordType *endp = &(a[bsetsize]);
+ register int degree = 0;
+
+ if ( a == NULL ) return 0;
+ while ( p < endp )
+ {
+ register SetWordType t = *p;
+ register SetWordType *b = &(bitmask[0]);
+ do {
+ if (t & *b) ++degree;
+ } while (++b < &(bitmask[sizeof(SetWordType)*8]));
+ p++;
+ }
+
+ return(degree);
+}
+
+void ANTLRParser::
+edecode(SetWordType *a)
+{
+ register SetWordType *p = a;
+ register SetWordType *endp = &(p[bsetsize]);
+ register unsigned e = 0;
+
+ if ( set_deg(a)>1 ) /* MR23 */ printMessage(stderr, " {");
+ do {
+ register SetWordType t = *p;
+ register SetWordType *b = &(bitmask[0]);
+ do {
+ if ( t & *b ) /* MR23 */ printMessage(stderr, " %s", token_tbl[e]);
+ e++;
+ } while (++b < &(bitmask[sizeof(SetWordType)*8]));
+ } while (++p < endp);
+ if ( set_deg(a)>1 ) /* MR23 */ printMessage(stderr, " }");
+}
+
+/* input looks like:
+ * zzFAIL(k, e1, e2, ...,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk)
+ * where the zzMiss stuff is set here to the token that did not match
+ * (and which set wasn't it a member of).
+ */
+
+// MR9 29-Sep-97 Stan Bochnak (S.Bochnak@microTool.com.pl)
+// MR9 Original fix to static allocated text didn't
+// MR9 work because a pointer to it was passed back
+// MR9 to caller. Replace with instance variable.
+
+const int SETWORDCOUNT=20;
+
+void
+ANTLRParser::FAIL(int k, ...)
+{
+//
+// MR1 10-Apr-97
+//
+
+ if (zzFAILtext == NULL) zzFAILtext=new char [1000]; // MR9
+ SetWordType **f=new SetWordType *[SETWORDCOUNT]; // MR1 // MR9
+ SetWordType **miss_set;
+ ANTLRChar **miss_text;
+ _ANTLRTokenPtr *bad_tok;
+ ANTLRChar **bad_text;
+//
+// 7-Apr-97 133MR1
+// err_k is passed as a "int *", not "unsigned *"
+//
+ int *err_k; // MR1
+ int i;
+ va_list ap;
+
+ va_start(ap, k);
+
+ zzFAILtext[0] = '\0';
+ if ( k > SETWORDCOUNT ) panic("FAIL: overflowed buffer");
+ for (i=1; i<=k; i++) /* collect all lookahead sets */
+ {
+ f[i-1] = va_arg(ap, SetWordType *);
+ }
+ for (i=1; i<=k; i++) /* look for offending token */
+ {
+ if ( i>1 ) strcat(zzFAILtext, " ");
+ strcat(zzFAILtext, LT(i)->getText());
+ if ( !set_el(LA(i), f[i-1]) ) break;
+ }
+ miss_set = va_arg(ap, SetWordType **);
+ miss_text = va_arg(ap, ANTLRChar **);
+ bad_tok = va_arg(ap, _ANTLRTokenPtr *);
+ bad_text = va_arg(ap, ANTLRChar **);
+ err_k = va_arg(ap, int *); // MR1
+ if ( i>k )
+ {
+ /* bad; lookahead is permutation that cannot be matched,
+ * but, the ith token of lookahead is valid at the ith position
+ * (The old LL sub 1 (k) versus LL(k) parsing technique)
+ */
+ *miss_set = NULL;
+ *miss_text = LT(1)->getText();
+ *bad_tok = LT(1);
+ *bad_text = (*bad_tok)->getText();
+ *err_k = k;
+//
+// MR4 20-May-97 erroneously deleted contents of f[]
+// MR4 reported by Bruce Guenter (bruceg@qcc.sk.ca)
+// MR1 10-Apr-97 release temporary storage
+//
+ delete [] f; // MR1
+ return; // MR1
+ }
+/* MR23 printMessage(stderr, "%s not in %dth set\n", zztokens[LA(i)], i);*/
+ *miss_set = f[i-1];
+ *miss_text = zzFAILtext;
+ *bad_tok = LT(i);
+ *bad_text = (*bad_tok)->getText();
+ if ( i==1 ) *err_k = 1;
+ else *err_k = k;
+//
+// MR4 20-May-97 erroneously deleted contents of f[]
+// MR4 reported by Bruce Guenter (bruceg@qcc.sk.ca)
+// MR1 10-Apr-97 release temporary storage
+//
+ delete [] f; // MR1
+ return; // MR1
+}
+
+int ANTLRParser::
+_match_wdfltsig(ANTLRTokenType tokenWanted, SetWordType *whatFollows)
+{
+ if ( dirty==LLk ) consume();
+
+ if ( LA(1)!=tokenWanted )
+ {
+ syntaxErrCount++; /* MR11 */
+ /* MR23 */ printMessage(stderr,
+ "line %d: syntax error at \"%s\" missing %s\n",
+ LT(1)->getLine(),
+ (LA(1)==eofToken && LT(1)->getText()[0] == '@')?"<eof>":LT(1)->getText(), /* MR21a */
+ token_tbl[tokenWanted]);
+ consumeUntil( whatFollows );
+ return 0;
+ }
+ else {
+ dirty++;
+ labase = (labase+1)&(LLk-1); // labase maintained even if !demand look
+/* if ( !demand_look ) consume(); */
+ return 1;
+ }
+}
+
+
+int ANTLRParser::
+_setmatch_wdfltsig(SetWordType *tokensWanted,
+ ANTLRTokenType tokenTypeOfSet,
+ SetWordType *whatFollows)
+{
+ if ( dirty==LLk ) consume();
+ if ( !set_el(LA(1), tokensWanted) )
+ {
+ syntaxErrCount++; /* MR11 */
+ /* MR23 */ printMessage(stderr,
+ "line %d: syntax error at \"%s\" missing %s\n",
+ LT(1)->getLine(),
+ (LA(1)==eofToken && LT(1)->getText()[0] == '@')?"<eof>":LT(1)->getText(), /* MR21a */
+ token_tbl[tokenTypeOfSet]);
+ consumeUntil( whatFollows );
+ return 0;
+ }
+ else {
+ dirty++;
+ labase = (labase+1)&(LLk-1); // labase maintained even if !demand look
+/* if ( !demand_look ) consume(); */
+ return 1;
+ }
+}
+
+char *ANTLRParser::
+eMsgd(char *err,int d)
+{
+ sprintf(eMsgBuffer, err, d); // dangerous, but I don't care
+ return eMsgBuffer;
+}
+
+char *ANTLRParser::
+eMsg(char *err, char *s)
+{
+ sprintf(eMsgBuffer, err, s);
+ return eMsgBuffer;
+}
+
+char *ANTLRParser::
+eMsg2(char *err,char *s, char *t)
+{
+ sprintf(eMsgBuffer, err, s, t);
+ return eMsgBuffer;
+}
+
+void ANTLRParser::
+panic(const char *msg) // MR20 const
+{
+ /* MR23 */ printMessage(stderr, "ANTLR panic: %s\n", msg);
+ exit(PCCTS_EXIT_FAILURE); // MR1
+}
+
+const ANTLRChar *ANTLRParser:: // MR1
+parserTokenName(int tok) { // MR1
+ return token_tbl[tok]; // MR1
+} // MR1
+
+void ANTLRParser::traceGuessDone(const ANTLRParserState *state) {
+
+ int doIt=0;
+
+ if (traceCurrentRuleName == NULL) return;
+
+ if (traceOptionValue <= 0) {
+ doIt=0;
+ } else if (traceGuessOptionValue <= 0) {
+ doIt=0;
+ } else {
+ doIt=1;
+ };
+
+ if (doIt) {
+ /* MR23 */ printMessage(stderr,"guess done - returning to rule %s {\"%s\"} at depth %d",
+ state->traceCurrentRuleName,
+ LT(1)->getType() == eofToken ? "@" : LT(1)->getText(),
+ state->traceDepth);
+ if (state->guessing != 0) {
+ /* MR23 */ printMessage(stderr," (guess mode continues - an enclosing guess is still active)");
+ } else {
+ /* MR23 */ printMessage(stderr," (guess mode ends)");
+ };
+ /* MR23 */ printMessage(stderr,"\n");
+ };
+}
+
+void ANTLRParser::traceGuessFail() {
+
+ int doIt=0;
+
+ if (traceCurrentRuleName == NULL) return; /* MR21 */
+
+ if (traceOptionValue <= 0) {
+ doIt=0;
+ } else if (guessing && traceGuessOptionValue <= 0) {
+ doIt=0;
+ } else {
+ doIt=1;
+ };
+
+ if (doIt) {
+ /* MR23 */ printMessage(stderr,"guess failed in %s\n",traceCurrentRuleName);
+ };
+}
+
+/* traceOption:
+ zero value turns off trace
+*/
+
+void ANTLRParser::tracein(const ANTLRChar * rule) {
+
+ int doIt=0;
+
+ traceDepth++;
+ traceCurrentRuleName=rule;
+
+ if (traceOptionValue <= 0) {
+ doIt=0;
+ } else if (guessing && traceGuessOptionValue <= 0) {
+ doIt=0;
+ } else {
+ doIt=1;
+ };
+
+ if (doIt) {
+ /* MR23 */ printMessage(stderr,"enter rule %s {\"%s\"} depth %d",
+ rule,
+ LT(1)->getType() == eofToken ? "@" : LT(1)->getText(),
+ traceDepth);
+ if (guessing) /* MR23 */ printMessage(stderr," guessing");
+ /* MR23 */ printMessage(stderr,"\n");
+ };
+ return;
+}
+
+void ANTLRParser::traceout(const ANTLRChar * rule) {
+
+ int doIt=0;
+
+ traceDepth--;
+
+ if (traceOptionValue <= 0) {
+ doIt=0;
+ } else if (guessing && traceGuessOptionValue <= 0) {
+ doIt=0;
+ } else {
+ doIt=1;
+ };
+
+ if (doIt) {
+ /* MR23 */ printMessage(stderr,"exit rule %s {\"%s\"} depth %d",
+ rule,
+ LT(1)->getType() == eofToken ? "@" : LT(1)->getText(),
+ traceDepth+1);
+ if (guessing) /* MR23 */ printMessage(stderr," guessing");
+ /* MR23 */ printMessage(stderr,"\n");
+ };
+}
+
+int ANTLRParser::traceOption(int delta) {
+
+ int prevValue=traceOptionValue;
+
+ traceOptionValue=traceOptionValue+delta;
+
+ if (traceCurrentRuleName != NULL) {
+ if (prevValue <= 0 && traceOptionValue > 0) {
+ /* MR23 */ printMessage(stderr,"trace enabled in rule %s depth %d\n",traceCurrentRuleName,traceDepth);
+ };
+ if (prevValue > 0 && traceOptionValue <= 0) {
+ /* MR23 */ printMessage(stderr,"trace disabled in rule %s depth %d\n",traceCurrentRuleName,traceDepth);
+ };
+ };
+
+ return prevValue;
+}
+
+int ANTLRParser::traceGuessOption(int delta) {
+
+ int prevValue=traceGuessOptionValue;
+
+ traceGuessOptionValue=traceGuessOptionValue+delta;
+
+ if (traceCurrentRuleName != NULL) {
+ if (prevValue <= 0 && traceGuessOptionValue > 0) {
+ /* MR23 */ printMessage(stderr,"guess trace enabled in rule %s depth %d\n",traceCurrentRuleName,traceDepth);
+ };
+ if (prevValue > 0 && traceGuessOptionValue <= 0) {
+ /* MR23 */ printMessage(stderr,"guess trace disabled in rule %s depth %d\n",traceCurrentRuleName,traceDepth);
+ };
+ };
+ return prevValue;
+}
+
+// MR19 V.H. Simonis Defer Fetch feature
+
+void ANTLRParser::undeferFetch()
+{
+
+#ifdef ZZDEFER_FETCH
+ if (stillToFetch) {
+ for (int stillToFetch_x = 0; stillToFetch_x < stillToFetch; ++stillToFetch_x) {
+ NLA = inputTokens->getToken()->getType();
+ dirty--;
+ lap = (lap+1)&(LLk-1);
+ }
+ stillToFetch = 0;
+ }
+#else
+ return;
+#endif
+
+}
+
+int ANTLRParser::isDeferFetchEnabled()
+{
+#ifdef ZZDEFER_FETCH
+ return 1;
+#else
+ return 0;
+#endif
+}
+
+//MR23
+int ANTLRParser::printMessage(FILE* pFile, const char* pFormat, ...)
+{
+ va_list marker;
+ va_start( marker, pFormat );
+ int iRet = printMessageV(pFile, pFormat, marker);
+ va_end( marker );
+ return iRet;
+}
+
+int ANTLRParser::printMessageV(FILE* pFile, const char* pFormat, va_list arglist) // MR23
+{
+ return vfprintf(pFile, pFormat, arglist);
+}
+
+// MR23 Move semantic predicate error handling from macro to virtual function
+//
+// Called by the zzfailed_pred
+
+void ANTLRParser::failedSemanticPredicate(const char* predicate)
+{
+ printMessage(stdout,"line %d: semantic error; failed predicate: '%s'\n",
+ LT(1)->getLine(), predicate);
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/AParser.h b/BaseTools/Source/C/VfrCompile/Pccts/h/AParser.h new file mode 100644 index 0000000000..fe405f4167 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/AParser.h @@ -0,0 +1,376 @@ +/* ANTLRParser.h
+ *
+ * Define the generic ANTLRParser superclass, which is subclassed to
+ * define an actual parser.
+ *
+ * Before entry into this file: ANTLRTokenType must be set.
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+#ifndef APARSER_H_GATE
+#define APARSER_H_GATE
+
+#include "pcctscfg.h"
+
+#include "pccts_stdio.h"
+#include "pccts_setjmp.h"
+
+PCCTS_NAMESPACE_STD
+
+#include ATOKEN_H
+#include ATOKENBUFFER_H
+
+#ifdef ZZCAN_GUESS
+#ifndef ZZINF_LOOK
+#define ZZINF_LOOK
+#endif
+#endif
+
+
+#define NLA (token_type[lap&(LLk-1)])/* --> next LA */
+
+typedef unsigned char SetWordType;
+
+/* Define external bit set stuff (for SetWordType) */
+#define EXT_WORDSIZE (sizeof(char)*8)
+#define EXT_LOGWORDSIZE 3
+
+ /* s y n t a c t i c p r e d i c a t e s t u f f */
+
+#ifndef zzUSER_GUESS_HOOK
+#define zzUSER_GUESS_HOOK(seqFrozen,zzrv)
+#endif
+
+#ifndef zzUSER_GUESS_DONE_HOOK
+#define zzUSER_GUESS_DONE_HOOK(seqFrozen)
+#endif
+
+/* MR14 Add zzUSER_GUESS_FAIL_HOOK and related code */
+
+#define zzUSER_GUESS_FAIL_HOOK_INTERNAL zzUSER_GUESS_FAIL_HOOK(SeqFrozen)
+#ifndef zzUSER_GUESS_FAIL_HOOK
+#define zzUSER_GUESS_FAIL_HOOK(zzGuessSeq)
+#endif
+
+
+typedef struct _zzjmp_buf {
+ jmp_buf state;
+ } zzjmp_buf;
+
+/* these need to be macros not member functions */
+#define zzGUESS_BLOCK ANTLRParserState zzst; int zzrv; int _marker; int zzGuessSeqFrozen;
+#define zzNON_GUESS_MODE if ( !guessing )
+#define zzGUESS_FAIL guess_fail();
+
+/* Note: zzGUESS_DONE does not execute longjmp() */
+
+#define zzGUESS_DONE {zzrv=1; inputTokens->rewind(_marker); guess_done(&zzst);zzUSER_GUESS_DONE_HOOK(zzGuessSeqFrozen) }
+#define zzGUESS saveState(&zzst); \
+ guessing = 1; \
+ zzGuessSeqFrozen = ++zzGuessSeq; \
+ _marker = inputTokens->mark(); \
+ zzrv = setjmp(guess_start.state); \
+ zzUSER_GUESS_HOOK(zzGuessSeqFrozen,zzrv) \
+ if ( zzrv ) zzGUESS_DONE
+
+#define zzTRACEdata const ANTLRChar *zzTracePrevRuleName = NULL;
+
+#ifndef zzTRACEIN
+#define zzTRACEIN(r) zzTracePrevRuleName=traceCurrentRuleName;tracein(r);
+#endif
+#ifndef zzTRACEOUT
+#define zzTRACEOUT(r) traceout(r);traceCurrentRuleName=zzTracePrevRuleName;
+#endif
+
+ /* a n t l r p a r s e r d e f */
+
+struct ANTLRParserState {
+ /* class variables */
+ zzjmp_buf guess_start;
+ int guessing;
+
+ int inf_labase;
+ int inf_last;
+
+ int dirty;
+
+ int traceOptionValue; // MR10
+ int traceGuessOptionValue; // MR10
+ const ANTLRChar *traceCurrentRuleName; // MR10
+ int traceDepth; // MR10
+
+};
+
+/* notes:
+ *
+ * multiple inheritance is a cool way to include what stuff is needed
+ * in this structure (like guess stuff). however, i'm not convinced that
+ * multiple inheritance works correctly on all platforms. not that
+ * much space is used--just include all possibly useful members.
+ *
+ * the class should also be a template with arguments for the lookahead
+ * depth and so on. that way, more than one parser can be defined (as
+ * each will probably have different lookahead requirements). however,
+ * am i sure that templates work? no, i'm not sure.
+ *
+ * no attributes are maintained and, hence, the 'asp' variable is not
+ * needed. $i can still be referenced, but it refers to the token
+ * associated with that rule element. question: where are the token's
+ * stored if not on the software stack? in local variables created
+ * and assigned to by antlr.
+ */
+class ANTLRParser {
+protected:
+ /* class variables */
+ static SetWordType bitmask[sizeof(SetWordType)*8];
+ static char eMsgBuffer[500];
+
+protected:
+ int LLk; // number of lookahead symbols (old LL_K)
+ int demand_look;
+ ANTLRTokenType eofToken; // when do I stop during resynch()s
+ int bsetsize; // size of bitsets created by ANTLR in
+ // units of SetWordType
+
+ ANTLRTokenBuffer *inputTokens; //place to get input tokens
+
+ zzjmp_buf guess_start; // where to jump back to upon failure
+ int guessing; // if guessing (using (...)? predicate)
+
+ // infinite lookahead stuff
+ int can_use_inf_look; // set by subclass (generated by ANTLR)
+ int inf_lap;
+ int inf_labase;
+ int inf_last;
+ int *_inf_line;
+
+ const ANTLRChar **token_tbl; // pointer to table of token type strings MR20 const
+
+ int dirty; // used during demand lookahead
+
+ ANTLRTokenType *token_type; // fast reference cache of token.getType()
+// ANTLRLightweightToken **token; // the token with all its attributes
+ int lap;
+ int labase;
+#ifdef ZZDEFER_FETCH
+ int stillToFetch; // MR19 V.H. Simonis
+#endif
+
+private:
+ void fill_inf_look();
+
+protected:
+ virtual void guess_fail() { // MR9 27-Sep-97 make virtual
+ traceGuessFail(); // MR10
+ longjmp(guess_start.state, 1); } // MR9
+ virtual void guess_done(ANTLRParserState *st) { // MR9 27-Sep-97 make virtual
+ restoreState(st); } // MR9
+ virtual int guess(ANTLRParserState *); // MR9 27-Sep-97 make virtual
+ void look(int);
+ int _match(ANTLRTokenType, ANTLRChar **, ANTLRTokenType *,
+ _ANTLRTokenPtr *, SetWordType **);
+ int _setmatch(SetWordType *, ANTLRChar **, ANTLRTokenType *,
+ _ANTLRTokenPtr *, SetWordType **,
+ SetWordType * tokclassErrset /* MR23 */);
+ int _match_wsig(ANTLRTokenType);
+ int _setmatch_wsig(SetWordType *);
+ virtual void consume();
+ virtual void resynch(SetWordType *wd,SetWordType mask); // MR21
+ void prime_lookahead();
+ virtual void tracein(const ANTLRChar *r); // MR10
+ virtual void traceout(const ANTLRChar *r); // MR10
+ static unsigned MODWORD(unsigned x) {return x & (EXT_WORDSIZE-1);} // x % EXT_WORDSIZE // MR9
+ static unsigned DIVWORD(unsigned x) {return x >> EXT_LOGWORDSIZE;} // x / EXT_WORDSIZE // MR9
+ int set_deg(SetWordType *);
+ int set_el(ANTLRTokenType, SetWordType *);
+ virtual void edecode(SetWordType *); // MR1
+ virtual void FAIL(int k, ...); // MR1
+ int traceOptionValue; // MR10
+ int traceGuessOptionValue; // MR10
+ const ANTLRChar *traceCurrentRuleName; // MR10
+ int traceDepth; // MR10
+ void traceReset(); // MR10
+ virtual void traceGuessFail(); // MR10
+ virtual void traceGuessDone(const ANTLRParserState *); // MR10
+ int zzGuessSeq; // MR10
+
+public:
+ ANTLRParser(ANTLRTokenBuffer *,
+ int k=1,
+ int use_inf_look=0,
+ int demand_look=0,
+ int bsetsize=1);
+ virtual ~ANTLRParser();
+
+ virtual void init();
+
+ ANTLRTokenType LA(int i)
+ {
+//
+// MR14 demand look will always be 0 for C++ mode
+//
+//// return demand_look ? token_type[(labase+(i)-1)&(LLk-1)] :
+//// token_type[(lap+(i)-1)&(LLk-1)];
+
+// MR19 V.H. Simonis Defer fetch feature
+
+#ifdef ZZDEFER_FETCH
+ undeferFetch();
+#endif
+ return token_type[(lap+(i)-1)&(LLk-1)];
+ }
+ _ANTLRTokenPtr LT(int i);
+
+ void setEofToken(ANTLRTokenType t) { eofToken = t; }
+ ANTLRTokenType getEofToken() const { return eofToken; } // MR14
+
+ void noGarbageCollectTokens() { inputTokens->noGarbageCollectTokens(); }
+ void garbageCollectTokens() { inputTokens->garbageCollectTokens(); }
+
+ virtual void syn(_ANTLRTokenPtr tok, ANTLRChar *egroup,
+ SetWordType *eset, ANTLRTokenType etok, int k);
+ virtual void saveState(ANTLRParserState *); // MR9 27-Sep-97 make virtual
+ virtual void restoreState(ANTLRParserState *); // MR9 27-Sep-97 make virtual
+
+ virtual void panic(const char *msg); // MR20 const
+
+ static char *eMsgd(char *,int);
+ static char *eMsg(char *,char *);
+ static char *eMsg2(char *,char *,char *);
+
+ virtual int printMessage(FILE* pFile, const char* pFormat, ...); // MR23
+ virtual int printMessageV(FILE* pFile, const char* pFormat, va_list arglist); // MR23
+
+ void consumeUntil(SetWordType *st);
+ void consumeUntilToken(int t);
+
+ virtual int _setmatch_wdfltsig(SetWordType *tokensWanted,
+ ANTLRTokenType tokenTypeOfSet,
+ SetWordType *whatFollows);
+ virtual int _match_wdfltsig(ANTLRTokenType tokenWanted,
+ SetWordType *whatFollows);
+
+ const ANTLRChar * parserTokenName(int tok); // MR1
+
+ int traceOptionValueDefault; // MR11
+ int traceOption(int delta); // MR11
+ int traceGuessOption(int delta); // MR11
+
+// MR8 5-Aug-97 S.Bochnak@microtool.com.pl
+// MR8 Move resynch static local variable
+// MR8 to class instance
+
+ int syntaxErrCount; // MR12
+ ANTLRTokenStream *getLexer() const { // MR12
+ return inputTokens ? inputTokens->getLexer() : 0; } // MR12
+protected: // MR8
+ int resynchConsumed; // MR8
+ char *zzFAILtext; // workarea required by zzFAIL // MR9
+ void undeferFetch(); // MR19 V.H. Simonis
+ int isDeferFetchEnabled(); // MR19 V.H. Simonis
+ virtual void failedSemanticPredicate(const char* predicate); /* MR23 */
+};
+
+#define zzmatch(_t) \
+ if ( !_match((ANTLRTokenType)_t, &zzMissText, &zzMissTok, \
+ (_ANTLRTokenPtr *) &zzBadTok, &zzMissSet) ) goto fail;
+
+#define zzmatch_wsig(_t,handler) \
+ if ( !_match_wsig((ANTLRTokenType)_t) ) if ( guessing ) zzGUESS_FAIL else {_signal=MismatchedToken; goto handler;}
+
+#define zzsetmatch(_ts,_tokclassErrset) \
+ if ( !_setmatch(_ts, &zzMissText, &zzMissTok, \
+ (_ANTLRTokenPtr *) &zzBadTok, &zzMissSet, _tokclassErrset) ) goto fail;
+
+#define zzsetmatch_wsig(_ts, handler) \
+ if ( !_setmatch_wsig(_ts) ) if ( guessing ) zzGUESS_FAIL else {_signal=MismatchedToken; goto handler;}
+
+/* For the dflt signal matchers, a FALSE indicates that an error occurred
+ * just like the other matchers, but in this case, the routine has already
+ * recovered--we do NOT want to consume another token. However, when
+ * the match was successful, we do want to consume hence _signal=0 so that
+ * a token is consumed by the "if (!_signal) consume(); _signal=NoSignal;"
+ * preamble.
+ */
+#define zzsetmatch_wdfltsig(tokensWanted, tokenTypeOfSet, whatFollows) \
+ if ( !_setmatch_wdfltsig(tokensWanted, tokenTypeOfSet, whatFollows) ) \
+ _signal = MismatchedToken;
+
+#define zzmatch_wdfltsig(tokenWanted, whatFollows) \
+ if ( !_match_wdfltsig(tokenWanted, whatFollows) ) _signal = MismatchedToken;
+
+
+// MR1 10-Apr-97 zzfailed_pred() macro does not backtrack in guess mode.
+// MR1 Identification and correction due to J. Lilley
+//
+// MR23 Call virtual method to report error.
+// MR23 Provide more control over failed predicate action
+// without any need for user to worry about guessing internals.
+
+#ifndef zzfailed_pred
+#define zzfailed_pred(_p,_hasuseraction,_useraction) \
+ if (guessing) { \
+ zzGUESS_FAIL; \
+ } else { \
+ zzfailed_pred_action(_p,_hasuseraction,_useraction) \
+ }
+#endif
+
+// MR23 Provide more control over failed predicate action
+// without any need for user to worry about guessing internals.
+// _hasuseraction == 0 => no user specified error action
+// _hasuseraction == 1 => user specified error action
+
+#ifndef zzfailed_pred_action
+#define zzfailed_pred_action(_p,_hasuseraction,_useraction) \
+ if (_hasuseraction) { _useraction } else { failedSemanticPredicate(_p); }
+#endif
+
+#define zzRULE \
+ SetWordType *zzMissSet=NULL; ANTLRTokenType zzMissTok=(ANTLRTokenType)0; \
+ _ANTLRTokenPtr zzBadTok=NULL; ANTLRChar *zzBadText=(ANTLRChar *)""; \
+ int zzErrk=1,zzpf=0; \
+ zzTRACEdata \
+ ANTLRChar *zzMissText=(ANTLRChar *)"";
+
+#endif
+
+ /* S t a n d a r d E x c e p t i o n S i g n a l s */
+
+#define NoSignal 0
+#define MismatchedToken 1
+#define NoViableAlt 2
+#define NoSemViableAlt 3
+
+/* MR7 Allow more control over signalling */
+/* by adding "Unwind" and "SetSignal" */
+
+#define Unwind 4
+#define setSignal(newValue) *_retsignal=_signal=(newValue)
+#define suppressSignal *_retsignal=_signal=0
+#define exportSignal *_retsignal=_signal
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/ASTBase.cpp b/BaseTools/Source/C/VfrCompile/Pccts/h/ASTBase.cpp new file mode 100644 index 0000000000..a94f080c86 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/ASTBase.cpp @@ -0,0 +1,256 @@ +/* Abstract syntax tree manipulation functions
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+#include "pcctscfg.h"
+
+#include "pccts_stdio.h"
+#include "pccts_stdarg.h"
+
+PCCTS_NAMESPACE_STD
+
+#define ANTLR_SUPPORT_CODE
+
+#include "ASTBase.h"
+
+/* ensure that tree manipulation variables are current after a rule
+ * reference
+ */
+void
+ASTBase::link(ASTBase **_root, ASTBase **_sibling, ASTBase **_tail)
+{
+ if ( *_sibling == NULL ) return;
+ if ( *_root == NULL ) *_root = *_sibling;
+ else if ( *_root != *_sibling ) (*_root)->_down = *_sibling;
+ if ( *_tail==NULL ) *_tail = *_sibling;
+ while ( (*_tail)->_right != NULL ) *_tail = (*_tail)->_right;
+}
+
+/* add a child node to the current sibling list */
+void
+ASTBase::subchild(ASTBase **_root, ASTBase **_sibling, ASTBase **_tail)
+{
+ if ( *_tail != NULL ) (*_tail)->_right = this;
+ else {
+ *_sibling = this;
+ if ( *_root != NULL ) (*_root)->_down = *_sibling;
+ }
+ *_tail = this;
+ if ( *_root == NULL ) *_root = *_sibling;
+}
+
+/* make a new AST node. Make the newly-created
+ * node the root for the current sibling list. If a root node already
+ * exists, make the newly-created node the root of the current root.
+ */
+void
+ASTBase::subroot(ASTBase **_root, ASTBase **_sibling, ASTBase **_tail)
+{
+ if ( *_root != NULL )
+ if ( (*_root)->_down == *_sibling ) *_sibling = *_tail = *_root;
+ *_root = this;
+ (*_root)->_down = *_sibling;
+}
+
+/* Apply preorder_action(), etc.. to root then each sibling */
+//
+// 7-Apr-97 133MR1
+// Fix suggested by Ron House (house@helios.usq.edu.au)
+//
+void
+ASTBase::preorder(void* pData /*= NULL*/ /* MR23 */)
+{
+ ASTBase *tree = this;
+
+ while ( tree!= NULL )
+ {
+ if ( tree->_down != NULL ) {
+ tree->preorder_before_action(pData); // MR1
+ };
+ tree->preorder_action(pData);
+ if ( tree->_down!=NULL )
+ {
+ tree->_down->preorder(pData);
+ tree->preorder_after_action(pData); // MR1
+ }
+ tree = tree->_right;
+ }
+}
+
+/* free all AST nodes in tree; apply func to each before freeing */
+void
+ASTBase::destroy()
+{
+ ASTBase* tree = this;
+ while (tree) {
+ if (tree->_down) tree->_down->destroy();
+
+ ASTBase* cur = tree;
+ tree = tree->_right;
+ delete cur;
+ }
+}
+
+/* build a tree (root child1 child2 ... NULL)
+ * If root is NULL, simply make the children siblings and return ptr
+ * to 1st sibling (child1). If root is not single node, return NULL.
+ *
+ * Siblings that are actually siblins lists themselves are handled
+ * correctly. For example #( NULL, #( NULL, A, B, C), D) results
+ * in the tree ( NULL A B C D ).
+ *
+ * Requires at least two parameters with the last one being NULL. If
+ * both are NULL, return NULL.
+ */
+ASTBase *
+ASTBase::tmake(ASTBase *root, ...)
+{
+ va_list ap;
+ register ASTBase *child, *sibling=NULL, *tail=NULL /*MR23*/, *w;
+
+ va_start(ap, root);
+
+ if ( root != NULL )
+ if ( root->_down != NULL ) {
+ root->reportOverwriteOfDownPointer(); /* MR21 Report problem which almost always an error */
+ return NULL;
+ }
+ child = va_arg(ap, ASTBase *);
+ while ( child != NULL )
+ {
+ for (w=child; w->_right!=NULL; w=w->_right) {;} /* find end of child */
+ if ( sibling == NULL ) {sibling = child; tail = w;}
+ else {tail->_right = child; tail = w;}
+ child = va_arg(ap, ASTBase *);
+ }
+ if ( root==NULL ) root = sibling;
+ else root->_down = sibling;
+ va_end(ap);
+ return root;
+}
+
+#ifndef PCCTS_NOT_USING_SOR
+
+/* tree duplicate */
+// forgot to check for NULL this (TJP July 23,1995)
+ASTBase *
+ASTBase::dup()
+{
+ ASTBase *u, *t=this;
+
+ if ( t == NULL ) return NULL;
+/*
+ u = new ASTBase;
+ *u = *t;
+*/
+ u = (ASTBase *)this->shallowCopy();
+ if ( t->_right!=NULL ) u->_right = t->_right->dup();
+ else u->_right = NULL;
+ if ( t->_down!=NULL ) u->_down = t->_down->dup();
+ else u->_down = NULL;
+ return u;
+}
+#endif
+
+//
+// 7-Apr-97 133MR1
+// Fix suggested by Asgeir Olafsson (olafsson@cstar.ac.com)
+//
+/* tree duplicate */
+
+#ifndef PCCTS_NOT_USING_SOR
+
+ASTBase *
+ASTDoublyLinkedBase::dup()
+{
+ ASTDoublyLinkedBase *u, *t=this;
+
+ if ( t == NULL ) return NULL;
+ u = (ASTDoublyLinkedBase *)this->shallowCopy();
+ u->_up = NULL; /* set by calling invocation */
+ u->_left = NULL;
+ if (t->_right!=NULL) { // MR1
+ u->_right=t->_right->dup(); // MR1
+ ((ASTDoublyLinkedBase *)u->_right)->_left = u; // MR1
+ } else { // MR1
+ u->_right = NULL; // MR1
+ }; // MR1
+ if (t->_down!=NULL) { // MR1
+ u->_down = t->_down->dup(); // MR1
+ ((ASTDoublyLinkedBase *)u->_down)->_up = u; // MR1
+ } else { // MR1
+ u->_down = NULL; // MR1
+ }; // MR1
+ return u;
+}
+
+#endif
+
+/*
+ * Set the 'up', and 'left' pointers of all nodes in 't'.
+ * Initial call is double_link(your_tree, NULL, NULL).
+ */
+void
+ASTDoublyLinkedBase::double_link(ASTBase *left, ASTBase *up)
+{
+ ASTDoublyLinkedBase *t = this;
+
+ t->_left = (ASTDoublyLinkedBase *) left;
+ t->_up = (ASTDoublyLinkedBase *) up;
+ if (t->_down != NULL)
+ ((ASTDoublyLinkedBase *)t->_down)->double_link(NULL, t);
+ if (t->_right != NULL)
+ ((ASTDoublyLinkedBase *)t->_right)->double_link(t, up);
+}
+
+// MR21 ASTBase::reportOverwriteOfDownPointer
+
+void ASTBase::reportOverwriteOfDownPointer()
+{
+ panic("Attempt to overwrite down pointer in ASTBase::tmake");
+}
+
+// MR21 ASTBase::panic
+
+void ASTBase::panic(const char *msg)
+{
+ /* MR23 */ printMessage(stderr,"ASTBase panic: %s\n", msg);
+ exit(PCCTS_EXIT_FAILURE);
+}
+
+#ifdef PCCTS_NOT_USING_SOR
+//MR23
+int ASTBase::printMessage(FILE* pFile, const char* pFormat, ...)
+{
+ va_list marker;
+ va_start( marker, pFormat );
+ int iRet = vfprintf(pFile, pFormat, marker);
+ va_end( marker );
+ return iRet;
+}
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/ASTBase.h b/BaseTools/Source/C/VfrCompile/Pccts/h/ASTBase.h new file mode 100644 index 0000000000..912f4b8482 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/ASTBase.h @@ -0,0 +1,122 @@ +/* Abstract syntax tree
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+#ifndef ASTBase_H
+#define ASTBase_H
+
+#include "pcctscfg.h"
+
+#include "pccts_stdio.h"
+#include "pccts_stdlib.h"
+
+PCCTS_NAMESPACE_STD
+
+#ifndef PCCTS_NOT_USING_SOR
+#include "PCCTSAST.h"
+#endif
+
+/*
+ * Notes:
+ *
+ * To specify a copy constructor, subclass one of these classes and
+ * give the copy constructor. To use dup(), you must define shallowCopy().
+ * shallowCopy() can use either a copy constructor or just copy the node
+ * itself.
+ */
+
+#ifdef PCCTS_NOT_USING_SOR
+class DllExportPCCTS ASTBase {
+#else
+class DllExportPCCTS ASTBase : public PCCTS_AST {
+#endif
+
+protected:
+ ASTBase *_right, *_down;
+
+public:
+
+#ifdef PCCTS_NOT_USING_SOR
+ ASTBase *right() { return _right; }
+ ASTBase *down() { return _down; }
+ void setRight(ASTBase *t) { _right = (ASTBase *)t; }
+ void setDown(ASTBase *t) { _down = (ASTBase *)t; }
+#else
+ PCCTS_AST *right() { return _right; } // define the SORCERER interface
+ PCCTS_AST *down() { return _down; }
+ void setRight(PCCTS_AST *t) { _right = (ASTBase *)t; }
+ void setDown(PCCTS_AST *t) { _down = (ASTBase *)t; }
+#endif
+ ASTBase() { _right = _down = NULL; }
+ virtual ~ASTBase() { ; }
+#ifndef PCCTS_NOT_USING_SOR
+ virtual ASTBase *dup();
+#endif
+ void destroy();
+ void preorder(void* pData = NULL /* MR23 */);
+ static ASTBase *tmake(ASTBase *, ...);
+ static void link(ASTBase **, ASTBase **, ASTBase **);
+ void subchild(ASTBase **, ASTBase **, ASTBase **);
+ void subroot(ASTBase **, ASTBase **, ASTBase **);
+ virtual void preorder_action(void* /*pData*/ = NULL /* MR23 */) { ; }
+ virtual void preorder_before_action(void* /*pData*/ = NULL /* MR23 */) { /* MR23 */ printMessage(stdout, " ("); }
+ virtual void preorder_after_action(void* /*pData*/ = NULL /* MR23 */) { /* MR23 */ printMessage(stdout, " )"); }
+ virtual void panic(const char *msg); /* MR21 */
+ virtual void reportOverwriteOfDownPointer(); /* MR21 */
+#ifdef PCCTS_NOT_USING_SOR
+ virtual int printMessage(FILE* pFile, const char* pFormat, ...); // MR23
+#endif
+};
+
+class DllExportPCCTS ASTDoublyLinkedBase : public ASTBase {
+protected:
+ ASTDoublyLinkedBase *_left, *_up;
+
+public:
+ void double_link(ASTBase *left, ASTBase *up);
+
+#ifndef PCCTS_NOT_USING_SOR
+ virtual ASTBase *dup();
+#endif
+
+#ifdef PCCTS_NOT_USING_SOR
+ ASTBase *left() { return _left; }
+ ASTBase *up() { return _up; }
+ void setLeft(ASTBase *t) { _left = (ASTDoublyLinkedBase *)t; } // MR6
+ void setUp(ASTBase *t) { _up = (ASTDoublyLinkedBase *)t; } // MR6
+#else
+ PCCTS_AST *left() { return _left; }
+ PCCTS_AST *up() { return _up; }
+ void setLeft(PCCTS_AST *t) { _left = (ASTDoublyLinkedBase *)t; } // MR6
+ void setUp(PCCTS_AST *t) { _up = (ASTDoublyLinkedBase *)t; } // MR6
+#endif
+
+};
+
+class AST; // announce that this class will be coming along shortly
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/ATokPtr.h b/BaseTools/Source/C/VfrCompile/Pccts/h/ATokPtr.h new file mode 100644 index 0000000000..75b4c86cbf --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/ATokPtr.h @@ -0,0 +1,88 @@ +/* ATokPtr.h
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Written by Russell Quong June 30, 1995
+ * Adapted by Terence Parr to ANTLR stuff
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+#ifndef ATokPtr_h
+#define ATokPtr_h
+
+#include "pcctscfg.h"
+
+#include "pccts_stdio.h"
+
+PCCTS_NAMESPACE_STD
+
+// pointer to a reference counted object
+// robust in that an unused ANTLRTokenPtr can point to NULL.
+
+class ANTLRAbstractToken;
+
+class DllExportPCCTS ANTLRTokenPtr {
+public:
+ ANTLRTokenPtr(ANTLRAbstractToken *addr=NULL){ptr_ = addr; ref();}
+ ANTLRTokenPtr(const ANTLRTokenPtr &lhs) {ptr_ = lhs.ptr_; lhs.ref();}
+ ~ANTLRTokenPtr();
+
+ // use ANTLRTokenPtr as a pointer to ANTLRToken
+//
+// 8-Apr-97 MR1 Make operator -> a const member function
+// as well as some other member functions
+//
+ ANTLRAbstractToken *operator-> () const { return ptr_; } // MR1
+//
+// 7-Apr-97 133MR1
+// Fix suggested by Andreas Magnusson
+// (Andreas.Magnusson@mailbox.swipnet.se)
+ void operator = (const ANTLRTokenPtr & lhs); // MR1
+ void operator = (ANTLRAbstractToken *addr);
+ int operator != (const ANTLRTokenPtr &q) const // MR1 // MR11 unsigned -> int
+ { return this->ptr_ != q.ptr_; }
+ int operator == (const ANTLRTokenPtr &q) const // MR1 // MR11 unsigned -> int
+ { return this->ptr_ == q.ptr_; }
+ int operator == (const ANTLRAbstractToken *addr) const // MR11
+ { return this->ptr_ == addr; }
+ int operator != (const ANTLRAbstractToken *addr) const // MR11
+ { return this->ptr_ != addr; }
+
+ void ref() const;
+ void deref();
+
+protected:
+ ANTLRAbstractToken *ptr_;
+};
+
+//typedef ANTLRTokenPtr _ANTLRTokenPtr;
+
+/*
+ * Since you cannot redefine operator->() to return one of the user's
+ * token object types, we must down cast. This is a drag. Here's
+ * a macro that helps. template: "mytoken(a-smart-ptr)->myfield".
+ */
+#define mytoken(tk) ((ANTLRToken *)(tk.operator->()))
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/ATokPtrImpl.h b/BaseTools/Source/C/VfrCompile/Pccts/h/ATokPtrImpl.h new file mode 100644 index 0000000000..9c07cf52a9 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/ATokPtrImpl.h @@ -0,0 +1,88 @@ +/*
+ * ATokPtrImpl.h (formerly ATokPtr.cpp)
+ *
+ * This is #included in ATokBuffer.cpp for historical reasons.
+ * It has been renamed because of problems with the .cpp extension
+ * when used with IDE.
+ *
+ *
+ * ANTLRToken MUST be defined before entry to this file.
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Written by Russell Quong June 30, 1995
+ * Adapted by Terence Parr to ANTLR stuff
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+#include "pcctscfg.h"
+
+PCCTS_NAMESPACE_STD
+
+#include "ATokPtr.h"
+
+void ANTLRTokenPtr::ref() const
+{
+ if (ptr_ != NULL) {
+ ptr_->ref();
+ }
+}
+
+void ANTLRTokenPtr::deref()
+{
+ if (ptr_ != NULL)
+ {
+ ptr_->deref();
+ if ( ptr_->nref()==0 )
+ {
+ delete ptr_;
+ ptr_ = NULL;
+ }
+ }
+}
+
+ANTLRTokenPtr::~ANTLRTokenPtr()
+{
+ deref();
+}
+
+//
+// 8-Apr-97 MR1 Make operator -> a const member function
+// as weall as some other member functions
+//
+void ANTLRTokenPtr::operator = (const ANTLRTokenPtr & lhs) // MR1
+{
+ lhs.ref(); // protect against "xp = xp"; ie same underlying object
+ deref();
+ ptr_ = lhs.ptr_;
+}
+
+void ANTLRTokenPtr::operator = (ANTLRAbstractToken *addr)
+{
+ if (addr != NULL) {
+ addr->ref();
+ }
+ deref();
+ ptr_ = addr;
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/AToken.h b/BaseTools/Source/C/VfrCompile/Pccts/h/AToken.h new file mode 100644 index 0000000000..6167c21ef5 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/AToken.h @@ -0,0 +1,325 @@ +/* ANTLRToken.h
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+#ifndef ATOKEN_H_GATE
+#define ATOKEN_H_GATE
+
+#include "pcctscfg.h"
+
+#include "pccts_string.h"
+#include "pccts_stdio.h"
+#include "pccts_stdlib.h"
+#include "pccts_stdarg.h" // MR23
+
+PCCTS_NAMESPACE_STD
+
+// MR9 RJV (JVincent@novell.com) Not needed for variable length strings
+
+//// MR9 #ifndef ANTLRCommonTokenTEXTSIZE
+//// MR9 #define ANTLRCommonTokenTEXTSIZE 100
+//// MR9 #endif
+
+
+/* must define what a char looks like; can make this a class too */
+typedef char ANTLRChar;
+
+/* D E F I N E S M A R T P O I N T E R S */
+
+//#include ATOKPTR_H not tested yet, leave out
+class ANTLRAbstractToken;
+typedef ANTLRAbstractToken *_ANTLRTokenPtr;
+
+class ANTLRAbstractToken {
+public:
+ virtual ~ANTLRAbstractToken() {;}
+ virtual ANTLRTokenType getType() const = 0;
+ virtual void setType(ANTLRTokenType t) = 0;
+ virtual int getLine() const = 0;
+ virtual void setLine(int line) = 0;
+ virtual ANTLRChar *getText() const = 0;
+ virtual void setText(const ANTLRChar *) = 0;
+
+ /* This function will disappear when I can use templates */
+ virtual ANTLRAbstractToken *makeToken(ANTLRTokenType tt,
+ ANTLRChar *text,
+ int line) = 0;
+
+ /* define to satisfy ANTLRTokenBuffer's need to determine whether or
+ not a token object can be destroyed. If nref()==0, no one has
+ a reference, and the object may be destroyed. This function defaults
+ to 1, hence, if you use deleteTokens() message with a token object
+ not derived from ANTLRCommonRefCountToken, the parser will compile
+ but will not delete objects after they leave the token buffer.
+ */
+
+ virtual unsigned nref() const { return 1; } // MR11
+ virtual void ref() {;}
+ virtual void deref() {;}
+
+ virtual void panic(const char *msg) // MR20 const
+ {
+ /* MR23 */ printMessage(stderr, "ANTLRAbstractToken panic: %s\n", msg);
+ exit(PCCTS_EXIT_FAILURE);
+ }
+
+ virtual int printMessage(FILE* pFile, const char* pFormat, ...) // MR23
+ {
+ va_list marker;
+ va_start( marker, pFormat );
+ int iRet = vfprintf(pFile, pFormat, marker);
+ va_end( marker );
+ return iRet;
+ }
+};
+
+/* This class should be subclassed. It cannot store token type or text */
+
+class ANTLRRefCountToken : public ANTLRAbstractToken {
+public:
+#ifdef DBG_REFCOUNTTOKEN
+ static int ctor;
+ static int dtor;
+#endif
+protected:
+ unsigned refcnt_;
+#ifdef DBG_REFCOUNTTOKEN
+ char object[200];
+#endif
+
+public:
+
+ // MR23 - No matter what you do, you're hammered.
+ // Don't give names to formals something breaks.
+ // Give names to formals and don't use them it breaks.
+
+#ifndef DBG_REFCOUNTTOKEN
+ ANTLRRefCountToken(ANTLRTokenType /* t MR23 */, const ANTLRChar * /* s MR23 */)
+#else
+ ANTLRRefCountToken(ANTLRTokenType t, const ANTLRChar * s)
+#endif
+
+#ifndef DBG_REFCOUNTTOKEN
+ {
+ refcnt_ = 0;
+ }
+#else
+ {
+ ctor++;
+ refcnt_ = 0;
+ if ( t==1 ) sprintf(object,"tok_EOF");
+ else sprintf(object,"tok_%s",s);
+ /* MR23 */ printMessage(stderr, "ctor %s #%d\n",object,ctor);
+ }
+#endif
+ ANTLRRefCountToken()
+#ifndef DBG_REFCOUNTTOKEN
+ { refcnt_ = 0; }
+#else
+ {
+ ctor++;
+ refcnt_ = 0;
+ sprintf(object,"tok_blank");
+ /* MR23 */ printMessage(stderr, "ctor %s #%d\n",object,ctor);
+ }
+ virtual ~ANTLRRefCountToken()
+ {
+ dtor++;
+ if ( dtor>ctor ) /* MR23 */ printMessage(stderr, "WARNING: dtor>ctor\n");
+ /* MR23 */ printMessage(stderr, "dtor %s #%d\n", object, dtor);
+ object[0]='\0';
+ }
+#endif
+
+ // reference counting stuff needed by ANTLRTokenPtr.
+ // User should not access these; for C++ language reasons, we had
+ // to make these public. Yuck.
+
+ void ref() { refcnt_++; }
+ void deref() { refcnt_--; }
+ unsigned nref() const { return refcnt_; } // MR11
+
+ virtual ANTLRAbstractToken *makeToken(ANTLRTokenType /*tt MR23*/,
+ ANTLRChar * /*txt MR23*/,
+ int /*line MR23*/)
+ {
+ panic("call to ANTLRRefCountToken::makeToken()\n");
+ return NULL;
+ }
+};
+
+class ANTLRCommonNoRefCountToken : public ANTLRAbstractToken {
+protected:
+ ANTLRTokenType _type;
+ int _line;
+ ANTLRChar *_text; // MR9 RJV
+
+public:
+ ANTLRCommonNoRefCountToken(ANTLRTokenType t, const ANTLRChar *s)
+ { setType(t); _line = 0; _text = NULL; setText(s); }
+ ANTLRCommonNoRefCountToken()
+ { setType((ANTLRTokenType)0); _line = 0; _text = NULL; setText(""); }
+
+ ~ANTLRCommonNoRefCountToken() { if (_text) delete [] _text; } // MR9 RJV: Added Destructor to remove string
+
+ ANTLRTokenType getType() const { return _type; }
+ void setType(ANTLRTokenType t) { _type = t; }
+ virtual int getLine() const { return _line; }
+ void setLine(int line) { _line = line; }
+ ANTLRChar *getText() const { return _text; }
+ int getLength() const { return strlen(getText()); } // MR11
+
+// MR9 RJV: Added code for variable length strings to setText()
+
+ void setText(const ANTLRChar *s)
+ { if (s != _text) {
+ if (_text) delete [] _text;
+ if (s != NULL) {
+ _text = new ANTLRChar[strlen(s)+1];
+ if (_text == NULL) panic("ANTLRCommonNoRefCountToken::setText new failed");
+ strcpy(_text,s);
+ } else {
+ _text = new ANTLRChar[1];
+ if (_text == NULL) panic("ANTLRCommonNoRefCountToken::setText new failed");
+ strcpy(_text,"");
+ };
+ };
+ }
+
+ virtual ANTLRAbstractToken *makeToken(ANTLRTokenType tt,
+ ANTLRChar *txt,
+ int line)
+ {
+ ANTLRAbstractToken *t = new ANTLRCommonNoRefCountToken;
+ t->setType(tt); t->setText(txt); t->setLine(line);
+ return t;
+ }
+
+// MR9 THM Copy constructor required when heap allocated string is used with copy semantics
+
+ ANTLRCommonNoRefCountToken (const ANTLRCommonNoRefCountToken& from) :
+ ANTLRAbstractToken(from) {
+ setType(from._type);
+ setLine(from._line);
+ _text=NULL;
+ setText(from._text);
+ };
+
+// MR9 THM operator =() required when heap allocated string is used with copy semantics
+
+ virtual ANTLRCommonNoRefCountToken& operator =(const ANTLRCommonNoRefCountToken& rhs) {
+
+////// MR15 WatCom can't hack use of operator =()
+////// Use this: *( (ANTRLAbstractToken *) this)=rhs;
+
+ *( (ANTLRAbstractToken *) this ) = rhs;
+
+ setType(rhs._type);
+ setLine(rhs._line);
+ setText(rhs._text);
+ return *this;
+ };
+};
+
+class ANTLRCommonToken : public ANTLRRefCountToken {
+protected:
+ ANTLRTokenType _type;
+ int _line;
+ ANTLRChar *_text; // MR9 RJV:Added
+
+public:
+ ANTLRCommonToken(ANTLRTokenType t, const ANTLRChar *s) : ANTLRRefCountToken(t,s)
+ { setType(t); _line = 0; _text = NULL; setText(s); } // MR9
+ ANTLRCommonToken()
+ { setType((ANTLRTokenType)0); _line = 0; _text = NULL; setText(""); } // MR9
+
+ virtual ~ANTLRCommonToken() { if (_text) delete [] _text; } // MR9 RJV: Added Destructor to remove string
+
+ ANTLRTokenType getType() const { return _type; }
+ void setType(ANTLRTokenType t) { _type = t; }
+ virtual int getLine() const { return _line; }
+ void setLine(int line) { _line = line; }
+ ANTLRChar *getText() const { return _text; }
+ int getLength() const { return strlen(getText()); } // MR11
+
+// MR9 RJV: Added code for variable length strings to setText()
+
+ void setText(const ANTLRChar *s)
+ { if (s != _text) {
+ if (_text) delete [] _text;
+ if (s != NULL) {
+ _text = new ANTLRChar[strlen(s)+1];
+ if (_text == NULL) panic("ANTLRCommonToken::setText new failed");
+ strcpy(_text,s);
+ } else {
+ _text = new ANTLRChar[1];
+ if (_text == NULL) panic("ANTLRCommonToken::setText new failed");
+ strcpy(_text,"");
+ };
+ };
+ }
+
+ virtual ANTLRAbstractToken *makeToken(ANTLRTokenType tt,
+ ANTLRChar *txt,
+ int line)
+ {
+ ANTLRAbstractToken *t = new ANTLRCommonToken(tt,txt);
+ t->setLine(line);
+ return t;
+ }
+
+// MR9 THM Copy constructor required when heap allocated string is used with copy semantics
+
+ ANTLRCommonToken (const ANTLRCommonToken& from) :
+ ANTLRRefCountToken(from) {
+ setType(from._type);
+ setLine(from._line);
+ _text=NULL;
+ setText(from._text);
+ };
+
+// MR9 THM operator =() required when heap allocated string is used with copy semantics
+
+ virtual ANTLRCommonToken& operator =(const ANTLRCommonToken& rhs) {
+
+////// MR15 WatCom can't hack use of operator =()
+////// Use this instead: *( (ANTRLRRefCountToken *) this)=rhs;
+
+ *( (ANTLRRefCountToken *) this) = rhs;
+
+ setType(rhs._type);
+ setLine(rhs._line);
+ setText(rhs._text);
+ return *this;
+ };
+};
+
+// used for backward compatibility
+typedef ANTLRCommonToken ANTLRCommonBacktrackingToken;
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/ATokenBuffer.cpp b/BaseTools/Source/C/VfrCompile/Pccts/h/ATokenBuffer.cpp new file mode 100644 index 0000000000..9a2f2fc88b --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/ATokenBuffer.cpp @@ -0,0 +1,374 @@ +/* ANTLRTokenBuffer.cpp
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+typedef int ANTLRTokenType; // fool AToken.h into compiling
+
+class ANTLRParser; /* MR1 */
+
+#define ANTLR_SUPPORT_CODE
+
+#include "pcctscfg.h"
+
+#include ATOKENBUFFER_H
+#include APARSER_H // MR23
+
+typedef ANTLRAbstractToken *_ANTLRTokenPtr;
+
+#if defined(DBG_TBUF)||defined(DBG_TBUF_MARK_REW)
+static unsigned char test[1000];
+#endif
+
+#ifdef DBG_REFCOUNTTOKEN
+int ANTLRRefCountToken::ctor = 0; /* MR23 */
+int ANTLRRefCountToken::dtor = 0; /* MR23 */
+#endif
+
+ANTLRTokenBuffer::
+ANTLRTokenBuffer(ANTLRTokenStream *_input, int _k, int _chunk_size_formal) /* MR14 */
+{
+ this->input = _input;
+ this->k = _k;
+ buffer_size = chunk_size = _chunk_size_formal;
+ buffer = (_ANTLRTokenPtr *)
+ calloc(chunk_size+1,sizeof(_ANTLRTokenPtr ));
+ if ( buffer == NULL ) {
+ panic("cannot alloc token buffer");
+ }
+ buffer++; // leave the first elem empty so tp-1 is valid ptr
+
+ tp = &buffer[0];
+ last = tp-1;
+ next = &buffer[0];
+ num_markers = 0;
+ end_of_buffer = &buffer[buffer_size-1];
+ threshold = &buffer[(int)(buffer_size/2)]; // MR23 - Used to be 1.0/2.0 !
+ _deleteTokens = 1; // assume we delete tokens
+ parser=NULL; // MR5 - uninitialized reference
+}
+
+static void f() {;}
+ANTLRTokenBuffer::
+~ANTLRTokenBuffer()
+{
+ f();
+ // Delete all remaining tokens (from 0..last inclusive)
+ if ( _deleteTokens )
+ {
+ _ANTLRTokenPtr *z;
+ for (z=buffer; z<=last; z++)
+ {
+ (*z)->deref();
+// z->deref();
+#ifdef DBG_REFCOUNTTOKEN
+ /* MR23 */ printMessage(stderr, "##########dtor: deleting token '%s' (ref %d)\n",
+ ((ANTLRCommonToken *)*z)->getText(), (*z)->nref());
+#endif
+ if ( (*z)->nref()==0 )
+ {
+ delete (*z);
+ }
+ }
+ }
+
+ if ( buffer!=NULL ) free((char *)(buffer-1));
+}
+
+#if defined(DBG_TBUF)||defined(DBG_TBUF_MARK_REW)
+#include "pccts_stdio.h"
+PCCTS_NAMESPACE_STD
+#endif
+
+_ANTLRTokenPtr ANTLRTokenBuffer::
+getToken()
+{
+ if ( tp <= last ) // is there any buffered lookahead still to be read?
+ {
+ return *tp++; // read buffered lookahead
+ }
+ // out of buffered lookahead, get some more "real"
+ // input from getANTLRToken()
+ if ( num_markers==0 )
+ {
+ if( next > threshold )
+ {
+#ifdef DBG_TBUF
+/* MR23 */ printMessage(stderr,"getToken: next > threshold (high water is %d)\n", threshold-buffer);
+#endif
+ makeRoom();
+ }
+ }
+ else {
+ if ( next > end_of_buffer )
+ {
+#ifdef DBG_TBUF
+/* MR23 */ printMessage(stderr,"getToken: next > end_of_buffer (size is %d)\n", buffer_size);
+#endif
+ extendBuffer();
+ }
+ }
+ *next = getANTLRToken();
+ (*next)->ref(); // say we have a copy of this pointer in buffer
+ last = next;
+ next++;
+ tp = last;
+ return *tp++;
+}
+
+void ANTLRTokenBuffer::
+rewind(int pos)
+{
+#if defined(DBG_TBUF)||defined(DBG_TBUF_MARK_REW)
+ /* MR23 */ printMessage(stderr, "rewind(%d)[nm=%d,from=%d,%d.n=%d]\n", pos, num_markers, tp-buffer,pos,test[pos]);
+ test[pos]--;
+#endif
+ tp = &buffer[pos];
+ num_markers--;
+}
+
+/*
+ * This function is used to specify that the token pointers read
+ * by the ANTLRTokenBuffer should be buffered up (to be reused later).
+ */
+int ANTLRTokenBuffer::
+mark()
+{
+#if defined(DBG_TBUF)||defined(DBG_TBUF_MARK_REW)
+ test[tp-buffer]++;
+ /* MR23 */ printMessage(stderr,"mark(%d)[nm=%d,%d.n=%d]\n",tp-buffer,num_markers+1,tp-buffer,test[tp-buffer]);
+#endif
+ num_markers++;
+ return tp - buffer;
+}
+
+/*
+ * returns the token pointer n positions ahead.
+ * This implies that bufferedToken(1) gets the NEXT symbol of lookahead.
+ * This is used in conjunction with the ANTLRParser lookahead buffer.
+ *
+ * No markers are set or anything. A bunch of input is buffered--that's all.
+ * The tp pointer is left alone as the lookahead has not been advanced
+ * with getToken(). The next call to getToken() will find a token
+ * in the buffer and won't have to call getANTLRToken().
+ *
+ * If this is called before a consume() is done, how_many_more_i_need is
+ * set to 'n'.
+ */
+_ANTLRTokenPtr ANTLRTokenBuffer::
+bufferedToken(int n)
+{
+// int how_many_more_i_need = (last-tp < 0) ? n : n-(last-tp)-1;
+ int how_many_more_i_need = (tp > last) ? n : n-(last-tp)-1;
+ // Make sure that at least n tokens are available in the buffer
+#ifdef DBG_TBUF
+ /* MR23 */ printMessage(stderr, "bufferedToken(%d)\n", n);
+#endif
+ for (int i=1; i<=how_many_more_i_need; i++)
+ {
+ if ( next > end_of_buffer ) // buffer overflow?
+ {
+ extendBuffer();
+ }
+ *next = getANTLRToken();
+ (*next)->ref(); // say we have a copy of this pointer in buffer
+ last = next;
+ next++;
+ }
+ return tp[n - 1];
+}
+
+/* If no markers are set, the none of the input needs to be saved (except
+ * for the lookahead Token pointers). We save only k-1 token pointers as
+ * we are guaranteed to do a getANTLRToken() right after this because otherwise
+ * we wouldn't have needed to extend the buffer.
+ *
+ * If there are markers in the buffer, we need to save things and so
+ * extendBuffer() is called.
+ */
+void ANTLRTokenBuffer::
+makeRoom()
+{
+#ifdef DBG_TBUF
+ /* MR23 */ printMessage(stderr, "in makeRoom.................\n");
+ /* MR23 */ printMessage(stderr, "num_markers==%d\n", num_markers);
+#endif
+/*
+ if ( num_markers == 0 )
+ {
+*/
+#ifdef DBG_TBUF
+ /* MR23 */ printMessage(stderr, "moving lookahead and resetting next\n");
+
+ _ANTLRTokenPtr *r;
+ /* MR23 */ printMessage(stderr, "tbuf = [");
+ for (r=buffer; r<=last; r++)
+ {
+ if ( *r==NULL ) /* MR23 */ printMessage(stderr, " xxx");
+ else /* MR23 */ printMessage(stderr, " '%s'", ((ANTLRCommonToken *)*r)->getText());
+ }
+ /* MR23 */ printMessage(stderr, " ]\n");
+
+ /* MR23 */ printMessage(stderr,
+ "before: tp=%d, last=%d, next=%d, threshold=%d\n",tp-buffer,last-buffer,next-buffer,threshold-buffer);
+#endif
+
+ // Delete all tokens from 0..last-(k-1) inclusive
+ if ( _deleteTokens )
+ {
+ _ANTLRTokenPtr *z;
+ for (z=buffer; z<=last-(k-1); z++)
+ {
+ (*z)->deref();
+// z->deref();
+#ifdef DBG_REFCOUNTTOKEN
+ /* MR23 */ printMessage(stderr, "##########makeRoom: deleting token '%s' (ref %d)\n",
+ ((ANTLRCommonToken *)*z)->getText(), (*z)->nref());
+#endif
+ if ( (*z)->nref()==0 )
+ {
+ delete (*z);
+ }
+ }
+ }
+
+ // reset the buffer to initial conditions, but move k-1 symbols
+ // to the beginning of buffer and put new input symbol at k
+ _ANTLRTokenPtr *p = buffer, *q = last-(k-1)+1;
+// ANTLRAbstractToken **p = buffer, **q = end_of_buffer-(k-1)+1;
+#ifdef DBG_TBUF
+ /* MR23 */ printMessage(stderr, "lookahead buffer = [");
+#endif
+ for (int i=1; i<=(k-1); i++)
+ {
+ *p++ = *q++;
+#ifdef DBG_TBUF
+ /* MR23 */ printMessage(stderr,
+ " '%s'", ((ANTLRCommonToken *)buffer[i-1])->getText());
+#endif
+ }
+#ifdef DBG_TBUF
+ /* MR23 */ printMessage(stderr, " ]\n");
+#endif
+ next = &buffer[k-1];
+ tp = &buffer[k-1]; // tp points to what will be filled in next
+ last = tp-1;
+#ifdef DBG_TBUF
+ /* MR23 */ printMessage(stderr,
+ "after: tp=%d, last=%d, next=%d\n",
+ tp-buffer, last-buffer, next-buffer);
+#endif
+/*
+ }
+ else {
+ extendBuffer();
+ }
+*/
+}
+
+/* This function extends 'buffer' by chunk_size and returns with all
+ * pointers at the same relative positions in the buffer (the buffer base
+ * address could have changed in realloc()) except that 'next' comes
+ * back set to where the next token should be stored. All other pointers
+ * are untouched.
+ */
+void
+ANTLRTokenBuffer::
+extendBuffer()
+{
+ int save_last = last-buffer, save_tp = tp-buffer, save_next = next-buffer;
+#ifdef DBG_TBUF
+ /* MR23 */ printMessage(stderr, "extending physical buffer\n");
+#endif
+ buffer_size += chunk_size;
+ buffer = (_ANTLRTokenPtr *)
+ realloc((char *)(buffer-1),
+ (buffer_size+1)*sizeof(_ANTLRTokenPtr ));
+ if ( buffer == NULL ) {
+ panic("cannot alloc token buffer");
+ }
+ buffer++; // leave the first elem empty so tp-1 is valid ptr
+
+ tp = buffer + save_tp; // put the pointers back to same relative position
+ last = buffer + save_last;
+ next = buffer + save_next;
+ end_of_buffer = &buffer[buffer_size-1];
+ threshold = &buffer[(int)(buffer_size*(1.0/2.0))];
+
+/*
+ // zero out new token ptrs so we'll know if something to delete in buffer
+ ANTLRAbstractToken **p = end_of_buffer-chunk_size+1;
+ for (; p<=end_of_buffer; p++) *p = NULL;
+*/
+}
+
+ANTLRParser * ANTLRTokenBuffer:: // MR1
+setParser(ANTLRParser *p) { // MR1
+ ANTLRParser *old=parser; // MR1
+ parser=p; // MR1
+ input->setParser(p); // MR1
+ return old; // MR1
+} // MR1
+ // MR1
+ANTLRParser * ANTLRTokenBuffer:: // MR1
+getParser() { // MR1
+ return parser; // MR1
+} // MR1
+
+void ANTLRTokenBuffer::panic(const char *msg) // MR23
+{
+ if (parser) //MR23
+ parser->panic(msg); //MR23
+ else //MR23
+ exit(PCCTS_EXIT_FAILURE);
+}
+
+//MR23
+int ANTLRTokenBuffer::printMessage(FILE* pFile, const char* pFormat, ...)
+{
+ va_list marker;
+ va_start( marker, pFormat );
+
+ int iRet = 0;
+ if (parser)
+ parser->printMessageV(pFile, pFormat, marker);
+ else
+ iRet = vfprintf(pFile, pFormat, marker);
+
+ va_end( marker );
+ return iRet;
+}
+
+/* to avoid having to link in another file just for the smart token ptr
+ * stuff, we include it here. Ugh.
+ *
+ * MR23 This causes nothing but problems for IDEs.
+ * Change from .cpp to .h
+ *
+ */
+
+#include ATOKPTR_IMPL_H
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/ATokenBuffer.h b/BaseTools/Source/C/VfrCompile/Pccts/h/ATokenBuffer.h new file mode 100644 index 0000000000..1c008fd59e --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/ATokenBuffer.h @@ -0,0 +1,109 @@ +/* ANTLRTokenBuffer.h
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+#ifndef ATOKENBUFFER_H_GATE
+#define ATOKENBUFFER_H_GATE
+
+#include "pcctscfg.h"
+
+#include "pccts_stdlib.h"
+
+PCCTS_NAMESPACE_STD
+
+#include ATOKEN_H
+#include ATOKENSTREAM_H
+
+/*
+ * The parser is "attached" to an ANTLRTokenBuffer via interface
+ * functions: getToken() and bufferedToken(). The object that actually
+ * consumes characters and constructs tokens is connected to the
+ * ANTLRTokenBuffer via interface function ANTLRTokenStream::getToken();
+ * where ANTLRTokenStream is really just a behavior (class with no data).
+ * C++ does not have this abstraction and hence we simply have come up
+ * with a fancy name for "void *". See the note in ANTLRTokenStream.h on
+ * the "behavior" of ANTLRTokenStream.
+ */
+
+class ANTLRParser; // MR1
+
+class DllExportPCCTS ANTLRTokenBuffer {
+protected:
+ ANTLRTokenStream *input; // where do I get tokens
+ int buffer_size;
+ int chunk_size;
+ int num_markers;
+ int k; // Need at least this many tokens in buffer
+ _ANTLRTokenPtr *buffer; // buffer used for arbitrary lookahead
+ _ANTLRTokenPtr *tp; // pts into buffer; current token ptr
+ _ANTLRTokenPtr *last; // pts to last valid token in buffer
+ _ANTLRTokenPtr *next; // place to put token from getANTLRToken()
+ _ANTLRTokenPtr *end_of_buffer;
+ /* when you try to write a token past this and there are no markers
+ set, then move k-1 tokens back to the beginning of the buffer.
+ We want to stay away from the end of the buffer because we have
+ to extend it if a marker is set and we reach the end (we cannot
+ move tokens to the beginning of the buffer in this case).
+ */
+ _ANTLRTokenPtr *threshold;
+ unsigned char _deleteTokens;
+
+ // This function is filled in by the subclass; it initiates fetch of input
+ virtual _ANTLRTokenPtr getANTLRToken() { return input->getToken(); }
+ void makeRoom();
+ void extendBuffer();
+
+public:
+ ANTLRTokenBuffer(ANTLRTokenStream *in, int k=1, int chksz=50);
+ virtual ~ANTLRTokenBuffer();
+ virtual _ANTLRTokenPtr getToken();
+ virtual void rewind(int pos);
+ virtual int mark();
+ virtual _ANTLRTokenPtr bufferedToken(int i);
+
+ void noGarbageCollectTokens() { _deleteTokens=0; }
+ void garbageCollectTokens() { _deleteTokens=1; }
+
+ virtual int bufferSize() { return buffer_size; }
+ virtual int minTokens() { return k; }
+ virtual void setMinTokens(int k_new) { k = k_new; }
+
+ virtual void panic(const char *msg); /* MR20 const */
+
+ virtual int printMessage(FILE* pFile, const char* pFormat, ...); // MR23
+
+protected: // MR1
+ ANTLRParser *parser; // MR1
+public: // MR1
+ ANTLRParser *setParser(ANTLRParser *p); // MR1
+ ANTLRParser *getParser(); // MR1
+ ANTLRTokenStream *getLexer() const { // MR12
+ return input;} // MR12
+};
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/ATokenStream.h b/BaseTools/Source/C/VfrCompile/Pccts/h/ATokenStream.h new file mode 100644 index 0000000000..3dfea6ebff --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/ATokenStream.h @@ -0,0 +1,51 @@ +/* ANTLRTokenStream.h
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+#ifndef ATOKENSTREAM_H_GATE
+#define ATOKENSTREAM_H_GATE
+
+#include "pcctscfg.h"
+
+/* This is really a behavior or protocol; it merely indicates the behavior
+ * required of the input and output of an ANTLRTokenBuffer. You could
+ * subclass it, but you can also just pass any old pointer to ANTLRTokenBuffer
+ * with a type cast (in which case, your getANTLRToken() would have to
+ * explicitly cast the input pointer to your REAL type (typically your lexer)).
+ */
+
+class ANTLRParser; // MR1
+
+class DllExportPCCTS ANTLRTokenStream {
+public:
+ virtual _ANTLRTokenPtr getToken() = 0;
+ virtual ANTLRParser * setParser(ANTLRParser * /*p MR23*/) {return 0; }; // MR12
+ virtual ANTLRParser * getParser() { return 0; }; // MR12
+};
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/BufFileInput.cpp b/BaseTools/Source/C/VfrCompile/Pccts/h/BufFileInput.cpp new file mode 100644 index 0000000000..99d08a42a4 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/BufFileInput.cpp @@ -0,0 +1,100 @@ +// FILE: BufFileInput.cpp
+// AUTHOR: Alexey Demakov (AVD) demakov@kazbek.ispras.ru
+// CREATION: 26-JAN-1998
+// DESCRIPTION: File Input Stream with lookahead for Scanner.
+// See file BufFileInput.h for details
+
+// Change History:
+//
+// 22-Jun-1998 assert.h -> PCCTS_ASSERT_H
+// string.h -> PCCTS_STRING_H
+//
+// 28-May-1998 Add virtual destructor to release buffer.
+//
+// Add dummy definition for ANTLRTokenType
+// to allow compilation without knowing
+// token type codes.
+//
+// Manfred Kogler (km@cast.uni-linz.ac.at)
+// (1.33MR14)
+//
+// 20-Jul-1998 MR14a - Reorder initialization list for ctor.
+//
+
+enum ANTLRTokenType {TER_HATES_CPP=0, SO_DO_OTHERS=9999 };
+
+#include "pcctscfg.h"
+#include "pccts_assert.h"
+#include "pccts_string.h"
+
+PCCTS_NAMESPACE_STD
+
+#include "BufFileInput.h"
+
+BufFileInput::BufFileInput( FILE *f, int buf_size )
+: input( f ),
+ buf( new int[buf_size] ),
+ size( buf_size ),
+ start( 0 ),
+ len( 0 )
+{
+}
+
+BufFileInput::~BufFileInput()
+{
+ delete [] buf;
+}
+
+int BufFileInput::nextChar( void )
+{
+ if( len > 0 )
+ {
+ // get char from buffer
+ int c = buf[start];
+
+ if( c != EOF )
+ {
+ start++; start %= size;
+ len--;
+ }
+ return c;
+ } else {
+ // get char from file
+ int c = getc( input );
+
+ if( c == EOF )
+ {
+ // if EOF - put it in the buffer as indicator
+ buf[start] = EOF;
+ len++;
+ }
+ return c;
+ }
+}
+
+int BufFileInput::lookahead( char* s )
+{
+ int l = strlen( s );
+
+ assert( 0 < l && l <= size );
+
+ while( len < l )
+ {
+ int c = getc( input );
+
+ buf[ (start+len) % size ] = c;
+
+ len++;
+
+ if( c == EOF ) return 0;
+ }
+
+ for( int i = 0; i < l; i++ )
+ {
+ if( s[i] != buf[ (start+i) % size ] ) return 0;
+ }
+ return 1;
+}
+
+// End of file BufFileInput.cpp
+
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/BufFileInput.h b/BaseTools/Source/C/VfrCompile/Pccts/h/BufFileInput.h new file mode 100644 index 0000000000..ea54c0ee26 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/BufFileInput.h @@ -0,0 +1,53 @@ +// FILE: BufFileInput.h
+// AUTHOR: Alexey Demakov (AVD) demakov@kazbek.ispras.ru
+// CREATION: 26-JAN-1998
+// DESCRIPTION: File Input Stream with lookahead for Scanner
+// Tested under Win32 with ANTLR 1.33 MR10 and MSVC 5.0
+
+// Change History:
+//
+// 28-May-1998 Add virtual destructor to release buffer
+// Manfred Kogler (km@cast.uni-linz.ac.at)
+// (1.33MR14)
+
+#ifndef BufFileInput_h
+#define BufFileInput_h
+
+#include "pcctscfg.h"
+
+#include "pccts_stdio.h"
+
+PCCTS_NAMESPACE_STD
+
+#include "DLexerBase.h"
+
+class DllExportPCCTS BufFileInput : public DLGInputStream
+{
+public:
+ // constructor
+ // f - input stream
+ // buf_size - size of buffer (maximal length for string in is_in)
+
+ BufFileInput(FILE *f, int buf_size = 8 );
+
+ virtual ~BufFileInput();
+
+ // gets next char from stream
+
+ virtual int nextChar( void );
+
+ // looks in stream and compares next l characters with s
+ // returns the result of comparision
+
+ int lookahead( char* s );
+
+private:
+ FILE *input; // input stream;
+ int* buf; // buffer
+ int size; // size of buffer
+ int start; // position of the first symbol in buffer
+ int len; // count of characters in buffers
+};
+
+#endif
+// end of file BufFileInput.h
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/DLG_stream_input.h b/BaseTools/Source/C/VfrCompile/Pccts/h/DLG_stream_input.h new file mode 100644 index 0000000000..d2147f5217 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/DLG_stream_input.h @@ -0,0 +1,98 @@ +
+/************************************************************/
+/* */
+/* Predefined char stream: Input from (c++) stream. */
+/* */
+/* By Hubert Holin (Hubert.Holin@Bigfoot.com), 1998. */
+/* */
+/* This is completely free stuff, do whatever you want with */
+/* it (but then, I will take no responsability for whatever */
+/* may happen if you do either... caveat emptor!). */
+/* */
+/************************************************************/
+
+#ifndef _DLG_STREAM_INPUT_H
+#define _DLG_STREAM_INPUT_H
+
+#include "pccts_istream.h"
+
+PCCTS_NAMESPACE_STD
+
+#ifndef DLGX_H
+#include "DLexerBase.h"
+#endif
+
+
+// NOTES: The semantics of the copy constructor
+// and the affectation operator may be unwaranted...
+// and the stream may not be reset.
+//
+// It would have been so much nicer for nextChar()
+// to throw (of for the DLGInputStream to change status)
+// upon hiting EOF than to return an "int"...
+
+template <
+ class E,
+ class T = ::std::char_traits<E>
+ >
+class DLG_stream_input : public DLGInputStream
+{
+public:
+
+ DLG_stream_input(::std::basic_istream<E,T> * p_input_stream)
+ : input(p_input_stream)
+ {
+ // nothing to do!
+ };
+
+ DLG_stream_input(const DLG_stream_input & a_recopier)
+ : input(a_recopier.input)
+ {
+ // nothing to do!
+ };
+
+ virtual ~DLG_stream_input()
+ {
+ this->purge(); // bloody templarized lookup...
+ };
+
+ DLG_stream_input operator = (const DLG_stream_input & a_affecter)
+ {
+ if (this != &a_affecter)
+ {
+ input = a_affecter.input;
+ }
+
+ return(*this);
+ };
+
+ virtual int nextChar()
+ {
+ E extracted_stuff;
+
+ input->get(extracted_stuff);
+
+ if (*input)
+ {
+ return(int(extracted_stuff));
+ }
+ else
+ {
+ return(EOF);
+ }
+ };
+
+protected:
+
+ ::std::basic_istream<E,T> * input;
+
+private:
+
+ void purge()
+ {
+ // nothing to do!
+ };
+};
+
+#endif /* _DLG_STREAM_INPUT_H */
+
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/DLexer.h b/BaseTools/Source/C/VfrCompile/Pccts/h/DLexer.h new file mode 100644 index 0000000000..37cac24f14 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/DLexer.h @@ -0,0 +1,191 @@ +/* DLexer.h (formerly DLexer.cpp)
+ *
+ * This was renamed because the use of the .cpp extension caused problems
+ * with IDEs.
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+#define ZZINC {if ( track_columns ) (++_endcol);}
+
+#define ZZGETC {ch = input->nextChar(); cl = ZZSHIFT(ch);}
+
+#define ZZNEWSTATE (newstate = dfa[state][cl])
+
+#ifndef ZZCOPY
+#define ZZCOPY \
+ /* Truncate matching buffer to size (not an error) */ \
+ if (nextpos < lastpos){ \
+ *(nextpos++) = ch; \
+ }else{ \
+ bufovf = 1; \
+ }
+#endif
+
+void DLGLexer::
+mode( int m )
+{
+ /* points to base of dfa table */
+ if (m<MAX_MODE){
+ automaton = m;
+ /* have to redo class since using different compression */
+ cl = ZZSHIFT(ch);
+ }else{
+ sprintf((char *)ebuf,"Invalid automaton mode = %d ",m);
+ errstd(ebuf);
+ }
+}
+
+ANTLRTokenType DLGLexer::
+nextTokenType(void)
+{
+ register int state, newstate;
+ /* last space reserved for the null char */
+ register DLGChar *lastpos;
+ ANTLRTokenType tk;
+
+skip:
+ bufovf = 0;
+ lastpos = &_lextext[_bufsize-1];
+ nextpos = _lextext;
+ _begcol = _endcol+1;
+more:
+ _begexpr = nextpos;
+ if ( interactive ) {
+ /* interactive version of automaton */
+ /* if there is something in ch, process it */
+ state = newstate = dfa_base[automaton];
+ if (charfull){
+ ZZINC;
+ ZZCOPY;
+ ZZNEWSTATE;
+ }
+ while (alternatives[newstate]){
+ state = newstate;
+ ZZGETC;
+ ZZINC;
+ ZZCOPY;
+ ZZNEWSTATE;
+ }
+ /* figure out if last character really part of token */
+ if ((state != dfa_base[automaton]) && (newstate == DfaStates)){
+ charfull = 1;
+ --nextpos;
+ }else{
+ charfull = 0;
+ state = newstate;
+ }
+ *(nextpos) = '\0';
+ /* Able to transition out of start state to some non err state?*/
+ if ( state == dfa_base[automaton] ){
+ /* make sure doesn't get stuck */
+ advance();
+ }
+ }
+ else { /* non-interactive version of automaton */
+ if (!charfull)
+ advance();
+ else
+ ZZINC;
+ state = dfa_base[automaton];
+ while (ZZNEWSTATE != DfaStates) {
+ state = newstate;
+ ZZCOPY;
+ ZZGETC;
+ ZZINC;
+ }
+ charfull = 1;
+ if ( state == dfa_base[automaton] ){
+ if (nextpos < lastpos){
+ *(nextpos++) = ch;
+ }else{
+ bufovf = 1;
+ }
+ *nextpos = '\0';
+ /* make sure doesn't get stuck */
+ advance();
+ }else{
+ *nextpos = '\0';
+ }
+ }
+ if ( track_columns ) _endcol -= charfull;
+ _endexpr = nextpos -1;
+ add_erase = 0;
+#ifdef OLD
+ tk = (ANTLRTokenType)
+ (*actions[accepts[state]])(this); // must pass this manually
+ // actions is not a [] of pointers
+ // to member functions.
+#endif
+ tk = (this->*actions[accepts[state]])();
+
+// MR1
+// MR1 11-Apr-97 Help for tracking DLG results
+// MR1
+
+#ifdef DEBUG_LEXER
+
+/* MR1 */ if (debugLexerFlag) {
+/* MR1 */ if (parser != NULL) {
+/* MR1 */ /* MR23 */ printMessage(stdout, "\ntoken name=%s",parser->parserTokenName(tk));
+/* MR1 */ } else {
+/* MR1 */ /* MR23 */ printMessage(stdout, "\ntoken nnumber=%d",tk);
+/* MR1 */ };
+/* MR1 */ /* MR23 */ printMessage(stdout, " lextext=(%s) mode=%d",
+/* MR1 */ (_lextext[0]=='\n' && _lextext[1]==0) ?
+/* MR1 */ "newline" : _lextext,
+/* MR1 */ automaton);
+/* MR1 */ if (interactive && !charfull) {
+/* MR1 */ /* MR23 */ printMessage(stdout, " char=empty");
+/* MR1 */ } else {
+/* MR1 */ if (ch=='\n') {
+/* MR1 */ /* MR23 */ printMessage(stdout, " char=newline");
+/* MR1 */ } else {
+/* MR1 */ /* MR23 */ printMessage(stdout, " char=(%c)",ch);
+/* MR1 */ };
+/* MR1 */ };
+/* MR1 */ /* MR23 */ printMessage(stdout, " %s\n",
+/* MR1 */ (add_erase==1 ? "skip()" :
+/* MR1 */ add_erase==2 ? "more()" :
+/* MR1 */ ""));
+/* MR1 */ };
+
+#endif
+
+ switch (add_erase) {
+ case 1: goto skip;
+ case 2: goto more;
+ }
+ return tk;
+}
+
+void DLGLexer::
+advance()
+{
+ if ( input==NULL ) err_in();
+ ZZGETC; charfull = 1; ZZINC;
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/DLexerBase.cpp b/BaseTools/Source/C/VfrCompile/Pccts/h/DLexerBase.cpp new file mode 100644 index 0000000000..b218afc038 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/DLexerBase.cpp @@ -0,0 +1,302 @@ +/* DLGLexerBase.c
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+#include "pcctscfg.h"
+
+#include "pccts_stdio.h"
+#include "pccts_stdlib.h"
+
+PCCTS_NAMESPACE_STD
+
+/* I have to put this here due to C++ limitation
+ * that you can't have a 'forward' decl for enums.
+ * I hate C++!!!!!!!!!!!!!!!
+ */
+
+// MR1
+// MR1 10-Apr-97 133MR1 Prevent use of varying sizes for the
+// MR1 ANTLRTokenType enum
+// MR1
+
+enum ANTLRTokenType { TER_HATES_CPP=0, ITS_UTTER_GARBAGE, // MR1
+ WITH_SOME_GOOD_IDEAS=9999}; // MR1
+
+#define ANTLR_SUPPORT_CODE
+
+#include "pcctscfg.h"
+#include DLEXERBASE_H
+#include APARSER_H // MR23
+
+DLGLexerBase::
+DLGLexerBase(DLGInputStream *in,
+ unsigned bufsize,
+ int _interactive,
+ int _track_columns)
+{
+ this->_bufsize = bufsize;
+ this->_lextext = new DLGChar[_bufsize];
+ if ( this->_lextext==NULL ) {
+ panic("text buffer is NULL");
+ }
+ this->_begexpr = this->_endexpr = NULL;
+ this->ch = this->bufovf = 0;
+ this->nextpos = NULL;
+ this->cl = 0;
+ this->add_erase = 0;
+ this->input = in;
+ this->_begcol = 0;
+ this->_endcol = 0;
+ this->_line = 1;
+ this->charfull = 0;
+ this->automaton = 0;
+ this->token_to_fill = NULL;
+ this->interactive = _interactive;
+ this->track_columns = _track_columns;
+ this->debugLexerFlag = 0; // MR1
+ this->parser = NULL; // MR1
+ this->lexErrCount=0; // MR11
+}
+
+// MR19 THM
+
+void DLGLexerBase::reset()
+{
+ this->charfull = 0;
+ this->_begcol = 0;
+ this->_endcol = 0;
+ this->automaton = 0;
+ this->_line=1;
+ this->lexErrCount=0;
+}
+
+void DLGLexerBase::
+setInputStream( DLGInputStream *in )
+{
+ this->input = in;
+ _line = 1;
+ charfull = 0;
+}
+
+/* saves dlg state, but not what feeds dlg (such as file position) */
+void DLGLexerBase::
+saveState(DLGState *state)
+{
+ state->input = input;
+ state->interactive = interactive;
+ state->track_columns = track_columns;
+ state->auto_num = automaton;
+ state->add_erase = add_erase;
+ state->lookc = ch;
+ state->char_full = charfull;
+ state->begcol = _begcol;
+ state->endcol = _endcol;
+ state->line = _line;
+ state->lextext = _lextext;
+ state->begexpr = _begexpr;
+ state->endexpr = _endexpr;
+ state->bufsize = _bufsize;
+ state->bufovf = bufovf;
+ state->nextpos = nextpos;
+ state->class_num = cl;
+ state->debugLexerFlag = debugLexerFlag; // MR1
+ state->parser = parser; // MR1
+}
+
+void DLGLexerBase::
+restoreState(DLGState *state)
+{
+ input = state->input;
+ interactive = state->interactive;
+ track_columns = state->track_columns;
+ automaton = state->auto_num;
+ add_erase = state->add_erase;
+ ch = state->lookc;
+ charfull = state->char_full;
+ _begcol = state->begcol;
+ _endcol = state->endcol;
+ _line = state->line;
+ _lextext = state->lextext;
+ _begexpr = state->begexpr;
+ _endexpr = state->endexpr;
+ _bufsize = state->bufsize;
+ bufovf = state->bufovf;
+ nextpos = state->nextpos;
+ cl = state->class_num;
+ debugLexerFlag = state->debugLexerFlag; // MR1
+ parser = state->parser; // MR1
+}
+
+/* erase what is currently in the buffer, and get a new reg. expr */
+void DLGLexerBase::
+skip()
+{
+ add_erase = 1;
+}
+
+/* don't erase what is in the lextext buffer, add on to it */
+void DLGLexerBase::
+more()
+{
+ add_erase = 2;
+}
+
+/* substitute c for the reg. expr last matched and is in the buffer */
+void DLGLexerBase::
+replchar(DLGChar c)
+{
+ /* can't allow overwriting null at end of string */
+ if (_begexpr < &_lextext[_bufsize-1]){
+ *_begexpr = c;
+ *(_begexpr+1) = '\0';
+ }
+ _endexpr = _begexpr;
+ if (c != '\0') {
+ nextpos = _begexpr + 1;
+ }
+ else {
+ nextpos = _begexpr; /* MR30 Zero terminates string. */
+ }
+}
+
+/* replace the string s for the reg. expr last matched and in the buffer */
+
+#ifdef _MSC_VER // MR23
+//Turn off "assignment within conditional expression" warning
+#pragma warning(disable : 4706)
+#endif
+void DLGLexerBase::
+replstr(const DLGChar *s) /* MR20 const */
+{
+ register DLGChar *l= &_lextext[_bufsize -1];
+
+ nextpos = _begexpr;
+ if (s){
+ while ((nextpos <= l) && (*(nextpos++) = *(s++))){
+ /* empty */
+ }
+ /* correct for NULL at end of string */
+ nextpos--;
+ }
+ if ((nextpos <= l) && (*(--s) == 0)){
+ bufovf = 0;
+ }else{
+ bufovf = 1;
+ }
+ *(nextpos) = '\0';
+ _endexpr = nextpos - 1;
+}
+#ifdef _MSC_VER // MR23
+#pragma warning(default: 4706)
+#endif
+
+void DLGLexerBase::
+errstd(const char *s) /* MR20 const */
+{
+ lexErrCount++; /* MR11 */
+ /* MR23 */ printMessage(stderr,
+ "%s near line %d (text was '%s')\n",
+ ((s == NULL) ? "Lexical error" : s),
+ _line,_lextext);
+}
+
+int DLGLexerBase::
+err_in()
+{
+ /* MR23 */ printMessage(stderr,"No input stream, function, or string\n");
+ /* return eof to get out gracefully */
+ return EOF;
+}
+
+ANTLRTokenType DLGLexerBase::
+erraction()
+{
+ errstd("invalid token");
+ advance();
+ skip();
+ return (ANTLRTokenType) 0; // bogus, but satisfies compiler
+}
+
+_ANTLRTokenPtr DLGLexerBase::
+getToken()
+{
+ if ( token_to_fill==NULL ) panic("NULL token_to_fill");
+ ANTLRTokenType tt = nextTokenType();
+ _ANTLRTokenPtr tk = token_to_fill->makeToken(tt, _lextext,_line);
+ return tk;
+}
+
+void DLGLexerBase::
+panic(const char *msg) /* MR20 const */
+{
+ if (parser) //MR23
+ parser->panic(msg); //MR23
+ else //MR23
+ {
+ /* MR23 */ printMessage(stderr, "DLG panic: %s\n", msg);
+ //
+ // 7-Apr-97 133MR1
+ //
+ exit(PCCTS_EXIT_FAILURE); // MR1
+ }
+}
+
+ANTLRParser * DLGLexerBase:: // MR1
+setParser(ANTLRParser *p) { // MR1
+ ANTLRParser *oldValue=parser; // MR1
+ parser=p; // MR1
+ return oldValue; // MR1
+} // MR1
+ // MR1
+ANTLRParser * DLGLexerBase:: // MR1
+getParser() { // MR1
+ return parser; // MR1
+} // MR1
+ // MR1
+int DLGLexerBase:: // MR1
+debugLexer(int newValue) { // MR1
+ int oldValue=debugLexerFlag; // MR1
+ debugLexerFlag=newValue; // MR1
+ return oldValue; // MR1
+} // MR1
+
+//MR23
+int DLGLexerBase::printMessage(FILE* pFile, const char* pFormat, ...)
+{
+ va_list marker;
+ va_start( marker, pFormat );
+
+ int iRet = 0;
+ if (parser)
+ parser->printMessageV(pFile, pFormat, marker);
+ else
+ iRet = vfprintf(pFile, pFormat, marker);
+
+ va_end( marker );
+ return iRet;
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/DLexerBase.h b/BaseTools/Source/C/VfrCompile/Pccts/h/DLexerBase.h new file mode 100644 index 0000000000..db6cc1890c --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/DLexerBase.h @@ -0,0 +1,198 @@ +/* DLGLexerBase.h
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+#ifndef DLGX_H
+#define DLGX_H
+
+#include "pcctscfg.h"
+#include "pccts_stdio.h"
+
+PCCTS_NAMESPACE_STD
+
+#include ATOKEN_H
+#include ATOKENSTREAM_H
+
+class ANTLRParser; // MR1
+
+/* must define what a char looks like; can make this a class too */
+typedef char DLGChar;
+
+/* Can have it as a class too: (ack this looks weird; is it right?)
+class DllExportPCCTS DLGChar {
+private:
+ int c;
+public:
+ DLGChar(int ch) { c = ch; }
+ int atom() { return c; }
+};
+*/
+
+/* user must subclass this */
+class DllExportPCCTS DLGInputStream {
+public:
+ virtual int nextChar() = 0;
+};
+
+/* Predefined char stream: Input from FILE */
+class DllExportPCCTS DLGFileInput : public DLGInputStream {
+private:
+ int found_eof;
+ FILE *input;
+public:
+ DLGFileInput(FILE *f) { input = f; found_eof = 0; }
+ int nextChar() {
+ int c;
+ if ( found_eof ) return EOF;
+ else {
+ c=getc(input);
+ if ( c==EOF ) found_eof = 1;
+ return c;
+ }
+ }
+ void DLGFileReset(FILE *f) {input=f; found_eof = 0; }; // MR11
+};
+
+// MR9 Suggested by Bruce Guenter (bruceg@qcc.sk.ca)
+// MR9 Make DLGStringInput const correct
+
+/* Predefined char stream: Input from string */
+class DllExportPCCTS DLGStringInput : public DLGInputStream {
+private:
+ const DLGChar *input; // MR9
+ const DLGChar *p; // MR9
+public:
+ DLGStringInput(const DLGChar *s) { input = s; p = &input[0];} // MR9
+ int nextChar()
+ {
+ if (*p) return (int) (unsigned char) *p++; // MR14
+ else return EOF;
+ }
+
+ void DLGStringReset(const DLGChar *s) {input=s; p= &input[0]; }; // MR11 // MR16
+};
+
+class DllExportPCCTS DLGState {
+public:
+ DLGInputStream *input;
+ int interactive;
+ int track_columns;
+ int auto_num;
+ int add_erase;
+ int lookc;
+ int char_full;
+ int begcol, endcol;
+ int line;
+ DLGChar *lextext, *begexpr, *endexpr;
+ int bufsize;
+ int bufovf;
+ DLGChar *nextpos;
+ int class_num;
+ int debugLexerFlag; // MR1
+ ANTLRParser *parser; // MR1
+};
+
+/* user must subclass this */
+class DllExportPCCTS DLGLexerBase : public ANTLRTokenStream {
+public:
+ virtual ANTLRTokenType erraction();
+
+protected:
+ DLGInputStream *input;
+ int interactive;
+ int track_columns;
+ DLGChar *_lextext; /* text of most recently matched token */
+ DLGChar *_begexpr; /* beginning of last reg expr recogn. */
+ DLGChar *_endexpr; /* beginning of last reg expr recogn. */
+ int _bufsize; /* number of characters in lextext */
+ int _begcol; /* column that first character of token is in*/
+ int _endcol; /* column that last character of token is in */
+ int _line; /* line current token is on */
+ int ch; /* character to determine next state */
+ int bufovf; /* indicates that buffer too small for text */
+ int charfull;
+ DLGChar *nextpos; /* points to next available position in lextext*/
+ int cl;
+ int automaton;
+ int add_erase;
+ DLGChar ebuf[70];
+ _ANTLRTokenPtr token_to_fill;
+
+ int debugLexerFlag; // MR1
+ ANTLRParser *parser; // MR1
+public:
+ virtual _ANTLRTokenPtr getToken(); // MR12 public
+ virtual void advance(void) = 0;
+ void skip(void); /* erase lextext, look for antoher token */
+ void more(void); /* keep lextext, look for another token */
+ void mode(int k); /* switch to automaton 'k' */
+ void saveState(DLGState *);
+ void restoreState(DLGState *);
+ virtual ANTLRTokenType nextTokenType(void)=0;/* get next token */
+ void replchar(DLGChar c); /* replace last recognized reg. expr. with
+ a character */
+ void replstr(const DLGChar *s); /* replace last recognized reg. expr. with
+ a string */ /* MR20 const */
+ virtual int err_in(); // MR1
+ virtual void errstd(const char *); // MR1 MR20 const
+ int line() { return _line; }
+ void set_line(int newValue) { _line=newValue; }; // MR1
+ virtual void newline() { _line++; }
+ DLGChar *lextext() { return _lextext; }
+
+ int begcol() { return _begcol; }
+ int endcol() { return _endcol; }
+ void set_begcol(int a) { _begcol=a; }
+ void set_endcol(int a) { _endcol=a; }
+ DLGChar *begexpr() { return _begexpr; }
+ DLGChar *endexpr() { return _endexpr; }
+ int bufsize() { return _bufsize; }
+
+ void setToken(ANTLRAbstractToken *t) { token_to_fill = t; }
+
+ void setInputStream(DLGInputStream *);
+ DLGLexerBase(DLGInputStream *in,
+ unsigned bufsize=2000,
+ int interactive=0,
+ int track_columns=0);
+ void reset(); // MR19
+ virtual ~DLGLexerBase() { delete [] _lextext; }
+ virtual void panic(const char *msg); // MR1 MR20 const
+ void trackColumns() {
+ track_columns = 1;
+ this->_begcol = 0;
+ this->_endcol = 0;
+ };
+ virtual ANTLRParser *setParser(ANTLRParser *p); // MR1
+ virtual ANTLRParser *getParser(); // MR1
+ virtual int debugLexer(int value); // MR1
+ int lexErrCount; // MR12
+ virtual int printMessage(FILE* pFile, const char* pFormat, ...); // MR23
+};
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/PBlackBox.h b/BaseTools/Source/C/VfrCompile/Pccts/h/PBlackBox.h new file mode 100644 index 0000000000..d25b8d6939 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/PBlackBox.h @@ -0,0 +1,134 @@ +#ifndef PBLACKBOX_H
+#define PBLACKBOX_H
+
+/*
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+/* Completely rewritten by Chris Uzdavinis (chris@atdesk.com) for MR23 */
+
+#include "pcctscfg.h"
+
+#include "pccts_iostream.h"
+
+PCCTS_NAMESPACE_STD
+
+// MR20 Added #include for "DLexerBase.h"
+
+#include "DLexerBase.h"
+
+//
+// The default buffer size of the lexer is given by the
+// second argument of the lexer's ctor. It is optional
+// and defaults to 2000
+//
+
+template<class Lexer, class Parser, class Token>
+class DllExportPCCTS ParserBlackBox {
+private:
+ // no copy construction allowed
+ ParserBlackBox(ParserBlackBox const &);
+
+ // no copy assignment allowed
+ ParserBlackBox & operator=(ParserBlackBox const &);
+
+protected:
+ DLGFileInput *in;
+ Lexer *scan;
+ _ANTLRTokenPtr tok;
+ ANTLRTokenBuffer *pipe;
+ Parser *_parser;
+ FILE *file;
+ int openByBlackBox; /* MR21 Don't close what we haven't opened */
+public:
+
+ ParserBlackBox(FILE *f)
+ : in(0)
+ , scan(0)
+ , tok(0)
+ , pipe(0)
+ , _parser(0)
+ , file(0)
+ , openByBlackBox(0)
+ {
+ if (f == NULL)
+ {
+ cerr << "invalid file pointer\n";
+ }
+ else
+ {
+ openByBlackBox = 0; /* MR21a */
+ file = f;
+ in = new DLGFileInput(f);
+ scan = new Lexer(in);
+ pipe = new ANTLRTokenBuffer(scan);
+ tok = new Token;
+ scan->setToken(tok);
+ _parser = new Parser(pipe);
+ _parser->init();
+ }
+ }
+ ParserBlackBox(char *fname)
+ : in(0)
+ , scan(0)
+ , tok(0)
+ , pipe(0)
+ , _parser(0)
+ , file(0)
+ , openByBlackBox(0)
+ {
+ FILE *f = fopen(fname, "r");
+ if ( f==NULL ) {
+ openByBlackBox = 0;
+ cerr << "cannot open " << fname << "\n"; return;
+ }
+ else {
+ openByBlackBox = 1;
+ file = f;
+ in = new DLGFileInput(f);
+ scan = new Lexer(in);
+ pipe = new ANTLRTokenBuffer(scan);
+ tok = new Token;
+ scan->setToken(tok);
+ _parser = new Parser(pipe);
+ _parser->init();
+ }
+ }
+
+ ~ParserBlackBox()
+ {
+ delete in; delete scan; delete pipe; delete _parser; delete tok;
+ if (1 == openByBlackBox) {
+ fclose(file);
+ }
+ }
+
+ Parser *parser() { return _parser; }
+ Lexer *getLexer() { return scan; }
+};
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/PCCTSAST.cpp b/BaseTools/Source/C/VfrCompile/Pccts/h/PCCTSAST.cpp new file mode 100644 index 0000000000..a8249cdac0 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/PCCTSAST.cpp @@ -0,0 +1,684 @@ +/*
+ * PCCTSAST.C
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to SORCERER -- SORCERER is in the public
+ * domain. An individual or company may do whatever they wish with
+ * source code distributed with SORCERER or the code generated by
+ * SORCERER, including the incorporation of SORCERER, or its output, into
+ * commerical software.
+ *
+ * We encourage users to develop software with SORCERER. However, we do
+ * ask that credit is given to us for developing SORCERER. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like SORCERER and have developed a nice tool with the
+ * output, please mention that you developed it using SORCERER. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * SORCERER 1.00B14 and ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * AHPCRC, University of Minnesota
+ * 1992-2000
+ */
+
+#define ANTLR_SUPPORT_CODE
+
+#include "pcctscfg.h"
+
+#include "PCCTSAST.h"
+#include "pccts_stdarg.h"
+
+PCCTS_NAMESPACE_STD
+
+#include <ctype.h>
+
+//#include "SList.h"
+
+ /* String Scanning/Parsing Stuff */
+
+const char *PCCTS_AST::scan_token_tbl[] = { /* MR20 const */
+ "invalid", /* 0 */
+ "LPAREN", /* 1 */
+ "RPAREN", /* 2 */
+ "PERCENT", /* 3 */
+ "INT", /* 4 */
+ "COLON", /* 5 */
+ "POUND", /* 6 */
+ "PERIOD", /* 7 */
+};
+
+void PCCTS_AST::
+addChild(PCCTS_AST *t)
+{
+ if ( t==NULL ) return;
+ PCCTS_AST *s = down();
+ if ( s!=NULL )
+ {
+ while ( s->right()!=NULL ) s = s->right();
+ s->setRight(t);
+ }
+ else
+ this->setDown(t);
+}
+
+void PCCTS_AST::
+lisp(FILE *f)
+{
+ if ( down() != NULL ) /* MR23 */ printMessage(f," (");
+ lisp_action(f);
+ if ( down()!=NULL ) down()->lisp(f);
+ if ( down() != NULL ) /* MR23 */ printMessage(f," )");
+ if ( right()!=NULL ) right()->lisp(f);
+}
+
+/* build a tree (root child1 child2 ... NULL)
+ * If root is NULL, simply make the children siblings and return ptr
+ * to 1st sibling (child1). If root is not single node, return NULL.
+ *
+ * Siblings that are actually sibling lists themselves are handled
+ * correctly. For example #( NULL, #( NULL, A, B, C), D) results
+ * in the tree ( NULL A B C D ).
+ *
+ * Requires at least two parameters with the last one being NULL. If
+ * both are NULL, return NULL.
+ *
+ * The down() and right() down/right pointers are used to make the tree.
+ */
+PCCTS_AST *PCCTS_AST::
+make(PCCTS_AST *rt, ...)
+{
+ va_list ap;
+ register PCCTS_AST *child, *sibling=NULL, *tail=NULL /*MR23*/, *w;
+ PCCTS_AST *root;
+
+ va_start(ap, rt);
+ root = rt;
+
+ if ( root != NULL )
+ if ( root->down() != NULL ) return NULL;
+ child = va_arg(ap, PCCTS_AST *);
+ while ( child != NULL )
+ {
+ /* find end of child */
+ for (w=child; w->right()!=NULL; w=w->right()) {;}
+ if ( sibling == NULL ) {sibling = child; tail = w;}
+ else {tail->setRight(child); tail = w;}
+ child = va_arg(ap, PCCTS_AST *);
+ }
+ if ( root==NULL ) root = sibling;
+ else root->setDown(sibling);
+ va_end(ap);
+ return root;
+}
+
+/* The following push and pop routines are only used by ast_find_all() */
+
+void PCCTS_AST::
+_push(PCCTS_AST **st, int *sp, PCCTS_AST *e)
+{
+ (*sp)--;
+ require((*sp)>=0, "stack overflow");
+ st[(*sp)] = e;
+}
+
+PCCTS_AST *PCCTS_AST::
+_pop(PCCTS_AST **st, int *sp)
+{
+ PCCTS_AST *e = st[*sp];
+ (*sp)++;
+ require((*sp)<=MaxTreeStackDepth, "stack underflow");
+ return e;
+}
+
+/* Find all occurrences of u in t.
+ * 'cursor' must be initialized to 't'. It eventually
+ * returns NULL when no more occurrences of 'u' are found.
+ */
+PCCTS_AST *PCCTS_AST::
+ast_find_all(PCCTS_AST *u, PCCTS_AST **cursor)
+{
+ PCCTS_AST *sib;
+ /*** static ***/ PCCTS_AST *template_stack[MaxTreeStackDepth]; /* MR23 Remove "static" */
+ /*** static ***/ int tsp = MaxTreeStackDepth; /* MR23 Remove "static" */
+
+////static int nesting = 0; /* MR23 Not referenced */
+
+ if ( *cursor == NULL ) return NULL;
+ if ( *cursor!=this ) sib = *cursor;
+ else {
+ /* else, first time--start at top of template 't' */
+ tsp = MaxTreeStackDepth;
+ sib = this;
+ /* bottom of stack is always a NULL--"cookie" indicates "done" */
+ _push(template_stack, &tsp, NULL);
+ }
+
+keep_looking:
+ if ( sib==NULL ) /* hit end of sibling list */
+ {
+ sib = _pop(template_stack, &tsp);
+ if ( sib == NULL ) { *cursor = NULL; return NULL; }
+ }
+
+ if ( sib->type() != u->type() )
+ {
+ /* look for another match */
+ if ( sib->down()!=NULL )
+ {
+ if ( sib->right()!=NULL ) _push(template_stack, &tsp, sib->right());
+ sib=sib->down();
+ goto keep_looking;
+ }
+ /* nothing below to try, try next sibling */
+ sib=sib->right();
+ goto keep_looking;
+ }
+
+ /* found a matching root node, try to match what's below */
+ if ( match_partial(sib, u) )
+ {
+ /* record sibling cursor so we can pick up next from there */
+ if ( sib->down()!=NULL )
+ {
+ if ( sib->right()!=NULL ) _push(template_stack, &tsp, sib->right());
+ *cursor = sib->down();
+ }
+ else if ( sib->right()!=NULL ) *cursor = sib->right();
+ else *cursor = _pop(template_stack, &tsp);
+ return sib;
+ }
+
+ /* no match, keep searching */
+ if ( sib->down()!=NULL )
+ {
+ if ( sib->right()!=NULL ) _push(template_stack, &tsp, sib->right());
+ sib=sib->down();
+ }
+ else sib = sib->right(); /* else, try to right if zip below */
+ goto keep_looking;
+}
+
+/* are two trees exactly alike? */
+int PCCTS_AST::
+match(PCCTS_AST *u)
+{
+ PCCTS_AST *t = this;
+ PCCTS_AST *sib;
+
+ if ( u==NULL ) return 0;
+
+ for (sib=t; sib!=NULL&&u!=NULL; sib=sib->right(), u=u->right())
+ {
+ if ( sib->type() != u->type() ) return 0;
+ if ( sib->down()!=NULL )
+ if ( !sib->down()->match(u->down()) ) return 0;
+ }
+ return 1;
+}
+
+/* Is 'u' a subtree of 't' beginning at the root? */
+int PCCTS_AST::
+match_partial(PCCTS_AST *t, PCCTS_AST *u)
+{
+ PCCTS_AST *sib;
+
+ if ( u==NULL ) return 1;
+ if ( t==NULL ) return 0; /* MR23 removed unreachable code */
+
+ for (sib=t; sib!=NULL&&u!=NULL; sib=sib->right(), u=u->right())
+ {
+ if ( sib->type() != u->type() ) return 0;
+ if ( sib->down()!=NULL )
+ if ( !match_partial(sib->down(), u->down()) ) return 0;
+ }
+ return 1;
+}
+
+#ifdef _MSC_VER // MR23
+//Turn off "unreachable code" warning
+#pragma warning(disable : 4702)
+#endif
+/* Walk the template tree 't' (matching against 'this'), filling in the
+ * 'labels' array, and setting 'n' according to how many labels were matched.
+ */
+int PCCTS_AST::
+scanmatch(ScanAST *t, PCCTS_AST **labels[], int *n)
+{
+ ScanAST *sib;
+ PCCTS_AST *u = this;
+
+ if ( u==NULL ) return 0;
+
+ for (sib=t; sib!=NULL&&u!=NULL; sib=sib->right(), u=u->right())
+ {
+ /* make sure tokens match; token of '0' means wildcard match */
+ if ( sib->type() != u->type() && sib->type()!=0 ) return 0;
+ /* we have a matched token here; set label pointers if exists */
+ if ( sib->label_num>0 )
+ {
+ require(labels!=NULL, "label found in template, but no array of labels");
+ (*n)++;
+ *(labels[sib->label_num-1]) = u;
+ }
+ /* match what's below if something there and current node is not wildcard */
+ if ( sib->down()!=NULL && sib->type()!=0 )
+ {
+ if ( sib->down()==NULL )
+ {
+ if ( u->down()!=NULL )
+ return 0;
+ else
+ return 1;
+ }
+ if ( !u->down()->scanmatch(sib->down(), labels, n) ) return 0;
+ }
+ }
+ return 1;
+}
+#ifdef _MSC_VER // MR23
+#pragma warning(default : 4702)
+#endif
+
+void PCCTS_AST::
+insert_after(PCCTS_AST *b)
+{
+ PCCTS_AST *end;
+ if ( b==NULL ) return;
+ /* find end of b's child list */
+ for (end=b; end->right()!=NULL; end=end->right()) {;}
+ end->setRight(this->right());
+ this->setRight(b);
+}
+
+void PCCTS_AST::
+append(PCCTS_AST *b)
+{
+ PCCTS_AST *end;
+ require(b!=NULL, "append: NULL input tree");
+ /* find end of child list */
+ for (end=this; end->right()!=NULL; end=end->right()) {;}
+ end->setRight(b);
+}
+
+PCCTS_AST *PCCTS_AST::
+tail()
+{
+ PCCTS_AST *end;
+ /* find end of child list */
+ for (end=this; end->right()!=NULL; end=end->right()) {;}
+ return end;
+}
+
+PCCTS_AST *PCCTS_AST::
+bottom()
+{
+ PCCTS_AST *end;
+ /* find end of child list */
+ for (end=this; end->down()!=NULL; end=end->down()) {;}
+ return end;
+}
+
+PCCTS_AST *PCCTS_AST::
+cut_between(PCCTS_AST *a, PCCTS_AST *b)
+{
+ PCCTS_AST *end, *ret;
+ if (a==NULL||b==NULL) return NULL;
+ /* find node pointing to b */
+ for (end=a; end->right()!=NULL&&end->right()!=b; end=end->right())
+ {;}
+ if (end->right()==NULL) return NULL; //ast_cut_between: a,b not connected
+ end->setRight(NULL); /* don't want it point to 'b' anymore */
+ ret = a->right();
+ a->setRight(b);
+ return ret;
+}
+
+#ifdef NOT_YET
+SList *PCCTS_AST::
+to_slist()
+{
+ SList *list = new SList;
+ PCCTS_AST *p;
+
+ for (p=this; p!=NULL; p=p->right())
+ {
+ list->add(p);
+ }
+ return list;
+}
+#endif
+
+void PCCTS_AST::
+tfree()
+{
+ PCCTS_AST *t = this;
+ if ( t->down()!=NULL ) t->down()->tfree();
+ if ( t->right()!=NULL ) t->right()->tfree();
+ delete t;
+}
+
+int PCCTS_AST::
+nsiblings()
+{
+ PCCTS_AST *t = this;
+ int n=0;
+
+ while ( t!=NULL )
+ {
+ n++;
+ t = t->right();
+ }
+ return n;
+}
+
+PCCTS_AST *PCCTS_AST::
+sibling_index(int i)
+{
+ PCCTS_AST *t = this;
+ int j=1;
+ require(i>0, "sibling_index: i<=0");
+
+ while ( t!=NULL )
+ {
+ if ( j==i ) return t;
+ j++;
+ t = t->right();
+ }
+ return NULL;
+}
+
+/* Assume this is a root node of a tree--
+ * duplicate that node and what's below; ignore siblings of root node.
+ */
+
+// MR9 23-Sep-97 RJV
+// MR9
+// MR9 RJV: Original version only duplicated the node and down elements.
+// MR9 Made copies of the pointers to sibling.
+// MR9 Changed call "down()->deepCopy()" to "down()->deepCopyBushy()"
+// MR9
+
+PCCTS_AST *PCCTS_AST::
+deepCopy()
+{
+ PCCTS_AST *u = this->shallowCopy();
+ if ( down()!=NULL ) u->setDown(down()->deepCopyBushy());
+ u->setRight(NULL);
+ return u;
+}
+
+/* Copy all nodes including siblings of root. */
+PCCTS_AST *PCCTS_AST::
+deepCopyBushy()
+{
+ PCCTS_AST *u = this->shallowCopy();
+ /* copy the rest of the tree */
+ if ( down()!=NULL ) u->setDown(down()->deepCopyBushy());
+ if ( right()!=NULL ) u->setRight(right()->deepCopyBushy());
+ return u;
+}
+
+void PCCTS_AST::
+scanast_free(ScanAST *t)
+{
+ if ( t == NULL ) return;
+ scanast_free( t->down() );
+ scanast_free( t->right() );
+ free( (char *) t ); // MR1
+}
+
+/*
+ * scan
+ *
+ * This function is like scanf(): it attempts to match a template
+ * against an input tree. A variable number of tree pointers
+ * may be set according to the '%i' labels in the template string.
+ * For example:
+ *
+ * t->ast_scan("#( 6 #(5 %1:4 %2:3) #(1 %3:3 %4:3) )",
+ * &w, &x, &y, &z);
+ *
+ * Naturally, you'd want this converted from
+ *
+ * t->ast_scan("#( RangeOp #(Minus %1:IConst %2:Var) #(Plus %3:Var %4Var) )",
+ * &w, &x, &y, &z);
+ *
+ * by SORCERER.
+ *
+ * This function call must be done withing a SORCERER file because SORCERER
+ * must convert the token references to the associated token number.
+ *
+ * This functions parses the template and creates trees which are then
+ * matched against the input tree. The labels are set as they are
+ * encountered; hence, partial matches may leave some pointers set
+ * and some NULL. This routines initializes all argument pointers to NULL
+ * at the beginning.
+ *
+ * This function returns the number of labels matched.
+ */
+int PCCTS_AST::
+ast_scan(char *templ, ...)
+{
+ va_list ap;
+ ScanAST *tmpl;
+ int n, i, found=0;
+ PCCTS_AST ***label_ptrs=NULL;
+
+ va_start(ap, templ);
+
+ /* make a ScanAST tree out of the template */
+ tmpl = stringparser_parse_scanast(templ, &n);
+
+ /* make an array out of the labels */
+ if ( n>0 )
+ {
+ label_ptrs = (PCCTS_AST ***) calloc(n, sizeof(PCCTS_AST **));
+ require(label_ptrs!=NULL, "scan: out of memory");
+ for (i=1; i<=n; i++)
+ {
+ label_ptrs[i-1] = va_arg(ap, PCCTS_AST **);
+ *(label_ptrs[i-1]) = NULL;
+ }
+ }
+
+ /* match the input tree against the template */
+ scanmatch(tmpl, label_ptrs, &found);
+
+ scanast_free(tmpl);
+ free( (char *) label_ptrs); // MR1
+
+ return found;
+}
+
+ScanAST *PCCTS_AST::
+new_scanast(int tok)
+{
+ ScanAST *p = (ScanAST *) calloc(1, sizeof(ScanAST));
+//
+// 7-Apr-97 133MR1
+//
+ if ( p == NULL )
+ panic("out of memory\n"); // MR23
+ p->_token = tok;
+ return p;
+}
+
+ScanAST *PCCTS_AST::
+stringparser_parse_scanast(char *templ, int *num_labels)
+{
+ StringLexer lex;
+ StringParser parser;
+ ScanAST *t;
+
+ stringlexer_init(&lex, templ);
+ stringparser_init(&parser, &lex);
+ t = stringparser_parse_tree(&parser);
+ *num_labels = parser.num_labels;
+ return t;
+}
+
+void PCCTS_AST::
+stringparser_match(StringParser *parser, int token)
+{
+ if ( parser->token != token ) panic("bad tree in scan()");
+}
+
+/*
+ * Match a tree of the form:
+ * (root child1 child2 ... childn)
+ * or,
+ * node
+ *
+ * where the elements are integers or labeled integers.
+ */
+ScanAST *PCCTS_AST::
+stringparser_parse_tree(StringParser *parser)
+{
+ ScanAST *t=NULL, *root, *child, *last=NULL /*MR23*/;
+
+ if ( parser->token != __POUND )
+ {
+ return stringparser_parse_element(parser);
+ }
+ stringparser_match(parser,__POUND);
+ parser->token = stringscan_gettok(parser->lexer);
+ stringparser_match(parser,__LPAREN);
+ parser->token = stringscan_gettok(parser->lexer);
+ root = stringparser_parse_element(parser);
+ while ( parser->token != __RPAREN )
+ {
+ child = stringparser_parse_element(parser);
+ if ( t==NULL ) { t = child; last = t; }
+ else { last->_right = child; last = child; }
+ }
+ stringparser_match(parser,__RPAREN);
+ parser->token = stringscan_gettok(parser->lexer);
+ root->_down = t;
+ return root;
+}
+
+ScanAST *PCCTS_AST::
+stringparser_parse_element(StringParser *parser)
+{
+ char ebuf[100];
+ int label = 0;
+
+ if ( parser->token == __POUND )
+ {
+ return stringparser_parse_tree(parser);
+ }
+ if ( parser->token == __PERCENT )
+ {
+ parser->token = stringscan_gettok(parser->lexer);
+ stringparser_match(parser,__INT);
+ label = atoi(parser->lexer->text);
+ parser->num_labels++;
+ if ( label==0 ) panic("%%0 is an invalid label");
+ parser->token = stringscan_gettok(parser->lexer);
+ stringparser_match(parser,__COLON);
+ parser->token = stringscan_gettok(parser->lexer);
+ /* can label tokens and wildcards */
+ if ( parser->token != __INT && parser->token != __PERIOD )
+ panic("can only label tokens");
+ }
+ if ( parser->token == __INT )
+ {
+ ScanAST *p = new_scanast(atoi(parser->lexer->text));
+ parser->token = stringscan_gettok(parser->lexer);
+ p->label_num = label;
+ return p;
+ }
+ if ( parser->token == __PERIOD )
+ {
+ ScanAST *p = new_scanast(0); /* token of 0 is wildcard */
+ parser->token = stringscan_gettok(parser->lexer);
+ p->label_num = label;
+ return p;
+ }
+ sprintf(ebuf, "mismatch token in scan(): %s", scan_token_str(parser->token));
+ panic(ebuf);
+ return NULL;
+}
+
+void PCCTS_AST::
+stringparser_init(StringParser *parser, StringLexer *input)
+{
+ parser->lexer = input;
+ parser->token = stringscan_gettok(parser->lexer);
+ parser->num_labels = 0;
+}
+
+void PCCTS_AST::
+stringlexer_init(StringLexer *scanner, char *input)
+{
+ scanner->text[0]='\0';
+ scanner->input = input;
+ scanner->p = input;
+ stringscan_advance(scanner);
+}
+
+void PCCTS_AST::
+stringscan_advance(StringLexer *scanner)
+{
+ if ( *(scanner->p) == '\0' ) scanner->c = __StringScanEOF;
+ scanner->c = *(scanner->p)++;
+}
+
+int PCCTS_AST::
+stringscan_gettok(StringLexer *scanner)
+{
+ char *index = &scanner->text[0];
+ char ebuf[100]; /* MR23 Remove static */
+
+ while ( isspace(scanner->c) ) { stringscan_advance(scanner); }
+ if ( isdigit(scanner->c) )
+ {
+ int tok = __INT;
+ while ( isdigit(scanner->c) ) {
+ *index++ = (char) /* static_cast<char> */ (scanner->c); // MR23
+ stringscan_advance(scanner);
+ }
+ *index = '\0';
+ return tok;
+ }
+ switch ( scanner->c )
+ {
+ case '#' : stringscan_advance(scanner); return __POUND;
+ case '(' : stringscan_advance(scanner); return __LPAREN;
+ case ')' : stringscan_advance(scanner); return __RPAREN;
+ case '%' : stringscan_advance(scanner); return __PERCENT;
+ case ':' : stringscan_advance(scanner); return __COLON;
+ case '.' : stringscan_advance(scanner); return __PERIOD;
+ case '\0' : return __StringScanEOF;
+ case __StringScanEOF : return __StringScanEOF;
+ default :
+ sprintf(ebuf, "invalid char in scan: '%c'", scanner->c);
+ panic(ebuf);
+ }
+ return __StringScanEOF; // never reached
+}
+
+const char *PCCTS_AST:: /* MR20 const */
+scan_token_str(int t)
+{
+ if ( VALID_SCAN_TOKEN(t) ) return scan_token_tbl[t];
+ else if ( t==__StringScanEOF ) return "<end-of-string>";
+ else return "<invalid-token>";
+}
+
+//MR23
+int PCCTS_AST::printMessage(FILE* pFile, const char* pFormat, ...)
+{
+ va_list marker;
+ va_start( marker, pFormat );
+ int iRet = vfprintf(pFile, pFormat, marker);
+ va_end( marker );
+ return iRet;
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/PCCTSAST.h b/BaseTools/Source/C/VfrCompile/Pccts/h/PCCTSAST.h new file mode 100644 index 0000000000..3485da7d1b --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/PCCTSAST.h @@ -0,0 +1,143 @@ +/* Abstract syntax tree
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+#ifndef PCCTSAST_H
+#define PCCTSAST_H
+
+#include "pcctscfg.h"
+
+#include "pccts_stdio.h"
+#include "pccts_stdlib.h"
+
+PCCTS_NAMESPACE_STD
+
+//class SList;
+
+#define StringScanMaxText 50
+#define MaxTreeStackDepth 400
+
+//
+// 7-Apr-97 133MR1 signed int not accepted by AT&T cfront
+//
+typedef struct stringlexer {
+ int c; // MR1
+ char *input;
+ char *p;
+ char text[StringScanMaxText];
+ } StringLexer;
+
+/* Define the structures needed for ast_scan() */
+typedef struct stringparser {
+ int token;
+ StringLexer *lexer;
+ int num_labels;
+ } StringParser;
+
+typedef struct _scanast {
+ struct _scanast *_right, *_down;
+ int _token;
+ int label_num;
+ int type() { return _token; }
+ struct _scanast *right() { return _right; }
+ struct _scanast *down() { return _down; }
+ } ScanAST;
+
+#define VALID_SCAN_TOKEN(t) (t>=__LPAREN && t<=__PERIOD)
+
+class DllExportPCCTS PCCTS_AST {
+protected:
+ static const char *scan_token_tbl[]; /* MR20 const */
+ enum {
+ __LPAREN=1,
+ __RPAREN=2,
+ __PERCENT=3,
+ __INT=4,
+ __COLON=5,
+ __POUND=6,
+ __PERIOD=7,
+ __StringScanEOF=-1};
+
+protected:
+ const char *scan_token_str(int t); /* MR20 const */
+ void stringlexer_init(StringLexer *scanner, char *input);
+ void stringparser_init(StringParser *, StringLexer *);
+ ScanAST *stringparser_parse_scanast(char *templ, int *n);
+ ScanAST *stringparser_parse_tree(StringParser *parser);
+ ScanAST *stringparser_parse_element(StringParser *parser);
+ void stringscan_advance(StringLexer *scanner);
+ int stringscan_gettok(StringLexer *scanner);
+ void _push(PCCTS_AST **st, int *sp, PCCTS_AST *e);
+ PCCTS_AST *_pop(PCCTS_AST **st, int *sp);
+ int match_partial(PCCTS_AST *t, PCCTS_AST *u);
+ int scanmatch(ScanAST *t, PCCTS_AST **labels[], int *n);
+ void scanast_free(ScanAST *t);
+ ScanAST *new_scanast(int tok);
+ void stringparser_match(StringParser *parser, int type);
+ virtual PCCTS_AST *deepCopyBushy();
+
+public:
+ PCCTS_AST() {;}
+ virtual ~PCCTS_AST() {;}
+
+ /* This group must be defined for SORCERER to work correctly */
+ virtual PCCTS_AST *right() = 0;
+ virtual PCCTS_AST *down() = 0;
+ virtual void setRight(PCCTS_AST *t) = 0;
+ virtual void setDown(PCCTS_AST *t) = 0;
+// we define these so ANTLR doesn't have to
+ virtual int type() { return 0; }
+ virtual void setType(int /*t MR23 */) {;}
+ virtual PCCTS_AST *shallowCopy() {panic("no shallowCopy() defined"); return NULL;}
+
+ /* These are not needed by ANTLR, but are support functions */
+ virtual PCCTS_AST *deepCopy(); // used by SORCERER in transform mode
+ virtual void addChild(PCCTS_AST *t);
+ virtual void lisp_action(FILE * /*f MR23 */) {;}
+ virtual void lisp(FILE *f);
+ static PCCTS_AST *make(PCCTS_AST *rt, ...);
+ virtual PCCTS_AST *ast_find_all(PCCTS_AST *u, PCCTS_AST **cursor);
+ virtual int match(PCCTS_AST *u);
+ virtual void insert_after(PCCTS_AST *b);
+ virtual void append(PCCTS_AST *b);
+ virtual PCCTS_AST *tail();
+ virtual PCCTS_AST *bottom();
+ static PCCTS_AST *cut_between(PCCTS_AST *a, PCCTS_AST *b);
+// virtual SList *to_slist();
+ virtual void tfree();
+ int ast_scan(char *templ, ...);
+ virtual int nsiblings();
+ virtual PCCTS_AST *sibling_index(int i);
+
+ void require(int e,const char *err){ if ( !e ) panic(err); } /* MR20 const */
+ virtual void panic(const char *err) // MR20 const
+ { /* MR23 */ printMessage(stderr, "PCCTS_AST: %s\n", err); exit(PCCTS_EXIT_FAILURE); }
+ virtual int printMessage(FILE* pFile, const char* pFormat, ...); // MR23
+};
+
+#endif /* PCCTSAST_H */
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/SList.h b/BaseTools/Source/C/VfrCompile/Pccts/h/SList.h new file mode 100644 index 0000000000..5b8bf97427 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/SList.h @@ -0,0 +1,72 @@ +#ifndef SList_h
+#define SList_h
+
+/*
+ * SList.h
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to SORCERER -- SORCERER is in the public
+ * domain. An individual or company may do whatever they wish with
+ * source code distributed with SORCERER or the code generated by
+ * SORCERER, including the incorporation of SORCERER, or its output, into
+ * commerical software.
+ *
+ * We encourage users to develop software with SORCERER. However, we do
+ * ask that credit is given to us for developing SORCERER. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like SORCERER and have developed a nice tool with the
+ * output, please mention that you developed it using SORCERER. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * PCCTS 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1992-2000
+ */
+
+#include "pcctscfg.h"
+
+#include "pccts_stdio.h"
+#include "pccts_stdlib.h"
+
+PCCTS_NAMESPACE_STD
+
+#include "PCCTSAST.h"
+
+class PCCTS_AST;
+
+class SListNode {
+protected:
+ void *_elem; /* pointer to any kind of element */
+ SListNode *_next;
+public:
+ SListNode() {_elem=_next=NULL;}
+ virtual ~SListNode() {_elem=_next=NULL;}
+ void *elem() { return _elem; }
+ void setElem(void *e) { _elem = e; }
+ void setNext(SListNode *t) { _next = t; }
+ SListNode *next() { return _next; }
+};
+
+class SList {
+ SListNode *head, *tail;
+public:
+ SList() {head=tail=NULL;}
+ virtual ~SList() {head=tail=NULL;}
+ virtual void *iterate(SListNode **);
+ virtual void add(void *e);
+ virtual void lfree();
+ virtual PCCTS_AST *to_ast(SList list);
+ virtual void require(int e,char *err){ if ( !e ) panic(err); }
+ virtual void panic(char *err){ /* MR23 */ printMessage(stderr, "SList panic: %s\n", err); exit(PCCTS_EXIT_FAILURE); }
+ virtual int printMessage(FILE* pFile, const char* pFormat, ...); // MR23
+};
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/antlr.h b/BaseTools/Source/C/VfrCompile/Pccts/h/antlr.h new file mode 100644 index 0000000000..80664535d3 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/antlr.h @@ -0,0 +1,807 @@ +/* antlr.h
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+#ifndef ANTLR_H
+#define ANTLR_H
+
+#include "pcctscfg.h"
+
+#include "pccts_stdio.h"
+
+/* turn off warnings for unreferenced labels */
+
+#ifdef _MSC_VER
+#pragma warning(disable:4102)
+#endif
+
+/*
+ * Define all of the stack setup and manipulation of $i, #i variables.
+ *
+ * Notes:
+ * The type 'Attrib' must be defined before entry into this .h file.
+ */
+
+
+#ifdef __USE_PROTOS
+#include "pccts_stdlib.h"
+#else
+#ifdef VAXC
+#include <stdlib.h>
+#else
+#include <malloc.h>
+#endif
+#endif
+#include "pccts_string.h"
+
+#if 0
+#include "set.h"
+#endif
+
+
+typedef int ANTLRTokenType;
+typedef unsigned char SetWordType;
+
+typedef char ANTLRChar;
+
+ /* G u e s s S t u f f */
+
+#ifdef ZZCAN_GUESS
+#ifndef ZZINF_LOOK
+#define ZZINF_LOOK
+#endif
+#endif
+
+#ifdef ZZCAN_GUESS
+typedef struct _zzjmp_buf {
+ jmp_buf state;
+ } zzjmp_buf;
+#endif
+
+
+/* can make this a power of 2 for more efficient lookup */
+
+#ifndef ZZLEXBUFSIZE
+#define ZZLEXBUFSIZE 8000 /* MR22 raise from 2k to 8k */
+#endif
+
+#define zzOvfChk \
+ if ( zzasp <= 0 ) \
+ { \
+ fprintf(stderr, zzStackOvfMsg, __FILE__, __LINE__); \
+ exit(PCCTS_EXIT_FAILURE); \
+ }
+
+#ifndef ZZA_STACKSIZE
+#define ZZA_STACKSIZE 400
+#endif
+#ifndef ZZAST_STACKSIZE
+#define ZZAST_STACKSIZE 400
+#endif
+
+#ifndef zzfailed_pred
+#ifdef ZZCAN_GUESS
+#define zzfailed_pred(_p,_hasuseraction,_useraction) \
+ if (zzguessing) { \
+ zzGUESS_FAIL; \
+ } else { \
+ zzfailed_pred_action(_p,_hasuseraction,_useraction); \
+ }
+#else
+#define zzfailed_pred(_p,_hasuseraction,_useraction) \
+ zzfailed_pred_action(_p,_hasuseraction,_useraction);
+#endif
+#endif
+
+/* MR23 Provide more control over failed predicate action
+ without any need for user to worry about guessing internals.
+ _hasuseraction == 0 => no user specified error action
+ _hasuseraction == 1 => user specified error action
+*/
+
+#ifndef zzfailed_pred_action
+#define zzfailed_pred_action(_p,_hasuseraction,_useraction) \
+ if (_hasuseraction) { _useraction } \
+ else { fprintf(stderr, "semantic error; failed predicate: '%s'\n",_p); }
+#endif
+
+/* MR19 zzchar_t additions */
+
+#ifdef LL_K
+#define LOOKAHEAD \
+ int zztokenLA[LL_K]; \
+ zzchar_t zztextLA[LL_K][ZZLEXBUFSIZE]; \
+ int zzlap = 0, zzlabase=0; /* labase only used for DEMAND_LOOK */
+#else
+#define LOOKAHEAD \
+ int zztoken;
+#endif
+
+#ifndef zzcr_ast
+#define zzcr_ast(ast,attr,tok,text)
+#endif
+
+#ifdef DEMAND_LOOK
+#define DemandLookData int zzdirty=1;
+#else
+#define DemandLookData
+#endif
+
+#ifndef zzUSER_GUESS_HOOK
+#define zzUSER_GUESS_HOOK(seqFrozen,zzrv)
+#endif
+
+#ifndef zzUSER_GUESS_DONE_HOOK
+#define zzUSER_GUESS_DONE_HOOK(seqFrozen)
+#endif
+
+ /* S t a t e S t u f f */
+
+#ifdef ZZCAN_GUESS
+#define zzGUESS_BLOCK zzantlr_state zzst; int zzrv; int zzGuessSeqFrozen;
+
+/* MR10 change zzGUESS: do zzGUESS_DONE when zzrv==1 after longjmp as in C++ mode */
+
+#define zzGUESS zzsave_antlr_state(&zzst); \
+ zzguessing = 1; \
+ zzGuessSeqFrozen=++zzGuessSeq; \
+ zzrv = setjmp(zzguess_start.state); \
+ zzUSER_GUESS_HOOK(zzGuessSeqFrozen,zzrv) \
+ if (zzrv) zzGUESS_DONE;
+#ifdef zzTRACE_RULES
+#define zzGUESS_FAIL { zzTraceGuessFail(); longjmp(zzguess_start.state, 1); }
+#else
+#define zzGUESS_FAIL longjmp(zzguess_start.state, 1)
+#endif
+
+/* MR10 change zzGUESS_DONE: zzrv=1 to simulate longjmp() return value as in C++ mode */
+
+#define zzGUESS_DONE { zzrestore_antlr_state(&zzst); zzrv=1; zzUSER_GUESS_DONE_HOOK(zzGuessSeqFrozen) }
+#define zzNON_GUESS_MODE if ( !zzguessing )
+#define zzGuessData \
+ zzjmp_buf zzguess_start; \
+ int zzguessing;
+#else
+#define zzGUESS_BLOCK
+#define zzGUESS
+#define zzGUESS_FAIL
+#define zzGUESS_DONE
+#define zzNON_GUESS_MODE
+#define zzGuessData
+#endif
+
+typedef struct _zzantlr_state {
+#ifdef ZZCAN_GUESS
+ zzjmp_buf guess_start;
+ int guessing;
+#endif
+ int asp;
+ int ast_sp;
+#ifdef ZZINF_LOOK
+ int inf_lap; /* not sure we need to save this one */
+ int inf_labase;
+ int inf_last;
+
+/* MR6 Gunnar Rxnning (gunnar@candleweb.no) */
+/* MR6 Additional state needs to be saved/restored */
+/* MR6 Matching changes in err.h */
+
+ int *inf_tokens; /* MR6 */
+ char **inf_text; /* MR6 */
+ char *inf_text_buffer; /* MR6 */
+ int *inf_line; /* MR6 */
+#endif
+#ifdef DEMAND_LOOK
+ int dirty;
+#endif
+
+#ifdef LL_K
+ int tokenLA[LL_K];
+ char textLA[LL_K][ZZLEXBUFSIZE];
+ int lap;
+ int labase;
+#else
+ int token;
+ char text[ZZLEXBUFSIZE];
+#endif
+#ifdef zzTRACE_RULES
+ int traceOptionValue; /* MR10 */
+ int traceGuessOptionValue; /* MR10 */
+ char *traceCurrentRuleName; /* MR10 */
+ int traceDepth; /* MR10 */
+#endif
+
+ } zzantlr_state;
+
+#ifdef zzTRACE_RULES
+extern int zzTraceOptionValueDefault;
+extern int zzTraceOptionValue;
+extern int zzTraceGuessOptionValue;
+extern char *zzTraceCurrentRuleName;
+extern int zzTraceDepth;
+#endif
+
+extern int zzGuessSeq; /* MR10 */
+extern int zzSyntaxErrCount; /* MR11 */
+extern int zzLexErrCount; /* MR11 */
+
+ /* I n f i n i t e L o o k a h e a d */
+
+
+#ifdef ZZINF_LOOK
+#define InfLookData \
+ int *zzinf_tokens; \
+ char **zzinf_text; \
+ char *zzinf_text_buffer; \
+ int *zzinf_line; \
+ int zzinf_labase; \
+ int zzinf_last;
+#else
+#define InfLookData
+#endif
+
+#ifdef ZZINF_LOOK
+
+#ifndef ZZINF_DEF_TEXT_BUFFER_SIZE
+#define ZZINF_DEF_TEXT_BUFFER_SIZE 20000
+#endif
+#ifndef ZZINF_DEF_TOKEN_BUFFER_SIZE
+#define ZZINF_DEF_TOKEN_BUFFER_SIZE 2000
+#endif
+/* WARNING!!!!!!
+ * ZZINF_BUFFER_TEXT_CHUNK_SIZE must be > sizeof(text) largest possible token.
+ */
+#ifndef ZZINF_BUFFER_TEXT_CHUNK_SIZE
+#define ZZINF_BUFFER_TEXT_CHUNK_SIZE 5000
+#endif
+#ifndef ZZINF_BUFFER_TOKEN_CHUNK_SIZE
+#define ZZINF_BUFFER_TOKEN_CHUNK_SIZE 1000
+#endif
+
+#if ZZLEXBUFSIZE > ZZINF_BUFFER_TEXT_CHUNK_SIZE
+#define ZZINF_BUFFER_TEXT_CHUNK_SIZE ZZLEXBUFSIZE+5
+#endif
+
+/* make inf_look user-access macros */
+#ifdef LL_K
+#define ZZINF_LA_VALID(i) (((zzinf_labase+i-1)-LL_K+1) <= zzinf_last)
+#define ZZINF_LA(i) zzinf_tokens[(zzinf_labase+i-1)-LL_K+1]
+#define ZZINF_LATEXT(i) zzinf_text[(zzinf_labase+i-1)-LL_K+1]
+/* MR6 In 1.33 vanilla the #define ZZINF_LINE(i) is was commented out */
+#define ZZINF_LINE(i) zzinf_line[(zzinf_labase+i-1)-LL_K+1]
+#else
+#define ZZINF_LA_VALID(i) (((zzinf_labase+i-1)) <= zzinf_last)
+#define ZZINF_LA(i) zzinf_tokens[(zzinf_labase+i-1)]
+#define ZZINF_LATEXT(i) zzinf_text[(zzinf_labase+i-1)]
+#endif
+
+#define inf_zzgettok _inf_zzgettok()
+extern void _inf_zzgettok();
+
+#endif /* ZZINF_LOOK */
+
+
+#ifdef LL_K
+
+#ifdef __USE_PROTOS
+#define ANTLR_INFO \
+ Attrib zzempty_attr(void) {static Attrib a; return a;} \
+ Attrib zzconstr_attr(int _tok, char *_text) \
+ {Attrib a; zzcr_attr((&a),_tok,_text); return a;} \
+ int zzasp=ZZA_STACKSIZE; \
+ char zzStackOvfMsg[]="fatal: attrib/AST stack overflow %s(%d)!\n"; \
+ Attrib zzaStack[ZZA_STACKSIZE]; DemandLookData \
+ InfLookData \
+ zzGuessData
+#else
+#define ANTLR_INFO \
+ Attrib zzempty_attr() {static Attrib a; return a;} \
+ Attrib zzconstr_attr(_tok, _text) int _tok; char *_text; \
+ {Attrib a; zzcr_attr((&a),_tok,_text); return a;} \
+ int zzasp=ZZA_STACKSIZE; \
+ char zzStackOvfMsg[]="fatal: attrib/AST stack overflow %s(%d)!\n"; \
+ Attrib zzaStack[ZZA_STACKSIZE]; DemandLookData \
+ InfLookData \
+ zzGuessData
+#endif
+
+#else
+
+#ifdef __USE_PROTOS
+#define ANTLR_INFO \
+ Attrib zzempty_attr(void) {static Attrib a; return a;} \
+ Attrib zzconstr_attr(int _tok, char *_text) \
+ {Attrib a; zzcr_attr((&a),_tok,_text); return a;} \
+ int zzasp=ZZA_STACKSIZE; \
+ char zzStackOvfMsg[]="fatal: attrib/AST stack overflow %s(%d)!\n"; \
+ Attrib zzaStack[ZZA_STACKSIZE]; DemandLookData \
+ InfLookData \
+ zzGuessData
+#else
+#define ANTLR_INFO \
+ Attrib zzempty_attr() {static Attrib a; return a;} \
+ Attrib zzconstr_attr(_tok, _text) int _tok; char *_text; \
+ {Attrib a; zzcr_attr((&a),_tok,_text); return a;} \
+ int zzasp=ZZA_STACKSIZE; \
+ char zzStackOvfMsg[]="fatal: attrib/AST stack overflow %s(%d)!\n"; \
+ Attrib zzaStack[ZZA_STACKSIZE]; DemandLookData \
+ InfLookData \
+ zzGuessData
+#endif
+
+#endif /* LL_k */
+
+
+#ifdef ZZINF_LOOK
+
+#ifdef LL_K
+#ifdef DEMAND_LOOK
+#define zzPrimeLookAhead {zzdirty=LL_K; zzlap = zzlabase = 0;}
+#else
+#define zzPrimeLookAhead {zzlap = zzlabase = 0; zzfill_inf_look();\
+ {int _i; for(_i=1;_i<=LL_K; _i++) \
+ {zzCONSUME;} zzlap = zzlabase = 0;}}
+#endif
+
+#else /* LL_K */
+
+#ifdef DEMAND_LOOK
+#define zzPrimeLookAhead zzfill_inf_look(); zzdirty=1
+#else
+#define zzPrimeLookAhead zzfill_inf_look(); inf_zzgettok
+
+#endif
+#endif /* LL_K */
+
+#else /* ZZINF_LOOK */
+
+#ifdef LL_K
+#ifdef DEMAND_LOOK
+#define zzPrimeLookAhead {zzdirty=LL_K; zzlap = zzlabase = 0;}
+#else
+#define zzPrimeLookAhead {int _i; zzlap = 0; for(_i=1;_i<=LL_K; _i++) \
+ {zzCONSUME;} zzlap = 0;}
+#endif
+
+#else
+
+#ifdef DEMAND_LOOK
+#define zzPrimeLookAhead zzdirty=1
+#else
+#define zzPrimeLookAhead zzgettok()
+#endif
+#endif /* LL_K */
+
+#endif /* ZZINF_LOOK */
+
+
+#ifdef LL_K
+#define zzenterANTLRs(s) \
+ zzlextext = &(zztextLA[0][0]); zzrdstr( s ); zzPrimeLookAhead;
+#define zzenterANTLRf(f) \
+ zzlextext = &(zztextLA[0][0]); zzrdfunc( f ); zzPrimeLookAhead;
+#define zzenterANTLR(f) \
+ zzlextext = &(zztextLA[0][0]); zzrdstream( f ); zzPrimeLookAhead;
+#ifdef ZZINF_LOOK
+#define zzleaveANTLR(f) free(zzinf_text_buffer); free(zzinf_text); free(zzinf_tokens); free(zzinf_line);
+#define zzleaveANTLRf(f) free(zzinf_text_buffer); free(zzinf_text); free(zzinf_tokens); free(zzinf_line);
+#define zzleaveANTLRs(f) free(zzinf_text_buffer); free(zzinf_text); free(zzinf_tokens); free(zzinf_line);
+#else
+#define zzleaveANTLR(f)
+#define zzleaveANTLRf(f)
+#define zzleaveANTLRs(f)
+#endif
+
+#else
+
+#define zzenterANTLRs(s) \
+ {static char zztoktext[ZZLEXBUFSIZE]; \
+ zzlextext = zztoktext; zzrdstr( s ); zzPrimeLookAhead;}
+#define zzenterANTLRf(f) \
+ {static char zztoktext[ZZLEXBUFSIZE]; \
+ zzlextext = zztoktext; zzrdfunc( f ); zzPrimeLookAhead;}
+#define zzenterANTLR(f) \
+ {static char zztoktext[ZZLEXBUFSIZE]; \
+ zzlextext = zztoktext; zzrdstream( f ); zzPrimeLookAhead;}
+#ifdef ZZINF_LOOK
+#define zzleaveANTLR(f) free(zzinf_text_buffer); free(zzinf_text); free(zzinf_tokens); free(zzinf_line);
+#define zzleaveANTLRf(f) free(zzinf_text_buffer); free(zzinf_text); free(zzinf_tokens); free(zzinf_line);
+#define zzleaveANTLRs(f) free(zzinf_text_buffer); free(zzinf_text); free(zzinf_tokens); free(zzinf_line);
+#else
+#define zzleaveANTLR(f)
+#define zzleaveANTLRf(f)
+#define zzleaveANTLRs(f)
+#endif
+
+#endif
+
+/* MR19 Paul D. Smith (psmith@baynetworks.com)
+ Need to adjust AST stack pointer at exit.
+ Referenced in ANTLRx macros.
+*/
+
+#ifdef GENAST
+#define ZZAST_ADJUST ++zzast_sp;
+#else
+#define ZZAST_ADJUST
+#endif
+
+#define ANTLR(st, f) zzbufsize = ZZLEXBUFSIZE; \
+ zzenterANTLR(f); \
+ { \
+ zzBLOCK(zztasp1); \
+ st; /* ++zzasp; Removed MR20 G. Hobbelt */ \
+ /* ZZAST_ADJUST Removed MR20 G. Hobbelt */ \
+ /* MR20 G. Hobbelt. Kill the top' attribute (+AST stack corr.) */ \
+ zzEXIT_ANTLR(zztasp1 + 1); \
+ } \
+ zzleaveANTLR(f);
+
+#define ANTLRm(st, f, _m) zzbufsize = ZZLEXBUFSIZE; \
+ zzmode(_m); \
+ zzenterANTLR(f); \
+ { \
+ zzBLOCK(zztasp1); \
+ st; /* ++zzasp; Removed MR20 G. Hobbelt */ \
+ /* ZZAST_ADJUST Removed MR20 G. Hobbelt */ \
+ /* MR20 G. Hobbelt. Kill the top' attribute (+AST stack corr.) */ \
+ zzEXIT_ANTLR(zztasp1 + 1); \
+ } \
+ zzleaveANTLR(f);
+
+#define ANTLRf(st, f) zzbufsize = ZZLEXBUFSIZE; \
+ zzenterANTLRf(f); \
+ { \
+ zzBLOCK(zztasp1); \
+ st; /* ++zzasp; Removed MR20 G. Hobbelt */ \
+ /* ZZAST_ADJUST Removed MR20 G. Hobbelt */ \
+ /* MR20 G. Hobbelt. Kill the top' attribute (+AST stack corr.) */ \
+ zzEXIT_ANTLR(zztasp1 + 1); \
+ } \
+ zzleaveANTLRf(f);
+
+#define ANTLRs(st, s) zzbufsize = ZZLEXBUFSIZE; \
+ zzenterANTLRs(s); \
+ { \
+ zzBLOCK(zztasp1); \
+ st; /* ++zzasp; Removed MR20 G. Hobbelt */ \
+ /* ZZAST_ADJUST Removed MR20 G. Hobbelt */ \
+ /* MR20 G. Hobbelt. Kill the top' attribute (+AST stack corr.) */ \
+ zzEXIT_ANTLR(zztasp1 + 1); \
+ } \
+ zzleaveANTLRs(s);
+
+#ifdef LL_K
+#define zztext (&(zztextLA[zzlap][0]))
+#else
+#define zztext zzlextext
+#endif
+
+
+ /* A r g u m e n t A c c e s s */
+
+#define zzaCur (zzaStack[zzasp])
+#define zzaRet (*zzaRetPtr)
+#define zzaArg(v,n) zzaStack[v-n]
+#define zzMakeAttr { zzNON_GUESS_MODE {zzOvfChk; --zzasp; zzcr_attr(&(zzaStack[zzasp]),LA(1),LATEXT(1));}}
+#ifdef zzdef0
+#define zzMake0 { zzOvfChk; --zzasp; zzdef0(&(zzaStack[zzasp]));}
+#else
+#define zzMake0 { zzOvfChk; --zzasp;}
+#endif
+#define zzaPush(_v) { zzOvfChk; zzaStack[--zzasp] = _v;}
+#ifndef zzd_attr
+#define zzREL(t) zzasp=(t); /* Restore state of stack */
+#else
+#define zzREL(t) for (; zzasp<(t); zzasp++) \
+ { zzd_attr(&(zzaStack[zzasp])); }
+#endif
+
+
+#define zzsetmatch(_es,_tokclassErrset) \
+ if ( !_zzsetmatch(_es, &zzBadText, &zzMissText, &zzMissTok, &zzBadTok, &zzMissSet, _tokclassErrset) ) goto fail; /* MR23 */
+
+#ifdef ZZCAN_GUESS
+#define zzsetmatch_wsig(_es, handler) \
+ if ( !_zzsetmatch_wsig(_es) ) if (zzguessing) { zzGUESS_FAIL; } else {_signal=MismatchedToken; goto handler;}
+#else
+#define zzsetmatch_wsig(_es, handler) \
+ if ( !_zzsetmatch_wsig(_es) ) {_signal=MismatchedToken; goto handler;}
+#endif
+
+#ifdef __USE_PROTOS
+extern int _zzsetmatch(SetWordType *, char **, char **, int *, int *, SetWordType **, SetWordType * /* MR23 */);
+extern int _zzsetmatch_wsig(SetWordType *);
+#else
+extern int _zzsetmatch();
+extern int _zzsetmatch_wsig();
+#endif
+
+#define zzmatch(_t) \
+ if ( !_zzmatch(_t, &zzBadText, &zzMissText, &zzMissTok, &zzBadTok, &zzMissSet) ) goto fail;
+
+#ifdef ZZCAN_GUESS
+#define zzmatch_wsig(_t,handler) \
+ if ( !_zzmatch_wsig(_t) ) if (zzguessing) { zzGUESS_FAIL; } else {_signal=MismatchedToken; goto handler;}
+#else
+#define zzmatch_wsig(_t,handler) \
+ if ( !_zzmatch_wsig(_t) ) {_signal=MismatchedToken; goto handler;}
+#endif
+
+#ifdef __USE_PROTOS
+extern int _zzmatch(int, char **, char **, int *, int *, SetWordType **);
+extern int _zzmatch_wsig(int);
+#else
+extern int _zzmatch();
+extern int _zzmatch_wsig();
+#endif
+
+#define zzmatch_wdfltsig(_t,_f) \
+ if ( !_zzmatch_wdfltsig(_t,_f) ) _signal=MismatchedToken;
+#define zzsetmatch_wdfltsig(tw,tt,wf) \
+ if ( !_zzsetmatch_wdfltsig(tw,tt,wf) ) _signal=MismatchedToken;
+
+#ifdef __USE_PROTOS
+extern int _zzmatch_wdfltsig(int, SetWordType *);
+extern int _zzsetmatch_wdfltsig(SetWordType *tokensWanted,
+ int tokenTypeOfSet,
+ SetWordType *whatFollows);
+#else
+extern int _zzmatch_wdfltsig();
+extern int _zzsetmatch_wdfltsig();
+#endif
+
+#ifdef GENAST
+#define zzRULE Attrib *zzaRetPtr = &(zzaStack[zzasp-1]); \
+ SetWordType *zzMissSet=NULL; int zzMissTok=0; \
+ int zzBadTok=0; char *zzBadText=""; \
+ int zzErrk=1,zzpf=0; \
+ zzTRACEdata \
+ char *zzMissText=""; zzASTVars
+#else
+#define zzRULE Attrib *zzaRetPtr = &(zzaStack[zzasp-1]); \
+ int zzBadTok=0; char *zzBadText=""; \
+ int zzErrk=1,zzpf=0; \
+ zzTRACEdata \
+ SetWordType *zzMissSet=NULL; int zzMissTok=0; char *zzMissText=""
+#endif
+
+#ifdef GENAST
+#define zzBLOCK(i) int i = zzasp - 1; int zztsp = zzast_sp
+#define zzEXIT(i) zzREL(i); zzastREL; zzNON_GUESS_MODE { zzastPush(*_root); }
+#define zzEXIT_ANTLR(i) zzREL(i); zzastREL /* [i_a] added as we want this for the ANTLRx() macros */
+#define zzLOOP(i) zzREL(i); zzastREL
+#else
+#define zzBLOCK(i) int i = zzasp - 1
+#define zzEXIT(i) zzREL(i)
+#define zzEXIT_ANTLR(i) zzREL(i) /* [i_a] added as we want this for the ANTLRx() macros */
+#define zzLOOP(i) zzREL(i)
+#endif
+
+#ifdef LL_K
+
+#ifdef DEMAND_LOOK
+#define LOOK(_k) {int i,stop=_k-(LL_K-zzdirty); for (i=1; i<=stop; i++) \
+ zzCONSUME;}
+#define zzCONSUME {zzgettok(); zzdirty--; \
+ zzlap = (zzlap+1)&(LL_K-1); \
+ zzlextext = &(zztextLA[zzlap][0]);}
+#else
+#ifdef ZZINF_LOOK
+#define zzCONSUME {inf_zzgettok; \
+ zzlap = (zzlap+1)&(LL_K-1); \
+ zzlextext = &(zztextLA[zzlap][0]); \
+ }
+#else
+#define zzCONSUME {zzgettok(); \
+ zzlap = (zzlap+1)&(LL_K-1); \
+ zzlextext = &(zztextLA[zzlap][0]);}
+#endif /* ZZINF_LOOK */
+#endif /* DEMAND_LOOK */
+
+#else /* LL_K */
+
+#ifdef DEMAND_LOOK
+#define LOOK(_k) if ( zzdirty) zzCONSUME;
+#ifdef ZZINF_LOOK
+#define zzCONSUME inf_zzgettok; zzdirty=0;
+#else
+#define zzCONSUME zzgettok(); zzdirty=0;
+#endif /* ZZINF_LOOK */
+
+#else /* DEMAND_LOOK */
+
+#ifdef ZZINF_LOOK
+#define zzCONSUME inf_zzgettok
+#else
+#define zzCONSUME zzgettok();
+#endif
+
+#endif /* DEMAND_LOOK */
+
+#endif /* LL_K */
+
+#ifdef LL_K
+#define NLA zztokenLA[zzlap&(LL_K-1)] /* --> next LA */
+#define NLATEXT zztextLA[zzlap&(LL_K-1)] /* --> next text of LA */
+#ifdef DEMAND_LOOK
+#define LA(i) zztokenLA[(zzlabase+(i)-1)&(LL_K-1)]
+#define LATEXT(i) (&(zztextLA[(zzlabase+(i)-1)&(LL_K-1)][0]))
+#else
+#define LA(i) zztokenLA[(zzlap+(i)-1)&(LL_K-1)]
+#define LATEXT(i) (&(zztextLA[(zzlap+(i)-1)&(LL_K-1)][0]))
+#endif
+#else
+#define NLA zztoken
+#define NLATEXT zztext
+#define LA(i) zztoken
+#define LATEXT(i) zztext
+#endif
+
+
+ /* S t a n d a r d S i g n a l s */
+
+#define NoSignal 0
+#define MismatchedToken 1
+#define NoViableAlt 2
+#define NoSemViableAlt 3
+
+/* MR7 Allow more control over signalling */
+/* by adding "Unwind" and "zzsetSignal" */
+
+#define Unwind 4
+#define zzsetSignal(newValue) *_retsignal=_signal=(newValue)
+#define zzsuppressSignal *_retsignal=_signal=0
+#define zzexportSignal *_retsignal=_signal
+
+ /* F u n c t i o n T r a c i n g */
+
+#ifndef zzTRACE_RULES
+#define zzTRACEdata
+#else
+#ifndef zzTRACEdata
+#define zzTRACEdata ANTLRChar *zzTracePrevRuleName = NULL;
+#endif
+#endif
+
+#ifndef zzTRACEIN
+#define zzTRACEIN(r) zzTracePrevRuleName=zzTraceCurrentRuleName;zzTraceIn(r);
+#endif
+#ifndef zzTRACEOUT
+#define zzTRACEOUT(r) zzTraceOut(r);zzTraceCurrentRuleName=zzTracePrevRuleName;
+#endif
+
+/* MR19 zzchar_t additions */
+
+#ifndef zzchar_t
+#ifdef ZZWCHAR_T
+#define zzchar_t wchar_t
+#else
+#define zzchar_t char
+#endif
+#endif
+
+
+/* MR26 */
+
+#ifdef PCCTS_USE_STDARG
+extern void zzFAIL(int k, ...);
+#else
+extern void zzFAIL();
+#endif
+ /* E x t e r n D e f s */
+
+#ifdef __USE_PROTOS
+extern Attrib zzempty_attr(void);
+extern Attrib zzconstr_attr(int, char *);
+extern void zzsyn(char *, int, char *, SetWordType *, int, int, char *);
+extern int zzset_el(unsigned, SetWordType *);
+extern int zzset_deg(SetWordType *);
+extern void zzedecode(SetWordType *);
+
+extern void zzresynch(SetWordType *, SetWordType);
+extern void zzsave_antlr_state(zzantlr_state *);
+extern void zzrestore_antlr_state(zzantlr_state *);
+extern void zzfill_inf_look(void);
+extern void zzconsumeUntil(SetWordType *st); /* MR7 */
+extern void zzconsumeUntilToken(int t); /* MR7 */
+extern void zzTraceIn(char * ruleName); /* MR10 */
+extern void zzTraceOut(char * ruleName); /* MR10 */
+extern int zzTraceOption(int delta); /* MR10 */
+extern int zzTraceGuessOption(int delta); /* MR10 */
+extern void zzTraceReset(void); /* MR10 */
+extern void zzTraceGuessFail(void); /* MR10 */
+#ifdef EXCEPTION_HANDLING
+extern void zzdflthandlers(int, int *);
+#endif
+#else
+extern Attrib zzempty_attr();
+extern Attrib zzconstr_attr();
+extern void zzsyn();
+extern int zzset_el();
+extern int zzset_deg();
+extern void zzedecode();
+extern void zzresynch();
+extern void zzsave_antlr_state();
+extern void zzrestore_antlr_state();
+extern void zzfill_inf_look();
+extern void zzconsumeUntil(); /* MR7 */
+extern void zzconsumeUntilToken(); /* MR7 */
+extern void zzTraceIn(); /* MR10 */
+extern void zzTraceOut(); /* MR10 */
+extern int zzTraceOption(); /* MR10 */
+extern int zzTraceGuessOption(); /* MR10 */
+extern void zzTraceReset(); /* MR10 */
+extern void zzTraceGuessFail(); /* MR10 */
+#ifdef EXCEPTION_HANDLING
+extern void zzdflthandlers();
+#endif
+#endif
+
+ /* G l o b a l V a r i a b l e s */
+
+/* Define a parser; user should do a "#parser myname" in their grammar file */
+/*extern struct pccts_parser zzparser;*/
+
+extern char *zztokens[];
+#ifdef LL_K
+extern int zztokenLA[];
+extern zzchar_t zztextLA[][ZZLEXBUFSIZE];
+extern int zzlap;
+extern int zzlabase;
+#else
+extern int zztoken;
+#endif
+
+extern char zzStackOvfMsg[];
+extern int zzasp;
+extern Attrib zzaStack[];
+#ifdef ZZINF_LOOK
+extern int *zzinf_tokens;
+extern char **zzinf_text;
+extern char *zzinf_text_buffer;
+extern int *zzinf_line;
+extern int zzinf_labase;
+extern int zzinf_last;
+#endif
+#ifdef DEMAND_LOOK
+extern int zzdirty;
+#endif
+#ifdef ZZCAN_GUESS
+extern int zzguessing;
+extern zzjmp_buf zzguess_start;
+#endif
+
+/* Define global veriables that refer to values exported by the scanner.
+ * These declarations duplicate those in dlgdef.h, but are needed
+ * if ANTLR is not to generate a .dlg file (-gx); PS, this is a hack.
+ */
+extern zzchar_t *zzlextext; /* text of most recently matched token */
+extern int zzbufsize; /* how long zzlextext is */
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/ast.c b/BaseTools/Source/C/VfrCompile/Pccts/h/ast.c new file mode 100644 index 0000000000..9326ae16ae --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/ast.c @@ -0,0 +1,345 @@ +/* Abstract syntax tree manipulation functions
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+#include "pcctscfg.h"
+
+#ifdef PCCTS_USE_STDARG
+#include "pccts_stdarg.h"
+#else
+#include <varargs.h>
+#endif
+
+/* ensure that tree manipulation variables are current after a rule
+ * reference
+ */
+
+void
+#ifdef __USE_PROTOS
+zzlink(AST **_root, AST **_sibling, AST **_tail)
+#else
+zzlink(_root, _sibling, _tail)
+AST **_root, **_sibling, **_tail;
+#endif
+{
+ if ( *_sibling == NULL ) return;
+ if ( *_root == NULL ) *_root = *_sibling;
+ else if ( *_root != *_sibling ) (*_root)->down = *_sibling;
+ if ( *_tail==NULL ) *_tail = *_sibling;
+ while ( (*_tail)->right != NULL ) *_tail = (*_tail)->right;
+}
+
+AST *
+#ifdef __USE_PROTOS
+zzastnew(void)
+#else
+zzastnew()
+#endif
+{
+ AST *p = (AST *) calloc(1, sizeof(AST));
+ if ( p == NULL ) fprintf(stderr,"%s(%d): cannot allocate AST node\n",__FILE__,__LINE__);
+ return p;
+}
+
+/* add a child node to the current sibling list */
+void
+#ifdef __USE_PROTOS
+zzsubchild(AST **_root, AST **_sibling, AST **_tail)
+#else
+zzsubchild(_root, _sibling, _tail)
+AST **_root, **_sibling, **_tail;
+#endif
+{
+ AST *n;
+ zzNON_GUESS_MODE {
+ n = zzastnew();
+#ifdef DEMAND_LOOK
+ zzcr_ast(n, &(zzaCur), LA(0), LATEXT(0));
+#else
+ zzcr_ast(n, &(zzaCur), LA(1), LATEXT(1));
+#endif
+ zzastPush( n );
+ if ( *_tail != NULL ) (*_tail)->right = n;
+ else {
+ *_sibling = n;
+ if ( *_root != NULL ) (*_root)->down = *_sibling;
+ }
+ *_tail = n;
+ if ( *_root == NULL ) *_root = *_sibling;
+ }
+}
+
+/* make a new AST node. Make the newly-created
+ * node the root for the current sibling list. If a root node already
+ * exists, make the newly-created node the root of the current root.
+ */
+void
+#ifdef __USE_PROTOS
+zzsubroot(AST **_root, AST **_sibling, AST **_tail)
+#else
+zzsubroot(_root, _sibling, _tail)
+AST **_root, **_sibling, **_tail;
+#endif
+{
+ AST *n;
+ zzNON_GUESS_MODE {
+ n = zzastnew();
+#ifdef DEMAND_LOOK
+ zzcr_ast(n, &(zzaCur), LA(0), LATEXT(0));
+#else
+ zzcr_ast(n, &(zzaCur), LA(1), LATEXT(1));
+#endif
+ zzastPush( n );
+ if ( *_root != NULL )
+ if ( (*_root)->down == *_sibling ) *_sibling = *_tail = *_root;
+ *_root = n;
+ (*_root)->down = *_sibling;
+ }
+}
+
+/* Apply function to root then each sibling
+ * example: print tree in child-sibling LISP-format (AST has token field)
+ *
+ * void show(tree)
+ * AST *tree;
+ * {
+ * if ( tree == NULL ) return;
+ * printf(" %s", zztokens[tree->token]);
+ * }
+ *
+ * void before() { printf(" ("); }
+ * void after() { printf(" )"); }
+ *
+ * LISPdump() { zzpre_ast(tree, show, before, after); }
+ *
+ */
+void
+#ifdef __USE_PROTOS
+zzpre_ast(
+ AST *tree,
+ void (*func)(AST *), /* apply this to each tree node */
+ void (*before)(AST *), /* apply this to root of subtree before preordering it */
+ void (*after)(AST *)) /* apply this to root of subtree after preordering it */
+#else
+zzpre_ast(tree, func, before, after)
+AST *tree;
+void (*func)(), /* apply this to each tree node */
+ (*before)(), /* apply this to root of subtree before preordering it */
+ (*after)(); /* apply this to root of subtree after preordering it */
+#endif
+{
+ while ( tree!= NULL )
+ {
+ if ( tree->down != NULL ) (*before)(tree);
+ (*func)(tree);
+ zzpre_ast(tree->down, func, before, after);
+ if ( tree->down != NULL ) (*after)(tree);
+ tree = tree->right;
+ }
+}
+
+/* free all AST nodes in tree; apply func to each before freeing */
+
+#if 0
+////void
+////#ifdef __USE_PROTOS
+////zzfree_ast(AST *tree)
+////#else
+////zzfree_ast(tree)
+////AST *tree;
+////#endif
+////{
+//// if ( tree == NULL ) return;
+//// zzfree_ast( tree->down );
+//// zzfree_ast( tree->right );
+//// zztfree( tree );
+////}
+#endif
+
+/*
+ MR19 Optimize freeing of the following structure to limit recursion
+ SAKAI Kiyotaka (ksakai@isr.co.jp)
+*/
+
+/*
+ NULL o
+ / \
+ NULL o
+ / \
+ NULL NULL
+*/
+
+/*
+ MR21 Another refinement to replace recursion with iteration
+ NAKAJIMA Mutsuki (muc@isr.co.jp).
+*/
+
+void
+#ifdef __USE_PROTOS
+zzfree_ast(AST *tree)
+#else
+zzfree_ast(tree)
+AST *tree;
+#endif
+{
+
+ AST *otree;
+
+ if (tree == NULL) return;
+
+ while (tree->down == NULL || tree->right == NULL) {
+
+ if (tree->down == NULL && tree->right == NULL) {
+ zztfree(tree);
+ return;
+ }
+
+ otree = tree;
+ if (tree->down == NULL) {
+ tree = tree->right;
+ } else {
+ tree = tree->down;
+ }
+ zztfree( otree );
+ }
+
+ while (tree != NULL) {
+ zzfree_ast(tree->down);
+ otree = tree;
+ tree = otree->right;
+ zztfree(otree);
+ }
+}
+
+/* build a tree (root child1 child2 ... NULL)
+ * If root is NULL, simply make the children siblings and return ptr
+ * to 1st sibling (child1). If root is not single node, return NULL.
+ *
+ * Siblings that are actually siblins lists themselves are handled
+ * correctly. For example #( NULL, #( NULL, A, B, C), D) results
+ * in the tree ( NULL A B C D ).
+ *
+ * Requires at least two parameters with the last one being NULL. If
+ * both are NULL, return NULL.
+ */
+#ifdef PCCTS_USE_STDARG
+AST *zztmake(AST *rt, ...)
+#else
+AST *zztmake(va_alist)
+va_dcl
+#endif
+{
+ va_list ap;
+ register AST *child, *sibling=NULL, *tail=NULL /* MR20 */, *w;
+ AST *root;
+
+#ifdef PCCTS_USE_STDARG
+ va_start(ap, rt);
+ root = rt;
+#else
+ va_start(ap);
+ root = va_arg(ap, AST *);
+#endif
+
+ if ( root != NULL )
+ if ( root->down != NULL ) return NULL;
+ child = va_arg(ap, AST *);
+ while ( child != NULL )
+ {
+ for (w=child; w->right!=NULL; w=w->right) {;} /* find end of child */
+ if ( sibling == NULL ) {sibling = child; tail = w;}
+ else {tail->right = child; tail = w;}
+ child = va_arg(ap, AST *);
+ }
+ if ( root==NULL ) root = sibling;
+ else root->down = sibling;
+ va_end(ap);
+ return root;
+}
+
+/* tree duplicate */
+AST *
+#ifdef __USE_PROTOS
+zzdup_ast(AST *t)
+#else
+zzdup_ast(t)
+AST *t;
+#endif
+{
+ AST *u;
+
+ if ( t == NULL ) return NULL;
+ u = zzastnew();
+ *u = *t;
+#ifdef zzAST_DOUBLE
+ u->up = NULL; /* set by calling invocation */
+ u->left = NULL;
+#endif
+ u->right = zzdup_ast(t->right);
+ u->down = zzdup_ast(t->down);
+#ifdef zzAST_DOUBLE
+ if ( u->right!=NULL ) u->right->left = u;
+ if ( u->down!=NULL ) u->down->up = u;
+#endif
+ return u;
+}
+
+void
+#ifdef __USE_PROTOS
+zztfree(AST *t)
+#else
+zztfree(t)
+AST *t;
+#endif
+{
+#ifdef zzd_ast
+ zzd_ast( t );
+#endif
+ free( t );
+}
+
+#ifdef zzAST_DOUBLE
+/*
+ * Set the 'up', and 'left' pointers of all nodes in 't'.
+ * Initial call is double_link(your_tree, NULL, NULL).
+ */
+void
+#ifdef __USE_PROTOS
+zzdouble_link(AST *t, AST *left, AST *up)
+#else
+zzdouble_link(t, left, up)
+AST *t, *left, *up;
+#endif
+{
+ if ( t==NULL ) return;
+ t->left = left;
+ t->up = up;
+ zzdouble_link(t->down, NULL, t);
+ zzdouble_link(t->right, t, up);
+}
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/ast.h b/BaseTools/Source/C/VfrCompile/Pccts/h/ast.h new file mode 100644 index 0000000000..5ff84bd76c --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/ast.h @@ -0,0 +1,121 @@ +/* Abstract syntax tree
+ *
+ * Macros, definitions
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+#ifndef ZZAST_H
+#define ZZAST_H
+
+#define zzastOvfChk \
+ if ( zzast_sp <= 0 ) \
+ { \
+ fprintf(stderr, zzStackOvfMsg, __FILE__, __LINE__); \
+ exit(PCCTS_EXIT_FAILURE); \
+ }
+
+#ifndef USER_DEFINED_AST
+#ifndef AST_FIELDS
+#define AST_FIELDS
+#endif
+
+typedef struct _ast {
+ struct _ast *right, *down;
+#ifdef zzAST_DOUBLE
+ struct _ast *left, *up;
+#endif
+ AST_FIELDS
+} AST;
+
+#else
+
+#ifdef zzAST_DOUBLE
+#define AST_REQUIRED_FIELDS struct _ast *right, *down, *left, *up;
+#else
+#define AST_REQUIRED_FIELDS struct _ast *right, *down;
+#endif
+
+#endif
+
+
+/* N o d e a c c e s s m a c r o s */
+#define zzchild(t) (((t)==NULL)? (AST *) NULL:(t->down)) /* MR19 */
+#define zzsibling(t) (((t)==NULL)? (AST *) NULL:(t->right)) /* MR19 */
+
+
+/* define global variables needed by #i stack */
+#define zzASTgvars \
+ AST *zzastStack[ZZAST_STACKSIZE]; \
+ int zzast_sp = ZZAST_STACKSIZE;
+
+#define zzASTVars AST *_ast = NULL, *_sibling = NULL, *_tail = NULL
+#define zzSTR ( (_tail==NULL)?(&_sibling):(&(_tail->right)) )
+#define zzastCur (zzastStack[zzast_sp])
+#define zzastArg(i) (zzastStack[zztsp-i])
+#define zzastPush(p) zzastOvfChk; zzastStack[--zzast_sp] = p;
+#define zzastDPush --zzast_sp
+#define zzastMARK zztsp=zzast_sp; /* Save state of stack */
+#define zzastREL zzast_sp=zztsp; /* Return state of stack */
+#define zzrm_ast {zzfree_ast(*_root); _tail = _sibling = (*_root)=NULL;}
+
+extern int zzast_sp;
+extern AST *zzastStack[];
+
+/* MR26 */
+
+#ifdef PCCTS_USE_STDARG
+AST *zztmake(AST *, ...);
+#else
+AST *zztmake();
+#endif
+
+#ifdef __USE_PROTOS
+void zzlink(AST **, AST **, AST **);
+void zzsubchild(AST **, AST **, AST **);
+void zzsubroot(AST **, AST **, AST **);
+void zzpre_ast(AST *, void (*)(AST *), void (*)(AST *), void (*)(AST *));
+void zzfree_ast(AST *);
+AST *zzdup_ast(AST *);
+void zztfree(AST *);
+void zzdouble_link(AST *, AST *, AST *);
+AST *zzastnew(void);
+
+#else
+
+void zzlink();
+AST *zzastnew();
+void zzsubchild();
+void zzsubroot();
+void zzpre_ast();
+void zzfree_ast();
+AST *zzdup_ast();
+void zztfree();
+void zzdouble_link();
+#endif
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/charbuf.h b/BaseTools/Source/C/VfrCompile/Pccts/h/charbuf.h new file mode 100644 index 0000000000..5f01c8ba35 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/charbuf.h @@ -0,0 +1,46 @@ +/* ANTLR attribute definition -- constant width text
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+#ifndef ZZCHARBUF_H
+#define ZZCHARBUF_H
+
+#include "pcctscfg.h"
+
+#include "pccts_string.h"
+
+#ifndef D_TextSize
+#define D_TextSize 30
+#endif
+
+typedef struct { char text[D_TextSize]; } Attrib;
+
+#define zzcr_attr(a,tok,t) strncpy((a)->text, t, D_TextSize-1); \
+ (a)->text[D_TextSize-1] = '\0';
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/charptr.c b/BaseTools/Source/C/VfrCompile/Pccts/h/charptr.c new file mode 100644 index 0000000000..d3f80e60ba --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/charptr.c @@ -0,0 +1,58 @@ +/*
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+#include "pcctscfg.h"
+
+#ifdef __STDC__
+#include "pccts_stdlib.h"
+#else
+#include <malloc.h>
+#endif
+#include "pccts_string.h"
+
+/* 133MR1 include stdio.h for fprintf in charptr.c */
+
+#include "pccts_stdio.h"
+
+/* 133MR1 include charptr.h for Attrib in charptr.c */
+
+#include "charptr.h"
+
+#ifdef __USE_PROTOS
+zzcr_attr(Attrib *a,int token,char *text)
+#else
+zzcr_attr(a,token,text)
+Attrib *a;
+int token;
+char *text;
+#endif
+{
+ *a = (char *) malloc(strlen(text)+1); /* MR6 */
+ if ( *a == NULL ) {fprintf(stderr, "zzcr_attr: out of memory!\n"); exit(-1);}
+ strcpy(*a, text);
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/charptr.h b/BaseTools/Source/C/VfrCompile/Pccts/h/charptr.h new file mode 100644 index 0000000000..e73da681a4 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/charptr.h @@ -0,0 +1,48 @@ +/*
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+/*
+ * WARNING!!!!: charptr.h does NOT make copies and the
+ * memory is freed after the attribute scope exits.
+ */
+
+#ifndef ZZCHARPTR_H
+#define ZZCHARPTR_H
+
+typedef char *Attrib;
+#define zzdef0(a) {*(a)=NULL;}
+/* MR8 Jens Tingleff (jensting@imaginet.fr) */
+/* Set memory pointer to null after free() */
+#define zzd_attr(a) {if ( *(a)!=NULL ) {free(*(a)); *(a)=NULL; }; }
+
+#ifdef __STDC__
+extern zzcr_attr(Attrib *,int,char *);
+#endif
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/config.h b/BaseTools/Source/C/VfrCompile/Pccts/h/config.h new file mode 100644 index 0000000000..8aa50ad618 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/config.h @@ -0,0 +1 @@ +#include "pcctscfg.h"
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/dlgauto.h b/BaseTools/Source/C/VfrCompile/Pccts/h/dlgauto.h new file mode 100644 index 0000000000..db94cefaca --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/dlgauto.h @@ -0,0 +1,504 @@ +/* dlgauto.h automaton
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Will Cohen and Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+#ifndef ZZDEFAUTO_H
+#define ZZDEFAUTO_H
+
+/* 10-Apr-97 133MR1 Uses __USE_PROTOS show should #include pcctscfg.h */
+
+#include "pcctscfg.h"
+
+zzchar_t *zzlextext; /* text of most recently matched token */
+zzchar_t *zzbegexpr; /* beginning of last reg expr recogn. */
+zzchar_t *zzendexpr; /* beginning of last reg expr recogn. */
+int zzbufsize = 0; /* number of characters in zzlextext */ /* MR7 */
+int zzbegcol = 0; /* column that first character of token is in*/
+int zzendcol = 0; /* column that last character of token is in */
+int zzline = 1; /* line current token is on */
+int zzreal_line=1; /* line of 1st portion of token that is not skipped */
+int zzchar; /* character to determine next state */
+int zzbufovf; /* indicates that buffer too small for text */
+int zzcharfull = 0;
+static zzchar_t *zznextpos;/* points to next available position in zzlextext*/
+static int zzclass;
+
+#ifdef __USE_PROTOS
+void zzerrstd(const char *);
+void (*zzerr)(const char *)=zzerrstd;/* pointer to error reporting function */
+extern int zzerr_in(void);
+static int (*zzfunc_in)(void) = zzerr_in; /* MR20 */
+#else
+void zzerrstd();
+void (*zzerr)()=zzerrstd; /* pointer to error reporting function */
+extern int zzerr_in();
+static int (*zzfunc_in)() = zzerr_in; /* MR20 */
+#endif
+
+static FILE *zzstream_in=0;
+static zzchar_t *zzstr_in=0;
+
+#ifdef USER_ZZMODE_STACK
+int zzauto = 0;
+#else
+static int zzauto = 0;
+#endif
+static int zzadd_erase;
+static char zzebuf[70];
+
+#ifdef ZZCOL
+#define ZZINC (++zzendcol)
+#else
+#define ZZINC
+#endif
+
+
+#define ZZGETC_STREAM {zzchar = getc(zzstream_in); zzclass = ZZSHIFT(zzchar);}
+#define ZZGETC_FUNC {zzchar = (*zzfunc_in)(); zzclass = ZZSHIFT(zzchar);}
+#define ZZGETC_STR { \
+ if (*zzstr_in){ \
+ zzchar = *zzstr_in; \
+ ++zzstr_in; \
+ }else{ \
+ zzchar = EOF; \
+ } \
+ zzclass = ZZSHIFT(zzchar); \
+}
+
+#define ZZNEWSTATE (newstate = dfa[state][zzclass])
+
+#ifndef ZZCOPY
+#define ZZCOPY \
+ /* Truncate matching buffer to size (not an error) */ \
+ if (zznextpos < lastpos){ \
+ *(zznextpos++) = zzchar; \
+ }else{ \
+ zzbufovf = 1; \
+ }
+#endif
+
+void
+#ifdef __USE_PROTOS
+zzrdstream( FILE *f )
+#else
+zzrdstream( f )
+FILE *f;
+#endif
+{
+ /* make sure that it is really set to something, otherwise just
+ leave it be.
+ */
+ if (f){
+ /* make sure that there is always someplace to get input
+ before closing zzstream_in
+ */
+#if 0
+ if (zzstream_in && zzstream_in!=stdin) fclose( zzstream_in );
+#endif
+ zzline = 1;
+ zzstream_in = f;
+ zzfunc_in = NULL;
+ zzstr_in = 0;
+ zzcharfull = 0;
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+zzrdfunc( int (*f)(void) )
+#else
+zzrdfunc( f )
+int (*f)();
+#endif
+{
+ /* make sure that it is really set to something, otherwise just
+ leave it be.
+ */
+ if (f){
+ /* make sure that there is always someplace to get input
+ before closing zzstream_in
+ */
+#if 0
+ if (zzstream_in && zzstream_in!=stdin) fclose( zzstream_in );
+#endif
+ zzline = 1;
+ zzstream_in = NULL;
+ zzfunc_in = f;
+ zzstr_in = 0;
+ zzcharfull = 0;
+ }
+}
+
+
+void
+#ifdef __USE_PROTOS
+zzrdstr( zzchar_t *s )
+#else
+zzrdstr( s )
+zzchar_t *s;
+#endif
+{
+ /* make sure that it is really set to something, otherwise just
+ leave it be.
+ */
+ if (s){
+ /* make sure that there is always someplace to get input
+ before closing zzstream_in
+ */
+#if 0
+ if (zzstream_in && zzstream_in!=stdin) fclose( zzstream_in );
+#endif
+ zzline = 1;
+ zzstream_in = NULL;
+ zzfunc_in = 0;
+ zzstr_in = s;
+ zzcharfull = 0;
+ }
+}
+
+
+#ifdef __USE_PROTOS
+void zzclose_stream(void)
+#else
+void zzclose_stream()
+#endif
+{
+#if 0
+ fclose( zzstream_in );
+ zzstream_in = NULL;
+ zzfunc_in = NULL;
+#endif
+}
+
+/* saves dlg state, but not what feeds dlg (such as file position) */
+void
+#ifdef __USE_PROTOS
+zzsave_dlg_state(struct zzdlg_state *state)
+#else
+zzsave_dlg_state(state)
+struct zzdlg_state *state;
+#endif
+{
+ state->stream = zzstream_in;
+ state->func_ptr = zzfunc_in;
+ state->str = zzstr_in;
+ state->auto_num = zzauto;
+ state->add_erase = zzadd_erase;
+ state->lookc = zzchar;
+ state->char_full = zzcharfull;
+ state->begcol = zzbegcol;
+ state->endcol = zzendcol;
+ state->line = zzline;
+ state->lextext = zzlextext;
+ state->begexpr = zzbegexpr;
+ state->endexpr = zzendexpr;
+ state->bufsize = zzbufsize;
+ state->bufovf = zzbufovf;
+ state->nextpos = zznextpos;
+ state->class_num = zzclass;
+}
+
+void
+#ifdef __USE_PROTOS
+zzrestore_dlg_state(struct zzdlg_state *state)
+#else
+zzrestore_dlg_state(state)
+struct zzdlg_state *state;
+#endif
+{
+ zzstream_in = state->stream;
+ zzfunc_in = state->func_ptr;
+ zzstr_in = state->str;
+ zzauto = state->auto_num;
+ zzadd_erase = state->add_erase;
+ zzchar = state->lookc;
+ zzcharfull = state->char_full;
+ zzbegcol = state->begcol;
+ zzendcol = state->endcol;
+ zzline = state->line;
+ zzlextext = state->lextext;
+ zzbegexpr = state->begexpr;
+ zzendexpr = state->endexpr;
+ zzbufsize = state->bufsize;
+ zzbufovf = state->bufovf;
+ zznextpos = state->nextpos;
+ zzclass = state->class_num;
+}
+
+void
+#ifdef __USE_PROTOS
+zzmode( int m )
+#else
+zzmode( m )
+int m;
+#endif
+{
+ /* points to base of dfa table */
+ if (m<MAX_MODE){
+ zzauto = m;
+ /* have to redo class since using different compression */
+ zzclass = ZZSHIFT(zzchar);
+ }else{
+ sprintf(zzebuf,"Invalid automaton mode = %d ",m);
+ zzerr(zzebuf);
+ }
+}
+
+/* erase what is currently in the buffer, and get a new reg. expr */
+
+#ifdef __USE_PROTOS
+void zzskip(void)
+#else
+void zzskip()
+#endif
+{
+ zzadd_erase = 1;
+}
+
+/* don't erase what is in the zzlextext buffer, add on to it */
+#ifdef __USE_PROTOS
+void zzmore()
+#else
+void zzmore()
+#endif
+{
+ zzadd_erase = 2;
+}
+
+/* substitute c for the reg. expr last matched and is in the buffer */
+#ifdef __USE_PROTOS
+void
+zzreplchar(zzchar_t c)
+#else
+void
+zzreplchar(c)
+zzchar_t c;
+#endif
+{
+ /* can't allow overwriting null at end of string */
+ if (zzbegexpr < &zzlextext[zzbufsize-1]){
+ *zzbegexpr = c;
+ *(zzbegexpr+1) = '\0';
+ }
+ zzendexpr = zzbegexpr;
+ if (c != '\0') {
+ zznextpos = zzbegexpr + 1;
+ }
+ else {
+ zznextpos = zzbegexpr; /* MR30 Zero terminates string. */
+ }
+}
+
+/* replace the string s for the reg. expr last matched and in the buffer */
+void
+#ifdef __USE_PROTOS
+zzreplstr(register zzchar_t *s)
+#else
+zzreplstr(s)
+register zzchar_t *s;
+#endif
+{
+ register zzchar_t *l= &zzlextext[zzbufsize -1];
+
+ zznextpos = zzbegexpr;
+ if (s){
+ while ((zznextpos <= l) && (*(zznextpos++) = *(s++))!=0){
+ /* empty */
+ }
+ /* correct for NULL at end of string */
+ zznextpos--;
+ }
+ if ((zznextpos <= l) && (*(--s) == 0)){
+ zzbufovf = 0;
+ }else{
+ zzbufovf = 1;
+ }
+ *(zznextpos) = '\0';
+ zzendexpr = zznextpos - 1;
+}
+
+#ifdef __USE_PROTOS
+void zzgettok(void)
+#else
+void zzgettok()
+#endif
+{
+ register int state, newstate;
+ /* last space reserved for the null char */
+ zzchar_t *lastpos; /* MR27 Remove register since address operator used. */
+
+skip:
+ zzreal_line = zzline;
+ zzbufovf = 0;
+ lastpos = &zzlextext[zzbufsize-1];
+ zznextpos = zzlextext;
+ zzbegcol = zzendcol+1;
+more:
+ zzbegexpr = zznextpos;
+#ifdef ZZINTERACTIVE
+ /* interactive version of automaton */
+ /* if there is something in zzchar, process it */
+ state = newstate = dfa_base[zzauto];
+ if (zzcharfull){
+ ZZINC;
+ ZZCOPY;
+ ZZNEWSTATE;
+ }
+ if (zzstr_in)
+ while (zzalternatives[newstate]){
+ state = newstate;
+ ZZGETC_STR;
+ ZZINC;
+ ZZCOPY;
+ ZZNEWSTATE;
+ }
+ else if (zzstream_in)
+ while (zzalternatives[newstate]){
+ state = newstate;
+ ZZGETC_STREAM;
+ ZZINC;
+ ZZCOPY;
+ ZZNEWSTATE;
+ }
+ else if (zzfunc_in)
+ while (zzalternatives[newstate]){
+ state = newstate;
+ ZZGETC_FUNC;
+ ZZINC;
+ ZZCOPY;
+ ZZNEWSTATE;
+ }
+ /* figure out if last character really part of token */
+ if ((state != dfa_base[zzauto]) && (newstate == DfaStates)){
+ zzcharfull = 1;
+ --zznextpos;
+ }else{
+ zzcharfull = 0;
+ state = newstate;
+ }
+ *(zznextpos) = '\0';
+ /* Able to transition out of start state to some non err state?*/
+ if ( state == dfa_base[zzauto] ){
+ /* make sure doesn't get stuck */
+ zzadvance();
+ }
+#else
+ /* non-interactive version of automaton */
+ if (!zzcharfull)
+ zzadvance();
+ else
+ ZZINC;
+ state = dfa_base[zzauto];
+ if (zzstr_in)
+ while (ZZNEWSTATE != DfaStates){
+ state = newstate;
+ ZZCOPY;
+ ZZGETC_STR;
+ ZZINC;
+ }
+ else if (zzstream_in)
+ while (ZZNEWSTATE != DfaStates){
+ state = newstate;
+ ZZCOPY;
+ ZZGETC_STREAM;
+ ZZINC;
+ }
+ else if (zzfunc_in)
+ while (ZZNEWSTATE != DfaStates){
+ state = newstate;
+ ZZCOPY;
+ ZZGETC_FUNC;
+ ZZINC;
+ }
+ zzcharfull = 1;
+ if ( state == dfa_base[zzauto] ){
+ if (zznextpos < lastpos){
+ *(zznextpos++) = zzchar;
+ }else{
+ zzbufovf = 1;
+ }
+ *zznextpos = '\0';
+ /* make sure doesn't get stuck */
+ zzadvance();
+ }else{
+ *zznextpos = '\0';
+ }
+#endif
+#ifdef ZZCOL
+ zzendcol -= zzcharfull;
+#endif
+ zzendexpr = zznextpos -1;
+ zzadd_erase = 0;
+ (*actions[accepts[state]])();
+ switch (zzadd_erase) {
+ case 1: goto skip;
+ case 2: goto more;
+ }
+}
+
+#ifdef __USE_PROTOS
+void zzadvance(void)
+#else
+void zzadvance()
+#endif
+{
+ if (zzstream_in) { ZZGETC_STREAM; zzcharfull = 1; ZZINC;}
+ if (zzfunc_in) { ZZGETC_FUNC; zzcharfull = 1; ZZINC;}
+ if (zzstr_in) { ZZGETC_STR; zzcharfull = 1; ZZINC;}
+ if (!(zzstream_in || zzfunc_in || zzstr_in)){
+ zzerr_in();
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+zzerrstd(const char *s)
+#else
+zzerrstd(s)
+char *s;
+#endif
+{
+ zzLexErrCount++; /* MR11 */
+ fprintf(stderr,
+ "%s near line %d (text was '%s')\n",
+ ((s == NULL) ? "Lexical error" : s),
+ zzline,zzlextext);
+}
+
+#ifdef __USE_PROTOS
+int zzerr_in(void)
+#else
+int zzerr_in()
+#endif
+{
+ fprintf(stderr,"No input stream, function, or string\n");
+ /* return eof to get out gracefully */
+ return EOF;
+}
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/dlgdef.h b/BaseTools/Source/C/VfrCompile/Pccts/h/dlgdef.h new file mode 100644 index 0000000000..733d2568e3 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/dlgdef.h @@ -0,0 +1,128 @@ +/* dlgdef.h
+ * Things in scanner produced by dlg that should be visible to the outside
+ * world
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+#ifndef ZZDLGDEF_H
+#define ZZDLGDEF_H
+
+#include "pcctscfg.h"
+
+#ifndef zzchar_t
+#ifdef ZZWCHAR_T
+#define zzchar_t wchar_t
+#else
+#define zzchar_t char
+#endif
+#endif
+
+struct zzdlg_state {
+ FILE *stream;
+#ifdef __USE_PROTOS
+ int (*func_ptr)(void);
+#else
+ int (*func_ptr)();
+#endif
+ zzchar_t *str;
+ int auto_num;
+ int add_erase;
+ int lookc;
+ int char_full;
+ int begcol, endcol;
+ int line;
+ zzchar_t *lextext, *begexpr, *endexpr;
+ int bufsize;
+ int bufovf;
+ zzchar_t *nextpos;
+ int class_num;
+};
+
+extern zzchar_t *zzlextext; /* text of most recently matched token */
+extern zzchar_t *zzbegexpr; /* beginning of last reg expr recogn. */
+extern zzchar_t *zzendexpr; /* beginning of last reg expr recogn. */
+extern int zzbufsize; /* how long zzlextext is */
+extern int zzbegcol; /* column that first character of token is in*/
+extern int zzendcol; /* column that last character of token is in */
+extern int zzline; /* line current token is on */
+extern int zzreal_line; /* line of 1st portion of token that is not skipped */
+extern int zzchar; /* character to determine next state */
+extern int zzbufovf; /* indicates that buffer too small for text */
+#ifdef __USE_PROTOS
+extern void (*zzerr)(const char *);/* pointer to error reporting function */
+#else
+extern void (*zzerr)();
+#endif
+
+#ifdef USER_ZZMODE_STACK
+extern int zzauto;
+#endif
+
+#ifdef __USE_PROTOS
+extern void zzadvance(void);
+extern void zzskip(void); /* erase zzlextext, look for antoher token */
+extern void zzmore(void); /* keep zzlextext, look for another token */
+extern void zzmode(int k); /* switch to automaton 'k' */
+extern void zzrdstream(FILE *);/* what stream to read from */
+extern void zzclose_stream(void);/* close the current input stream */
+extern void zzrdfunc(int (*)(void));/* what function to get char from */
+extern void zzrdstr( zzchar_t * );
+extern void zzgettok(void); /* get next token */
+extern void zzreplchar(zzchar_t c);/* replace last recognized reg. expr. with
+ a character */
+extern void zzreplstr(zzchar_t *s);/* replace last recognized reg. expr. with
+ a string */
+extern void zzsave_dlg_state(struct zzdlg_state *);
+extern void zzrestore_dlg_state(struct zzdlg_state *);
+extern int zzerr_in(void);
+extern void zzerrstd(const char *);
+extern void zzerraction(void);
+
+#else
+
+extern void zzadvance();
+extern void zzskip(); /* erase zzlextext, look for antoher token */
+extern void zzmore(); /* keep zzlextext, look for another token */
+extern void zzmode(/*k*/); /* switch to automaton 'k' */
+extern void zzrdstream(); /* what stream to read from */
+extern void zzclose_stream();/* close the current input stream */
+extern void zzrdfunc(); /* what function to get char from */
+extern void zzrdstr();
+extern void zzgettok(); /* get next token */
+extern void zzreplchar(); /* replace last recognized reg. expr. with
+ a character */
+extern void zzreplstr(); /* replace last recognized reg. expr. with
+ a string */
+extern void zzsave_dlg_state();
+extern void zzrestore_dlg_state();
+extern int zzerr_in();
+extern void zzerrstd();
+extern void zzerraction();
+#endif
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/err.h b/BaseTools/Source/C/VfrCompile/Pccts/h/err.h new file mode 100644 index 0000000000..b2b196bd75 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/err.h @@ -0,0 +1,1170 @@ +/*
+ * err.h
+ *
+ * Standard error handling mechanism
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * Has grown to hold all kinds of stuff (err.h is increasingly misnamed)
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+#ifndef ERR_H
+#define ERR_H
+
+#include "pcctscfg.h"
+#include <stdlib.h>
+#include <assert.h>
+
+/* */
+/* 7-Apr-97 133MR1 */
+/* Proper choice of STDC and cplusplus pre-processor symbols (?) */
+/* */
+#include "pccts_string.h"
+
+#ifdef PCCTS_USE_STDARG
+#include "pccts_stdarg.h"
+#else
+#include <varargs.h>
+#endif
+
+#ifdef DUM
+/* Define usable bits per unsigned int word (used for set stuff) */
+#ifdef PC
+#define BSETWORDSIZE 16
+#define BSETLOGWORDSIZE 4
+#else
+#define BSETWORDSIZE 32
+#define BSETLOGWORDSIZE 5
+#endif
+#endif
+
+#define BSETWORDSIZE 8
+#define BSETLOGWORDSIZE 3 /* SetWordType is 8bits */
+
+#define BSETMODWORD(x) ((x) & (BSETWORDSIZE-1)) /* x % BSETWORDSIZE */
+#define BSETDIVWORD(x) ((x) >> BSETLOGWORDSIZE) /* x / BSETWORDSIZE */
+
+/* This is not put into the global pccts_parser structure because it is
+ * hidden and does not need to be saved during a "save state" operation
+ */
+/* maximum of 32 bits/unsigned int and must be 8 bits/byte */
+static SetWordType bitmask[] = {
+ 0x00000001, 0x00000002, 0x00000004, 0x00000008,
+ 0x00000010, 0x00000020, 0x00000040, 0x00000080
+};
+
+#ifdef zzTRACE_RULES
+int zzTraceOptionValueDefault=1;
+int zzTraceOptionValue=1;
+int zzTraceGuessOptionValue=1;
+char *zzTraceCurrentRuleName=NULL;
+int zzTraceDepth=0;
+#endif
+
+int zzGuessSeq=0; /* MR10 */
+int zzSyntaxErrCount=0; /* MR11 */
+int zzLexErrCount=0; /* MR11 */
+
+void
+#ifdef __USE_PROTOS
+zzresynch(SetWordType *wd,SetWordType mask)
+#else
+zzresynch(wd,mask)
+SetWordType *wd, mask;
+#endif
+{
+ static int consumed = 1;
+
+ /* if you enter here without having consumed a token from last resynch
+ * force a token consumption.
+ */
+ if ( !consumed ) {zzCONSUME; consumed=1; return;} /* MR10 */
+
+ /* if current token is in resynch set, we've got what we wanted */
+ if ( wd[LA(1)]&mask || LA(1) == zzEOF_TOKEN ) {consumed=0; return;}
+
+ /* scan until we find something in the resynch set */
+ while ( !(wd[LA(1)]&mask) && LA(1) != zzEOF_TOKEN ) {zzCONSUME;}
+ consumed=1;
+}
+
+/* */
+/* 7-Apr-97 133MR1 for C++ and MR7 for C */
+/* Change suggested by Eli Sternheim (eli@interhdl.com) */
+/* */
+
+void
+#ifdef __USE_PROTOS
+zzconsumeUntil(SetWordType *st)
+#else
+zzconsumeUntil(st)
+SetWordType *st;
+#endif
+{
+ int tmp; /* MR7 */
+ while ( !zzset_el( (tmp=LA(1)), st) && tmp!=1 /* Eof */) { /* MR7 */
+ zzCONSUME; } /* MR7 */
+}
+
+/* */
+/* 7-Apr-97 133MR1 for C++ and MR7 for C */
+/* Change suggested by Eli Sternheim (eli@interhdl.com) */
+/* */
+
+void
+#ifdef __USE_PROTOS
+zzconsumeUntilToken(int t)
+#else
+zzconsumeUntilToken(t)
+int t;
+#endif
+{
+ int tmp; /* MR7 */
+ while ( (tmp=LA(1)) !=t && tmp!=1 /* Eof */) { zzCONSUME; } /* MR7 */
+}
+
+/* input looks like:
+ * zzFAIL(k, e1, e2, ...,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText)
+ * where the zzMiss stuff is set here to the token that did not match
+ * (and which set wasn't it a member of).
+ */
+
+#ifdef PCCTS_USE_STDARG
+void zzFAIL(int k, ...)
+#else
+void zzFAIL(va_alist)
+va_dcl
+#endif
+{
+#ifdef LL_K
+ static char text[LL_K*ZZLEXBUFSIZE+1];
+ SetWordType *f[LL_K];
+#else
+ static char text[ZZLEXBUFSIZE+1];
+ SetWordType *f[1];
+#endif
+ SetWordType **miss_set;
+ char **miss_text;
+ int *bad_tok;
+ char **bad_text;
+ int *err_k;
+ int i;
+ va_list ap;
+#ifndef PCCTS_USE_STDARG /* MR20 */
+ int k;
+#endif
+#ifdef PCCTS_USE_STDARG /* MR20 */
+ va_start(ap, k);
+#else
+ va_start(ap);
+ k = va_arg(ap, int); /* how many lookahead sets? */
+#endif
+ assert(k <= sizeof(f)/sizeof(f[0])); /* MR20 G. Hobbelt */
+ text[0] = '\0';
+ for (i=1; i<=k; i++) /* collect all lookahead sets */
+ {
+ f[i-1] = va_arg(ap, SetWordType *);
+ }
+ for (i=1; i<=k; i++) /* look for offending token */
+ {
+ if ( i>1 ) strcat(text, " ");
+ strcat(text, LATEXT(i));
+ if ( !zzset_el((unsigned)LA(i), f[i-1]) ) break;
+ }
+ miss_set = va_arg(ap, SetWordType **);
+ miss_text = va_arg(ap, char **);
+ bad_tok = va_arg(ap, int *);
+ bad_text = va_arg(ap, char **);
+ err_k = va_arg(ap, int *);
+ if ( i>k )
+ {
+ /* bad; lookahead is permutation that cannot be matched,
+ * but, the ith token of lookahead is valid at the ith position
+ * (The old LL sub 1 (k) versus LL(k) parsing technique)
+ */
+ *miss_set = NULL;
+ *miss_text = zzlextext;
+ *bad_tok = LA(1);
+ *bad_text = LATEXT(1);
+ *err_k = k;
+ return;
+ }
+/* fprintf(stderr, "%s not in %dth set\n", zztokens[LA(i)], i);*/
+ *miss_set = f[i-1];
+ *miss_text = text;
+ *bad_tok = LA(i);
+ *bad_text = LATEXT(i);
+ if ( i==1 ) *err_k = 1;
+ else *err_k = k;
+}
+
+#ifdef __USE_PROTOS
+void zzTraceGuessDone(zzantlr_state *state)
+#else
+void zzTraceGuessDone(state)
+ zzantlr_state *state;
+#endif
+{
+#ifdef zzTRACE_RULES
+#ifdef ZZCAN_GUESS
+
+ int doIt=0;
+
+ if (zzTraceCurrentRuleName == NULL) return;
+
+ if (zzTraceOptionValue <= 0) {
+ doIt=0;
+ } else if (zzTraceGuessOptionValue <= 0) {
+ doIt=0;
+ } else {
+ doIt=1;
+ };
+
+ if (doIt) {
+ fprintf(stderr,"guess done - returning to rule %s {\"%s\"} at depth %d",
+ state->traceCurrentRuleName,
+ LATEXT(1),
+ state->traceDepth);
+ if (state->guessing != 0) {
+ fprintf(stderr," (guess mode continues - an enclosing guess is still active)");
+ } else {
+ fprintf(stderr," (guess mode ends)");
+ };
+ fprintf(stderr,"\n");
+ };
+#endif
+#endif
+}
+
+void
+#ifdef __USE_PROTOS
+zzsave_antlr_state(zzantlr_state *buf)
+#else
+zzsave_antlr_state(buf)
+zzantlr_state *buf;
+#endif
+{
+#ifdef LL_K
+ int i;
+#endif
+
+#ifdef ZZCAN_GUESS
+ buf->guess_start = zzguess_start;
+ buf->guessing = zzguessing;
+#endif
+ buf->asp = zzasp;
+#ifdef GENAST
+ buf->ast_sp = zzast_sp;
+#endif
+#ifdef ZZINF_LOOK
+ buf->inf_labase = zzinf_labase;
+ buf->inf_last = zzinf_last;
+
+/* MR6 Gunnar Rxnning (gunnar@candleweb.no) */
+/* MR6 Additional state needs to be saved/restored */
+
+ buf->inf_tokens = zzinf_tokens; /* MR6 */
+ buf->inf_text = zzinf_text; /* MR6 */
+ buf->inf_text_buffer = zzinf_text_buffer; /* MR6 */
+ buf->inf_line = zzinf_line; /* MR6 */
+
+#endif
+#ifdef DEMAND_LOOK
+ buf->dirty = zzdirty;
+#endif
+#ifdef LL_K
+ for (i=0; i<LL_K; i++) buf->tokenLA[i] = zztokenLA[i];
+ for (i=0; i<LL_K; i++) strcpy(buf->textLA[i], zztextLA[i]);
+ buf->lap = zzlap;
+ buf->labase = zzlabase;
+#else
+ buf->token = zztoken;
+ strcpy(buf->text, zzlextext);
+#endif
+#ifdef zzTRACE_RULES
+
+ /* MR10 */
+
+ buf->traceOptionValue=zzTraceOptionValue;
+ buf->traceGuessOptionValue=zzTraceGuessOptionValue;
+ buf->traceCurrentRuleName=zzTraceCurrentRuleName;
+ buf->traceDepth=zzTraceDepth;
+#endif
+}
+
+void
+#ifdef __USE_PROTOS
+zzrestore_antlr_state(zzantlr_state *buf)
+#else
+zzrestore_antlr_state(buf)
+zzantlr_state *buf;
+#endif
+{
+
+#ifdef zzTRACE_RULES
+ int prevTraceOptionValue;
+#endif
+
+#ifdef LL_K
+ int i;
+#endif
+
+#ifdef ZZCAN_GUESS
+ zzguess_start = buf->guess_start;
+ zzguessing = buf->guessing;
+#endif
+ zzasp = buf->asp;
+#ifdef GENAST
+ zzast_sp = buf->ast_sp;
+#endif
+#ifdef ZZINF_LOOK
+ zzinf_labase = buf->inf_labase;
+ zzinf_last = buf->inf_last;
+
+/* MR6 Gunnar Rxnning (gunnar@candleweb.no) */
+/* MR6 Additional state needs to be saved/restored */
+
+ zzinf_tokens = buf->inf_tokens; /* MR6 */
+ zzinf_text = buf->inf_text; /* MR6 */
+ zzinf_text_buffer = buf->inf_text_buffer; /* MR6 */
+ zzinf_line = buf->inf_line; /* MR6 */
+#endif
+#ifdef DEMAND_LOOK
+ zzdirty = buf->dirty;
+#endif
+#ifdef LL_K
+ for (i=0; i<LL_K; i++) zztokenLA[i] = buf->tokenLA[i];
+ for (i=0; i<LL_K; i++) strcpy(zztextLA[i], buf->textLA[i]);
+ zzlap = buf->lap;
+ zzlabase = buf->labase;
+#else
+ zztoken = buf->token;
+ strcpy(zzlextext, buf->text);
+#endif
+#ifdef zzTRACE_RULES
+
+ prevTraceOptionValue=zzTraceOptionValue;
+ zzTraceOptionValue=buf->traceOptionValue;
+ if ( (prevTraceOptionValue > 0) !=
+ (zzTraceOptionValue > 0)) {
+ if (zzTraceOptionValue > 0) {
+ fprintf(stderr,"trace enable restored in rule %s depth %d\n",
+ zzTraceCurrentRuleName,zzTraceDepth);
+ };
+ if (zzTraceOptionValue <= 0) {
+ fprintf(stderr,"trace disable restored in rule %s depth %d\n",
+ zzTraceCurrentRuleName,zzTraceDepth);
+ };
+ };
+
+ zzTraceOptionValue=buf->traceOptionValue; /* MR10 */
+ zzTraceGuessOptionValue=buf->traceGuessOptionValue; /* MR10 */
+ zzTraceCurrentRuleName=buf->traceCurrentRuleName; /* MR10 */
+ zzTraceDepth=buf->traceDepth; /* MR10 */
+ zzTraceGuessDone(buf); /* MR10 */
+#endif
+}
+
+void
+#ifdef __USE_PROTOS
+zzedecode(SetWordType *a)
+#else
+zzedecode(a)
+SetWordType *a;
+#endif
+{
+ register SetWordType *p = a;
+ register SetWordType *endp = &(p[zzSET_SIZE]);
+ register unsigned e = 0;
+
+ if ( zzset_deg(a)>1 ) fprintf(stderr, " {");
+ do {
+ register SetWordType t = *p;
+ register SetWordType *b = &(bitmask[0]);
+ do {
+ if ( t & *b ) fprintf(stderr, " %s", zztokens[e]);
+ e++;
+ } while (++b < &(bitmask[sizeof(SetWordType)*8]));
+ } while (++p < endp);
+ if ( zzset_deg(a)>1 ) fprintf(stderr, " }");
+}
+
+#ifndef USER_ZZSYN
+/* standard error reporting function */
+void
+#ifdef __USE_PROTOS
+zzsyn(char *text, int tok, char *egroup, SetWordType *eset, int etok, int k, char *bad_text)
+#else
+zzsyn(text, tok, egroup, eset, etok, k, bad_text)
+char *text, *egroup, *bad_text;
+int tok;
+int etok;
+int k;
+SetWordType *eset;
+#endif
+{
+
+ zzSyntaxErrCount++; /* MR11 */
+ fprintf(stderr, "line %d: syntax error at \"%s\"", zzline, (tok==zzEOF_TOKEN)?"EOF":bad_text);
+ if ( !etok && !eset ) {fprintf(stderr, "\n"); return;}
+ if ( k==1 ) fprintf(stderr, " missing");
+ else
+ {
+ fprintf(stderr, "; \"%s\" not", bad_text);
+ if ( zzset_deg(eset)>1 ) fprintf(stderr, " in");
+ }
+ if ( zzset_deg(eset)>0 ) zzedecode(eset);
+ else fprintf(stderr, " %s", zztokens[etok]);
+ if ( strlen(egroup) > 0 ) fprintf(stderr, " in %s", egroup);
+ fprintf(stderr, "\n");
+}
+#endif
+
+/* is b an element of set p? */
+int
+#ifdef __USE_PROTOS
+zzset_el(unsigned b, SetWordType *p)
+#else
+zzset_el(b,p)
+unsigned b;
+SetWordType *p;
+#endif
+{
+ return( p[BSETDIVWORD(b)] & bitmask[BSETMODWORD(b)] );
+}
+
+int
+#ifdef __USE_PROTOS
+zzset_deg(SetWordType *a)
+#else
+zzset_deg(a)
+SetWordType *a;
+#endif
+{
+ /* Fast compute degree of a set... the number
+ of elements present in the set. Assumes
+ that all word bits are used in the set
+ */
+ register SetWordType *p = a;
+ register SetWordType *endp = &(a[zzSET_SIZE]);
+ register int degree = 0;
+
+ if ( a == NULL ) return 0;
+ while ( p < endp )
+ {
+ register SetWordType t = *p;
+ register SetWordType *b = &(bitmask[0]);
+ do {
+ if (t & *b) ++degree;
+ } while (++b < &(bitmask[sizeof(SetWordType)*8]));
+ p++;
+ }
+
+ return(degree);
+}
+
+#ifdef DEMAND_LOOK
+
+#ifdef LL_K
+int
+#ifdef __USE_PROTOS
+_zzmatch(int _t, char **zzBadText, char **zzMissText,
+ int *zzMissTok, int *zzBadTok,
+ SetWordType **zzMissSet)
+#else
+_zzmatch(_t, zzBadText, zzMissText, zzMissTok, zzBadTok, zzMissSet)
+int _t;
+char **zzBadText;
+char **zzMissText;
+int *zzMissTok, *zzBadTok;
+SetWordType **zzMissSet;
+#endif
+{
+ if ( zzdirty==LL_K ) {
+ zzCONSUME;
+ }
+ if ( LA(1)!=_t ) {
+ *zzBadText = *zzMissText=LATEXT(1);
+ *zzMissTok= _t; *zzBadTok=LA(1);
+ *zzMissSet=NULL;
+ return 0;
+ }
+ zzMakeAttr
+ zzdirty++;
+ zzlabase++;
+ return 1;
+}
+
+int
+#ifdef __USE_PROTOS
+_zzmatch_wsig(int _t)
+#else
+_zzmatch_wsig(_t)
+int _t;
+#endif
+{
+ if ( zzdirty==LL_K ) {
+ zzCONSUME;
+ }
+ if ( LA(1)!=_t ) {
+ return 0;
+ }
+ zzMakeAttr
+ zzdirty++;
+ zzlabase++;
+ return 1;
+}
+
+#else
+
+int
+#ifdef __USE_PROTOS
+_zzmatch(int _t, char **zzBadText, char **zzMissText,
+ int *zzMissTok, int *zzBadTok, SetWordType **zzMissSet)
+#else
+_zzmatch(_t, zzBadText, zzMissText, zzMissTok, zzBadTok, zzMissSet)
+int _t;
+char **zzBadText;
+char **zzMissText;
+int *zzMissTok, *zzBadTok;
+SetWordType **zzMissSet;
+#endif
+{
+ if ( zzdirty ) {zzCONSUME;}
+ if ( LA(1)!=_t ) {
+ *zzBadText = *zzMissText=LATEXT(1);
+ *zzMissTok= _t; *zzBadTok=LA(1);
+ *zzMissSet=NULL;
+ return 0;
+ }
+ zzdirty = 1;
+ zzMakeAttr
+ return 1;
+}
+
+int
+#ifdef __USE_PROTOS
+_zzmatch_wsig(int _t)
+#else
+_zzmatch_wsig(_t)
+int _t;
+#endif
+{
+ if ( zzdirty ) {zzCONSUME;}
+ if ( LA(1)!=_t ) {
+ return 0;
+ }
+ zzdirty = 1;
+ zzMakeAttr
+ return 1;
+}
+
+#endif /*LL_K*/
+
+#else
+
+int
+#ifdef __USE_PROTOS
+_zzmatch(int _t, char **zzBadText, char **zzMissText,
+ int *zzMissTok, int *zzBadTok,
+ SetWordType **zzMissSet)
+#else
+_zzmatch(_t, zzBadText, zzMissText, zzMissTok, zzBadTok, zzMissSet)
+int _t;
+char **zzBadText;
+char **zzMissText;
+int *zzMissTok, *zzBadTok;
+SetWordType **zzMissSet;
+#endif
+{
+ if ( LA(1)!=_t ) {
+ *zzBadText = *zzMissText=LATEXT(1);
+ *zzMissTok= _t; *zzBadTok=LA(1);
+ *zzMissSet=NULL;
+ return 0;
+ }
+ zzMakeAttr
+ return 1;
+}
+
+int
+#ifdef __USE_PROTOS
+_zzmatch_wsig(int _t)
+#else
+_zzmatch_wsig(_t)
+int _t;
+#endif
+{
+ if ( LA(1)!=_t ) return 0;
+ zzMakeAttr
+ return 1;
+}
+
+#endif /*DEMAND_LOOK*/
+
+#ifdef ZZINF_LOOK
+void
+#ifdef __USE_PROTOS
+_inf_zzgettok(void)
+#else
+_inf_zzgettok()
+#endif
+{
+ if ( zzinf_labase >= zzinf_last )
+ {NLA = zzEOF_TOKEN; strcpy(NLATEXT, "");}
+ else {
+ NLA = zzinf_tokens[zzinf_labase];
+ zzline = zzinf_line[zzinf_labase]; /* wrong in 1.21 */
+ strcpy(NLATEXT, zzinf_text[zzinf_labase]);
+ zzinf_labase++;
+ }
+}
+#endif
+
+#ifdef ZZINF_LOOK
+/* allocate default size text,token and line arrays;
+ * then, read all of the input reallocing the arrays as needed.
+ * Once the number of total tokens is known, the LATEXT(i) array (zzinf_text)
+ * is allocated and it's pointers are set to the tokens in zzinf_text_buffer.
+ */
+void
+#ifdef __USE_PROTOS
+zzfill_inf_look(void)
+#else
+zzfill_inf_look()
+#endif
+{
+ int tok, line;
+ int zzinf_token_buffer_size = ZZINF_DEF_TOKEN_BUFFER_SIZE;
+ int zzinf_text_buffer_size = ZZINF_DEF_TEXT_BUFFER_SIZE;
+ int zzinf_text_buffer_index = 0;
+ int zzinf_lap = 0;
+
+ /* allocate text/token buffers */
+ zzinf_text_buffer = (char *) malloc(zzinf_text_buffer_size);
+ if ( zzinf_text_buffer == NULL )
+ {
+ fprintf(stderr, "cannot allocate lookahead text buffer (%d bytes)\n",
+ zzinf_text_buffer_size);
+ exit(PCCTS_EXIT_FAILURE);
+ }
+ zzinf_tokens = (int *) calloc(zzinf_token_buffer_size,sizeof(int));
+ if ( zzinf_tokens == NULL )
+ {
+ fprintf(stderr, "cannot allocate token buffer (%d tokens)\n",
+ zzinf_token_buffer_size);
+ exit(PCCTS_EXIT_FAILURE);
+ }
+ zzinf_line = (int *) calloc(zzinf_token_buffer_size,sizeof(int));
+ if ( zzinf_line == NULL )
+ {
+ fprintf(stderr, "cannot allocate line buffer (%d ints)\n",
+ zzinf_token_buffer_size);
+ exit(PCCTS_EXIT_FAILURE);
+ }
+
+ /* get tokens, copying text to text buffer */
+ zzinf_text_buffer_index = 0;
+ do {
+ zzgettok();
+ line = zzreal_line;
+ while ( zzinf_lap>=zzinf_token_buffer_size )
+ {
+ zzinf_token_buffer_size += ZZINF_BUFFER_TOKEN_CHUNK_SIZE;
+ zzinf_tokens = (int *) realloc(zzinf_tokens,
+ zzinf_token_buffer_size*sizeof(int));
+ if ( zzinf_tokens == NULL )
+ {
+ fprintf(stderr, "cannot allocate lookahead token buffer (%d tokens)\n",
+ zzinf_token_buffer_size);
+ exit(PCCTS_EXIT_FAILURE);
+ }
+ zzinf_line = (int *) realloc(zzinf_line,
+ zzinf_token_buffer_size*sizeof(int));
+ if ( zzinf_line == NULL )
+ {
+ fprintf(stderr, "cannot allocate lookahead line buffer (%d ints)\n",
+ zzinf_token_buffer_size);
+ exit(PCCTS_EXIT_FAILURE);
+ }
+
+ }
+ while ( (zzinf_text_buffer_index+strlen(NLATEXT)+1) >= zzinf_text_buffer_size )
+ {
+ zzinf_text_buffer_size += ZZINF_BUFFER_TEXT_CHUNK_SIZE;
+ zzinf_text_buffer = (char *) realloc(zzinf_text_buffer,
+ zzinf_text_buffer_size);
+ if ( zzinf_text_buffer == NULL )
+ {
+ fprintf(stderr, "cannot allocate lookahead text buffer (%d bytes)\n",
+ zzinf_text_buffer_size);
+ exit(PCCTS_EXIT_FAILURE);
+ }
+ }
+ /* record token and text and line of input symbol */
+ tok = zzinf_tokens[zzinf_lap] = NLA;
+ strcpy(&zzinf_text_buffer[zzinf_text_buffer_index], NLATEXT);
+ zzinf_text_buffer_index += strlen(NLATEXT)+1;
+ zzinf_line[zzinf_lap] = line;
+ zzinf_lap++;
+ } while (tok!=zzEOF_TOKEN);
+ zzinf_labase = 0;
+ zzinf_last = zzinf_lap-1;
+
+ /* allocate ptrs to text of ith token */
+ zzinf_text = (char **) calloc(zzinf_last+1,sizeof(char *));
+ if ( zzinf_text == NULL )
+ {
+ fprintf(stderr, "cannot allocate lookahead text buffer (%d)\n",
+ zzinf_text_buffer_size);
+ exit(PCCTS_EXIT_FAILURE);
+ }
+ zzinf_text_buffer_index = 0;
+ zzinf_lap = 0;
+ /* set ptrs so that zzinf_text[i] is the text of the ith token found on input */
+ while (zzinf_lap<=zzinf_last)
+ {
+ zzinf_text[zzinf_lap++] = &zzinf_text_buffer[zzinf_text_buffer_index];
+ zzinf_text_buffer_index += strlen(&zzinf_text_buffer[zzinf_text_buffer_index])+1;
+ }
+}
+#endif
+
+int
+#ifdef __USE_PROTOS
+_zzsetmatch(SetWordType *e, char **zzBadText, char **zzMissText,
+ int *zzMissTok, int *zzBadTok,
+ SetWordType **zzMissSet,
+ SetWordType *zzTokclassErrset /* MR23 */)
+#else
+_zzsetmatch(e, zzBadText, zzMissText, zzMissTok, zzBadTok, zzMissSet, zzTokclassErrset /* MR23 */)
+SetWordType *e;
+char **zzBadText;
+char **zzMissText;
+int *zzMissTok, *zzBadTok;
+SetWordType **zzMissSet;
+SetWordType *zzTokclassErrset;
+#endif
+{
+#ifdef DEMAND_LOOK
+#ifdef LL_K
+ if ( zzdirty==LL_K ) {zzCONSUME;}
+#else
+ if ( zzdirty ) {zzCONSUME;}
+#endif
+#endif
+ if ( !zzset_el((unsigned)LA(1), e) ) {
+ *zzBadText = LATEXT(1); *zzMissText=NULL;
+ *zzMissTok= 0; *zzBadTok=LA(1);
+ *zzMissSet=zzTokclassErrset; /* MR23 */
+ return 0;
+ }
+ zzMakeAttr /* MR14 Ger Hobbelt (hobbelt@axa.nl) */
+#ifdef DEMAND_LOOK
+#ifdef LL_K
+ zzdirty++;
+ zzlabase++; /* MR14 Ger Hobbelt (hobbelt@axa.nl) */
+#else
+ zzdirty = 1;
+#endif
+#endif
+ return 1;
+}
+
+int
+#ifdef __USE_PROTOS
+_zzmatch_wdfltsig(int tokenWanted, SetWordType *whatFollows)
+#else
+_zzmatch_wdfltsig(tokenWanted, whatFollows)
+int tokenWanted;
+SetWordType *whatFollows;
+#endif
+{
+#ifdef DEMAND_LOOK
+#ifdef LL_K
+ if ( zzdirty==LL_K ) {
+ zzCONSUME;
+ }
+#else
+ if ( zzdirty ) {zzCONSUME;}
+#endif
+#endif
+
+ if ( LA(1)!=tokenWanted )
+ {
+ zzSyntaxErrCount++; /* MR11 */
+ fprintf(stderr,
+ "line %d: syntax error at \"%s\" missing %s\n",
+ zzline,
+ (LA(1)==zzEOF_TOKEN)?"<eof>":(char *)LATEXT(1),
+ zztokens[tokenWanted]);
+ zzconsumeUntil( whatFollows );
+ return 0;
+ }
+ else {
+ zzMakeAttr
+#ifdef DEMAND_LOOK
+#ifdef LL_K
+ zzdirty++;
+ zzlabase++;
+#else
+ zzdirty = 1;
+#endif
+#else
+/* zzCONSUME; consume if not demand lookahead */
+#endif
+ return 1;
+ }
+}
+
+int
+#ifdef __USE_PROTOS
+_zzsetmatch_wdfltsig(SetWordType *tokensWanted,
+ int tokenTypeOfSet,
+ SetWordType *whatFollows)
+#else
+_zzsetmatch_wdfltsig(tokensWanted, tokenTypeOfSet, whatFollows)
+SetWordType *tokensWanted;
+int tokenTypeOfSet;
+SetWordType *whatFollows;
+#endif
+{
+#ifdef DEMAND_LOOK
+#ifdef LL_K
+ if ( zzdirty==LL_K ) {zzCONSUME;}
+#else
+ if ( zzdirty ) {zzCONSUME;}
+#endif
+#endif
+ if ( !zzset_el((unsigned)LA(1), tokensWanted) )
+ {
+ zzSyntaxErrCount++; /* MR11 */
+ fprintf(stderr,
+ "line %d: syntax error at \"%s\" missing %s\n",
+ zzline,
+ (LA(1)==zzEOF_TOKEN)?"<eof>":(char *)LATEXT(1),
+ zztokens[tokenTypeOfSet]);
+ zzconsumeUntil( whatFollows );
+ return 0;
+ }
+ else {
+ zzMakeAttr
+#ifdef DEMAND_LOOK
+#ifdef LL_K
+ zzdirty++;
+ zzlabase++;
+#else
+ zzdirty = 1;
+#endif
+#else
+/* zzCONSUME; consume if not demand lookahead */
+#endif
+ return 1;
+ }
+}
+
+int
+#ifdef __USE_PROTOS
+_zzsetmatch_wsig(SetWordType *e)
+#else
+_zzsetmatch_wsig(e)
+SetWordType *e;
+#endif
+{
+#ifdef DEMAND_LOOK
+#ifdef LL_K
+ if ( zzdirty==LL_K ) {zzCONSUME;}
+#else
+ if ( zzdirty ) {zzCONSUME;}
+#endif
+#endif
+ if ( !zzset_el((unsigned)LA(1), e) ) return 0;
+ zzMakeAttr /* MR14 Ger Hobbelt (hobbelt@axa.nl) */
+#ifdef DEMAND_LOOK
+#ifdef LL_K
+ zzdirty++;
+ zzlabase++; /* MR14 Ger Hobbelt (hobbelt@axa.nl) */
+#else
+ zzdirty = 1;
+#endif
+#endif
+ return 1;
+}
+
+#ifdef USER_ZZMODE_STACK
+static int zzmstk[ZZMAXSTK] = { -1 };
+static int zzmdep = 0;
+static char zzmbuf[70];
+
+void
+#ifdef __USE_PROTOS
+zzmpush( int m )
+#else
+zzmpush( m )
+int m;
+#endif
+{
+ if(zzmdep == ZZMAXSTK - 1) {
+ sprintf(zzmbuf, "Mode stack overflow ");
+ zzerr(zzmbuf);
+ } else {
+ zzmstk[zzmdep++] = zzauto;
+ zzmode(m);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+zzmpop( void )
+#else
+zzmpop( )
+#endif
+{
+ if(zzmdep == 0)
+ { sprintf(zzmbuf, "Mode stack underflow ");
+ zzerr(zzmbuf);
+ }
+ else
+ { zzmdep--;
+ zzmode(zzmstk[zzmdep]);
+ }
+}
+
+void
+#ifdef __USE_PROTOS
+zzsave_mode_stack( int modeStack[], int *modeLevel )
+#else
+zzsave_mode_stack( modeStack, modeLevel )
+int modeStack[];
+int *modeLevel;
+#endif
+{
+ int i;
+ memcpy(modeStack, zzmstk, sizeof(zzmstk));
+ *modeLevel = zzmdep;
+ zzmdep = 0;
+
+ return;
+}
+
+void
+#ifdef __USE_PROTOS
+zzrestore_mode_stack( int modeStack[], int *modeLevel )
+#else
+zzrestore_mode_stack( modeStack, modeLevel )
+int modeStack[];
+int *modeLevel;
+#endif
+{
+ int i;
+
+ memcpy(zzmstk, modeStack, sizeof(zzmstk));
+ zzmdep = *modeLevel;
+
+ return;
+}
+#endif /* USER_ZZMODE_STACK */
+
+#ifdef __USE_PROTOS
+void zzTraceReset(void)
+#else
+void zzTraceReset()
+#endif
+{
+#ifdef zzTRACE_RULES
+ zzTraceOptionValue=zzTraceOptionValueDefault;
+ zzTraceGuessOptionValue=1;
+ zzTraceCurrentRuleName=NULL;
+ zzTraceDepth=0;
+#endif
+}
+
+#ifdef __USE_PROTOS
+void zzTraceGuessFail(void)
+#else
+void zzTraceGuessFail()
+#endif
+{
+
+#ifdef zzTRACE_RULES
+#ifdef ZZCAN_GUESS
+
+ int doIt=0;
+
+ if (zzTraceOptionValue <= 0) {
+ doIt=0;
+ } else if (zzguessing && zzTraceGuessOptionValue <= 0) {
+ doIt=0;
+ } else {
+ doIt=1;
+ };
+
+ if (doIt) {
+ fprintf(stderr,"guess failed\n");
+ };
+#endif
+#endif
+}
+
+/* zzTraceOption:
+ zero value turns off trace
+*/
+
+#ifdef __USE_PROTOS
+void zzTraceIn(char * rule)
+#else
+void zzTraceIn(rule)
+ char *rule;
+#endif
+{
+#ifdef zzTRACE_RULES
+
+ int doIt=0;
+
+ zzTraceDepth++;
+ zzTraceCurrentRuleName=rule;
+
+ if (zzTraceOptionValue <= 0) {
+ doIt=0;
+#ifdef ZZCAN_GUESS
+ } else if (zzguessing && zzTraceGuessOptionValue <= 0) {
+ doIt=0;
+#endif
+ } else {
+ doIt=1;
+ };
+
+ if (doIt) {
+ fprintf(stderr,"enter rule %s {\"%s\"} depth %d",
+ rule,
+ LA(1)==1 ? "@" : (char *) LATEXT(1), /* MR19 */
+ zzTraceDepth);
+#ifdef ZZCAN_GUESS
+ if (zzguessing) fprintf(stderr," guessing");
+#endif
+ fprintf(stderr,"\n");
+ };
+#endif
+ return;
+}
+
+#ifdef __USE_PROTOS
+void zzTraceOut(char * rule)
+#else
+void zzTraceOut(rule)
+ char *rule;
+#endif
+{
+#ifdef zzTRACE_RULES
+ int doIt=0;
+
+ zzTraceDepth--;
+
+ if (zzTraceOptionValue <= 0) {
+ doIt=0;
+#ifdef ZZCAN_GUESS
+ } else if (zzguessing && zzTraceGuessOptionValue <= 0) {
+ doIt=0;
+#endif
+ } else {
+ doIt=1;
+ };
+
+ if (doIt) {
+ fprintf(stderr,"exit rule %s {\"%s\"} depth %d",
+ rule,
+ LA(1)==1 ? "@" : (char *) LATEXT(1), /* MR19 */
+ zzTraceDepth+1);
+#ifdef ZZCAN_GUESS
+ if (zzguessing) fprintf(stderr," guessing");
+#endif
+ fprintf(stderr,"\n");
+ };
+#endif
+}
+
+#ifdef __USE_PROTOS
+int zzTraceOption(int delta)
+#else
+int zzTraceOption(delta)
+ int delta;
+#endif
+{
+#ifdef zzTRACE_RULES
+ int prevValue=zzTraceOptionValue;
+
+ zzTraceOptionValue=zzTraceOptionValue+delta;
+
+ if (zzTraceCurrentRuleName != NULL) {
+ if (prevValue <= 0 && zzTraceOptionValue > 0) {
+ fprintf(stderr,"trace enabled in rule %s depth %d\n",
+ zzTraceCurrentRuleName,zzTraceDepth);
+ };
+ if (prevValue > 0 && zzTraceOptionValue <= 0) {
+ fprintf(stderr,"trace disabled in rule %s depth %d\n",
+ zzTraceCurrentRuleName,zzTraceDepth);
+ };
+ };
+ return prevValue;
+#else
+ return 0;
+#endif
+}
+
+#ifdef __USE_PROTOS
+int zzTraceGuessOption(int delta)
+#else
+int zzTraceGuessOption(delta)
+ int delta;
+#endif
+{
+#ifdef zzTRACE_RULES
+#ifdef ZZCAN_GUESS
+ int prevValue=zzTraceGuessOptionValue;
+
+ zzTraceGuessOptionValue=zzTraceGuessOptionValue+delta;
+
+ if (zzTraceCurrentRuleName != NULL) {
+ if (prevValue <= 0 && zzTraceGuessOptionValue > 0) {
+ fprintf(stderr,"guess trace enabled in rule %s depth %d\n",
+ zzTraceCurrentRuleName,zzTraceDepth);
+ };
+ if (prevValue > 0 && zzTraceGuessOptionValue <= 0) {
+ fprintf(stderr,"guess trace disabled in rule %s depth %d\n",
+ zzTraceCurrentRuleName,zzTraceDepth);
+ };
+ };
+ return prevValue;
+#else
+ return 0;
+#endif
+#else
+ return 0;
+#endif
+}
+
+#endif /* ERR_H */
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/int.h b/BaseTools/Source/C/VfrCompile/Pccts/h/int.h new file mode 100644 index 0000000000..cdcaa92426 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/int.h @@ -0,0 +1,37 @@ +/* ANTLR attribute definition -- long integers
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * ANTLR 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+#ifndef ZZINT_H
+#define ZZINT_H
+
+typedef long Attrib;
+
+#define zzcr_attr(a,tok,t) *(a) = atol(t);
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_assert.h b/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_assert.h new file mode 100644 index 0000000000..ff0dfb5126 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_assert.h @@ -0,0 +1,10 @@ +#ifndef __PCCTS_ASSERT_H__
+#define __PCCTS_ASSERT_H__
+
+#ifdef PCCTS_USE_NAMESPACE_STD
+#include <cassert>
+#else
+#include <assert.h>
+#endif
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_iostream.h b/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_iostream.h new file mode 100644 index 0000000000..972b32cbd1 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_iostream.h @@ -0,0 +1,10 @@ +#ifndef __PCCTS_IOSTREAM_H__
+#define __PCCTS_IOSTREAM_H__
+
+#ifdef PCCTS_USE_NAMESPACE_STD
+#include <iostream>
+#else
+#include <iostream.h>
+#endif
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_istream.h b/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_istream.h new file mode 100644 index 0000000000..e25cb8c483 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_istream.h @@ -0,0 +1,10 @@ +#ifndef __PCCTS_ISTREAM_H__
+#define __PCCTS_ISTREAM_H__
+
+#ifdef PCCTS_USE_NAMESPACE_STD
+#include <istream>
+#else
+#include <istream.h>
+#endif
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_setjmp.h b/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_setjmp.h new file mode 100644 index 0000000000..9ea185ca73 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_setjmp.h @@ -0,0 +1,10 @@ +#ifndef __PCCTS_SETJMP_H__
+#define __PCCTS_SETJMP_H__
+
+#ifdef PCCTS_USE_NAMESPACE_STD
+#include <csetjmp>
+#else
+#include <setjmp.h>
+#endif
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_stdarg.h b/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_stdarg.h new file mode 100644 index 0000000000..e957430c32 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_stdarg.h @@ -0,0 +1,10 @@ +#ifndef __PCCTS_STDARG_H__
+#define __PCCTS_STDARG_H__
+
+#ifdef PCCTS_USE_NAMESPACE_STD
+#include <cstdarg>
+#else
+#include <stdarg.h>
+#endif
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_stdio.h b/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_stdio.h new file mode 100644 index 0000000000..ac34d1086d --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_stdio.h @@ -0,0 +1,10 @@ +#ifndef __PCCTS_STDIO_H__
+#define __PCCTS_STDIO_H__
+
+#ifdef PCCTS_USE_NAMESPACE_STD
+#include <cstdio>
+#else
+#include <stdio.h>
+#endif
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_stdlib.h b/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_stdlib.h new file mode 100644 index 0000000000..f0b344e8dc --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_stdlib.h @@ -0,0 +1,10 @@ +#ifndef __PCCTS_STDLIB_H__
+#define __PCCTS_STDLIB_H__
+
+#ifdef PCCTS_USE_NAMESPACE_STD
+#include <cstdlib>
+#else
+#include <stdlib.h>
+#endif
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_string.h b/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_string.h new file mode 100644 index 0000000000..458a08a94b --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/pccts_string.h @@ -0,0 +1,10 @@ +#ifndef __PCCTS_STRING_H__
+#define __PCCTS_STRING_H__
+
+#ifdef PCCTS_USE_NAMESPACE_STD
+#include <cstring>
+#else
+#include <string.h>
+#endif
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/pcctscfg.h b/BaseTools/Source/C/VfrCompile/Pccts/h/pcctscfg.h new file mode 100644 index 0000000000..0c3c5ba6fd --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/pcctscfg.h @@ -0,0 +1,359 @@ +#ifndef PCCTS_CONFIG_H
+#define PCCTS_CONFIG_H
+/*
+ * pcctscfg.h (formerly config.h) (for ANTLR, DLG, and SORCERER)
+ *
+ * This is a simple configuration file that doesn't have config stuff
+ * in it, but it's a start.
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
+ * Set (PCCTS) -- PCCTS is in the public domain. An individual or
+ * company may do whatever they wish with source code distributed with
+ * PCCTS or the code generated by PCCTS, including the incorporation of
+ * PCCTS, or its output, into commerical software.
+ *
+ * We encourage users to develop software with PCCTS. However, we do ask
+ * that credit is given to us for developing PCCTS. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like PCCTS and have developed a nice tool with the
+ * output, please mention that you developed it using PCCTS. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * Used by PCCTS 1.33 (SORCERER 1.00B11 and up)
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1989-2000
+ */
+
+/* This file knows about the following ``environments''
+ UNIX (default)
+ DOS (use #define PC)
+ MAC (use #define MPW; has a few things for THINK C, Metrowerks)
+ MS/C++ (MR14 Microsoft Visual C++ environment uses symbol _MSC_VER)
+
+ */
+
+/* should test __STDC__ for 1, but some compilers don't set value, just def */
+
+#ifndef __USE_PROTOS
+#ifdef __STDC__
+#define __USE_PROTOS
+#endif
+#ifdef __cplusplus
+#define __USE_PROTOS
+#endif
+#endif
+
+#ifdef PCCTS_USE_NAMESPACE_STD
+#define PCCTS_NAMESPACE_STD namespace std {}; using namespace std;
+#else
+#define PCCTS_NAMESPACE_STD
+#endif
+
+#include "pccts_stdio.h"
+#include "pccts_stdlib.h"
+
+/* largest file name size */
+
+#ifdef _MAX_PATH
+#define MaxFileName _MAX_PATH /* MR9 RJV: MAX_PATH defined in stdlib.h (MSVC++ 5.0) */
+#else
+#define MaxFileName 300
+#endif
+
+/*
+* Define PC32 if in a 32-bit PC environment (e.g. extended DOS or Win32).
+* The macros tested here are defined by Watcom, Microsoft, Borland,
+* and djgpp, respectively, when they are used as 32-bit compilers.
+* Users of these compilers *must* be sure to define PC in their
+* makefiles for this to work correctly.
+*/
+#ifdef PC
+# if (defined(__WATCOMC__) || defined(_WIN32) || defined(__WIN32__) || \
+ defined(__GNUC__) || defined(__GNUG__))
+# ifndef PC32
+# define PC32
+# endif
+# endif
+#endif
+
+/* MR1 10-Apr-97 Default for PC is short file names */
+/* MR1 Default for non-PC is long file names */
+/* MR1 Can override via command line option LONGFILENAMES */
+
+#ifndef LONGFILENAMES
+#ifndef PC
+#define LONGFILENAMES
+#endif
+#endif
+
+#ifndef LONGFILENAMES
+#define ATOKEN_H "AToken.h"
+#define ATOKPTR_H "ATokPtr.h"
+#define ATOKPTR_IMPL_H "ATokPtrIm.h"
+#define ATOKENBUFFER_H "ATokBuf.h"
+#define ATOKENBUFFER_C "ATokBuf.cpp"
+#define ATOKENSTREAM_H "ATokStr.h"
+#define APARSER_H "AParser.h"
+#define APARSER_C "AParser.cpp"
+#define ASTBASE_H "ASTBase.h"
+#define ASTBASE_C "ASTBase.cpp"
+#define PCCTSAST_C "PCCTSAST.cpp"
+#define LIST_C "List.cpp"
+#define DLEXERBASE_H "DLexBase.h"
+#define DLEXERBASE_C "DLexBase.cpp"
+#define DLEXER_H "DLexer.h"
+#define STREESUPPORT_C "STreeSup.C"
+#else
+#define ATOKEN_H "AToken.h"
+#define ATOKPTR_H "ATokPtr.h"
+#define ATOKPTR_IMPL_H "ATokPtrImpl.h"
+#define ATOKENBUFFER_H "ATokenBuffer.h"
+#define ATOKENBUFFER_C "ATokenBuffer.cpp"
+#define ATOKENSTREAM_H "ATokenStream.h"
+#define APARSER_H "AParser.h"
+#define APARSER_C "AParser.cpp"
+#define ASTBASE_H "ASTBase.h"
+#define ASTBASE_C "ASTBase.cpp"
+#define PCCTSAST_C "PCCTSAST.cpp"
+#define LIST_C "List.cpp"
+#define DLEXERBASE_H "DLexerBase.h"
+#define DLEXERBASE_C "DLexerBase.cpp"
+#define DLEXER_H "DLexer.h"
+#define STREESUPPORT_C "STreeSupport.cpp"
+#endif
+
+/* SORCERER Stuff */
+
+/* MR8 6-Aug-97 Change from ifdef PC to ifndef LONGFILENAMES */
+
+#ifndef LONGFILENAMES
+#define STPARSER_H "STreePar.h"
+#define STPARSER_C "STreePar.C"
+#else
+#define STPARSER_H "STreeParser.h"
+#define STPARSER_C "STreeParser.cpp"
+#endif
+
+#ifdef MPW
+#define CPP_FILE_SUFFIX ".cp"
+#define CPP_FILE_SUFFIX_NO_DOT "cp"
+#define OBJ_FILE_SUFFIX ".o"
+#else
+#ifdef PC
+#define CPP_FILE_SUFFIX ".cpp"
+#define CPP_FILE_SUFFIX_NO_DOT "cpp"
+#define OBJ_FILE_SUFFIX ".obj"
+#else
+#ifdef __VMS
+#define CPP_FILE_SUFFIX ".cpp"
+#define CPP_FILE_SUFFIX_NO_DOT "cpp"
+#define OBJ_FILE_SUFFIX ".obj"
+#else
+#define CPP_FILE_SUFFIX ".cpp"
+#define CPP_FILE_SUFFIX_NO_DOT "cpp"
+#define OBJ_FILE_SUFFIX ".o"
+#endif
+#endif
+#endif
+
+/* User may redefine how line information looks */ /* make it #line MR7 */
+/* MR21 Use #ifndef */
+
+#ifndef LineInfoFormatStr
+#define LineInfoFormatStr "#line %d \"%s\"\n"
+#endif
+
+#ifdef MPW /* Macintosh Programmer's Workshop */
+#define ErrHdr "File \"%s\"; Line %d #"
+#else
+#ifdef _MSC_VER /* MR14 Microsoft Visual C++ environment */
+#define ErrHdr "%s(%d) :"
+#else
+#define ErrHdr "%s, line %d:" /* default */
+#endif
+#endif
+
+/* must assume old K&R cpp here, can't use #if defined(..)... */
+
+#ifdef MPW
+#define TopDirectory ":"
+#define DirectorySymbol ":"
+#define OutputDirectoryOption "Directory where all output files should go (default=\":\")"
+#else
+#ifdef PC
+#define TopDirectory "."
+#define DirectorySymbol "\\"
+#define OutputDirectoryOption "Directory where all output files should go (default=\".\")"
+#else
+#ifdef __VMS
+#define TopDirectory "[000000]"
+#define DirectorySymbol "]"
+#define OutputDirectoryOption "Directory where all output files should go (default=\"[]\")"
+#else
+#define TopDirectory "."
+#define DirectorySymbol "/"
+#define OutputDirectoryOption "Directory where all output files should go (default=\".\")"
+#endif
+#endif
+#endif
+
+#ifdef MPW
+
+/* Make sure we have prototypes for all functions under MPW */
+
+#include "pccts_string.h"
+#include "pccts_stdlib.h"
+
+/* MR6 2-Jun-97 Fixes false dependency caused by VC++ #include scanner */
+/* MR6 Reported by Brad Schick (schick@interaccess.com) */
+#define MPW_CursorCtl_Header <CursorCtl.h>
+#include MPW_CursorCtl_Header
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern void fsetfileinfo (const char *filename, unsigned long newcreator, unsigned long newtype);
+#ifdef __cplusplus
+}
+#endif
+
+/* File creators for various popular development environments */
+
+#define MAC_FILE_CREATOR 'MPS ' /* MPW Text files */
+#if 0
+#define MAC_FILE_CREATOR 'KAHL' /* THINK C/Symantec C++ Text files */
+#endif
+#if 0
+#define MAC_FILE_CREATOR 'CWIE' /* Metrowerks C/C++ Text files */
+#endif
+
+#endif
+
+#ifdef MPW
+#define DAWDLE SpinCursor(1)
+#else
+#define DAWDLE
+#endif
+
+#ifdef MPW
+#define SPECIAL_INITS
+#define SPECIAL_FOPEN
+#endif
+
+#ifdef MPW
+#ifdef __cplusplus
+inline
+#else
+static
+#endif
+void special_inits()
+{
+ InitCursorCtl((acurHandle) 0);
+}
+#endif
+
+#ifdef MPW
+#ifdef __cplusplus
+inline
+#else
+static
+#endif
+void special_fopen_actions(char * s)
+{
+ fsetfileinfo (s, MAC_FILE_CREATOR, 'TEXT');
+}
+#endif
+
+/* Define usable bits for set.c stuff */
+#define BytesPerWord sizeof(unsigned)
+#define WORDSIZE (sizeof(unsigned)*8)
+#define LogWordSize (WORDSIZE==16?4:5)
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+#if defined(VAXC) || defined(__VMS)
+#include <ssdef.h>
+#define PCCTS_EXIT_SUCCESS 1
+#define PCCTS_EXIT_FAILURE SS$_ABORT
+#define zzDIE return SS$_ABORT;
+#define zzDONE return 1;
+
+#else /* !VAXC and !__VMS */
+
+#define PCCTS_EXIT_SUCCESS 0
+#define PCCTS_EXIT_FAILURE 1
+#define zzDIE return 1;
+#define zzDONE return 0;
+
+#endif
+
+#ifdef USER_ZZMODE_STACK
+# ifndef ZZSTACK_MAX_MODE
+# define ZZSTACK_MAX_MODE 32
+# endif
+# define ZZMAXSTK (ZZSTACK_MAX_MODE * 2)
+#endif
+
+#ifndef DllExportPCCTS
+#define DllExportPCCTS
+#endif
+
+#ifdef PC
+#ifndef PCCTS_CASE_INSENSITIVE_FILE_NAME
+#define PCCTS_CASE_INSENSITIVE_FILE_NAME
+#endif
+#endif
+
+#ifdef PC32
+#ifndef PCCTS_CASE_INSENSITIVE_FILE_NAME
+#define PCCTS_CASE_INSENSITIVE_FILE_NAME
+#endif
+#endif
+
+#ifdef __VMS
+#ifndef PCCTS_CASE_INSENSITIVE_FILE_NAME
+#define PCCTS_CASE_INSENSITIVE_FILE_NAME
+#endif
+#endif
+
+#ifdef __USE_PROTOS
+#ifndef PCCTS_USE_STDARG
+#define PCCTS_USE_STDARG
+#endif
+#endif
+
+#ifdef __STDC__
+#ifndef PCCTS_USE_STDARG
+#define PCCTS_USE_STDARG
+#endif
+#endif
+
+#ifdef __cplusplus
+#ifndef PCCTS_USE_STDARG
+#define PCCTS_USE_STDARG
+#endif
+#endif
+
+#ifdef _MSC_VER
+/*Turn off the warnings for:
+ unreferenced inline/local function has been removed
+*/
+#pragma warning(disable : 4514)
+/* function not expanded */
+#pragma warning(disable : 4710)
+#endif
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/pcnames.bat b/BaseTools/Source/C/VfrCompile/Pccts/h/pcnames.bat new file mode 100644 index 0000000000..8784aee9ab --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/pcnames.bat @@ -0,0 +1,11 @@ +ren aparser.c aparser.cpp
+ren astbase.c astbase.cpp
+ren atokenbu.c atokbuf.cpp
+ren atokenbu.h atokbuf.h
+ren atokenst.h atokstr.h
+ren dlexerba.c dlexbase.cpp
+ren dlexerba.h dlexbase.h
+ren dlexer.c dlexer.cpp
+ren list.c list.cpp
+ren pblackbo.h pblckbox.h
+ren pcctsast.c pcctsast.cpp
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/slist.cpp b/BaseTools/Source/C/VfrCompile/Pccts/h/slist.cpp new file mode 100644 index 0000000000..faf2fe4967 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/slist.cpp @@ -0,0 +1,116 @@ +/*
+ * SList.C
+ *
+ * SOFTWARE RIGHTS
+ *
+ * We reserve no LEGAL rights to SORCERER -- SORCERER is in the public
+ * domain. An individual or company may do whatever they wish with
+ * source code distributed with SORCERER or the code generated by
+ * SORCERER, including the incorporation of SORCERER, or its output, into
+ * commerical software.
+ *
+ * We encourage users to develop software with SORCERER. However, we do
+ * ask that credit is given to us for developing SORCERER. By "credit",
+ * we mean that if you incorporate our source code into one of your
+ * programs (commercial product, research project, or otherwise) that you
+ * acknowledge this fact somewhere in the documentation, research report,
+ * etc... If you like SORCERER and have developed a nice tool with the
+ * output, please mention that you developed it using SORCERER. In
+ * addition, we ask that this header remain intact in our source code.
+ * As long as these guidelines are kept, we expect to continue enhancing
+ * this system and expect to make other tools available as they are
+ * completed.
+ *
+ * PCCTS 1.33
+ * Terence Parr
+ * Parr Research Corporation
+ * with Purdue University and AHPCRC, University of Minnesota
+ * 1992-2000
+ */
+
+#define ANTLR_SUPPORT_CODE
+
+#include "SList.h"
+#include "pccts_stdarg.h" // MR23
+
+/* Iterate over a list of elements; returns ptr to a new element
+ * in list upon every call and NULL when no more are left.
+ * Very useful like this:
+ *
+ * cursor = mylist;
+ * while ( (p=mylist->iterate(&cursor)) ) {
+ * // place with element p
+ * }
+ *
+ * The cursor must be initialized to point to the list to iterate over.
+ */
+void *SList::
+iterate(SListNode **cursor)
+{
+ void *e;
+
+ if ( cursor == NULL || *cursor==NULL ) return NULL;
+ if ( head == *cursor ) { *cursor = (*cursor)->next(); }
+ e = (*cursor)->elem();
+ (*cursor) = (*cursor)->next();
+ return e;
+}
+
+/* add an element to end of list. */
+void SList::
+add(void *e)
+{
+ SListNode *p, *tail=NULL;
+ require(e!=NULL, "slist_add: attempting to add NULL list element");
+
+ p = new SListNode;
+ require(p!=NULL, "add: cannot alloc new list node");
+ p->setElem(e);
+ if ( head == NULL )
+ {
+ head = tail = p;
+ }
+ else /* find end of list */
+ {
+ tail->setNext(p);
+ tail = p;
+ }
+}
+
+void SList::
+lfree()
+{
+ SListNode *p,*q;
+
+ if ( head==NULL ) return; /* empty list */
+ for (p = head; p!=NULL; p=q)
+ {
+ q = p->next();
+ free(p);
+ }
+}
+
+PCCTS_AST *SList::
+to_ast(SList list)
+{
+ PCCTS_AST *t=NULL, *last=NULL;
+ SListNode *p;
+
+ for (p = head; p!=NULL; p=p->next())
+ {
+ PCCTS_AST *u = (PCCTS_AST *)p->elem();
+ if ( last==NULL ) last = t = u;
+ else { last->setRight(u); last = u; }
+ }
+ return t;
+}
+
+// MR23
+int SList::printMessage(FILE* pFile, const char* pFormat, ...)
+{
+ va_list marker;
+ va_start( marker, pFormat );
+ int iRet = vfprintf(pFile, pFormat, marker);
+ va_end( marker );
+ return iRet;
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/history.ps b/BaseTools/Source/C/VfrCompile/Pccts/history.ps new file mode 100644 index 0000000000..e2600d5129 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/history.ps @@ -0,0 +1,473 @@ +%!PS-Adobe-3.0 +%%Creator: groff version 1.06 +%%DocumentNeededResources: font Times-Roman +%%+ font Times-Italic +%%+ font Courier +%%DocumentSuppliedResources: procset grops 1.06 0 +%%Pages: 3 +%%PageOrder: Ascend +%%Orientation: Portrait +%%EndComments +%%BeginProlog +%%BeginResource: procset grops 1.06 0 + +/setpacking where { + pop + currentpacking + true setpacking +} if + +/grops 120 dict dup begin + +% The ASCII code of the space character. +/SC 32 def + +/A /show load def +/B { 0 SC 3 -1 roll widthshow } bind def +/C { 0 exch ashow } bind def +/D { 0 exch 0 SC 5 2 roll awidthshow } bind def +/E { 0 rmoveto show } bind def +/F { 0 rmoveto 0 SC 3 -1 roll widthshow } bind def +/G { 0 rmoveto 0 exch ashow } bind def +/H { 0 rmoveto 0 exch 0 SC 5 2 roll awidthshow } bind def +/I { 0 exch rmoveto show } bind def +/J { 0 exch rmoveto 0 SC 3 -1 roll widthshow } bind def +/K { 0 exch rmoveto 0 exch ashow } bind def +/L { 0 exch rmoveto 0 exch 0 SC 5 2 roll awidthshow } bind def +/M { rmoveto show } bind def +/N { rmoveto 0 SC 3 -1 roll widthshow } bind def +/O { rmoveto 0 exch ashow } bind def +/P { rmoveto 0 exch 0 SC 5 2 roll awidthshow } bind def +/Q { moveto show } bind def +/R { moveto 0 SC 3 -1 roll widthshow } bind def +/S { moveto 0 exch ashow } bind def +/T { moveto 0 exch 0 SC 5 2 roll awidthshow } bind def + +% name size font SF - + +/SF { + findfont exch + [ exch dup 0 exch 0 exch neg 0 0 ] makefont + dup setfont + [ exch /setfont cvx ] cvx bind def +} bind def + +% name a c d font MF - + +/MF { + findfont + [ 5 2 roll + 0 3 1 roll % b + neg 0 0 ] makefont + dup setfont + [ exch /setfont cvx ] cvx bind def +} bind def + +/level0 0 def +/RES 0 def +/PL 0 def +/LS 0 def + +% Guess the page length. +% This assumes that the imageable area is vertically centered on the page. +% PLG - length + +/PLG { + gsave newpath clippath pathbbox grestore + exch pop add exch pop +} bind def + +% BP - + +/BP { + /level0 save def + 1 setlinecap + 1 setlinejoin + 72 RES div dup scale + LS { + 90 rotate + } { + 0 PL translate + } ifelse + 1 -1 scale +} bind def + +/EP { + level0 restore + showpage +} bind def + + +% centerx centery radius startangle endangle DA - + +/DA { + newpath arcn stroke +} bind def + +% x y SN - x' y' +% round a position to nearest (pixel + (.25,.25)) + +/SN { + transform + .25 sub exch .25 sub exch + round .25 add exch round .25 add exch + itransform +} bind def + +% endx endy startx starty DL - +% we round the endpoints of the line, so that parallel horizontal +% and vertical lines will appear even + +/DL { + SN + moveto + SN + lineto stroke +} bind def + +% centerx centery radius DC - + +/DC { + newpath 0 360 arc closepath +} bind def + + +/TM matrix def + +% width height centerx centery DE - + +/DE { + TM currentmatrix pop + translate scale newpath 0 0 .5 0 360 arc closepath + TM setmatrix +} bind def + +% these are for splines + +/RC /rcurveto load def +/RL /rlineto load def +/ST /stroke load def +/MT /moveto load def +/CL /closepath load def + +% fill the last path + +% amount FL - + +/FL { + currentgray exch setgray fill setgray +} bind def + +% fill with the ``current color'' + +/BL /fill load def + +/LW /setlinewidth load def +% new_font_name encoding_vector old_font_name RE - + +/RE { + findfont + dup maxlength dict begin + { + 1 index /FID ne { def } { pop pop } ifelse + } forall + /Encoding exch def + dup /FontName exch def + currentdict end definefont pop +} bind def + +/DEFS 0 def + +% hpos vpos EBEGIN - + +/EBEGIN { + moveto + DEFS begin +} bind def + +/EEND /end load def + +/CNT 0 def +/level1 0 def + +% llx lly newwid wid newht ht newllx newlly PBEGIN - + +/PBEGIN { + /level1 save def + translate + div 3 1 roll div exch scale + neg exch neg exch translate + % set the graphics state to default values + 0 setgray + 0 setlinecap + 1 setlinewidth + 0 setlinejoin + 10 setmiterlimit + [] 0 setdash + /setstrokeadjust where { + pop + false setstrokeadjust + } if + /setoverprint where { + pop + false setoverprint + } if + newpath + /CNT countdictstack def + userdict begin + /showpage {} def +} bind def + +/PEND { + clear + countdictstack CNT sub { end } repeat + level1 restore +} bind def + +end def + +/setpacking where { + pop + setpacking +} if +%%EndResource +%%IncludeResource: font Times-Roman +%%IncludeResource: font Times-Italic +%%IncludeResource: font Courier +grops begin/DEFS 1 dict def DEFS begin/u{.001 mul}bind def end/RES 72 def/PL +792 def/LS false def/ENC0[/asciicircum/asciitilde/Scaron/Zcaron/scaron/zcaron +/Ydieresis/trademark/quotesingle/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/space +/exclam/quotedbl/numbersign/dollar/percent/ampersand/quoteright/parenleft +/parenright/asterisk/plus/comma/hyphen/period/slash/zero/one/two/three/four +/five/six/seven/eight/nine/colon/semicolon/less/equal/greater/question/at/A/B/C +/D/E/F/G/H/I/J/K/L/M/N/O/P/Q/R/S/T/U/V/W/X/Y/Z/bracketleft/backslash +/bracketright/circumflex/underscore/quoteleft/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q +/r/s/t/u/v/w/x/y/z/braceleft/bar/braceright/tilde/.notdef/quotesinglbase +/guillemotleft/guillemotright/bullet/florin/fraction/perthousand/dagger +/daggerdbl/endash/emdash/ff/fi/fl/ffi/ffl/dotlessi/dotlessj/grave/hungarumlaut +/dotaccent/breve/caron/ring/ogonek/quotedblleft/quotedblright/oe/lslash +/quotedblbase/OE/Lslash/.notdef/exclamdown/cent/sterling/currency/yen/brokenbar +/section/dieresis/copyright/ordfeminine/guilsinglleft/logicalnot/minus +/registered/macron/degree/plusminus/twosuperior/threesuperior/acute/mu +/paragraph/periodcentered/cedilla/onesuperior/ordmasculine/guilsinglright +/onequarter/onehalf/threequarters/questiondown/Agrave/Aacute/Acircumflex/Atilde +/Adieresis/Aring/AE/Ccedilla/Egrave/Eacute/Ecircumflex/Edieresis/Igrave/Iacute +/Icircumflex/Idieresis/Eth/Ntilde/Ograve/Oacute/Ocircumflex/Otilde/Odieresis +/multiply/Oslash/Ugrave/Uacute/Ucircumflex/Udieresis/Yacute/Thorn/germandbls +/agrave/aacute/acircumflex/atilde/adieresis/aring/ae/ccedilla/egrave/eacute +/ecircumflex/edieresis/igrave/iacute/icircumflex/idieresis/eth/ntilde/ograve +/oacute/ocircumflex/otilde/odieresis/divide/oslash/ugrave/uacute/ucircumflex +/udieresis/yacute/thorn/ydieresis]def/Courier@0 ENC0/Courier RE/Times-Italic@0 +ENC0/Times-Italic RE/Times-Roman@0 ENC0/Times-Roman RE +%%EndProlog +%%Page: 1 1 +%%BeginPageSetup +BP +%%EndPageSetup +/F0 13/Times-Roman@0 SF(The History of PCCTS)228.232 84 Q/F1 11/Times-Roman@0 +SF(The Purdue Compiler)190.468 108 Q(-Construction T)-.22 E(ool Set)-.88 E/F2 +10/Times-Italic@0 SF -.92(Te)262.245 144 S -.37(re).92 G(nce P).37 E(arr)-.8 E +/F3 10/Times-Roman@0 SF -.15(Pa)234.755 156 S(rr Research Corporation).15 E +(Minneapolis, Minnesota)239.39 168 Q(and)280.78 180 Q(Uni)239.315 192 Q -.15 +(ve)-.25 G(rsity of Minnesota).15 E +(Army High Performance Computing Research Center)180.38 204 Q F2 +([Updated 8-7-94])252.31 228 Q F1 .084(The PCCTS project be)97 259.6 R -.055 +(ga)-.165 G 2.834(na).055 G 2.833(sap)220.547 259.6 S(arser)240.876 259.6 Q +.083(-generator project for a graduate course at Purdue Uni-)-.22 F -.165(ve)72 +275.6 S 1.085(rsity in the F).165 F 1.086 +(all of 1988 taught by Hank Dietz\212 translator)-.165 F 1.086 +(-writing systems.)-.22 F 1.086(Under the guid-)6.586 F .627 +(ance of Professor Dietz, the parser generator)72 291.6 R 3.377(,A)-.44 G .626 +(NTLR \(originally called YUCC\), continued after)285.18 291.6 R .253 +(the termination of the course and e)72 307.6 R -.165(ve)-.275 G .254 +(ntually became the subject of T).165 F .254(erence P)-.77 F(arr')-.165 E 3.004 +(sM)-.605 G(aster')445.083 307.6 Q 3.004(st)-.605 G(hesis.)479.25 307.6 Q +(Originally)72 323.6 Q 4.092(,l)-.715 G -.165(ex)126.406 323.6 S 1.342 +(ical analysis w).165 F 1.342(as performed via ALX which w)-.11 F 1.342 +(as soon replaced by W)-.11 F 1.341(ill Cohen')-.44 F(s)-.605 E .594 +(DLG in the F)72 339.6 R .594(all of 1989 \(DF)-.165 F .595(A-based le)-.814 F +.595(xical-analyzer generator)-.165 F 3.345(,a)-.44 G .595(lso an of)367.188 +339.6 R .595(fshoot of the graduate)-.275 F(translation course\).)72 355.6 Q +.877(The alpha v)97 375.2 R .877(ersion of ANTLR w)-.165 F .877(as totally re) +-.11 F .876(written resulting in 1.00B.)-.275 F -1.221(Ve)6.376 G .876 +(rsion 1.00B w)1.221 F(as)-.11 E 1.577(released via an internet ne)72 391.2 R +1.577(wsgroup \(comp.compilers\) posting in February of 1990 and quickly)-.275 +F -.055(ga)72 407.2 S .356(thered a lar).055 F .356(ge follo)-.198 F 3.106 +(wing. 1.00B)-.275 F .356(generated only LL\(1\) parsers, b)3.106 F .356 +(ut allo)-.22 F .356(wed the mer)-.275 F .356(ged descrip-)-.198 F 1.859 +(tion of le)72 423.2 R 1.859(xical and syntactic analysis.)-.165 F 1.86 +(It had rudimentary attrib)7.359 F 1.86(ute handling similar to that of)-.22 F +-.55 -1.32(YA C)72 439.2 T 3.549(Ca)1.32 G .799 +(nd did not incorporate rule parameters or return v)109.231 439.2 R .798 +(alues; do)-.275 F(wnw)-.275 E .798(ard inheritance w)-.11 F .798(as v)-.11 F +(ery)-.165 E -.165(aw)72 455.2 S(kw).165 E 6.433(ard. 1.00B-generated)-.11 F +3.684(parsers terminated upon the \214rst syntax error)6.433 F 9.184(.L)-.605 G +-.165(ex)440.916 455.2 S 3.684(ical classes).165 F(\(modes\) were not allo)72 +471.2 Q(wed and DLG did not ha)-.275 E .33 -.165(ve a)-.22 H 2.75(ni).165 G +(nteracti)305.959 471.2 Q .33 -.165(ve m)-.275 H(ode.).165 E .831 +(Upon starting his Ph.D. at Purdue in the F)97 490.8 R .83(all of 1990, T)-.165 +F .83(erence P)-.77 F .83(arr be)-.165 F -.055(ga)-.165 G 3.58(nt).055 G .83 +(he second total)436.351 490.8 R(re)72 506.8 Q 1.646(write of ANTLR.)-.275 F +1.646(The method by which grammars may be practically analyzed to generate) +7.146 F/F4 11/Times-Italic@0 SF(LL)72.638 522.8 Q F1(\().583 E F4(k).396 E F1 +3.849(\)l).737 G 1.099(ookahead information w)105.703 522.8 R 1.099(as disco) +-.11 F -.165(ve)-.165 G 1.099(red in August of 1990 just before his return.) +.165 F -1.221(Ve)6.598 G(rsion)1.221 E .626 +(1.00 incorporated this algorithm and included the AST mechanism, le)72 538.8 R +.626(xical classes, error classes,)-.165 F .354(and automatic error reco)72 +554.8 R -.165(ve)-.165 G .353(ry; code quality and portability were higher).165 +F 5.853(.I)-.605 G 3.103(nF)395.965 554.8 S .353(ebruary of 1992 1.00)410.684 +554.8 R -.11(wa)72 570.8 S 2.76(sr).11 G .01 +(eleased via an article in SIGPLAN Notices.)95.418 570.8 R .01 +(Peter Dahl, Ph.D. candidate, and Professor Matt)5.51 F(O'K)72 586.8 Q 2.074 +(eefe \(both at the Uni)-.275 F -.165(ve)-.275 G 2.073 +(rsity of Minnesota\) tested this v).165 F 2.073(ersion e)-.165 F(xtensi)-.165 +E -.165(ve)-.275 G(ly).165 E 7.573(.D)-.715 G 2.073(ana Hogg)448.522 586.8 R +(att)-.055 E .078(\(Micro Data Base Systems, Inc.\) came up with the idea of e\ +rror grouping \(strings attached to non-)72 602.8 R +(terminals\) and tested 1.00 hea)72 618.8 Q(vily)-.22 E(.)-.715 E -1.221(Ve)97 +638.4 S .878(rsion 1.06 w)1.221 F .877 +(as released in December 1992 and represented a lar)-.11 F .877 +(ge feature enhancement)-.198 F -.165(ove)72 654.4 S 3.648(r1).165 G 3.648 +(.00. F)100.365 654.4 R .898(or e)-.165 F .899 +(xample, rudimentary semantic predicates were introduced, error messages were) +-.165 F 2.281(signi\214cantly impro)72 670.4 R -.165(ve)-.165 G 5.031(df).165 G +(or)181.953 670.4 Q F4(k)5.427 E F1 2.281 +(>1 lookahead and ANTLR parsers could indicate that lookahead).737 F 1.381 +(fetches were to occur only when necessary for the parse \(normally)72 686.4 R +4.131(,t)-.715 G 1.381(he lookahead `)387.051 686.4 R(`pipe')-.814 E 4.132('w) +-.814 G(as)494.837 686.4 Q 1.182(constantly full\).)72 702.4 R 1.182 +(Russell Quong joined the project in the Spring of 1992 to aid in the semantic) +6.682 F .681(predicate design.)72 718.4 R(Be)6.181 E .681(ginning and adv)-.165 +F .682(anced tutorials were created and released as well.)-.275 F 3.432(Am) +6.182 G(ak)485.179 718.4 Q(e-)-.11 E .993(\214le generator w)72 734.4 R .993 +(as included that sets up dependencies and such correctly for ANTLR and DLG.) +-.11 F EP +%%Page: 2 2 +%%BeginPageSetup +BP +%%EndPageSetup +/F0 11/Times-Roman@0 SF 2.75(-2-)278.837 52 S -1.221(Ve)72 88 S 1.414(ry fe) +1.221 F 4.164(w1)-.275 G 1.414(.00 incompatibilities were introduced \(1.00 w) +122.81 88 R 1.415(as quite dif)-.11 F 1.415(ferent from 1.00B in some)-.275 F +(areas\).)72 104 Q 1.089(1.10 w)97 123.6 R 1.088 +(as released on August 31, 1993 and incorporated b)-.11 F 1.088(ug \214x)-.22 F +1.088(es, a fe)-.165 F 3.838(wf)-.275 G 1.088(eature enhance-)433.59 123.6 R +3.112(ments and a major ne)72 139.6 R 5.863(wc)-.275 G(apability \212)196.957 +139.6 Q 3.113(an arbitrary lookahead operator \(syntactic predicate\),)5.863 F +/F1 11/Courier@0 SF(\(alpha\)?beta)72 155.6 Q F0 6.754(.T)C 1.254 +(his feature w)167.425 155.6 R 1.254 +(as co-designed with Professor Russell Quong also at Purdue.)-.11 F 3.297 -.88 +(To s)72 171.6 T 1.537 +(upport in\214nite lookahead, a preprocessor \215ag, ZZINF_LOOK, w).88 F 1.537 +(as created that forced the)-.11 F .21(ANTLR\(\) macro to tok)72 187.6 R .21 +(enize all input prior to parsing.)-.11 F .209(Hence, at an)5.709 F 2.959(ym) +-.165 G .209(oment, an action or predi-)389.215 187.6 R .936 +(cate can see the entire input sentence.)72 203.6 R .936 +(The predicate mechanism of 1.06 w)6.436 F .937(as e)-.11 F .937 +(xtended to allo)-.165 F(w)-.275 E .55 +(multiple predicates to be hoisted; the syntactic conte)72 219.6 R .55 +(xt of a predicate w)-.165 F .55(as also mo)-.11 F -.165(ve)-.165 G 3.299(da) +.165 G .549(long with)461.585 219.6 R(the predicate.)72 235.6 Q .754 +(In February of 1994, SORCERER \(a simple tree-parser generator\) w)97 255.2 R +.755(as released.)-.11 F .755(This tool)6.255 F(allo)72 271.2 Q .6(ws the user\ + to parse child-sibling trees by specifying a grammar rather than b)-.275 F +.599(uilding a recur)-.22 F(-)-.22 E(si)72 287.2 Q -.165(ve)-.275 G 1.39 +(-descent tree w).165 F(alk)-.11 E 1.391(er by hand.)-.11 F -.88(Wo)6.891 G +1.391(rk to).88 F -.11(wa)-.275 G 1.391 +(rds a library of tree transformations is underw).11 F(ay)-.11 E(.)-.715 E .581 +(Aaron Sa)72 303.2 R(wde)-.165 E 3.331(ya)-.165 G 3.331(tT)145.531 303.2 S .581 +(he Uni)158.641 303.2 R -.165(ve)-.275 G .58 +(rsity of Minnesota became a second author of SORCERER after the).165 F +(initial release.)72 319.2 Q .627(On April 1, 1994, PCCTS 1.20 w)97 338.8 R +.627(as released.)-.11 F .627(This w)6.127 F .627(as the \214rst v)-.11 F .627 +(ersion to acti)-.165 F -.165(ve)-.275 G .627(ly support).165 F 1.664 +(C++ output.)72 354.8 R 1.664(It also included important \214x)7.164 F 1.663 +(es re)-.165 F -.055(ga)-.165 G 1.663 +(rding semantic predicates and \(..\)+ subrules.).055 F(This v)72 370.8 Q +(ersion also introduced tok)-.165 E(en classes, the `)-.11 E(`)-.814 E/F2 11 +/Times-Italic@0 SF(not)A F0 1.628 -.814('' o)D(perator).814 E 2.75(,a)-.44 G +(nd tok)355.294 370.8 Q(en ranges.)-.11 E .764 +(On June 19, 1994, SORCERER 1.00B9 w)97 390.4 R .765(as released.)-.11 F .765 +(Gary Funck of Intrepid T)6.265 F(echnology)-.77 E .807 +(joined the SORCERER team and pro)72 406.4 R .807(vided v)-.165 F .807(ery v) +-.165 F .807(aluable suggestions re)-.275 F -.055(ga)-.165 G .806(rding the `) +.055 F(`transform')-.814 E(')-.814 E(mode of SORCERER.)72 422.4 Q 1.137 +(On August 8, 1994, PCCTS 1.21 w)97 442 R 1.137(as released.)-.11 F 1.138 +(It mainly cleaned up the C++ output and)6.637 F(included a number of b)72 458 +Q(ug \214x)-.22 E(es.)-.165 E .316(From the 1.21 release forw)97 477.6 R .316 +(ard, the maintenance and support of all PCCTS tools will be pri-)-.11 F 1.557 +(marily pro)72 493.6 R 1.557(vided by P)-.165 F 1.557 +(arr Research Corporation, Minneapolis MN---an or)-.165 F -.055(ga)-.198 G +1.558(nization founded on).055 F 1.616(the principles of e)72 509.6 R 1.616 +(xcellence in research and inte)-.165 F 1.616(grity in b)-.165 F 1.616 +(usiness; we are de)-.22 F -.22(vo)-.275 G 1.616(ted to pro).22 F(viding)-.165 +E 1.202(really cool softw)72 525.6 R 1.202(are tools.)-.11 F 1.202 +(Please see \214le PCCTS.FUTURE for more information.)6.702 F 1.203(All PCCTS) +6.703 F(tools currently in the public domain will continue to be in the public\ + domain.)72 541.6 Q 1.198(Looking to)97 561.2 R -.11(wa)-.275 G 1.198 +(rds the future, a graphical user).11 F(-interf)-.22 E 1.197 +(ace is in the design phase.)-.11 F 1.197(This w)6.697 F(ould)-.11 E(allo)72 +577.2 Q 2.753(wu)-.275 G .003(sers to vie)104.42 577.2 R 2.753(wt)-.275 G .004 +(he syntax diagram representation of their grammars and w)162.509 577.2 R .004 +(ould highlight non-)-.11 F 1.181(deterministic productions.)72 593.2 R -.165 +(Pa)6.681 G 1.18(rsing can be traced graphically as well.).165 F 1.18 +(This system will be b)6.68 F(uilt)-.22 E .167(using a multiplatform windo)72 +609.2 R 2.917(wl)-.275 G(ibrary)211.73 609.2 Q 5.667(.W)-.715 G 2.917(ea) +255.204 609.2 S .168(lso anticipate the introduction of a sophisticated error) +267.889 609.2 R(handling mechanism called `)72 625.2 Q(`parser e)-.814 E +(xception handling')-.165 E 2.75('i)-.814 G 2.75(nan)327.431 625.2 S +(ear future release.)348.815 625.2 Q(Currently)97 644.8 Q 3.019(,P)-.715 G .269 +(CCTS is used at o)150.333 644.8 R -.165(ve)-.165 G 3.019(r1).165 G .269 +(000 kno)253.098 644.8 R .268(wn academic, go)-.275 F -.165(ve)-.165 G .268 +(rnment, and commercial sites).165 F .859(in 37 countries.)72 660.8 R .859 +(Of course, the true number of users is unkno)6.359 F .859(wn due to the lar) +-.275 F .859(ge number of ftp)-.198 F(sites.)72 676.8 Q EP +%%Page: 3 3 +%%BeginPageSetup +BP +%%EndPageSetup +/F0 11/Times-Roman@0 SF 2.75(-3-)278.837 52 S(Credits)272.11 88 Q .44 LW +472.162 103.75 103.838 103.75 DL(Idea/T)134.236 117 Q 52.987(ool Coder)-.88 F +(Co-designer\(s\))345.436 117 Q 281.334 103.75 281.334 124.75 DL 209.273 103.75 +209.273 124.75 DL 209.273 124.75 103.838 124.75 DL 103.838 126.75 209.273 +126.75 DL 281.334 124.75 209.273 124.75 DL 209.273 126.75 281.334 126.75 DL +472.162 124.75 281.334 124.75 DL 281.334 126.75 472.162 126.75 DL(ANTLR 1.00A) +109.338 140 Q -.77(Te)217.523 140 S(rence P).77 E 13.75(arr Hank)-.165 F(Dietz) +2.75 E 82.83(ALX T)109.338 156 R(erence P)-.77 E 13.75(arr Hank)-.165 F(Dietz) +2.75 E(ANTLR 1.00B)109.338 172 Q -.77(Te)217.523 172 S(rence P).77 E 13.75 +(arr Hank)-.165 F(Dietz, W)2.75 E(ill Cohen)-.44 E(DLG 1.00B)109.338 188 Q -.44 +(Wi)217.523 188 S(ll Cohen).44 E -.77(Te)289.584 188 S(rence P).77 E(arr)-.165 +E 2.75(,H)-.44 G(ank Dietz)358.147 188 Q(NF)109.338 204 Q 2.75(AR)-.814 G +30.778(elabelling W)140.611 204 R(ill Cohen)-.44 E/F1 11/Times-Italic@0 SF(LL) +109.976 220 Q F0(\().583 E F1(k).396 E F0 2.75(\)a).737 G 40.447(nalysis T) +143.768 220 R(erence P)-.77 E 13.75(arr Hank)-.165 F(Dietz)2.75 E(ANTLR 1.00) +109.338 236 Q -.77(Te)217.523 236 S(rence P).77 E 13.75(arr Hank)-.165 F +(Dietz, W)2.75 E(ill Cohen)-.44 E(DLG 1.00)109.338 252 Q -.44(Wi)217.523 252 S +(ll Cohen).44 E -.77(Te)289.584 252 S(rence P).77 E(arr)-.165 E 2.75(,H)-.44 G +(ank Dietz)358.147 252 Q(ANTLR 1.06)109.338 268 Q -.77(Te)217.523 268 S +(rence P).77 E 13.75(arr W)-.165 F(ill Cohen, Russell Quong, Hank Dietz)-.44 E +(DLG 1.06)109.338 284 Q -.44(Wi)217.523 284 S(ll Cohen).44 E -.77(Te)289.584 +284 S(rence P).77 E(arr)-.165 E 2.75(,H)-.44 G(ank Dietz)358.147 284 Q +(ANTLR 1.10)109.338 300 Q -.77(Te)217.523 300 S(rence P).77 E 13.75(arr W)-.165 +F(ill Cohen, Russell Quong)-.44 E(ANTLR 1.20)109.338 316 Q -.77(Te)217.523 316 +S(rence P).77 E 13.75(arr W)-.165 F(ill Cohen, Russell Quong)-.44 E(ANTLR 1.21) +109.338 332 Q -.77(Te)217.523 332 S(rence P).77 E 13.75(arr Russell)-.165 F +(Quong)2.75 E(DLG 1.10)109.338 348 Q -.44(Wi)217.523 348 S(ll Cohen).44 E -.77 +(Te)289.584 348 S(rence P).77 E(arr)-.165 E(DLG 1.20)109.338 364 Q -.44(Wi) +217.523 364 S(ll Cohen).44 E -.77(Te)289.584 364 S(rence P).77 E(arr)-.165 E +(DLG 1.21)109.338 380 Q -.77(Te)217.523 380 S(rence P).77 E(arr)-.165 E +(Semantic predicates)109.338 396 Q -.77(Te)217.523 396 S(rence P).77 E 13.75 +(arr Russell)-.165 F(Quonq)2.75 E(Syntactic predicates)109.338 412 Q -.77(Te) +217.523 412 S(rence P).77 E 13.75(arr Russell)-.165 F(Quonq)2.75 E +(SORCERER 1.00A)109.338 428 Q -.77(Te)217.523 428 S(rence P).77 E(arr)-.165 E +(SORCERER 1.00B)109.338 444 Q -.77(Te)217.523 444 S(rence P).77 E 13.75 +(arr Aaron)-.165 F(Sa)2.75 E(wde)-.165 E(y)-.165 E(SORCERER 1.00B9)109.338 460 +Q -.77(Te)217.523 460 S(rence P).77 E 13.75(arr Aaron)-.165 F(Sa)2.75 E(wde) +-.165 E 1.43 -.715(y, G)-.165 H(ary Funck).715 E 472.162 467.75 103.838 467.75 +DL 472.162 103.75 472.162 467.75 DL 103.838 103.75 103.838 467.75 DL EP +%%Trailer +end +%%EOF diff --git a/BaseTools/Source/C/VfrCompile/Pccts/history.txt b/BaseTools/Source/C/VfrCompile/Pccts/history.txt new file mode 100644 index 0000000000..89ad8408c9 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/history.txt @@ -0,0 +1,186 @@ +
+
+
+ The History of PCCTS
+
+ The Purdue Compiler-Construction Tool Set
+
+
+ Terence Parr
+ Parr Research Corporation
+ Minneapolis, Minnesota
+ and
+ University of Minnesota
+ Army High Performance Computing Research Center
+
+ [Updated 8-7-94]
+
+
+ The PCCTS project began as a parser-generator project for a gra-
+duate course at Purdue University in the Fall of 1988 taught by Hank
+Dietz- translator-writing systems. Under the guidance of Professor
+Dietz, the parser generator, ANTLR (originally called YUCC), continued
+after the termination of the course and eventually became the subject
+of Terence Parr's Master's thesis. Originally, lexical analysis was
+performed via ALX which was soon replaced by Will Cohen's DLG in the
+Fall of 1989 (DFA-based lexical-analyzer generator, also an offshoot
+of the graduate translation course).
+
+ The alpha version of ANTLR was totally rewritten resulting in
+1.00B. Version 1.00B was released via an internet newsgroup
+(comp.compilers) posting in February of 1990 and quickly gathered a
+large following. 1.00B generated only LL(1) parsers, but allowed the
+merged description of lexical and syntactic analysis. It had rudimen-
+tary attribute handling similar to that of YACC and did not incor-
+porate rule parameters or return values; downward inheritance was very
+awkward. 1.00B-generated parsers terminated upon the first syntax
+error. Lexical classes (modes) were not allowed and DLG did not have
+an interactive mode.
+
+ Upon starting his Ph.D. at Purdue in the Fall of 1990, Terence
+Parr began the second total rewrite of ANTLR. The method by which
+grammars may be practically analyzed to generate LL(k) lookahead
+information was discovered in August of 1990 just before his return.
+Version 1.00 incorporated this algorithm and included the AST mechan-
+ism, lexical classes, error classes, and automatic error recovery;
+code quality and portability were higher. In February of 1992 1.00
+was released via an article in SIGPLAN Notices. Peter Dahl, Ph.D.
+candidate, and Professor Matt O'Keefe (both at the University of Min-
+nesota) tested this version extensively. Dana Hoggatt (Micro Data
+Base Systems, Inc.) came up with the idea of error grouping (strings
+attached to non-terminals) and tested 1.00 heavily.
+
+ Version 1.06 was released in December 1992 and represented a
+large feature enhancement over 1.00. For example, rudimentary seman-
+tic predicates were introduced, error messages were significantly
+improved for k>1 lookahead and ANTLR parsers could indicate that loo-
+kahead fetches were to occur only when necessary for the parse
+
+
+
+ Page 1
+
+ PCCTS
+
+
+(normally, the lookahead "pipe" was constantly full). Russell Quong
+joined the project in the Spring of 1992 to aid in the semantic predi-
+cate design. Beginning and advanced tutorials were created and
+released as well. A makefile generator was included that sets up
+dependencies and such correctly for ANTLR and DLG. Very few 1.00
+incompatibilities were introduced (1.00 was quite different from 1.00B
+in some areas).
+
+ 1.10 was released on August 31, 1993 and incorporated bug fixes,
+a few feature enhancements and a major new capability - an arbitrary
+lookahead operator (syntactic predicate), (alpha)?beta. This feature
+was co-designed with Professor Russell Quong also at Purdue. To sup-
+port infinite lookahead, a preprocessor flag, ZZINF_LOOK, was created
+that forced the ANTLR() macro to tokenize all input prior to parsing.
+Hence, at any moment, an action or predicate can see the entire input
+sentence. The predicate mechanism of 1.06 was extended to allow mul-
+tiple predicates to be hoisted; the syntactic context of a predicate
+was also moved along with the predicate.
+
+ In February of 1994, SORCERER (a simple tree-parser generator)
+was released. This tool allows the user to parse child-sibling trees
+by specifying a grammar rather than building a recursive-descent tree
+walker by hand. Work towards a library of tree transformations is
+underway. Aaron Sawdey at The University of Minnesota became a second
+author of SORCERER after the initial release.
+
+ On April 1, 1994, PCCTS 1.20 was released. This was the first
+version to actively support C++ output. It also included important
+fixes regarding semantic predicates and (..)+ subrules. This version
+also introduced token classes, the "not" operator, and token ranges.
+
+ On June 19, 1994, SORCERER 1.00B9 was released. Gary Funck of
+Intrepid Technology joined the SORCERER team and provided very valu-
+able suggestions regarding the "transform" mode of SORCERER.
+
+ On August 8, 1994, PCCTS 1.21 was released. It mainly cleaned up
+the C++ output and included a number of bug fixes.
+
+ From the 1.21 release forward, the maintenance and support of all
+PCCTS tools will be primarily provided by Parr Research Corporation,
+Minneapolis MN---an organization founded on the principles of excel-
+lence in research and integrity in business; we are devoted to provid-
+ing really cool software tools. Please see file PCCTS.FUTURE for more
+information. All PCCTS tools currently in the public domain will con-
+tinue to be in the public domain.
+
+ Looking towards the future, a graphical user-interface is in the
+design phase. This would allow users to view the syntax diagram
+representation of their grammars and would highlight nondeterministic
+productions. Parsing can be traced graphically as well. This system
+will be built using a multiplatform window library. We also antici-
+pate the introduction of a sophisticated error handling mechanism
+called "parser exception handling" in a near future release.
+
+
+
+
+ Page 2
+
+ PCCTS
+
+
+ Currently, PCCTS is used at over 1000 known academic, government,
+and commercial sites in 37 countries. Of course, the true number of
+users is unknown due to the large number of ftp sites.
+ Credits
+
+_____________________________________________________________________________
+_____________________________________________________________________________
+|ANTLR 1.00A Terence Parr Hank Dietz |
+|ALX Terence Parr Hank Dietz |
+|ANTLR 1.00B Terence Parr Hank Dietz, Will Cohen |
+|DLG 1.00B Will Cohen Terence Parr, Hank Dietz |
+|NFA Relabelling Will Cohen |
+|LL(k) analysis Terence Parr Hank Dietz |
+|ANTLR 1.00 Terence Parr Hank Dietz, Will Cohen |
+|DLG 1.00 Will Cohen Terence Parr, Hank Dietz |
+|ANTLR 1.06 Terence Parr Will Cohen, Russell Quong, Hank Dietz|
+|DLG 1.06 Will Cohen Terence Parr, Hank Dietz |
+|ANTLR 1.10 Terence Parr Will Cohen, Russell Quong |
+|ANTLR 1.20 Terence Parr Will Cohen, Russell Quong |
+|ANTLR 1.21 Terence Parr Russell Quong |
+|DLG 1.10 Will Cohen Terence Parr |
+|DLG 1.20 Will Cohen Terence Parr |
+|DLG 1.21 Terence Parr |
+|Semantic predicates Terence Parr Russell Quonq |
+|Syntactic predicates Terence Parr Russell Quonq |
+|SORCERER 1.00A Terence Parr |
+|SORCERER 1.00B Terence Parr Aaron Sawdey |
+|SORCERER 1.00B9 Terence Parr Aaron Sawdey, Gary Funck |
+|___________________________________________________________________________|
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Page 3
+
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/makefile.old b/BaseTools/Source/C/VfrCompile/Pccts/makefile.old new file mode 100644 index 0000000000..f9b2dd2b9b --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/makefile.old @@ -0,0 +1,66 @@ +#
+# Main makefile for PCCTS 1.33MR33 /* MRXXX */
+#
+# Terence Parr
+# Parr Research Corporation
+#
+# verbosity versus silence...
+PSss=
+#
+# this can be set to /user/local/bin etc...
+BINDIR=bin
+# This part added by Thomas Herter, M"unchen, Germany. See also manpages
+# target.
+MANDIR=$(HOME)/man
+MANEXT=1
+MANFILES=dlg/dlg.1 antlr/antlr.1
+
+#CC=cc
+#CC=gcc
+#COPT=-O2
+
+pccts:
+ @echo " "
+ @echo " Welcome to PCCTS 1.33MR33 installation"
+ @echo " "
+ @echo " (Version 1.33 Maintenance Release #33)" # mrxxx
+ @echo " "
+ @echo " Released 19 April 2002"
+ @echo " "
+ @echo " Featuring"
+ @echo " ANTLR -- ANother Tool for Language Recognition"
+ @echo " DLG -- DFA-based Lexical Analyzer Generator"
+ @echo " SORCERER -- Source-to-source translator (tree walker)"
+ @echo " "
+ @echo " http://www.antlr.org"
+ @echo " "
+ @echo " Trouble reports to tmoog@polhode.com"
+ @echo " Additional PCCTS 1.33 information at"
+ @echo " http://www.polhode.com"
+ @echo
+ @echo
+ @echo "To substitute gcc for CC to invoke compiler: make CC=gcc"
+ @echo "If there are problems with cr and lf try: unzip -a ..."
+ @echo
+#
+ @if [ ! -d $(BINDIR) ] ; then mkdir $(BINDIR) ; fi
+ @echo Making executables...
+ (cd ./antlr; $(MAKE) CC="$(CC)" COPT="$(COPT)")
+ @echo antlr executable now in $(BINDIR)
+ (cd ./dlg; $(MAKE) CC="$(CC)" COPT="$(COPT)")
+ @echo dlg executable now in $(BINDIR)
+ @echo
+ @echo " PCCTS 1.33MR33 installation complete" # MRXXX
+
+clean:
+ (cd ./antlr; $(MAKE) -s clean)
+ (cd ./dlg; $(MAKE) -s clean)
+
+
+manpages:
+ # mkdir -p $(MANDIR)/man$(MANEXT)
+ if [ ! -d $(MANDIR) ] ; then \
+ mkdir $(MANDIR) ; fi
+ if [ ! -d $(MANDIR)/man$(MANEXT) ] ; then \
+ mkdir $(MANDIR)/man$(MANEXT); fi
+ cp -p $(MANFILES) $(MANDIR)/man$(MANEXT)
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk.c b/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk.c new file mode 100644 index 0000000000..4952a30b38 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk.c @@ -0,0 +1,1063 @@ +/*
+ * genmk -- a program to make makefiles for PCCTS
+ *
+ * ANTLR 1.33MR23
+ * Terence John Parr 1989 - 2000
+ * Purdue University
+ * U of MN
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include "pcctscfg.h" /* be sensitive to what ANTLR/DLG call the files */
+
+#ifdef VAXC
+#define DIE return 0;
+#define DONE return 1;
+#else
+#define DIE return 1;
+#define DONE return 0;
+#endif
+
+#ifndef require
+#define require(expr, err) {if ( !(expr) ) fatal(err);}
+#endif
+
+#define MAX_FILES 50
+#define MAX_CFILES 1600
+#define MAX_SFILES 50
+#define MAX_SORS 50
+#define MAX_CLASSES 50
+
+char *RENAME_OBJ_FLAG="-o",
+ *RENAME_EXE_FLAG="-o";
+
+char *dlg = "parser.dlg";
+char *err = "err.c";
+char *hdr = "stdpccts.h";
+char *tok = "tokens.h";
+char *mode = "mode.h";
+char *scan = "scan";
+
+char ATOKENBUFFER_O[100];
+char APARSER_O[100];
+char ASTBASE_O[100];
+char PCCTSAST_O[100];
+char LIST_O[100];
+char DLEXERBASE_O[100];
+
+/* Option flags */
+static char *project="t", *files[MAX_FILES], *classes[MAX_CLASSES];
+static char *cfiles[MAX_CFILES];
+static char *sfiles[MAX_SORS][MAX_SFILES],*sclasses[MAX_SORS];
+static int num_sfiles[MAX_SORS]; /*sorcerer files in group */
+static int num_sors = 0; /*sorcerer groups */
+static int num_files = 0; /* grammar files */
+static int num_cfiles = 0; /* additional C/C++ files */
+static int num_classes = 0; /* ANTLR classes */
+static int user_lexer = 0;
+static char *user_token_types = NULL;
+static int gen_CPP = 0;
+static char *outdir=".";
+static char *dlg_class = "DLGLexer";
+static int gen_trees = 0;
+static int gen_hoist = 0;
+static int nondef_comp = 0; /* 1=compiler is non default */
+static char *compilerCCC="CC";
+static char *compilerCC="cc";
+static char *pccts_path="/usr/local/pccts";
+
+#ifdef __STDC__
+void help(void);
+void mk(char *project, char **files, int n, int argc, char **argv);
+void pfiles(char **files, int n, char *suffix);
+void fatal(char *msg);
+void warn(char *msg);
+#else
+void help();
+void mk();
+void pfiles();
+void fatal();
+void warn();
+#endif
+
+typedef struct _Opt {
+ char *option;
+ int arg;
+#ifdef __cplusplus
+ void (*process)(...);
+#else
+ void (*process)();
+#endif
+ char *descr;
+ } Opt;
+
+#ifdef __STDC__
+static void ProcessArgs(int, char **, Opt *);
+#else
+static void ProcessArgs();
+#endif
+
+static void
+#ifdef __STDC__
+pProj(char *s, char *t )
+#else
+pProj( s, t )
+char *s;
+char *t;
+#endif
+{
+ project = t;
+}
+
+static void
+#ifdef __STDC__
+pUL( char *s )
+#else
+pUL( s )
+char *s;
+#endif
+{
+ user_lexer = 1;
+}
+
+static void
+#ifdef __STDC__
+pCPP( char *s )
+#else
+pCPP( s )
+char *s;
+#endif
+{
+ gen_CPP = 1;
+}
+
+static void
+#ifdef __STDC__
+pUT( char *s, char *t )
+#else
+pUT( s, t )
+char *s;
+char *t;
+#endif
+{
+ user_token_types = t;
+}
+
+static void
+#ifdef __STDC__
+pTrees( char *s )
+#else
+pTrees( s )
+char *s;
+#endif
+{
+ gen_trees = 1;
+}
+
+static void
+#ifdef __STDC__
+pHoist( char *s )
+#else
+pHoist( s )
+char *s;
+#endif
+{
+ gen_hoist = 1;
+}
+
+static void
+#ifdef __STDC__
+pSor( char *s )
+#else
+pSor( s )
+char *s;
+#endif
+{
+ require(num_sors<MAX_SORS, "exceeded max # of sorcerer groups");
+ num_sors++;
+ pTrees(NULL); /* silently turn on tree generation */
+}
+
+static void
+#ifdef __STDC__
+pSFiles( char *s, char *t )
+#else
+pSFiles( s, t )
+char *s;
+char *t;
+#endif
+{
+ if (num_sors==0)
+ {
+ pSor(NULL);
+ warn("sorcerer input file before any '-sor' option");
+ }
+
+ require(num_sfiles[num_sors-1]<MAX_SFILES,
+ "exceeded max # of sorcerer input files");
+ sfiles[num_sors-1][num_sfiles[num_sors-1]++] = t;
+}
+
+static void
+#ifdef __STDC__
+pCFiles( char *s, char *t )
+#else
+pCFiles( s, t )
+char *s;
+char *t;
+#endif
+{
+ require(num_cfiles<MAX_CFILES, "exceeded max # of C/C++ input files");
+ cfiles[num_cfiles++] = t;
+}
+
+int
+#ifdef __STDC__
+isKnownSuffix( char *s )
+#else
+isKnownSuffix( s )
+ char *s;
+#endif
+{
+ if(s==NULL) return 0;
+ if (strcasecmp(s,".c")==0) return 1;
+ if (strcasecmp(s,".cc")==0) return 1;
+ if (strcasecmp(s,".cpp")==0) return 1;
+ if (strcasecmp(s,".cxx")==0) return 1;
+ if (strcasecmp(s,CPP_FILE_SUFFIX)==0) return 1;
+ if (strcasecmp(s,".sor")==0) return 2;
+ return 0;
+}
+
+static void
+#ifdef __STDC__
+pFile( char *s )
+#else
+pFile( s )
+char *s;
+#endif
+{
+ if ( *s=='-' )
+ {
+ fprintf(stderr, "invalid option: '%s'; ignored...",s);
+ return;
+ }
+ switch(isKnownSuffix(strrchr(s,'.')))
+ {
+ case 1: /* c/c++ */
+ pCFiles("-cfiles",s);
+ return;
+ case 2: /* sorcerer */
+ pSFiles("",s);
+ return;
+ default: /* grammar (ANTLR) */
+ break;
+ }
+ require(num_files<MAX_FILES, "exceeded max # of input files");
+ files[num_files++] = s;
+}
+
+static void
+#ifdef __STDC__
+pClass( char *s, char *t )
+#else
+pClass( s, t )
+char *s;
+char *t;
+#endif
+{
+ if (num_sors==0)
+ {
+ require(num_classes<MAX_CLASSES, "exceeded max # of grammar classes");
+ classes[num_classes++] = t;
+ } else
+ {
+ sclasses[num_sors-1] = t; /* one class per sorcerer group (last valid) */
+ }
+}
+
+static void
+#ifdef __STDC__
+pDLGClass( char *s, char *t )
+#else
+pDLGClass( s, t )
+char *s;
+char *t;
+#endif
+{
+ if ( !gen_CPP ) {
+ fprintf(stderr, "-dlg-class makes no sense without C++ mode; ignored...");
+ }
+ else dlg_class = t;
+}
+
+static void
+#ifdef __STDC__
+pOdir( char *s, char *t )
+#else
+pOdir( s, t )
+char *s;
+char *t;
+#endif
+{
+ outdir = t;
+}
+
+static void
+#ifdef __STDC__
+pHdr( char *s, char *t )
+#else
+pHdr( s, t )
+char *s;
+char *t;
+#endif
+{
+ hdr = t;
+}
+
+static void
+#ifdef __STDC__
+pCompiler( char *s, char *t )
+#else
+pCompiler( s, t )
+char *s;
+char *t;
+#endif
+{
+ compilerCCC = t;
+ compilerCC = t;
+ nondef_comp = 1;
+}
+
+static void
+#ifdef __STDC__
+ppccts_path( char *s, char *t )
+#else
+ppccts_path( s, t )
+char *s;
+char *t;
+#endif
+{
+ pccts_path = t;
+}
+
+Opt options[] = {
+ { "-CC", 0, pCPP, "Generate C++ output"},
+ { "-class", 1, pClass, "Name of a grammar class defined in grammar (if C++)"},
+ { "-dlg-class", 1,pDLGClass,"Name of DLG lexer class (default=DLGLexer) (if C++)"},
+ { "-header", 1,pHdr, "Name of ANTLR standard header info (default=no file)"},
+ { "-o", 1, pOdir, "Directory where output files should go (default=\".\")"},
+ { "-project", 1, pProj, "Name of executable to create (default=t)"},
+ { "-token-types", 1, pUT, "Token types are in this file (don't use tokens.h)"},
+ { "-trees", 0, pTrees, "Generate ASTs"},
+ { "-user-lexer", 0, pUL, "Do not create a DLG-based scanner"},
+ { "-mrhoist",0,pHoist, "Maintenance release style hoisting"},
+ { "-cfiles",1,pCFiles, "Additional files in C or C++ to compile"},
+ { "-sor",0,pSor, "Start of sorcerer group"},
+ { "-pccts_path",1,ppccts_path,
+ "Path for $PCCTS directory (default is /usr/local/pccts)"},
+ { "-compiler",1,pCompiler,
+ "Default compiler (default is CC/cc)"},
+ { "*", 0,pFile, "" }, /* anything else is a file */
+ { NULL, 0, NULL, NULL }
+};
+
+#ifdef __STDC__
+extern char *DIR(void);
+#else
+extern char *DIR();
+#endif
+
+#ifdef __STDC__
+int main(int argc, char **argv)
+#else
+int main(argc, argv)
+int argc;
+char **argv;
+#endif
+{
+ int i;
+
+ if ( argc == 1 ) { help(); DIE; }
+ for(i=0;i<MAX_SORS;i++) num_sfiles[i]=0;
+
+ ProcessArgs(argc-1, &(argv[1]), options);
+
+ strcpy(ATOKENBUFFER_O, ATOKENBUFFER_C);
+ ATOKENBUFFER_O[strlen(ATOKENBUFFER_C)-strlen(CPP_FILE_SUFFIX)] = '\0';
+ strcat(ATOKENBUFFER_O, OBJ_FILE_SUFFIX);
+ strcpy(APARSER_O, APARSER_C);
+ APARSER_O[strlen(APARSER_O)-strlen(CPP_FILE_SUFFIX)] = '\0';
+ strcat(APARSER_O, OBJ_FILE_SUFFIX);
+
+ strcpy(ASTBASE_O, ASTBASE_C);
+ ASTBASE_O[strlen(ASTBASE_C)-strlen(CPP_FILE_SUFFIX)] = '\0';
+ strcat(ASTBASE_O, OBJ_FILE_SUFFIX);
+
+ strcpy(PCCTSAST_O, PCCTSAST_C);
+ PCCTSAST_O[strlen(PCCTSAST_C)-strlen(CPP_FILE_SUFFIX)] = '\0';
+ strcat(PCCTSAST_O, OBJ_FILE_SUFFIX);
+
+ strcpy(LIST_O, LIST_C);
+ LIST_O[strlen(LIST_C)-strlen(CPP_FILE_SUFFIX)] = '\0';
+ strcat(LIST_O, OBJ_FILE_SUFFIX);
+
+ strcpy(DLEXERBASE_O, DLEXERBASE_C);
+ DLEXERBASE_O[strlen(DLEXERBASE_C)-strlen(CPP_FILE_SUFFIX)] = '\0';
+ strcat(DLEXERBASE_O, OBJ_FILE_SUFFIX);
+
+ if ( num_files == 0 ) fatal("no grammar files specified; exiting...");
+ if ( !gen_CPP && num_classes>0 ) {
+ warn("can't define classes w/o C++ mode; turning on C++ mode...\n");
+ gen_CPP=1;
+ }
+ if (!gen_CPP && num_sors) {
+ warn("can't define sorcerer group in C mode (yet); turning on C++ mode...\n");
+ gen_CPP=1;
+ }
+ if ( gen_CPP && num_classes==0 ) {
+ fatal("must define classes >0 grammar classes in C++ mode\n");
+ }
+
+ mk(project, files, num_files, argc, argv);
+ DONE;
+}
+
+#ifdef __STDC__
+void help(void)
+#else
+void help()
+#endif
+{
+ Opt *p = options;
+ static char buf[1000+1];
+
+ fprintf(stderr, "genmk [options] f1.g ... fn.g\n");
+ while ( p->option!=NULL && *(p->option) != '*' )
+ {
+ buf[0]='\0';
+ if ( p->arg ) sprintf(buf, "%s ___", p->option);
+ else strcpy(buf, p->option);
+ fprintf(stderr, "\t%-16s %s\n", buf, p->descr);
+ p++;
+ }
+}
+
+#ifdef __STDC__
+void mk(char *project, char **files, int n, int argc, char **argv)
+#else
+void mk(project, files, n, argc, argv)
+char *project;
+char **files;
+int n;
+int argc;
+char **argv;
+#endif
+{
+ int i,j;
+
+ printf("#\n");
+ printf("# PCCTS makefile for: ");
+ pfiles(files, n, NULL);
+ printf("\n");
+ printf("#\n");
+ printf("# Created from:");
+ for (i=0; i<argc; i++) printf(" %s", argv[i]);
+ printf("\n");
+ printf("#\n");
+ printf("# PCCTS release 1.33MR23\n");
+ printf("# Project: %s\n", project);
+ if ( gen_CPP ) printf("# C++ output\n");
+ else printf("# C output\n");
+ if ( user_lexer ) printf("# User-defined scanner\n");
+ else printf("# DLG scanner\n");
+ if ( user_token_types!=NULL ) printf("# User-defined token types in '%s'\n", user_token_types);
+ else printf("# ANTLR-defined token types\n");
+ printf("#\n");
+/***********
+ printf(".SUFFIXES:\n.SUFFIXES:\t.o .cpp .c .h .g .i .dlg .sor\n");
+ ***********/
+ if ( user_token_types!=NULL ) {
+ printf("# Make sure #tokdefs directive in ANTLR grammar lists this file:\n");
+ printf("TOKENS = %s", user_token_types);
+ }
+ else printf("TOKENS = %stokens.h", DIR());
+ printf("\n");
+ printf("#\n");
+ printf("# The following filenames must be consistent with ANTLR/DLG flags\n");
+ printf("DLG_FILE = %s%s\n", DIR(), dlg);
+ printf("ERR = %serr\n", DIR());
+ if ( strcmp(hdr,"stdpccts.h")!=0 ) printf("HDR_FILE = %s%s\n", DIR(), hdr);
+ else printf("HDR_FILE =\n");
+ if ( !gen_CPP ) printf("MOD_FILE = %s%s\n", DIR(), mode);
+ if ( !gen_CPP ) printf("SCAN = %s\n", scan);
+ else printf("SCAN = %s%s\n", DIR(), dlg_class);
+
+ printf("PCCTS = %s\n",pccts_path);
+ printf("ANTLR_H = $(PCCTS)%sh\n", DirectorySymbol);
+ if (num_sors>0) {
+ printf("SOR_H = $(PCCTS)%ssorcerer%sh\n", DirectorySymbol, DirectorySymbol);
+ printf("SOR_LIB = $(PCCTS)%ssorcerer%slib\n",
+ DirectorySymbol, DirectorySymbol);
+ }
+ printf("BIN = $(PCCTS)%sbin\n", DirectorySymbol);
+ printf("ANTLR = $(BIN)%santlr\n", DirectorySymbol);
+ printf("DLG = $(BIN)%sdlg\n", DirectorySymbol);
+ if (num_sors>0) printf("SOR = $(BIN)%ssor\n", DirectorySymbol);
+ printf("CFLAGS = -I. -I$(ANTLR_H)");
+ if (num_sors>0) printf(" -I$(SOR_H)");
+ if ( strcmp(outdir, ".")!=0 ) printf(" -I%s", outdir);
+ printf(" $(COTHER)");
+ printf("\n");
+ printf("AFLAGS =");
+ if ( strcmp(outdir,".")!=0 ) printf(" -o %s", outdir);
+ if ( user_lexer ) printf(" -gx");
+ if ( gen_CPP ) printf(" -CC");
+ if ( strcmp(hdr,"stdpccts.h")!=0 ) printf(" -gh %s", hdr);
+ if ( gen_trees ) printf(" -gt");
+ if ( gen_hoist ) {
+ printf(" -mrhoist on") ;
+ } else {
+ printf(" -mrhoist off");
+ };
+ printf(" $(AOTHER)");
+ printf("\n");
+ printf("DFLAGS = -C2 -i");
+ if ( gen_CPP ) printf(" -CC");
+ if ( strcmp(dlg_class,"DLGLexer")!=0 ) printf(" -cl %s", dlg_class);
+ if ( strcmp(outdir,".")!=0 ) printf(" -o %s", outdir);
+ printf(" $(DOTHER)");
+ printf("\n");
+ if (num_sors>0)
+ {
+ printf("SFLAGS = -CPP");
+ if ( strcmp(outdir,".")!=0 ) printf(" -out-dir %s", outdir);
+ printf(" $(SOTHER)\n");
+ }
+ printf("GRM = ");
+ pfiles(files, n, NULL);
+ printf("\n");
+ printf("SRC = ");
+ if ( gen_CPP ) pfiles(files, n, CPP_FILE_SUFFIX_NO_DOT);
+ else pfiles(files, n, "c");
+ if ( gen_CPP ) {
+ printf(" \\\n\t");
+ pclasses(classes, num_classes, CPP_FILE_SUFFIX_NO_DOT);
+ printf(" \\\n\t");
+ printf("$(ANTLR_H)%s%s", DirectorySymbol, APARSER_C);
+ if ( !user_lexer ) printf(" $(ANTLR_H)%s%s", DirectorySymbol, DLEXERBASE_C);
+ if ( gen_trees ) {
+ printf(" \\\n\t");
+ printf("$(ANTLR_H)%s%s", DirectorySymbol, ASTBASE_C);
+ printf(" $(ANTLR_H)%s%s", DirectorySymbol, PCCTSAST_C);
+/* printf(" $(ANTLR_H)%s%s", DirectorySymbol, LIST_C); */
+ printf(" \\\n\t");
+ }
+ printf(" $(ANTLR_H)%s%s", DirectorySymbol, ATOKENBUFFER_C);
+ }
+ if ( !user_lexer ) {
+ if ( gen_CPP ) printf(" $(SCAN)%s", CPP_FILE_SUFFIX);
+ else printf(" %s$(SCAN).c", DIR());
+ }
+ if ( !gen_CPP ) printf(" $(ERR).c");
+ for (i=0;i<num_sors;i++)
+ {
+ printf(" \\\n\t");
+ pclasses(&sclasses[i],1,CPP_FILE_SUFFIX_NO_DOT);
+ printf(" ");
+ pfiles(&sfiles[i][0],num_sfiles[i],CPP_FILE_SUFFIX_NO_DOT);
+ }
+ if(num_sors>0)
+ printf(" \\\n\t$(SOR_LIB)%sSTreeParser.cpp", DirectorySymbol);
+ if (num_cfiles>0)
+ {
+ printf(" \\\n\t");
+ pfiles(cfiles,num_cfiles,NULL);
+ }
+ printf("\n\n");
+ printf("OBJ = ");
+ pfiles(files, n, "o");
+ if ( gen_CPP ) {
+ printf(" \\\n\t");
+ pclasses(classes, num_classes, "o");
+ printf(" \\\n\t");
+ printf("%s%s", DIR(), APARSER_O);
+ if ( !user_lexer ) {
+ printf(" %s%s", DIR(), DLEXERBASE_O);
+ }
+ if ( gen_trees ) {
+ printf(" \\\n\t");
+ printf("%s%s", DIR(), ASTBASE_O);
+ printf(" %s%s", DIR(), PCCTSAST_O);
+/* printf(" %s%s", DIR(), LIST_O); */
+ printf(" \\\n\t");
+ }
+ printf(" %s%s", DIR(), ATOKENBUFFER_O);
+ }
+ if ( !user_lexer ) {
+ if ( gen_CPP ) printf(" $(SCAN)%s", OBJ_FILE_SUFFIX);
+ else printf(" %s$(SCAN)%s", DIR(), OBJ_FILE_SUFFIX);
+ }
+ if ( !gen_CPP ) printf(" $(ERR)%s", OBJ_FILE_SUFFIX);
+ for (i=0;i<num_sors;i++)
+ {
+ printf(" \\\n\t");
+ pclasses(&sclasses[i],1,"o");
+ printf(" ");
+ pfiles(&sfiles[i][0],num_sfiles[i],"o");
+ }
+ if(num_sors>0) printf(" \\\n\tSTreeParser.o");
+ if (num_cfiles>0)
+ {
+ printf(" \\\n\t");
+ pfiles(cfiles,num_cfiles,"o");
+ }
+ printf("\n\n");
+
+ printf("ANTLR_SPAWN = ");
+ if ( gen_CPP ) pfiles(files, n, CPP_FILE_SUFFIX_NO_DOT);
+ else pfiles(files, n, "c");
+ if ( gen_CPP ) {
+ printf(" ");
+ pclasses(classes, num_classes, CPP_FILE_SUFFIX_NO_DOT);
+ printf(" \\\n\t\t");
+ pclasses(classes, num_classes, "h");
+ if ( strcmp(hdr,"stdpccts.h")!=0 ) {
+ printf(" \\\n\t\t");
+ printf("$(HDR_FILE) stdpccts.h");
+ }
+ }
+ if ( user_lexer ) {
+ if ( !user_token_types ) printf(" $(TOKENS)");
+ }
+ else {
+ printf(" $(DLG_FILE)");
+ if ( !user_token_types ) printf(" $(TOKENS)");
+ }
+ if ( !gen_CPP ) printf(" $(ERR).c");
+ printf("\n");
+
+ if ( !user_lexer ) {
+ if ( gen_CPP ) printf("DLG_SPAWN = $(SCAN)%s", CPP_FILE_SUFFIX);
+ else printf("DLG_SPAWN = %s$(SCAN).c", DIR());
+ if ( gen_CPP ) printf(" $(SCAN).h");
+ if ( !gen_CPP ) printf(" $(MOD_FILE)");
+ printf("\n");
+ }
+
+ if ( gen_CPP ) {
+ if ( !nondef_comp )
+ printf("ifdef CXX\nCCC = $(CXX)\nendif\n\nifndef CCC\n");
+ printf("CCC = %s\n",compilerCCC);
+ if ( !nondef_comp ) printf("endif\n\n");
+ }
+ else
+ {
+ if ( !nondef_comp ) printf("ifndef CC\n");
+ printf("CC = %s\n",compilerCC);
+ if ( !nondef_comp ) printf("endif\n\n");
+ }
+
+ /* set up dependencies */
+ printf("\n%s : $(SRC) $(OBJ)\n", project);
+ printf("\t%s %s %s $(CFLAGS) $(OBJ)\n",
+ gen_CPP?"$(CCC)":"$(CC)",
+ RENAME_EXE_FLAG,
+ project);
+ printf("\n");
+
+ /* implicit rules */
+
+/* if(gen_CPP)
+ printf("%%.o : %%.cpp\n\t$(CCC) -c $(CFLAGS) $<\n\n");
+
+ printf("%%.o : %%.c\n\t%s -c $(CFLAGS) $<\n\n",
+ gen_CPP?"$(CCC)":"$(CC)");
+*/
+ /* how to compile parser files */
+
+ for (i=0; i<num_files; i++)
+ {
+ pfiles(&files[i], 1, "o");
+ if ( user_lexer ) {
+ printf(" : $(TOKENS)");
+ }
+ else {
+ if ( gen_CPP ) printf(" : $(TOKENS) $(SCAN).h");
+ else printf(" : $(MOD_FILE) $(TOKENS)");
+ }
+ printf(" ");
+ if ( gen_CPP ) pfiles(&files[i], 1, CPP_FILE_SUFFIX_NO_DOT);
+ else pfiles(&files[i], 1, "c");
+ if ( gen_CPP && strcmp(hdr,"stdpccts.h")!=0 ) printf(" $(HDR_FILE)");
+ printf("\n");
+ printf("\t%s -c $(CFLAGS) %s ",
+ gen_CPP?"$(CCC)":"$(CC)",RENAME_OBJ_FLAG);
+ pfiles(&files[i], 1, "o");
+ printf(" ");
+ if ( gen_CPP ) pfiles(&files[i], 1, CPP_FILE_SUFFIX_NO_DOT);
+ else pfiles(&files[i], 1, "c");
+ printf("\n\n");
+ }
+
+ for (i=0; i<num_cfiles; i++)
+ {
+ pfiles(&cfiles[i], 1, "o");
+ printf(" : ");
+ pfiles(&cfiles[i], 1, NULL);
+ if ( gen_CPP && strcmp(hdr,"stdpccts.h")!=0 ) printf(" $(HDR_FILE)");
+/*** printf(" "); ***/
+/*** pfiles(&cfiles[i], 1, "h"); ***/
+ printf("\n");
+ printf("\t%s -c $(CFLAGS) %s ",
+ gen_CPP?"$(CCC)":"$(CC)",RENAME_OBJ_FLAG);
+ pfiles(&cfiles[i], 1, "o");
+ printf(" ");
+ pfiles(&cfiles[i], 1, NULL);
+ printf("\n\n");
+
+/*
+ * pfiles(&cfiles[i], 1, "h");
+ * printf(" :\ntouch ");
+ * pfiles(&cfiles[i], 1, "h");
+ * printf("\n\n");
+ */
+ }
+
+ /* how to compile err.c */
+ if ( !gen_CPP ) {
+ printf("$(ERR)%s : $(ERR).c", OBJ_FILE_SUFFIX);
+ if ( !user_lexer ) printf(" $(TOKENS)");
+ printf("\n");
+ printf("\t%s -c $(CFLAGS) %s $(ERR)%s $(ERR).c",
+ gen_CPP?"$(CCC)":"$(CC)",
+ RENAME_OBJ_FLAG,
+ OBJ_FILE_SUFFIX);
+ printf("\n\n");
+ }
+
+ /* how to compile Class.c */
+ for (i=0; i<num_classes; i++)
+ {
+ pclasses(&classes[i], 1, "o");
+ if ( user_lexer ) {
+ printf(" : $(TOKENS)");
+ }
+ else {
+ printf(" : $(TOKENS) $(SCAN).h");
+ }
+ printf(" ");
+ pclasses(&classes[i], 1, CPP_FILE_SUFFIX_NO_DOT);
+ printf(" ");
+ pclasses(&classes[i], 1, "h");
+ if ( gen_CPP && strcmp(hdr,"stdpccts.h")!=0 ) printf(" $(HDR_FILE)");
+ printf("\n");
+ printf("\t%s -c $(CFLAGS) %s ",
+ gen_CPP?"$(CCC)":"$(CC)",
+ RENAME_OBJ_FLAG);
+ pclasses(&classes[i], 1, "o");
+ printf(" ");
+ pclasses(&classes[i], 1, CPP_FILE_SUFFIX_NO_DOT);
+ printf("\n\n");
+ }
+
+ /* how to compile scan.c */
+ if ( !user_lexer ) {
+ if ( gen_CPP ) printf("$(SCAN)%s : $(SCAN)%s", OBJ_FILE_SUFFIX, CPP_FILE_SUFFIX);
+ else printf("%s$(SCAN)%s : %s$(SCAN).c", DIR(), OBJ_FILE_SUFFIX, DIR());
+ if ( !user_lexer ) printf(" $(TOKENS)");
+ printf("\n");
+ if ( gen_CPP ) printf("\t$(CCC) -c $(CFLAGS) %s $(SCAN)%s $(SCAN)%s",
+ RENAME_OBJ_FLAG,
+ OBJ_FILE_SUFFIX,
+ CPP_FILE_SUFFIX);
+ else printf("\t$(CC) -c $(CFLAGS) %s %s$(SCAN)%s %s$(SCAN).c",
+ RENAME_OBJ_FLAG,
+ DIR(),
+ OBJ_FILE_SUFFIX,
+ DIR());
+ printf("\n\n");
+ }
+/* how to compile sorcerer classes */
+ for (i=0;i<num_sors;i++)
+ {
+ pclasses(&sclasses[i], 1, "o");
+ printf(" : ");
+ pclasses(&sclasses[i], 1, CPP_FILE_SUFFIX_NO_DOT);
+ printf(" ");
+ pclasses(&sclasses[i], 1, "h");
+ if ( gen_CPP && strcmp(hdr,"stdpccts.h")!=0 ) printf(" $(HDR_FILE)");
+ printf("\n");
+ printf("\t%s -c $(CFLAGS) %s ",
+ gen_CPP?"$(CCC)":"$(CC)",
+ RENAME_OBJ_FLAG);
+ pclasses(&sclasses[i], 1, "o");
+ printf(" ");
+ pclasses(&sclasses[i], 1, CPP_FILE_SUFFIX_NO_DOT);
+ printf("\n\n");
+/* how to compile i-th sorcerer's files*/
+ for (j=0; j<num_sfiles[i]; j++)
+ {
+ pfiles(&sfiles[i][j], 1, "o");
+ printf(" : ");
+ if ( gen_CPP ) pfiles(&sfiles[i][j], 1, CPP_FILE_SUFFIX_NO_DOT);
+ else pfiles(&sfiles[i][j], 1, "c");
+ if ( gen_CPP && strcmp(hdr,"stdpccts.h")!=0 ) printf(" $(HDR_FILE)");
+ printf("\n");
+ printf("\t%s -c $(CFLAGS) %s ",
+ gen_CPP?"$(CCC)":"$(CC)",RENAME_OBJ_FLAG);
+ pfiles(&sfiles[i][j], 1, "o");
+ printf(" ");
+ if ( gen_CPP ) pfiles(&sfiles[i][j], 1, CPP_FILE_SUFFIX_NO_DOT);
+ else pfiles(&sfiles[i][j], 1, "c");
+ printf("\n\n");
+ }
+ if ( gen_CPP ) pfiles(&sfiles[i][0], num_sfiles[i], CPP_FILE_SUFFIX_NO_DOT);
+ else pfiles(&sfiles[i][0], num_sfiles[i], "c");
+ if ( gen_CPP )
+ {
+ printf(" ");
+ pclasses(&sclasses[i], 1, CPP_FILE_SUFFIX_NO_DOT);
+ printf(" ");
+ pclasses(&sclasses[i], 1, "h");
+ if ( strcmp(hdr,"stdpccts.h")!=0 )
+ {
+ printf(" ");
+ printf("$(HDR_FILE) stdpccts.h");
+ }
+ }
+ printf(" : ");
+ pfiles(&sfiles[i][0],num_sfiles[i],NULL);
+ printf("\n\t$(SOR) $(SFLAGS) ");
+ pfiles(&sfiles[i][0],num_sfiles[i],NULL);
+ printf("\n\n");
+ }
+ if(num_sors>0)
+ {
+ printf("STreeParser%s : $(SOR_LIB)%sSTreeParser.cpp\n",
+ OBJ_FILE_SUFFIX,DirectorySymbol);
+ printf("\t%s -c $(CFLAGS) %s ",
+ gen_CPP?"$(CCC)":"$(CC)",RENAME_OBJ_FLAG);
+ printf("STreeParser%s ",OBJ_FILE_SUFFIX);
+ printf("$(SOR_LIB)%sSTreeParser.cpp\n\n",DirectorySymbol);
+ }
+
+ printf("$(ANTLR_SPAWN) : $(GRM)\n");
+ printf("\t$(ANTLR) $(AFLAGS) $(GRM)\n");
+
+ if ( !user_lexer )
+ {
+ printf("\n");
+ printf("$(DLG_SPAWN) : $(DLG_FILE)\n");
+ if ( gen_CPP ) printf("\t$(DLG) $(DFLAGS) $(DLG_FILE)\n");
+ else printf("\t$(DLG) $(DFLAGS) $(DLG_FILE) $(SCAN).c\n");
+ }
+
+ /* do the makes for ANTLR/DLG support */
+ if ( gen_CPP ) {
+ printf("\n");
+ printf("%s%s : $(ANTLR_H)%s%s\n", DIR(), APARSER_O, DirectorySymbol, APARSER_C);
+ printf("\t%s -c $(CFLAGS) %s ",
+ gen_CPP?"$(CCC)":"$(CC)",
+ RENAME_OBJ_FLAG);
+ printf("%s%s $(ANTLR_H)%s%s\n", DIR(), APARSER_O, DirectorySymbol, APARSER_C);
+ printf("\n");
+ printf("%s%s : $(ANTLR_H)%s%s\n", DIR(), ATOKENBUFFER_O, DirectorySymbol, ATOKENBUFFER_C);
+ printf("\t%s -c $(CFLAGS) %s ",
+ gen_CPP?"$(CCC)":"$(CC)",
+ RENAME_OBJ_FLAG);
+ printf("%s%s $(ANTLR_H)%s%s\n", DIR(), ATOKENBUFFER_O, DirectorySymbol, ATOKENBUFFER_C);
+ if ( !user_lexer ) {
+ printf("\n");
+ printf("%s%s : $(ANTLR_H)%s%s\n", DIR(), DLEXERBASE_O, DirectorySymbol, DLEXERBASE_C);
+ printf("\t%s -c $(CFLAGS) %s ",
+ gen_CPP?"$(CCC)":"$(CC)",
+ RENAME_OBJ_FLAG);
+ printf("%s%s $(ANTLR_H)%s%s\n", DIR(), DLEXERBASE_O, DirectorySymbol, DLEXERBASE_C);
+ }
+ if ( gen_trees ) {
+ printf("\n");
+ printf("%s%s : $(ANTLR_H)%s%s\n", DIR(), ASTBASE_O, DirectorySymbol, ASTBASE_C);
+ printf("\t%s -c $(CFLAGS) %s ",
+ gen_CPP?"$(CCC)":"$(CC)",
+ RENAME_OBJ_FLAG);
+ printf("%s%s $(ANTLR_H)%s%s\n", DIR(), ASTBASE_O, DirectorySymbol, ASTBASE_C);
+ printf("\n");
+ printf("%s%s : $(ANTLR_H)%s%s\n", DIR(), PCCTSAST_O, DirectorySymbol, PCCTSAST_C);
+ printf("\t%s -c $(CFLAGS) %s ",
+ gen_CPP?"$(CCC)":"$(CC)",
+ RENAME_OBJ_FLAG);
+ printf("%s%s $(ANTLR_H)%s%s\n", DIR(), PCCTSAST_O, DirectorySymbol, PCCTSAST_C);
+ printf("\n");
+/*
+ printf("%s%s : $(ANTLR_H)%s%s\n", DIR(), LIST_O, DirectorySymbol, LIST_C);
+ printf("\t%s -c $(CFLAGS) %s ",
+ gen_CPP?"$(CCC)":"$(CC)",RENAME_OBJ_FLAG);
+ printf("%s%s $(ANTLR_H)%s%s\n", DIR(), LIST_O, DirectorySymbol, LIST_C);
+*/
+ }
+ }
+
+ /* clean and scrub targets */
+
+ printf("\nclean:\n");
+ printf("\trm -f *%s core %s", OBJ_FILE_SUFFIX, project);
+ if ( strcmp(outdir, ".")!=0 ) printf(" %s*%s", DIR(), OBJ_FILE_SUFFIX);
+ printf("\n");
+
+ printf("\nscrub: clean\n");
+/* printf("\trm -f *%s core %s", OBJ_FILE_SUFFIX, project); */
+/* if ( strcmp(outdir, ".")!=0 ) printf(" %s*%s", DIR(), OBJ_FILE_SUFFIX); */
+ printf("\trm -f $(ANTLR_SPAWN)");
+ if ( !user_lexer ) printf(" $(DLG_SPAWN)");
+ for (i=0;i<num_sors;i++)
+ {
+ printf(" ");
+ if ( gen_CPP ) pfiles(&sfiles[i][0], num_sfiles[i], CPP_FILE_SUFFIX_NO_DOT);
+ else pfiles(&sfiles[i][0], num_sfiles[i], "c");
+ if ( gen_CPP )
+ {
+ printf(" ");
+ pclasses(&sclasses[i], 1, CPP_FILE_SUFFIX_NO_DOT);
+ printf(" ");
+ pclasses(&sclasses[i], 1, "h");
+ }
+ }
+ printf("\n\n");
+}
+
+#ifdef __STDC__
+void pfiles(char **files, int n, char *suffix)
+#else
+void pfiles(files, n, suffix)
+char **files;
+int n;
+char *suffix;
+#endif
+{
+ int first=1;
+
+ while ( n>0 )
+ {
+ char *p = &(*files)[strlen(*files)-1];
+ if ( !first ) putchar(' ');
+ first=0;
+ while ( p > *files && *p != '.' ) --p;
+ if ( p == *files )
+ {
+ fprintf(stderr,
+ "genmk: filenames must be file.suffix format: %s\n",
+ *files);
+ exit(-1);
+ }
+ if ( suffix == NULL ) printf("%s", *files);
+ else
+ {
+ *p = '\0';
+ printf("%s", DIR());
+ if ( strcmp(suffix, "o")==0 ) printf("%s%s", *files, OBJ_FILE_SUFFIX);
+ else printf("%s.%s", *files, suffix);
+ *p = '.';
+ }
+ files++;
+ --n;
+ }
+}
+
+#ifdef __STDC__
+pclasses(char **classes, int n, char *suffix)
+#else
+pclasses(classes, n, suffix)
+char **classes;
+int n;
+char *suffix;
+#endif
+{
+ int first=1;
+
+ while ( n>0 )
+ {
+ if ( !first ) putchar(' ');
+ first=0;
+ if ( suffix == NULL ) printf("%s", *classes);
+ else {
+ printf("%s", DIR());
+ if ( strcmp(suffix, "o")==0 ) printf("%s%s", *classes, OBJ_FILE_SUFFIX);
+ else printf("%s.%s", *classes, suffix);
+ }
+ classes++;
+ --n;
+ }
+}
+
+static void
+#ifdef __STDC__
+ProcessArgs( int argc, char **argv, Opt *options )
+#else
+ProcessArgs( argc, argv, options )
+int argc;
+char **argv;
+Opt *options;
+#endif
+{
+ Opt *p;
+ require(argv!=NULL, "ProcessArgs: command line NULL");
+
+ while ( argc-- > 0 )
+ {
+ p = options;
+ while ( p->option != NULL )
+ {
+ if ( strcmp(p->option, "*") == 0 ||
+ strcmp(p->option, *argv) == 0 )
+ {
+ if ( p->arg )
+ {
+ (*p->process)( *argv, *(argv+1) );
+ argv++;
+ argc--;
+ }
+ else
+ (*p->process)( *argv );
+ break;
+ }
+ p++;
+ }
+ argv++;
+ }
+}
+
+#ifdef __STDC__
+void fatal( char *err_)
+#else
+void fatal( err_)
+char *err_;
+#endif
+{
+ fprintf(stderr, "genmk: %s\n", err_);
+ exit(1);
+}
+
+#ifdef __STDC__
+void warn( char *err_)
+#else
+void warn( err_)
+char *err_;
+#endif
+{
+ fprintf(stderr, "genmk: %s\n", err_);
+}
+
+#ifdef __STDC__
+char *DIR(void)
+#else
+char *DIR()
+#endif
+{
+ static char buf[200+1];
+
+ if ( strcmp(outdir,TopDirectory)==0 ) return "";
+ sprintf(buf, "%s%s", outdir, DirectorySymbol);
+ return buf;
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk_old.c b/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk_old.c new file mode 100644 index 0000000000..2cf9fad727 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk_old.c @@ -0,0 +1,762 @@ +/*
+ * genmk -- a program to make makefiles for PCCTS
+ *
+ * ANTLR 1.33MR10
+ * Terence John Parr 1989 - 1998
+ * Purdue University
+ * U of MN
+ */
+
+#include <stdio.h>
+#include "pcctscfg.h" /* be sensitive to what ANTLR/DLG call the files */
+
+#ifdef VAXC
+#define DIE return 0;
+#define DONE return 1;
+#else
+#define DIE return 1;
+#define DONE return 0;
+#endif
+
+#ifndef require
+#define require(expr, err) {if ( !(expr) ) fatal(err);}
+#endif
+
+#define MAX_FILES 50
+#define MAX_CLASSES 50
+
+char *RENAME_OBJ_FLAG="-o",
+ *RENAME_EXE_FLAG="-o";
+
+char *dlg = "parser.dlg";
+char *err = "err.c";
+char *hdr = "stdpccts.h";
+char *tok = "tokens.h";
+char *mode = "mode.h";
+char *scan = "scan";
+
+char ATOKENBUFFER_O[100];
+char APARSER_O[100];
+char ASTBASE_O[100];
+char PCCTSAST_O[100];
+char LIST_O[100];
+char DLEXERBASE_O[100];
+
+/* Option flags */
+static char *project="t", *files[MAX_FILES], *classes[MAX_CLASSES];
+static int num_files = 0;
+static int num_classes = 0;
+static int user_lexer = 0;
+static char *user_token_types = NULL;
+static int gen_CPP = 0;
+static char *outdir=".";
+static char *dlg_class = "DLGLexer";
+static int gen_trees = 0;
+static int gen_hoist = 0;
+static char cfiles[1600]="";
+static char *compilerCCC="CC";
+static char *compilerCC="cc";
+static char *pccts_path="/usr/local/pccts";
+
+void help();
+void mk();
+void pfiles();
+void pclasses();
+void fatal();
+void warn();
+
+typedef struct _Opt {
+ char *option;
+ int arg;
+#ifdef __cplusplus
+ void (*process)(...);
+#else
+ void (*process)();
+#endif
+ char *descr;
+ } Opt;
+
+#ifdef __STDC__
+static void ProcessArgs(int, char **, Opt *);
+#else
+static void ProcessArgs();
+#endif
+
+static void
+pProj( s, t )
+char *s;
+char *t;
+{
+ project = t;
+}
+
+static void
+pUL( s )
+char *s;
+{
+ user_lexer = 1;
+}
+
+static void
+pCPP( s )
+char *s;
+{
+ gen_CPP = 1;
+}
+
+static void
+pUT( s, t )
+char *s;
+char *t;
+{
+ user_token_types = t;
+}
+
+static void
+pTrees( s )
+char *s;
+{
+ gen_trees = 1;
+}
+
+static void
+pHoist( s )
+char *s;
+{
+ gen_hoist = 1;
+}
+
+static void
+#ifdef __STDC__
+pFile( char *s )
+#else
+pFile( s )
+char *s;
+#endif
+{
+ if ( *s=='-' )
+ {
+ fprintf(stderr, "invalid option: '%s'; ignored...",s);
+ return;
+ }
+
+ require(num_files<MAX_FILES, "exceeded max # of input files");
+ files[num_files++] = s;
+}
+
+static void
+#ifdef __STDC__
+pClass( char *s, char *t )
+#else
+pClass( s, t )
+char *s;
+char *t;
+#endif
+{
+ require(num_classes<MAX_CLASSES, "exceeded max # of grammar classes");
+ classes[num_classes++] = t;
+}
+
+static void
+#ifdef __STDC__
+pDLGClass( char *s, char *t )
+#else
+pDLGClass( s, t )
+char *s;
+char *t;
+#endif
+{
+ if ( !gen_CPP ) {
+ fprintf(stderr, "-dlg-class makes no sense without C++ mode; ignored...");
+ }
+ else dlg_class = t;
+}
+
+static void
+#ifdef __STDC__
+pOdir( char *s, char *t )
+#else
+pOdir( s, t )
+char *s;
+char *t;
+#endif
+{
+ outdir = t;
+}
+
+static void
+#ifdef __STDC__
+pHdr( char *s, char *t )
+#else
+pHdr( s, t )
+char *s;
+char *t;
+#endif
+{
+ hdr = t;
+}
+
+static void
+#ifdef __STDC__
+pCFiles( char *s, char *t )
+#else
+pCFiles( s, t )
+char *s;
+char *t;
+#endif
+{
+ strcat(strcat(cfiles," "), t);
+}
+
+static void
+#ifdef __STDC__
+pCompiler( char *s, char *t )
+#else
+pCompiler( s, t )
+char *s;
+char *t;
+#endif
+{
+ compilerCCC = t;
+ compilerCC = t;
+}
+
+static void
+#ifdef __STDC__
+ppccts_path( char *s, char *t )
+#else
+ppccts_path( s, t )
+char *s;
+char *t;
+#endif
+{
+ pccts_path = t;
+}
+
+Opt options[] = {
+ { "-CC", 0, pCPP, "Generate C++ output"},
+ { "-class", 1, pClass, "Name of a grammar class defined in grammar (if C++)"},
+ { "-dlg-class", 1,pDLGClass,"Name of DLG lexer class (default=DLGLexer) (if C++)"},
+ { "-header", 1,pHdr, "Name of ANTLR standard header info (default=no file)"},
+ { "-o", 1, pOdir, "Directory where output files should go (default=\".\")"},
+ { "-project", 1, pProj, "Name of executable to create (default=t)"},
+ { "-token-types", 1, pUT, "Token types are in this file (don't use tokens.h)"},
+ { "-trees", 0, pTrees, "Generate ASTs"},
+ { "-user-lexer", 0, pUL, "Do not create a DLG-based scanner"},
+ { "-mrhoist",0,pHoist, "Maintenance release style hoisting"},
+ { "-cfiles",1,pCFiles, "Additional files in C or C++ to compile"},
+ { "-pccts_path",1,ppccts_path,
+ "Path for $PCCTS directory (default is /usr/local/pccts)"},
+ { "-compiler",1,pCompiler,
+ "Default compiler (default is CC/cc)"},
+ { "*", 0,pFile, "" }, /* anything else is a file */
+ { NULL, 0, NULL, NULL }
+};
+
+extern char *DIR();
+
+int main(argc, argv)
+int argc;
+char **argv;
+{
+ if ( argc == 1 ) { help(); DIE; }
+ ProcessArgs(argc-1, &(argv[1]), options);
+
+ strcpy(ATOKENBUFFER_O, ATOKENBUFFER_C);
+ ATOKENBUFFER_O[strlen(ATOKENBUFFER_C)-strlen(CPP_FILE_SUFFIX)] = '\0';
+ strcat(ATOKENBUFFER_O, OBJ_FILE_SUFFIX);
+ strcpy(APARSER_O, APARSER_C);
+ APARSER_O[strlen(APARSER_O)-strlen(CPP_FILE_SUFFIX)] = '\0';
+ strcat(APARSER_O, OBJ_FILE_SUFFIX);
+
+ strcpy(ASTBASE_O, ASTBASE_C);
+ ASTBASE_O[strlen(ASTBASE_C)-strlen(CPP_FILE_SUFFIX)] = '\0';
+ strcat(ASTBASE_O, OBJ_FILE_SUFFIX);
+
+ strcpy(PCCTSAST_O, PCCTSAST_C);
+ PCCTSAST_O[strlen(PCCTSAST_C)-strlen(CPP_FILE_SUFFIX)] = '\0';
+ strcat(PCCTSAST_O, OBJ_FILE_SUFFIX);
+
+ strcpy(LIST_O, LIST_C);
+ LIST_O[strlen(LIST_C)-strlen(CPP_FILE_SUFFIX)] = '\0';
+ strcat(LIST_O, OBJ_FILE_SUFFIX);
+
+ strcpy(DLEXERBASE_O, DLEXERBASE_C);
+ DLEXERBASE_O[strlen(DLEXERBASE_C)-strlen(CPP_FILE_SUFFIX)] = '\0';
+ strcat(DLEXERBASE_O, OBJ_FILE_SUFFIX);
+
+ if ( num_files == 0 ) fatal("no grammar files specified; exiting...");
+ if ( !gen_CPP && num_classes>0 ) {
+ warn("can't define classes w/o C++ mode; turning on C++ mode...\n");
+ gen_CPP=1;
+ }
+ if ( gen_CPP && num_classes==0 ) {
+ fatal("must define classes >0 grammar classes in C++ mode\n");
+ }
+
+ mk(project, files, num_files, argc, argv);
+ DONE;
+}
+
+void help()
+{
+ Opt *p = options;
+ static char buf[1000+1];
+
+ fprintf(stderr, "genmk [options] f1.g ... fn.g\n");
+ while ( p->option!=NULL && *(p->option) != '*' )
+ {
+ buf[0]='\0';
+ if ( p->arg ) sprintf(buf, "%s ___", p->option);
+ else strcpy(buf, p->option);
+ fprintf(stderr, "\t%-16s %s\n", buf, p->descr);
+ p++;
+ }
+}
+
+void mk(project, files, n, argc, argv)
+char *project;
+char **files;
+int n;
+int argc;
+char **argv;
+{
+ int i;
+
+ printf("#\n");
+ printf("# PCCTS makefile for: ");
+ pfiles(files, n, NULL);
+ printf("\n");
+ printf("#\n");
+ printf("# Created from:");
+ for (i=0; i<argc; i++) printf(" %s", argv[i]);
+ printf("\n");
+ printf("#\n");
+ printf("# PCCTS release 1.33MR21\n");
+ printf("# Project: %s\n", project);
+ if ( gen_CPP ) printf("# C++ output\n");
+ else printf("# C output\n");
+ if ( user_lexer ) printf("# User-defined scanner\n");
+ else printf("# DLG scanner\n");
+ if ( user_token_types!=NULL ) printf("# User-defined token types in '%s'\n", user_token_types);
+ else printf("# ANTLR-defined token types\n");
+ printf("#\n");
+ printf(".SUFFIXES:\n.SUFFIXES: .o .cpp .c .h .g .i .dlg\n");
+ if ( user_token_types!=NULL ) {
+ printf("# Make sure #tokdefs directive in ANTLR grammar lists this file:\n");
+ printf("TOKENS = %s", user_token_types);
+ }
+ else printf("TOKENS = %stokens.h", DIR());
+ printf("\n");
+ printf("#\n");
+ printf("# The following filenames must be consistent with ANTLR/DLG flags\n");
+ printf("DLG_FILE = %s%s\n", DIR(), dlg);
+ printf("ERR = %serr\n", DIR());
+ if ( strcmp(hdr,"stdpccts.h")!=0 ) printf("HDR_FILE = %s%s\n", DIR(), hdr);
+ else printf("HDR_FILE =\n");
+ if ( !gen_CPP ) printf("MOD_FILE = %s%s\n", DIR(), mode);
+ if ( !gen_CPP ) printf("SCAN = %s\n", scan);
+ else printf("SCAN = %s%s\n", DIR(), dlg_class);
+
+ printf("PCCTS = %s\n",pccts_path);
+ printf("ANTLR_H = $(PCCTS)%sh\n", DirectorySymbol);
+ printf("BIN = $(PCCTS)%sbin\n", DirectorySymbol);
+ printf("ANTLR = $(BIN)%santlr\n", DirectorySymbol);
+ printf("DLG = $(BIN)%sdlg\n", DirectorySymbol);
+ printf("CFLAGS = -I. -I$(ANTLR_H)");
+ if ( strcmp(outdir, ".")!=0 ) printf(" -I%s", outdir);
+ printf(" $(COTHER)");
+ printf("\n");
+ printf("AFLAGS =");
+ if ( strcmp(outdir,".")!=0 ) printf(" -o %s", outdir);
+ if ( user_lexer ) printf(" -gx");
+ if ( gen_CPP ) printf(" -CC");
+ if ( strcmp(hdr,"stdpccts.h")!=0 ) printf(" -gh %s", hdr);
+ if ( gen_trees ) printf(" -gt");
+ if ( gen_hoist ) {
+ printf(" -mrhoist on") ;
+ } else {
+ printf(" -mrhoist off");
+ };
+ printf(" $(AOTHER)");
+ printf("\n");
+ printf("DFLAGS = -C2 -i");
+ if ( gen_CPP ) printf(" -CC");
+ if ( strcmp(dlg_class,"DLGLexer")!=0 ) printf(" -cl %s", dlg_class);
+ if ( strcmp(outdir,".")!=0 ) printf(" -o %s", outdir);
+ printf(" $(DOTHER)");
+ printf("\n");
+ printf("GRM = ");
+ pfiles(files, n, NULL);
+ printf("\n");
+ printf("MYFILES = %s\n",cfiles);
+ printf("SRC = ");
+ if ( gen_CPP ) pfiles(files, n, CPP_FILE_SUFFIX_NO_DOT);
+ else pfiles(files, n, "c");
+ if ( gen_CPP ) {
+ printf(" \\\n ");
+ printf(" ");
+ pclasses(classes, num_classes, CPP_FILE_SUFFIX_NO_DOT);
+ printf(" \\\n ");
+ printf("$(ANTLR_H)%s%s", DirectorySymbol, APARSER_C);
+ if ( !user_lexer ) printf(" $(ANTLR_H)%s%s", DirectorySymbol, DLEXERBASE_C);
+ if ( gen_trees ) {
+ printf(" \\\n ");
+ printf("$(ANTLR_H)%s%s", DirectorySymbol, ASTBASE_C);
+ printf(" $(ANTLR_H)%s%s", DirectorySymbol, PCCTSAST_C);
+/* printf(" $(ANTLR_H)%s%s", DirectorySymbol, LIST_C); */
+ printf(" \\\n ");
+ }
+ printf(" $(ANTLR_H)%s%s", DirectorySymbol, ATOKENBUFFER_C);
+ }
+ if ( !user_lexer ) {
+ if ( gen_CPP ) printf(" $(SCAN)%s", CPP_FILE_SUFFIX);
+ else printf(" %s$(SCAN).c", DIR());
+ }
+ if ( !gen_CPP ) printf(" $(ERR).c");
+ printf("\\\n $(MYFILES)\n");
+ printf("OBJ = ");
+ pfiles(files, n, "o");
+ if ( gen_CPP ) {
+ printf(" \\\n ");
+ printf(" ");
+ pclasses(classes, num_classes, "o");
+ printf(" \\\n ");
+ printf(" %s%s", DIR(), APARSER_O);
+ if ( !user_lexer ) {
+ printf(" %s%s", DIR(), DLEXERBASE_O);
+ }
+ if ( gen_trees ) {
+ printf(" \\\n ");
+ printf("%s%s", DIR(), ASTBASE_O);
+ printf(" %s%s", DIR(), PCCTSAST_O);
+/* printf(" %s%s", DIR(), LIST_O); */
+ printf(" \\\n ");
+ }
+ printf(" %s%s", DIR(), ATOKENBUFFER_O);
+ }
+ if ( !user_lexer ) {
+ if ( gen_CPP ) printf(" $(SCAN)%s", OBJ_FILE_SUFFIX);
+ else printf(" %s$(SCAN)%s", DIR(), OBJ_FILE_SUFFIX);
+ }
+ if ( !gen_CPP ) printf(" $(ERR)%s", OBJ_FILE_SUFFIX);
+ printf("\\\n $(MYFILES:.cpp=.o)\n");
+
+ printf("ANTLR_SPAWN = ");
+ if ( gen_CPP ) pfiles(files, n, CPP_FILE_SUFFIX_NO_DOT);
+ else pfiles(files, n, "c");
+ if ( gen_CPP ) {
+ printf(" ");
+ pclasses(classes, num_classes, CPP_FILE_SUFFIX_NO_DOT);
+ printf(" \\\n ");
+ pclasses(classes, num_classes, "h");
+ if ( strcmp(hdr,"stdpccts.h")!=0 ) {
+ printf(" \\\n ");
+ printf("$(HDR_FILE) stdpccts.h");
+ }
+ }
+ if ( user_lexer ) {
+ if ( !user_token_types ) printf(" $(TOKENS)");
+ }
+ else {
+ printf(" $(DLG_FILE)");
+ if ( !user_token_types ) printf(" $(TOKENS)");
+ }
+ if ( !gen_CPP ) printf(" $(ERR).c");
+ printf("\n");
+
+ if ( !user_lexer ) {
+ if ( gen_CPP ) printf("DLG_SPAWN = $(SCAN)%s", CPP_FILE_SUFFIX);
+ else printf("DLG_SPAWN = %s$(SCAN).c", DIR());
+ if ( gen_CPP ) printf(" $(SCAN).h");
+ if ( !gen_CPP ) printf(" $(MOD_FILE)");
+ printf("\n");
+ }
+
+ if ( gen_CPP ) {
+ printf("CCC = %s\n",compilerCCC);
+ }
+ else printf("CC = %s\n",compilerCC);
+
+ /* set up dependencies */
+ printf("\n%s : $(OBJ) $(SRC)\n", project);
+ printf(" %s %s %s $(CFLAGS) $(OBJ)\n",
+ gen_CPP?"$(CCC)":"$(CC)",
+ RENAME_EXE_FLAG,
+ project);
+ printf("\n");
+
+ /* implicit rules */
+
+ if(gen_CPP)
+ printf("%%.o : %%.cpp\n\t$(CCC) -c $(CFLAGS) $<\n\n");
+
+ printf("%%.o : %%.c\n\t%s -c $(CFLAGS) $<\n\n",
+ gen_CPP?"$(CCC)":"$(CC)");
+
+ /* how to compile parser files */
+
+ for (i=0; i<num_files; i++)
+ {
+ pfiles(&files[i], 1, "o");
+ if ( user_lexer ) {
+ printf(" : $(TOKENS)");
+ }
+ else {
+ if ( gen_CPP ) printf(" : $(TOKENS) $(SCAN).h");
+ else printf(" : $(MOD_FILE) $(TOKENS)");
+ }
+ printf(" ");
+ if ( gen_CPP ) pfiles(&files[i], 1, CPP_FILE_SUFFIX_NO_DOT);
+ else pfiles(&files[i], 1, "c");
+ if ( gen_CPP && strcmp(hdr,"stdpccts.h")!=0 ) printf(" $(HDR_FILE)");
+ printf("\n");
+ printf(" %s -c $(CFLAGS) %s ",
+ gen_CPP?"$(CCC)":"$(CC)",RENAME_OBJ_FLAG);
+ pfiles(&files[i], 1, "o");
+ printf(" ");
+ if ( gen_CPP ) pfiles(&files[i], 1, CPP_FILE_SUFFIX_NO_DOT);
+ else pfiles(&files[i], 1, "c");
+ printf("\n\n");
+ }
+
+ /* how to compile err.c */
+ if ( !gen_CPP ) {
+ printf("$(ERR)%s : $(ERR).c", OBJ_FILE_SUFFIX);
+ if ( !user_lexer ) printf(" $(TOKENS)");
+ printf("\n");
+ printf(" %s -c $(CFLAGS) %s $(ERR)%s $(ERR).c",
+ gen_CPP?"$(CCC)":"$(CC)",
+ RENAME_OBJ_FLAG,
+ OBJ_FILE_SUFFIX);
+ printf("\n\n");
+ }
+
+ /* how to compile Class.c */
+ for (i=0; i<num_classes; i++)
+ {
+ pclasses(&classes[i], 1, "o");
+ if ( user_lexer ) {
+ printf(" : $(TOKENS)");
+ }
+ else {
+ printf(" : $(TOKENS) $(SCAN).h");
+ }
+ printf(" ");
+ pclasses(&classes[i], 1, CPP_FILE_SUFFIX_NO_DOT);
+ printf(" ");
+ pclasses(&classes[i], 1, "h");
+ if ( gen_CPP && strcmp(hdr,"stdpccts.h")!=0 ) printf(" $(HDR_FILE)");
+ printf("\n");
+ printf(" %s -c $(CFLAGS) %s ",
+ gen_CPP?"$(CCC)":"$(CC)",
+ RENAME_OBJ_FLAG);
+ pclasses(&classes[i], 1, "o");
+ printf(" ");
+ pclasses(&classes[i], 1, CPP_FILE_SUFFIX_NO_DOT);
+ printf("\n\n");
+ }
+
+ /* how to compile scan.c */
+ if ( !user_lexer ) {
+ if ( gen_CPP ) printf("$(SCAN)%s : $(SCAN)%s", OBJ_FILE_SUFFIX, CPP_FILE_SUFFIX);
+ else printf("%s$(SCAN)%s : %s$(SCAN).c", DIR(), OBJ_FILE_SUFFIX, DIR());
+ if ( !user_lexer ) printf(" $(TOKENS)");
+ printf("\n");
+ if ( gen_CPP ) printf(" $(CCC) -c $(CFLAGS) %s $(SCAN)%s $(SCAN)%s",
+ RENAME_OBJ_FLAG,
+ OBJ_FILE_SUFFIX,
+ CPP_FILE_SUFFIX);
+ else printf(" $(CC) -c $(CFLAGS) %s %s$(SCAN)%s %s$(SCAN).c",
+ RENAME_OBJ_FLAG,
+ DIR(),
+ OBJ_FILE_SUFFIX,
+ DIR());
+ printf("\n\n");
+ }
+
+ printf("$(ANTLR_SPAWN) : $(GRM)\n");
+ printf(" $(ANTLR) $(AFLAGS) $(GRM)\n");
+
+ if ( !user_lexer )
+ {
+ printf("\n");
+ printf("$(DLG_SPAWN) : $(DLG_FILE)\n");
+ if ( gen_CPP ) printf(" $(DLG) $(DFLAGS) $(DLG_FILE)\n");
+ else printf(" $(DLG) $(DFLAGS) $(DLG_FILE) $(SCAN).c\n");
+ }
+
+ /* do the makes for ANTLR/DLG support */
+ if ( gen_CPP ) {
+ printf("\n");
+ printf("%s%s : $(ANTLR_H)%s%s\n", DIR(), APARSER_O, DirectorySymbol, APARSER_C);
+ printf(" %s -c $(CFLAGS) %s ",
+ gen_CPP?"$(CCC)":"$(CC)",
+ RENAME_OBJ_FLAG);
+ printf("%s%s $(ANTLR_H)%s%s\n", DIR(), APARSER_O, DirectorySymbol, APARSER_C);
+ printf("\n");
+ printf("%s%s : $(ANTLR_H)%s%s\n", DIR(), ATOKENBUFFER_O, DirectorySymbol, ATOKENBUFFER_C);
+ printf(" %s -c $(CFLAGS) %s ",
+ gen_CPP?"$(CCC)":"$(CC)",
+ RENAME_OBJ_FLAG);
+ printf("%s%s $(ANTLR_H)%s%s\n", DIR(), ATOKENBUFFER_O, DirectorySymbol, ATOKENBUFFER_C);
+ if ( !user_lexer ) {
+ printf("\n");
+ printf("%s%s : $(ANTLR_H)%s%s\n", DIR(), DLEXERBASE_O, DirectorySymbol, DLEXERBASE_C);
+ printf(" %s -c $(CFLAGS) %s ",
+ gen_CPP?"$(CCC)":"$(CC)",
+ RENAME_OBJ_FLAG);
+ printf("%s%s $(ANTLR_H)%s%s\n", DIR(), DLEXERBASE_O, DirectorySymbol, DLEXERBASE_C);
+ }
+ if ( gen_trees ) {
+ printf("\n");
+ printf("%s%s : $(ANTLR_H)%s%s\n", DIR(), ASTBASE_O, DirectorySymbol, ASTBASE_C);
+ printf(" %s -c $(CFLAGS) %s ",
+ gen_CPP?"$(CCC)":"$(CC)",
+ RENAME_OBJ_FLAG);
+ printf("%s%s $(ANTLR_H)%s%s\n", DIR(), ASTBASE_O, DirectorySymbol, ASTBASE_C);
+ printf("\n");
+ printf("%s%s : $(ANTLR_H)%s%s\n", DIR(), PCCTSAST_O, DirectorySymbol, PCCTSAST_C);
+ printf(" %s -c $(CFLAGS) %s ",
+ gen_CPP?"$(CCC)":"$(CC)",
+ RENAME_OBJ_FLAG);
+ printf("%s%s $(ANTLR_H)%s%s\n", DIR(), PCCTSAST_O, DirectorySymbol, PCCTSAST_C);
+ printf("\n");
+/*
+ printf("%s%s : $(ANTLR_H)%s%s\n", DIR(), LIST_O, DirectorySymbol, LIST_C);
+ printf(" %s -c $(CFLAGS) %s ",
+ gen_CPP?"$(CCC)":"$(CC)",RENAME_OBJ_FLAG);
+ printf("%s%s $(ANTLR_H)%s%s\n", DIR(), LIST_O, DirectorySymbol, LIST_C);
+*/
+ }
+ }
+
+ /* clean and scrub targets */
+
+ printf("\nclean:\n");
+ printf(" rm -f *%s core %s", OBJ_FILE_SUFFIX, project);
+ if ( strcmp(outdir, ".")!=0 ) printf(" %s*%s", DIR(), OBJ_FILE_SUFFIX);
+ printf("\n");
+
+ printf("\nscrub:\n");
+ printf(" rm -f *%s core %s", OBJ_FILE_SUFFIX, project);
+ if ( strcmp(outdir, ".")!=0 ) printf(" %s*%s", DIR(), OBJ_FILE_SUFFIX);
+ printf(" $(ANTLR_SPAWN)");
+ if ( !user_lexer ) printf(" $(DLG_SPAWN)");
+ printf("\n");
+}
+
+void pfiles(files, n, suffix)
+char **files;
+int n;
+char *suffix;
+{
+ int first=1;
+
+ while ( n>0 )
+ {
+ char *p = &(*files)[strlen(*files)-1];
+ if ( !first ) putchar(' ');
+ first=0;
+ while ( p > *files && *p != '.' ) --p;
+ if ( p == *files )
+ {
+ fprintf(stderr,
+ "genmk: filenames must be file.suffix format: %s\n",
+ *files);
+ exit(-1);
+ }
+ if ( suffix == NULL ) printf("%s", *files);
+ else
+ {
+ *p = '\0';
+ printf("%s", DIR());
+ if ( strcmp(suffix, "o")==0 ) printf("%s%s", *files, OBJ_FILE_SUFFIX);
+ else printf("%s.%s", *files, suffix);
+ *p = '.';
+ }
+ files++;
+ --n;
+ }
+}
+
+void pclasses(classes, n, suffix)
+char **classes;
+int n;
+char *suffix;
+{
+ int first=1;
+
+ while ( n>0 )
+ {
+ if ( !first ) putchar(' ');
+ first=0;
+ if ( suffix == NULL ) printf("%s", *classes);
+ else {
+ printf("%s", DIR());
+ if ( strcmp(suffix, "o")==0 ) printf("%s%s", *classes, OBJ_FILE_SUFFIX);
+ else printf("%s.%s", *classes, suffix);
+ }
+ classes++;
+ --n;
+ }
+}
+
+static void
+#ifdef __STDC__
+ProcessArgs( int argc, char **argv, Opt *options )
+#else
+ProcessArgs( argc, argv, options )
+int argc;
+char **argv;
+Opt *options;
+#endif
+{
+ Opt *p;
+ require(argv!=NULL, "ProcessArgs: command line NULL");
+
+ while ( argc-- > 0 )
+ {
+ p = options;
+ while ( p->option != NULL )
+ {
+ if ( strcmp(p->option, "*") == 0 ||
+ strcmp(p->option, *argv) == 0 )
+ {
+ if ( p->arg )
+ {
+ (*p->process)( *argv, *(argv+1) );
+ argv++;
+ argc--;
+ }
+ else
+ (*p->process)( *argv );
+ break;
+ }
+ p++;
+ }
+ argv++;
+ }
+}
+
+void fatal( err_)
+char *err_;
+{
+ fprintf(stderr, "genmk: %s\n", err_);
+ exit(1);
+}
+
+void warn( err_)
+char *err_;
+{
+ fprintf(stderr, "genmk: %s\n", err_);
+}
+
+char *DIR()
+{
+ static char buf[200+1];
+
+ if ( strcmp(outdir,TopDirectory)==0 ) return "";
+ sprintf(buf, "%s%s", outdir, DirectorySymbol);
+ return buf;
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/makefile b/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/makefile new file mode 100644 index 0000000000..a003c2f321 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/makefile @@ -0,0 +1,29 @@ +##
+## 7-Apr-97
+## added support/genmk/makefile to pccts 1.33MR1 distribution kit
+## (support/genmk/makefile" omitted from 1.33 distribution kit)
+##
+SRC=genmk.c
+OBJ=genmk.o
+# Define PC if you use a PC OS (changes directory symbol and object file extension)
+# see pccts/h/pcctscfg.h
+CC=cc
+COPT=-O
+#CFLAGS=-I../../h -DPC
+CFLAGS=$(COPT) -I../../h
+BAG=../../bin/bag
+
+genmk: $(OBJ) $(SRC) ../../h/pcctscfg.h
+ $(CC) -o genmk $(OBJ)
+
+clean:
+ rm -rf core *.o
+
+scrub:
+ rm -rf genmk core *.o
+
+shar:
+ shar genmk.c makefile > genmk.shar
+
+archive:
+ $(BAG) genmk.c makefile > genmk.bag
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/makefile b/BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/makefile new file mode 100644 index 0000000000..44caef1aa5 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/makefile @@ -0,0 +1,19 @@ +BAG=../../bin/bag
+SRC=test.c rexpr.c
+OBJ=test.o rexpr.o
+CFLAGS = -g
+
+test: $(OBJ) $(SRC)
+ cc -g -o texpr $(OBJ)
+
+shar:
+ shar makefile test.c rexpr.c rexpr.h > rexpr.shar
+
+archive:
+ $(BAG) makefile test.c rexpr.c rexpr.h > rexpr.bag
+
+clean:
+ rm -rf *.o core texpr
+
+scrub:
+ rm -rf *.o core texpr
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/rexpr.c b/BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/rexpr.c new file mode 100644 index 0000000000..805bf65533 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/rexpr.c @@ -0,0 +1,586 @@ +/*
+ * This file contains code for
+ *
+ * int rexpr(char *expr, char *s);
+ *
+ * which answers
+ *
+ * 1 if 's' is in the language described by the regular expression 'expr'
+ * 0 if it is not
+ * -1 if the regular expression is invalid
+ *
+ * Language membership is determined by constructing a non-deterministic
+ * finite automata (NFA) from the regular expression. A depth-
+ * first-search is performed on the NFA (graph) to check for a match of 's'.
+ * Each non-epsilon arc consumes one character from 's'. Backtracking is
+ * performed to check all possible paths through the NFA.
+ *
+ * Regular expressions follow the meta-language:
+ *
+ * <regExpr> ::= <andExpr> ( '|' <andExpr> )*
+ *
+ * <andExpr> ::= <expr> ( <expr> )*
+ *
+ * <expr> ::= {'~'} '[' <atomList> ']' <repeatSymbol>
+ * | '(' <regExpr> ')' <repeatSymbol>
+ * | '{' <regExpr> '}' <repeatSymbol>
+ * | <atom> <repeatSymbol>
+ *
+ * <repeatSymbol> ::= { '*' | '+' }
+ *
+ * <atomList> ::= <atom> ( <atom> )*
+ * | { <atomList> } <atom> '-' <atom> { <atomList> }
+ *
+ * <atom> ::= Token[Atom]
+ *
+ * Notes:
+ * ~ means complement the set in [..]. i.e. all characters not listed
+ * * means match 0 or more times (can be on expression or atom)
+ * + means match 1 or more times (can be on expression or atom)
+ * {} optional
+ * () grouping
+ * [] set of atoms
+ * x-y all characters from x to y (found only in [..])
+ * \xx the character with value xx
+ *
+ * Examples:
+ * [a-z]+
+ * match 1 or more lower-case letters (e.g. variable)
+ *
+ * 0x[0-9A-Fa-f]+
+ * match a hex number with 0x on front (e.g. 0xA1FF)
+ *
+ * [0-9]+.[0-9]+{e[0-9]+}
+ * match a floating point number (e.g. 3.14e21)
+ *
+ * Code example:
+ * if ( rexpr("[a-zA-Z][a-zA-Z0-9]+", str) ) then str is keyword
+ *
+ * Terence Parr
+ * Purdue University
+ * April 1991
+ */
+
+#include <stdio.h>
+#include <ctype.h>
+#ifdef __STDC__
+#include <stdlib.h>
+#else
+#include <malloc.h>
+#endif
+#include "rexpr.h"
+
+#ifdef __USE_PROTOS
+static int regExpr( GraphPtr g );
+static int andExpr( GraphPtr g );
+static int expr( GraphPtr g );
+static int repeatSymbol( GraphPtr g );
+static int atomList( char *p, int complement );
+static void next( void );
+static ArcPtr newGraphArc( void );
+static NodePtr newNode( void );
+static int ArcBetweenGraphNode( NodePtr i, NodePtr j, int label );
+static Graph BuildNFA_atom( int label );
+static Graph BuildNFA_AB( Graph A, Graph B );
+static Graph BuildNFA_AorB( Graph A, Graph B );
+static Graph BuildNFA_set( char *s );
+static Graph BuildNFA_Astar( Graph A );
+static Graph BuildNFA_Aplus( Graph A );
+static Graph BuildNFA_Aoptional( Graph A );
+#else
+static int regExpr();
+static int andExpr();
+static int expr();
+static int repeatSymbol();
+static int atomList();
+static void next();
+static ArcPtr newGraphArc();
+static NodePtr newNode();
+static int ArcBetweenGraphNode();
+static Graph BuildNFA_atom();
+static Graph BuildNFA_AB();
+static Graph BuildNFA_AorB();
+static Graph BuildNFA_set();
+static Graph BuildNFA_Astar();
+static Graph BuildNFA_Aplus();
+static Graph BuildNFA_Aoptional();
+#endif
+
+static char *_c;
+static int token, tokchar;
+static NodePtr accept;
+static NodePtr freelist = NULL;
+
+/*
+ * return 1 if s in language described by expr
+ * 0 if s is not
+ * -1 if expr is an invalid regular expression
+ */
+#ifdef __USE_PROTOS
+static int rexpr(char *expr,char *s)
+#else
+static int rexpr(expr, s)
+char *expr, *s;
+#endif
+{
+ NodePtr p,q;
+ Graph nfa;
+ int result;
+
+ fprintf(stderr, "rexpr(%s,%s);\n", expr,s);
+ freelist = NULL;
+ _c = expr;
+ next();
+ if ( regExpr(&nfa) == -1 ) return -1;
+ accept = nfa.right;
+ result = match(nfa.left, s);
+ /* free all your memory */
+ p = q = freelist;
+ while ( p!=NULL ) { q = p->track; free(p); p = q; }
+ return result;
+}
+
+/*
+ * do a depth-first-search on the NFA looking for a path from start to
+ * accept state labelled with the characters of 's'.
+ */
+
+#ifdef __USE_PROTOS
+static int match(NodePtr automaton,char *s)
+#else
+static int match(automaton, s)
+NodePtr automaton;
+char *s;
+#endif
+{
+ ArcPtr p;
+
+ if ( automaton == accept && *s == '\0' ) return 1; /* match */
+
+ for (p=automaton->arcs; p!=NULL; p=p->next) /* try all arcs */
+ {
+ if ( p->label == Epsilon )
+ {
+ if ( match(p->target, s) ) return 1;
+ }
+ else if ( p->label == *s )
+ if ( match(p->target, s+1) ) return 1;
+ }
+ return 0;
+}
+
+/*
+ * <regExpr> ::= <andExpr> ( '|' {<andExpr>} )*
+ *
+ * Return -1 if syntax error
+ * Return 0 if none found
+ * Return 1 if a regExrp was found
+ */
+
+#ifdef __USE_PROTOS
+static int regExpr(GraphPtr g)
+#else
+static int regExpr(g)
+GraphPtr g;
+#endif
+{
+ Graph g1, g2;
+
+ if ( andExpr(&g1) == -1 )
+ {
+ return -1;
+ }
+
+ while ( token == '|' )
+ {
+ int a;
+ next();
+ a = andExpr(&g2);
+ if ( a == -1 ) return -1; /* syntax error below */
+ else if ( !a ) return 1; /* empty alternative */
+ g1 = BuildNFA_AorB(g1, g2);
+ }
+
+ if ( token!='\0' ) return -1;
+
+ *g = g1;
+ return 1;
+}
+
+/*
+ * <andExpr> ::= <expr> ( <expr> )*
+ */
+
+#ifdef __USE_PROTOS
+static int andExpr(GraphPtr g)
+#else
+static int andExpr(g)
+GraphPtr g;
+#endif
+{
+ Graph g1, g2;
+
+ if ( expr(&g1) == -1 )
+ {
+ return -1;
+ }
+
+ while ( token==Atom || token=='{' || token=='(' || token=='~' || token=='[' )
+ {
+ if (expr(&g2) == -1) return -1;
+ g1 = BuildNFA_AB(g1, g2);
+ }
+
+ *g = g1;
+ return 1;
+}
+
+/*
+ * <expr> ::= {'~'} '[' <atomList> ']' <repeatSymbol>
+ * | '(' <regExpr> ')' <repeatSymbol>
+ * | '{' <regExpr> '}' <repeatSymbol>
+ * | <atom> <repeatSymbol>
+ */
+
+#ifdef __USE_PROTOS
+static int expr(GraphPtr g)
+#else
+static int expr(g)
+GraphPtr g;
+#endif
+{
+ int complement = 0;
+ char s[257]; /* alloc space for string of char in [] */
+
+ if ( token == '~' || token == '[' )
+ {
+ if ( token == '~' ) {complement = 1; next();}
+ if ( token != '[' ) return -1;
+ next();
+ if ( atomList( s, complement ) == -1 ) return -1;
+ *g = BuildNFA_set( s );
+ if ( token != ']' ) return -1;
+ next();
+ repeatSymbol( g );
+ return 1;
+ }
+ if ( token == '(' )
+ {
+ next();
+ if ( regExpr( g ) == -1 ) return -1;
+ if ( token != ')' ) return -1;
+ next();
+ repeatSymbol( g );
+ return 1;
+ }
+ if ( token == '{' )
+ {
+ next();
+ if ( regExpr( g ) == -1 ) return -1;
+ if ( token != '}' ) return -1;
+ next();
+ /* S p e c i a l C a s e O p t i o n a l { } */
+ if ( token != '*' && token != '+' )
+ {
+ *g = BuildNFA_Aoptional( *g );
+ }
+ repeatSymbol( g );
+ return 1;
+ }
+ if ( token == Atom )
+ {
+ *g = BuildNFA_atom( tokchar );
+ next();
+ repeatSymbol( g );
+ return 1;
+ }
+
+ return -1;
+}
+
+/*
+ * <repeatSymbol> ::= { '*' | '+' }
+ */
+#ifdef __USE_PROTOS
+static int repeatSymbol(GraphPtr g)
+#else
+static int repeatSymbol(g)
+GraphPtr g;
+#endif
+{
+ switch ( token )
+ {
+ case '*' : *g = BuildNFA_Astar( *g ); next(); break;
+ case '+' : *g = BuildNFA_Aplus( *g ); next(); break;
+ }
+ return 1;
+}
+
+/*
+ * <atomList> ::= <atom> { <atom> }*
+ * { <atomList> } <atom> '-' <atom> { <atomList> }
+ *
+ * a-b is same as ab
+ * q-a is same as q
+ */
+
+#ifdef __USE_PROTOS
+static int atomList(char *p, int complement)
+#else
+static int atomList(p, complement)
+char *p;
+int complement;
+#endif
+{
+ static unsigned char set[256]; /* no duplicates */
+ int first, last, i;
+ char *s = p;
+
+ if ( token != Atom ) return -1;
+
+ for (i=0; i<256; i++) set[i] = 0;
+ while ( token == Atom )
+ {
+ if ( !set[tokchar] ) *s++ = tokchar;
+ set[tokchar] = 1; /* Add atom to set */
+ next();
+ if ( token == '-' ) /* have we found '-' */
+ {
+ first = *(s-1); /* Get last char */
+ next();
+ if ( token != Atom ) return -1;
+ else
+ {
+ last = tokchar;
+ }
+ for (i = first+1; i <= last; i++)
+ {
+ if ( !set[tokchar] ) *s++ = i;
+ set[i] = 1; /* Add atom to set */
+ }
+ next();
+ }
+ }
+ *s = '\0';
+ if ( complement )
+ {
+ for (i=0; i<256; i++) set[i] = !set[i];
+ for (i=1,s=p; i<256; i++) if ( set[i] ) *s++ = i;
+ *s = '\0';
+ }
+ return 1;
+}
+
+/* a somewhat stupid lexical analyzer */
+
+#ifdef __USE_PROTOS
+static void next(void)
+#else
+static void next()
+#endif
+{
+ while ( *_c==' ' || *_c=='\t' || *_c=='\n' ) _c++;
+ if ( *_c=='\\' )
+ {
+ _c++;
+ if ( isdigit(*_c) )
+ {
+ int n=0;
+ while ( isdigit(*_c) )
+ {
+ n = n*10 + (*_c++ - '0');
+ }
+ if ( n>255 ) n=255;
+ tokchar = n;
+ }
+ else
+ {
+ switch (*_c)
+ {
+ case 'n' : tokchar = '\n'; break;
+ case 't' : tokchar = '\t'; break;
+ case 'r' : tokchar = '\r'; break;
+ default : tokchar = *_c;
+ }
+ _c++;
+ }
+ token = Atom;
+ }
+ else if ( isgraph(*_c) && *_c!='[' && *_c!='(' && *_c!='{' &&
+ *_c!='-' && *_c!='}' && *_c!=')' && *_c!=']' &&
+ *_c!='+' && *_c!='*' && *_c!='~' && *_c!='|' )
+ {
+ token = Atom;
+ tokchar = *_c++;
+ }
+ else
+ {
+ token = tokchar = *_c++;
+ }
+}
+
+/* N F A B u i l d i n g R o u t i n e s */
+
+#ifdef __USE_PROTOS
+static ArcPtr newGraphArc(void)
+#else
+static ArcPtr newGraphArc()
+#endif
+{
+ ArcPtr p;
+ p = (ArcPtr) calloc(1, sizeof(Arc));
+ if ( p==NULL ) {fprintf(stderr,"rexpr: out of memory\n"); exit(-1);}
+ if ( freelist != NULL ) p->track = (ArcPtr) freelist;
+ freelist = (NodePtr) p;
+ return p;
+}
+
+#ifdef __USE_PROTOS
+static NodePtr newNode(void)
+#else
+static NodePtr newNode()
+#endif
+{
+ NodePtr p;
+ p = (NodePtr) calloc(1, sizeof(Node));
+ if ( p==NULL ) {fprintf(stderr,"rexpr: out of memory\n"); exit(-1);}
+ if ( freelist != NULL ) p->track = freelist;
+ freelist = p;
+ return p;
+}
+
+#ifdef __USE_PROTOS
+static void ArcBetweenGraphNodes(NodePtr i,NodePtr j,int label)
+#else
+static void ArcBetweenGraphNodes(i, j, label)
+NodePtr i, j;
+int label;
+#endif
+{
+ ArcPtr a;
+
+ a = newGraphArc();
+ if ( i->arcs == NULL ) i->arctail = i->arcs = a;
+ else {(i->arctail)->next = a; i->arctail = a;}
+ a->label = label;
+ a->target = j;
+}
+
+#ifdef __USE_PROTOS
+static Graph BuildNFA_atom(int label)
+#else
+static Graph BuildNFA_atom(label)
+int label;
+#endif
+{
+ Graph g;
+
+ g.left = newNode();
+ g.right = newNode();
+ ArcBetweenGraphNodes(g.left, g.right, label);
+ return( g );
+}
+
+#ifdef __USE_PROTOS
+static Graph BuildNFA_AB(Graph A,Graph B)
+#else
+static Graph BuildNFA_AB(A, B)
+Graph A, B;
+#endif
+{
+ Graph g;
+
+ ArcBetweenGraphNodes(A.right, B.left, Epsilon);
+ g.left = A.left;
+ g.right = B.right;
+ return( g );
+}
+
+#ifdef __USE_PROTOS
+static Graph BuildNFA_AorB(Graph A,Graph B)
+#else
+static Graph BuildNFA_AorB(A, B)
+Graph A, B;
+#endif
+{
+ Graph g;
+
+ g.left = newNode();
+ ArcBetweenGraphNodes(g.left, A.left, Epsilon);
+ ArcBetweenGraphNodes(g.left, B.left, Epsilon);
+ g.right = newNode();
+ ArcBetweenGraphNodes(A.right, g.right, Epsilon);
+ ArcBetweenGraphNodes(B.right, g.right, Epsilon);
+ return( g );
+}
+
+#ifdef __USE_PROTOS
+static Graph BuildNFA_set(char *s)
+#else
+static Graph BuildNFA_set( s )
+char *s;
+#endif
+{
+ Graph g;
+
+ if ( s == NULL ) return g;
+
+ g.left = newNode();
+ g.right = newNode();
+ while ( *s != '\0' )
+ {
+ ArcBetweenGraphNodes(g.left, g.right, *s++);
+ }
+ return g;
+}
+
+#ifdef __USE_PROTOS
+static Graph BuildNFA_Astar(Graph A)
+#else
+static Graph BuildNFA_Astar( A )
+Graph A;
+#endif
+{
+ Graph g;
+
+ g.left = newNode();
+ g.right = newNode();
+
+ ArcBetweenGraphNodes(g.left, A.left, Epsilon);
+ ArcBetweenGraphNodes(g.left, g.right, Epsilon);
+ ArcBetweenGraphNodes(A.right, g.right, Epsilon);
+ ArcBetweenGraphNodes(A.right, A.left, Epsilon);
+
+ return( g );
+}
+
+#ifdef __USE_PROTOS
+static Graph BuildNFA_Aplus(Graph A)
+#else
+static Graph BuildNFA_Aplus( A )
+Graph A;
+#endif
+{
+ ArcBetweenGraphNodes(A.right, A.left, Epsilon);
+
+ return( A );
+}
+
+#ifdef __USE_PROTOS
+static Graph BuildNFA_Aoptional(Graph A)
+#else
+static Graph BuildNFA_Aoptional( A )
+Graph A;
+#endif
+{
+ Graph g;
+
+ g.left = newNode();
+ g.right = newNode();
+
+ ArcBetweenGraphNodes(g.left, A.left, Epsilon);
+ ArcBetweenGraphNodes(g.left, g.right, Epsilon);
+ ArcBetweenGraphNodes(A.right, g.right, Epsilon);
+
+ return( g );
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/rexpr.h b/BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/rexpr.h new file mode 100644 index 0000000000..e67a9652fb --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/rexpr.h @@ -0,0 +1,30 @@ +#define Atom 256 /* token Atom (an impossible char value) */
+#define Epsilon 257 /* epsilon arc (an impossible char value) */
+
+/* track field must be same for all node types */
+typedef struct _a {
+ struct _a *track; /* track mem allocation */
+ int label;
+ struct _a *next;
+ struct _n *target;
+ } Arc, *ArcPtr;
+
+typedef struct _n {
+ struct _n *track;
+ ArcPtr arcs, arctail;
+ } Node, *NodePtr;
+
+typedef struct {
+ NodePtr left,
+ right;
+ } Graph, *GraphPtr;
+
+#ifdef __USE_PROTOS
+int rexpr( char *expr, char *s );
+int match( NodePtr automaton, char *s );
+#else
+int rexpr();
+int match();
+#endif
+
+
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/test.c b/BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/test.c new file mode 100644 index 0000000000..2619539e4b --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/test.c @@ -0,0 +1,19 @@ +#include <stdio.h>
+#include "rexpr.h"
+
+/*
+ * test for rexpr().
+ * To make this test:
+ * cc -o rexpr test.c rexpr.c
+ * Then from command line type:
+ * rexpr r string
+ * where r is the regular expression that decribes a language
+ * and string is the string to verify.
+ */
+main(argc,argv)
+int argc;
+char *argv[];
+{
+ if ( argc!=3 ) fprintf(stderr,"rexpr: expr s\n");
+ else printf("%d\n", rexpr(argv[1], argv[2]));
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/support/set/set.c b/BaseTools/Source/C/VfrCompile/Pccts/support/set/set.c new file mode 100644 index 0000000000..eb6fba7393 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/support/set/set.c @@ -0,0 +1,816 @@ +/* set.c
+
+ The following is a general-purpose set library originally developed
+ by Hank Dietz and enhanced by Terence Parr to allow dynamic sets.
+
+ Sets are now structs containing the #words in the set and
+ a pointer to the actual set words.
+
+ Generally, sets need not be explicitly allocated. They are
+ created/extended/shrunk when appropriate (e.g. in set_of()).
+ HOWEVER, sets need to be destroyed (free()ed) when they go out of scope
+ or are otherwise no longer needed. A routine is provided to
+ free a set.
+
+ Sets can be explicitly created with set_new(s, max_elem).
+
+ Sets can be declared to have minimum size to reduce realloc traffic.
+ Default minimum size = 1.
+
+ Sets can be explicitly initialized to have no elements (set.n == 0)
+ by using the 'empty' initializer:
+
+ Examples:
+ set a = empty; -- set_deg(a) == 0
+
+ return( empty );
+
+ Example set creation and destruction:
+
+ set
+ set_of2(e,g)
+ unsigned e,g;
+ {
+ set a,b,c;
+
+ b = set_of(e); -- Creates space for b and sticks in e
+ set_new(c, g); -- set_new(); set_orel() ==> set_of()
+ set_orel(g, &c);
+ a = set_or(b, c);
+ .
+ .
+ .
+ set_free(b);
+ set_free(c);
+ return( a );
+ }
+
+ 1987 by Hank Dietz
+
+ Modified by:
+ Terence Parr
+ Purdue University
+ October 1989
+
+ Made it smell less bad to C++ 7/31/93 -- TJP
+*/
+
+#include <stdio.h>
+#include "pcctscfg.h"
+#ifdef __STDC__
+#include <stdlib.h>
+#else
+#include <malloc.h>
+#endif
+#include <string.h>
+
+#include "set.h"
+
+#define MIN(i,j) ( (i) > (j) ? (j) : (i))
+#define MAX(i,j) ( (i) < (j) ? (j) : (i))
+
+/* elems can be a maximum of 32 bits */
+static unsigned bitmask[] = {
+ 0x00000001, 0x00000002, 0x00000004, 0x00000008,
+ 0x00000010, 0x00000020, 0x00000040, 0x00000080,
+ 0x00000100, 0x00000200, 0x00000400, 0x00000800,
+ 0x00001000, 0x00002000, 0x00004000, 0x00008000,
+#if !defined(PC) || defined(PC32)
+ 0x00010000, 0x00020000, 0x00040000, 0x00080000,
+ 0x00100000, 0x00200000, 0x00400000, 0x00800000,
+ 0x01000000, 0x02000000, 0x04000000, 0x08000000,
+ 0x10000000, 0x20000000, 0x40000000, 0x80000000
+#endif
+};
+
+set empty = set_init;
+static unsigned min=1;
+
+#define StrSize 200
+
+#ifdef MEMCHK
+#define CHK(a) \
+ if ( a.setword != NULL ) \
+ if ( !valid(a.setword) ) \
+ {fprintf(stderr, "%s(%d): invalid set\n",__FILE__,__LINE__); exit(-1);}
+#else
+#define CHK(a)
+#endif
+
+/*
+ * Set the minimum size (in words) of a set to reduce realloc calls
+ */
+void
+#ifdef __USE_PROTOS
+set_size( unsigned n )
+#else
+set_size( n )
+unsigned n;
+#endif
+{
+ min = n;
+}
+
+unsigned int
+#ifdef __USE_PROTOS
+set_deg( set a )
+#else
+set_deg( a )
+set a;
+#endif
+{
+ /* Fast compute degree of a set... the number
+ of elements present in the set. Assumes
+ that all word bits are used in the set
+ and that SETSIZE(a) is a multiple of WORDSIZE.
+ */
+ register unsigned *p = &(a.setword[0]);
+ register unsigned *endp = NULL; /* MR27 Avoid false memory check report */
+ register unsigned degree = 0;
+
+ CHK(a);
+ if ( a.n == 0 ) return(0);
+ endp = &(a.setword[a.n]);
+ while ( p < endp )
+ {
+ register unsigned t = *p;
+ register unsigned *b = &(bitmask[0]);
+ do {
+ if (t & *b) ++degree;
+ } while (++b < &(bitmask[WORDSIZE]));
+ p++;
+ }
+
+ return(degree);
+}
+
+set
+#ifdef __USE_PROTOS
+set_or( set b, set c )
+#else
+set_or( b, c )
+set b;
+set c;
+#endif
+{
+ /* Fast set union operation */
+ /* resultant set size is max(b, c); */
+ set *big;
+ set t;
+ unsigned int m,n;
+ register unsigned *r, *p, *q, *endp;
+
+ CHK(b); CHK(c);
+ t = empty;
+ if (b.n > c.n) {big= &b; m=b.n; n=c.n;} else {big= &c; m=c.n; n=b.n;}
+ set_ext(&t, m);
+ r = t.setword;
+
+ /* Or b,c until max of smaller set */
+ q = c.setword;
+ p = b.setword;
+ endp = &(b.setword[n]);
+ while ( p < endp ) *r++ = *p++ | *q++;
+
+ /* Copy rest of bigger set into result */
+ p = &(big->setword[n]);
+ endp = &(big->setword[m]);
+ while ( p < endp ) *r++ = *p++;
+
+ return(t);
+}
+
+set
+#ifdef __USE_PROTOS
+set_and( set b, set c )
+#else
+set_and( b, c )
+set b;
+set c;
+#endif
+{
+ /* Fast set intersection operation */
+ /* resultant set size is min(b, c); */
+ set t;
+ unsigned int n;
+ register unsigned *r, *p, *q, *endp;
+
+ CHK(b); CHK(c);
+ t = empty;
+ n = (b.n > c.n) ? c.n : b.n;
+ if ( n == 0 ) return t; /* TJP 4-27-92 fixed for empty set */
+ set_ext(&t, n);
+ r = t.setword;
+
+ /* & b,c until max of smaller set */
+ q = c.setword;
+ p = b.setword;
+ endp = &(b.setword[n]);
+ while ( p < endp ) *r++ = *p++ & *q++;
+
+ return(t);
+}
+
+set
+#ifdef __USE_PROTOS
+set_dif( set b, set c )
+#else
+set_dif( b, c )
+set b;
+set c;
+#endif
+{
+ /* Fast set difference operation b - c */
+ /* resultant set size is size(b) */
+ set t;
+ unsigned int n;
+ register unsigned *r, *p, *q, *endp;
+
+ CHK(b); CHK(c);
+ t = empty;
+ n = (b.n <= c.n) ? b.n : c.n ;
+ if ( b.n == 0 ) return t; /* TJP 4-27-92 fixed for empty set */
+ /* WEC 12-1-92 fixed for c.n = 0 */
+ set_ext(&t, b.n);
+ r = t.setword;
+
+ /* Dif b,c until smaller set size */
+ q = c.setword;
+ p = b.setword;
+ endp = &(b.setword[n]);
+ while ( p < endp ) *r++ = *p++ & (~ *q++);
+
+ /* Copy rest of b into result if size(b) > c */
+ if ( b.n > n )
+ {
+ p = &(b.setword[n]);
+ endp = &(b.setword[b.n]);
+ while ( p < endp ) *r++ = *p++;
+ }
+
+ return(t);
+}
+
+set
+#ifdef __USE_PROTOS
+set_of( unsigned b )
+#else
+set_of( b )
+unsigned b;
+#endif
+{
+ /* Fast singleton set constructor operation */
+ static set a;
+
+ if ( b == nil ) return( empty );
+ set_new(a, b);
+ a.setword[DIVWORD(b)] = bitmask[MODWORD(b)];
+
+ return(a);
+}
+
+/*
+ * Extend (or shrink) the set passed in to have n words.
+ *
+ * if n is smaller than the minimum, boost n to have the minimum.
+ * if the new set size is the same as the old one, do nothing.
+ *
+ * TJP 4-27-92 Fixed so won't try to alloc 0 bytes
+ */
+void
+#ifdef __USE_PROTOS
+set_ext( set *a, unsigned int n )
+#else
+set_ext( a, n )
+set *a;
+unsigned int n;
+#endif
+{
+ register unsigned *p;
+ register unsigned *endp;
+ unsigned int size;
+
+ CHK((*a));
+ if ( a->n == 0 )
+ {
+ if ( n == 0 ) return;
+ if (a->setword != NULL) {
+ free (a->setword); /* MR20 */
+ }
+ a->setword = (unsigned *) calloc(n, BytesPerWord);
+ if ( a->setword == NULL )
+ {
+ fprintf(stderr, "set_ext(%d words): cannot allocate set\n", n);
+ exit(-1);
+ }
+ a->n = n;
+ return;
+ }
+ if ( n < min ) n = min;
+ if ( a->n == n || n == 0 ) return;
+ size = a->n;
+ a->n = n;
+ a->setword = (unsigned *) realloc( (char *)a->setword, (n*BytesPerWord) );
+ if ( a->setword == NULL )
+ {
+ fprintf(stderr, "set_ext(%d words): cannot allocate set\n", n);
+ exit(-1);
+ }
+
+ p = &(a->setword[size]); /* clear from old size to new size */
+ endp = &(a->setword[a->n]);
+ do {
+ *p++ = 0;
+ } while ( p < endp );
+}
+
+set
+#ifdef __USE_PROTOS
+set_not( set a )
+#else
+set_not( a )
+set a;
+#endif
+{
+ /* Fast not of set a (assumes all bits used) */
+ /* size of resultant set is size(a) */
+ /* ~empty = empty cause we don't know how bit to make set */
+ set t;
+ register unsigned *r;
+ register unsigned *p = a.setword;
+ register unsigned *endp = &(a.setword[a.n]);
+
+ CHK(a);
+ t = empty;
+ if ( a.n == 0 ) return( empty );
+ set_ext(&t, a.n);
+ r = t.setword;
+
+ do {
+ *r++ = (~ *p++);
+ } while ( p < endp );
+
+ return(t);
+}
+
+int
+#ifdef __USE_PROTOS
+set_equ( set a, set b )
+#else
+set_equ( a, b )
+set a;
+set b;
+#endif
+{
+/* 8-Nov-97 Make it work with sets of different sizes */
+/* Easy to understand, too. Probably faster. */
+/* Check for a equal to b */
+
+ unsigned int count; /* MR11 */
+ unsigned int i; /* MR11 */
+
+ CHK(a); CHK(b);
+
+ count=MIN(a.n,b.n);
+ if (count == 0) return 1;
+ for (i=0; i < count; i++) {
+ if (a.setword[i] != b.setword[i]) return 0;
+ };
+ if (a.n < b.n) {
+ for (i=count; i < b.n; i++) {
+ if (b.setword[i] != 0) return 0;
+ }
+ return 1;
+ } else if (a.n > b.n) {
+ for (i=count; i < a.n; i++) {
+ if (a.setword[i] != 0) return 0;
+ }
+ return 1;
+ } else {
+ return 1;
+ };
+}
+
+int
+#ifdef __USE_PROTOS
+set_sub( set a, set b )
+#else
+set_sub( a, b )
+set a;
+set b;
+#endif
+{
+
+/* 8-Nov-97 Make it work with sets of different sizes */
+/* Easy to understand, too. Probably faster. */
+/* Check for a is a PROPER subset of b */
+
+ unsigned int count;
+ unsigned int i;
+
+ CHK(a); CHK(b);
+
+ if (a.n == 0) return 1;
+ count=MIN(a.n,b.n);
+ for (i=0; i < count; i++) {
+ if (a.setword[i] & ~b.setword[i]) return 0;
+ };
+ if (a.n <= b.n) {
+ return 1;
+ } else {
+ for (i=count; i<a.n ; i++) {
+ if (a.setword[i]) return 0;
+ };
+ };
+ return 1;
+}
+
+unsigned
+#ifdef __USE_PROTOS
+set_int( set b )
+#else
+set_int( b )
+set b;
+#endif
+{
+ /* Fast pick any element of the set b */
+ register unsigned *p = b.setword;
+ register unsigned *endp = &(b.setword[b.n]);
+
+ CHK(b);
+ if ( b.n == 0 ) return( nil );
+
+ do {
+ if (*p) {
+ /* Found a non-empty word of the set */
+ register unsigned i = ((p - b.setword) << LogWordSize);
+ register unsigned t = *p;
+ p = &(bitmask[0]);
+ while (!(*p & t)) {
+ ++i; ++p;
+ }
+ return(i);
+ }
+ } while (++p < endp);
+
+ /* Empty -- only element it contains is nil */
+ return(nil);
+}
+
+int
+#ifdef __USE_PROTOS
+set_el( unsigned b, set a )
+#else
+set_el( b, a )
+unsigned b;
+set a;
+#endif
+{
+ CHK(a);
+ /* nil is an element of every set */
+ if (b == nil) return(1);
+ if ( a.n == 0 || NumWords(b) > a.n ) return(0);
+
+ /* Otherwise, we have to check */
+ return( a.setword[DIVWORD(b)] & bitmask[MODWORD(b)] );
+}
+
+int
+#ifdef __USE_PROTOS
+set_nil( set a )
+#else
+set_nil( a )
+set a;
+#endif
+{
+ /* Fast check for nil set */
+ register unsigned *p = a.setword;
+ register unsigned *endp;
+
+ CHK(a);
+ if ( a.n == 0 ) return(1);
+ endp = &(a.setword[a.n]);
+
+ /* The set is not empty if any word used to store
+ the set is non-zero. This means one must be a
+ bit careful about doing things like negation.
+ */
+ do {
+ if (*p) return(0);
+ } while (++p < endp);
+
+ return(1);
+}
+
+char *
+#ifdef __USE_PROTOS
+set_str( set a )
+#else
+set_str( a )
+set a;
+#endif
+{
+ /* Fast convert set a into ASCII char string...
+ assumes that all word bits are used in the set
+ and that SETSIZE is a multiple of WORDSIZE.
+ Trailing 0 bits are removed from the string.
+ if no bits are on or set is empty, "" is returned.
+ */
+ register unsigned *p = a.setword;
+ register unsigned *endp = &(a.setword[a.n]);
+ static char str_tmp[StrSize+1];
+ register char *q = &(str_tmp[0]);
+
+ CHK(a);
+ if ( a.n==0 ) {*q=0; return( &(str_tmp[0]) );}
+ do {
+ register unsigned t = *p;
+ register unsigned *b = &(bitmask[0]);
+ do {
+ *(q++) = (char) ((t & *b) ? '1' : '0');
+ } while (++b < &(bitmask[WORDSIZE]));
+ } while (++p < endp);
+
+ /* Trim trailing 0s & NULL terminate the string */
+ while ((q > &(str_tmp[0])) && (*(q-1) != '1')) --q;
+ *q = 0;
+
+ return(&(str_tmp[0]));
+}
+
+set
+#ifdef __USE_PROTOS
+set_val( register char *s )
+#else
+set_val( s )
+register char *s;
+#endif
+{
+ /* Fast convert set ASCII char string into a set.
+ If the string ends early, the remaining set bits
+ are all made zero.
+ The resulting set size is just big enough to hold all elements.
+ */
+ static set a;
+ register unsigned *p, *endp;
+
+ set_new(a, strlen(s));
+ p = a.setword;
+ endp = &(a.setword[a.n]);
+ do {
+ register unsigned *b = &(bitmask[0]);
+ /* Start with a word with no bits on */
+ *p = 0;
+ do {
+ if (*s) {
+ if (*s == '1') {
+ /* Turn-on this bit */
+ *p |= *b;
+ }
+ ++s;
+ }
+ } while (++b < &(bitmask[WORDSIZE]));
+ } while (++p < endp);
+
+ return(a);
+}
+
+/*
+ * Or element e into set a. a can be empty.
+ */
+void
+#ifdef __USE_PROTOS
+set_orel( unsigned e, set *a )
+#else
+set_orel( e, a )
+unsigned e;
+set *a;
+#endif
+{
+ CHK((*a));
+ if ( e == nil ) return;
+ if ( NumWords(e) > a->n ) set_ext(a, NumWords(e));
+ a->setword[DIVWORD(e)] |= bitmask[MODWORD(e)];
+}
+
+/*
+ * Or set b into set a. a can be empty. does nothing if b empty.
+ */
+void
+#ifdef __USE_PROTOS
+set_orin( set *a, set b )
+#else
+set_orin( a, b )
+set *a;
+set b;
+#endif
+{
+ /* Fast set union operation */
+ /* size(a) is max(a, b); */
+ unsigned int m;
+ register unsigned *p,
+ *q = b.setword,
+ *endq; /* MR20 */
+
+ CHK((*a)); CHK(b);
+ if ( b.n == 0 ) return;
+ endq = &(b.setword[b.n]); /* MR20 */
+ m = (a->n > b.n) ? a->n : b.n;
+ set_ext(a, m);
+ p = a->setword;
+ do {
+ *p++ |= *q++;
+ } while ( q < endq );
+}
+
+/*
+ * And set b into set a. a can be empty. does nothing if b empty.
+ */
+void
+#ifdef __USE_PROTOS
+set_andin( set *a, set b )
+#else
+set_andin( a, b )
+set *a;
+set b;
+#endif
+{
+ /* Fast set intersection operation */
+ /* size(a) is max(a, b); */
+ unsigned int m;
+ register unsigned *p,
+ *q = b.setword,
+ *endq = &(b.setword[b.n]);
+
+ CHK((*a)); CHK(b);
+ if ( b.n == 0 ) return;
+ m = (a->n > b.n) ? a->n : b.n;
+ set_ext(a, m);
+ p = a->setword;
+ do {
+ *p++ &= *q++;
+ } while ( q < endq );
+}
+
+void
+#ifdef __USE_PROTOS
+set_rm( unsigned e, set a )
+#else
+set_rm( e, a )
+unsigned e;
+set a;
+#endif
+{
+ /* Does not effect size of set */
+ CHK(a);
+ if ( (e == nil) || (NumWords(e) > a.n) ) return;
+ a.setword[DIVWORD(e)] ^= (a.setword[DIVWORD(e)]&bitmask[MODWORD(e)]);
+}
+
+void
+#ifdef __USE_PROTOS
+set_clr( set a )
+#else
+set_clr( a )
+set a;
+#endif
+{
+ /* Does not effect size of set */
+ register unsigned *p = a.setword;
+ register unsigned *endp;
+
+ CHK(a);
+ if ( a.n == 0 ) return;
+ endp = &(a.setword[a.n]);
+ do {
+ *p++ = 0;
+ } while ( p < endp );
+}
+
+set
+#ifdef __USE_PROTOS
+set_dup( set a )
+#else
+set_dup( a )
+set a;
+#endif
+{
+ set b;
+ register unsigned *p,
+ *q = a.setword,
+ *endq; /* MR20 */
+
+ CHK(a);
+ b = empty;
+ if ( a.n == 0 ) return( empty );
+ endq = &(a.setword[a.n]); /* MR20 */
+ set_ext(&b, a.n);
+ p = b.setword;
+ do {
+ *p++ = *q++;
+ } while ( q < endq );
+
+ return(b);
+}
+
+/*
+ * Return a nil terminated list of unsigned ints that represents all
+ * "on" bits in the bit set.
+ *
+ * e.g. {011011} --> {1, 2, 4, 5, nil}
+ *
+ * _set_pdq and set_pdq are useful when an operation is required on each element
+ * of a set. Normally, the sequence is:
+ *
+ * while ( set_deg(a) > 0 ) {
+ * e = set_int(a);
+ * set_rm(e, a);
+ * ...process e...
+ * }
+ * Now,
+ *
+ * t = e = set_pdq(a);
+ * while ( *e != nil ) {
+ * ...process *e...
+ * e++;
+ * }
+ * free( t );
+ *
+ * We have saved many set calls and have not destroyed set a.
+ */
+void
+#ifdef __USE_PROTOS
+_set_pdq( set a, register unsigned *q )
+#else
+_set_pdq( a, q )
+set a;
+register unsigned *q;
+#endif
+{
+ register unsigned *p = a.setword,
+ *endp = &(a.setword[a.n]);
+ register unsigned e=0;
+
+ CHK(a);
+ /* are there any space (possibility of elements)? */
+ if ( a.n == 0 ) return;
+ do {
+ register unsigned t = *p;
+ register unsigned *b = &(bitmask[0]);
+ do {
+ if ( t & *b ) *q++ = e;
+ ++e;
+ } while (++b < &(bitmask[WORDSIZE]));
+ } while (++p < endp);
+ *q = nil;
+}
+
+/*
+ * Same as _set_pdq except allocate memory. set_pdq is the natural function
+ * to use.
+ */
+unsigned *
+#ifdef __USE_PROTOS
+set_pdq( set a )
+#else
+set_pdq( a )
+set a;
+#endif
+{
+ unsigned *q;
+ int max_deg;
+
+ CHK(a);
+ max_deg = WORDSIZE*a.n;
+ /* assume a.n!=0 & no elements is rare, but still ok */
+ if ( a.n == 0 ) return(NULL);
+ q = (unsigned *) malloc((max_deg+1)*BytesPerWord);
+ if ( q == NULL ) return( NULL );
+ _set_pdq(a, q);
+ return( q );
+}
+
+/* a function that produces a hash number for the set
+ */
+unsigned int
+#ifdef __USE_PROTOS
+set_hash( set a, register unsigned int mod )
+#else
+set_hash( a, mod )
+set a;
+register unsigned int mod;
+#endif
+{
+ /* Fast hash of set a (assumes all bits used) */
+ register unsigned *p = &(a.setword[0]);
+ register unsigned *endp = &(a.setword[a.n]);
+ register unsigned i = 0;
+
+ CHK(a);
+ while (p<endp){
+ i += (*p);
+ ++p;
+ }
+
+ return(i % mod);
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/support/set/set.h b/BaseTools/Source/C/VfrCompile/Pccts/support/set/set.h new file mode 100644 index 0000000000..5d68152df4 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/support/set/set.h @@ -0,0 +1,121 @@ +#ifndef __GATE_SET_H
+#define __GATE_SET_H
+
+/* set.h
+
+ The following is a general-purpose set library originally developed
+ by Hank Dietz and enhanced by Terence Parr to allow dynamic sets.
+
+ Sets are now structs containing the #words in the set and
+ a pointer to the actual set words.
+
+ 1987 by Hank Dietz
+
+ Modified by:
+ Terence Parr
+ Purdue University
+ October 1989
+
+ Added ANSI prototyping Dec. 1992 -- TJP
+*/
+
+#include "pcctscfg.h"
+
+#ifdef NOT_USED /* SEE config.h */
+/* Define usable bits per unsigned int word */
+#ifdef PC
+#define WORDSIZE 16
+#define LogWordSize 4
+#else
+#define WORDSIZE 32
+#define LogWordSize 5
+#endif
+#define BytesPerWord sizeof(unsigned)
+#endif
+
+#define SETSIZE(a) ((a).n<<LogWordSize) /* Maximum items per set */
+#define MODWORD(x) ((x) & (WORDSIZE-1)) /* x % WORDSIZE */
+#define DIVWORD(x) ((x) >> LogWordSize) /* x / WORDSIZE */
+#define nil (~((unsigned) 0)) /* An impossible set member all bits on (big!) */
+
+typedef struct _set {
+ unsigned int n; /* Number of words in set */
+ unsigned *setword;
+ } set;
+
+#define set_init {0, NULL}
+#define set_null(a) ((a).setword==NULL)
+
+#define NumBytes(x) (((x)>>3)+1) /* Num bytes to hold x */
+#define NumWords(x) ((((unsigned)(x))>>LogWordSize)+1) /* Num words to hold x */
+
+
+/* M a c r o s */
+
+/* make arg1 a set big enough to hold max elem # of arg2 */
+#define set_new(a,_max) \
+if (((a).setword=(unsigned *)calloc(NumWords(_max),BytesPerWord))==NULL) \
+ fprintf(stderr, "set_new: Cannot allocate set with max of %d\n", _max); \
+ (a).n = NumWords(_max);
+
+#define set_free(a) \
+ {if ( (a).setword != NULL ) free((char *)((a).setword)); \
+ (a) = empty;}
+
+#ifdef __USE_PROTOS
+extern void set_size( unsigned );
+extern unsigned int set_deg( set );
+extern set set_or( set, set );
+extern set set_and( set, set );
+extern set set_dif( set, set );
+extern set set_of( unsigned );
+extern void set_ext( set *, unsigned int );
+extern set set_not( set );
+extern int set_equ( set, set );
+extern int set_sub( set, set );
+extern unsigned set_int( set );
+extern int set_el( unsigned, set );
+extern int set_nil( set );
+extern char * set_str( set );
+extern set set_val( register char * );
+extern void set_orel( unsigned, set * );
+extern void set_orin( set *, set );
+extern void set_andin( set *, set );
+extern void set_rm( unsigned, set );
+extern void set_clr( set );
+extern set set_dup( set );
+extern void set_PDQ( set, register unsigned * );
+extern unsigned *set_pdq( set );
+extern void _set_pdq( set a, register unsigned *q );
+extern unsigned int set_hash( set, register unsigned int );
+#else
+extern void set_size();
+extern unsigned int set_deg();
+extern set set_or();
+extern set set_and();
+extern set set_dif();
+extern set set_of();
+extern void set_ext();
+extern set set_not();
+extern int set_equ();
+extern int set_sub();
+extern unsigned set_int();
+extern int set_el();
+extern int set_nil();
+extern char * set_str();
+extern set set_val();
+extern void set_orel();
+extern void set_orin();
+extern void set_andin();
+extern void set_rm();
+extern void set_clr();
+extern set set_dup();
+extern void set_PDQ();
+extern unsigned *set_pdq();
+extern void _set_pdq();
+extern unsigned int set_hash();
+#endif
+
+extern set empty;
+
+#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/support/sym/sym.c b/BaseTools/Source/C/VfrCompile/Pccts/support/sym/sym.c new file mode 100644 index 0000000000..eccce059bb --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/support/sym/sym.c @@ -0,0 +1,402 @@ +/*
+ * Simple symbol table manager using coalesced chaining to resolve collisions
+ *
+ * Doubly-linked lists are used for fast removal of entries.
+ *
+ * 'sym.h' must have a definition for typedef "Sym". Sym must include at
+ * minimum the following fields:
+ *
+ * ...
+ * char *symbol;
+ * struct ... *next, *prev, **head, *scope;
+ * unsigned int hash;
+ * ...
+ *
+ * 'template.h' can be used as a template to create a 'sym.h'.
+ *
+ * 'head' is &(table[hash(itself)]).
+ * The hash table is not resizable at run-time.
+ * The scope field is used to link all symbols of a current scope together.
+ * Scope() sets the current scope (linked list) to add symbols to.
+ * Any number of scopes can be handled. The user passes the address of
+ * a pointer to a symbol table
+ * entry (INITIALIZED TO NULL first time).
+ *
+ * Available Functions:
+ *
+ * zzs_init(s1,s2) -- Create hash table with size s1, string table size s2.
+ * zzs_done() -- Free hash and string table created with zzs_init().
+ * zzs_add(key,rec)-- Add 'rec' with key 'key' to the symbol table.
+ * zzs_newadd(key) -- create entry; add using 'key' to the symbol table.
+ * zzs_get(key) -- Return pointer to last record entered under 'key'
+ * Else return NULL
+ * zzs_del(p) -- Unlink the entry associated with p. This does
+ * NOT free 'p' and DOES NOT remove it from a scope
+ * list. If it was a part of your intermediate code
+ * tree or another structure. It will still be there.
+ * It is only removed from further consideration
+ * by the symbol table.
+ * zzs_keydel(s) -- Unlink the entry associated with key s.
+ * Calls zzs_del(p) to unlink.
+ * zzs_scope(sc) -- Specifies that everything added to the symbol
+ * table with zzs_add() is added to the list (scope)
+ * 'sc'. 'sc' is of 'Sym **sc' type and must be
+ * initialized to NULL before trying to add anything
+ * to it (passing it to zzs_scope()). Scopes can be
+ * switched at any time and merely links a set of
+ * symbol table entries. If a NULL pointer is
+ * passed, the current scope is returned.
+ * zzs_rmscope(sc) -- Remove (zzs_del()) all elements of scope 'sc'
+ * from the symbol table. The entries are NOT
+ * free()'d. A pointer to the first
+ * element in the "scope" is returned. The user
+ * can then manipulate the list as he/she chooses
+ * (such as freeing them all). NOTE that this
+ * function sets your scope pointer to NULL,
+ * but returns a pointer to the list for you to use.
+ * zzs_stat() -- Print out the symbol table and some relevant stats.
+ * zzs_new(key) -- Create a new record with calloc() of type Sym.
+ * Add 'key' to the string table and make the new
+ * records 'symbol' pointer point to it.
+ * zzs_strdup(s) -- Add s to the string table and return a pointer
+ * to it. Very fast allocation routine
+ * and does not require strlen() nor calloc().
+ *
+ * Example:
+ *
+ * #include <stdio.h>
+ * #include "sym.h"
+ *
+ * main()
+ * {
+ * Sym *scope1=NULL, *scope2=NULL, *a, *p;
+ *
+ * zzs_init(101, 100);
+ *
+ * a = zzs_new("Apple"); zzs_add(a->symbol, a); -- No scope
+ * zzs_scope( &scope1 ); -- enter scope 1
+ * a = zzs_new("Plum"); zzs_add(a->symbol, a);
+ * zzs_scope( &scope2 ); -- enter scope 2
+ * a = zzs_new("Truck"); zzs_add(a->symbol, a);
+ *
+ * p = zzs_get("Plum");
+ * if ( p == NULL ) fprintf(stderr, "Hmmm...Can't find 'Plum'\n");
+ *
+ * p = zzs_rmscope(&scope1)
+ * for (; p!=NULL; p=p->scope) {printf("Scope1: %s\n", p->symbol);}
+ * p = zzs_rmscope(&scope2)
+ * for (; p!=NULL; p=p->scope) {printf("Scope2: %s\n", p->symbol);}
+ * }
+ *
+ * Terence Parr
+ * Purdue University
+ * February 1990
+ *
+ * CHANGES
+ *
+ * Terence Parr
+ * May 1991
+ * Renamed functions to be consistent with ANTLR
+ * Made HASH macro
+ * Added zzs_keydel()
+ * Added zzs_newadd()
+ * Fixed up zzs_stat()
+ *
+ * July 1991
+ * Made symbol table entry save its hash code for fast comparison
+ * during searching etc...
+ */
+
+#include <stdio.h>
+#if defined(__STDC__) || defined(__USE_PROTOS)
+#include <string.h>
+#include <stdlib.h>
+#else
+#include <malloc.h>
+#endif
+#include "sym.h"
+
+#define StrSame 0
+
+static Sym **CurScope = NULL;
+static unsigned size = 0;
+static Sym **table=NULL;
+static char *strings;
+static char *strp;
+static int strsize = 0;
+
+#ifdef __USE_PROTOS
+void zzs_init(int sz,int strs)
+#else
+void zzs_init(sz, strs)
+int sz, strs;
+#endif
+{
+ if ( sz <= 0 || strs <= 0 ) return;
+ table = (Sym **) calloc(sz, sizeof(Sym *));
+ if ( table == NULL )
+ {
+ fprintf(stderr, "Cannot allocate table of size %d\n", sz);
+ exit(1);
+ }
+ strings = (char *) calloc(strs, sizeof(char));
+ if ( strings == NULL )
+ {
+ fprintf(stderr, "Cannot allocate string table of size %d\n", strs);
+ exit(1);
+ }
+ size = sz;
+ strsize = strs;
+ strp = strings;
+}
+
+#ifdef __USE_PROTOS
+void zzs_done(void)
+#else
+void zzs_done()
+#endif
+{
+ if ( table != NULL ) free( table );
+ if ( strings != NULL ) free( strings );
+}
+
+#ifdef __USE_PROTOS
+void zzs_add(char *key,Sym rec)
+#else
+void zzs_add(key, rec)
+char *key;
+register Sym *rec;
+#endif
+{
+ register unsigned int h=0;
+ register char *p=key;
+
+ HASH(p, h);
+ rec->hash = h; /* save hash code for fast comp later */
+ h %= size;
+
+ if ( CurScope != NULL ) {rec->scope = *CurScope; *CurScope = rec;}
+ rec->next = table[h]; /* Add to doubly-linked list */
+ rec->prev = NULL;
+ if ( rec->next != NULL ) (rec->next)->prev = rec;
+ table[h] = rec;
+ rec->head = &(table[h]);
+}
+
+#ifdef __USE_PROTOS
+Sym * zzs_get(char *key)
+#else
+Sym * zzs_get(key)
+char *key;
+#endif
+{
+ register unsigned int h=0;
+ register char *p=key;
+ register Sym *q;
+
+ HASH(p, h);
+
+ for (q = table[h%size]; q != NULL; q = q->next)
+ {
+ if ( q->hash == h ) /* do we even have a chance of matching? */
+ if ( strcmp(key, q->symbol) == StrSame ) return( q );
+ }
+ return( NULL );
+}
+
+/*
+ * Unlink p from the symbol table. Hopefully, it's actually in the
+ * symbol table.
+ *
+ * If p is not part of a bucket chain of the symbol table, bad things
+ * will happen.
+ *
+ * Will do nothing if all list pointers are NULL
+ */
+#ifdef __USE_PROTOS
+void zzs_del(Sym *p)
+#else
+void zzs_del(p)
+register Sym *p;
+#endif
+{
+ if ( p == NULL ) {fprintf(stderr, "zzs_del(NULL)\n"); exit(1);}
+ if ( p->prev == NULL ) /* Head of list */
+ {
+ register Sym **t = p->head;
+
+ if ( t == NULL ) return; /* not part of symbol table */
+ (*t) = p->next;
+ if ( (*t) != NULL ) (*t)->prev = NULL;
+ }
+ else
+ {
+ (p->prev)->next = p->next;
+ if ( p->next != NULL ) (p->next)->prev = p->prev;
+ }
+ p->next = p->prev = NULL; /* not part of symbol table anymore */
+ p->head = NULL;
+}
+
+#ifdef __USE_PROTOS
+void zzs_keydel(char *key)
+#else
+void zzs_keydel(key)
+char *key;
+#endif
+{
+ Sym *p = zzs_get(key);
+
+ if ( p != NULL ) zzs_del( p );
+}
+
+/* S c o p e S t u f f */
+
+/* Set current scope to 'scope'; return current scope if 'scope' == NULL */
+
+#ifdef __USE_PROTOS
+Sym ** zzs_scope(Sym **scope)
+#else
+Sym ** zzs_scope(scope)
+Sym **scope;
+#endif
+{
+ if ( scope == NULL ) return( CurScope );
+ CurScope = scope;
+ return( scope );
+}
+
+/* Remove a scope described by 'scope'. Return pointer to 1st element in scope */
+
+#ifdef __USE_PROTOS
+Sym * zzs_rmscope(Sym **scope)
+#else
+Sym * zzs_rmscope(scope)
+register Sym **scope;
+#endif
+{
+ register Sym *p;
+ Sym *start;
+
+ if ( scope == NULL ) return(NULL);
+ start = p = *scope;
+ for (; p != NULL; p=p->scope) { zzs_del( p ); }
+ *scope = NULL;
+ return( start );
+}
+
+#ifdef __USE_PROTOS
+void zzs_stat(void)
+#else
+void zzs_stat()
+#endif
+{
+ static unsigned short count[20];
+ unsigned int i,n=0,low=0, hi=0;
+ register Sym **p;
+ float avg=0.0;
+
+ for (i=0; i<20; i++) count[i] = 0;
+ for (p=table; p<&(table[size]); p++)
+ {
+ register Sym *q = *p;
+ unsigned int len;
+
+ if ( q != NULL && low==0 ) low = p-table;
+ len = 0;
+ if ( q != NULL ) printf("[%d]", p-table);
+ while ( q != NULL )
+ {
+ len++;
+ n++;
+ printf(" %s", q->symbol);
+ q = q->next;
+ if ( q == NULL ) printf("\n");
+ }
+ if ( len>=20 ) printf("zzs_stat: count table too small\n");
+ else count[len]++;
+ if ( *p != NULL ) hi = p-table;
+ }
+
+ printf("Storing %d recs used %d hash positions out of %d\n",
+ n, size-count[0], size);
+ printf("%f %% utilization\n",
+ ((float)(size-count[0]))/((float)size));
+ for (i=0; i<20; i++)
+ {
+ if ( count[i] != 0 )
+ {
+ avg += (((float)(i*count[i]))/((float)n)) * i;
+ printf("Buckets of len %d == %d (%f %% of recs)\n",
+ i, count[i], 100.0*((float)(i*count[i]))/((float)n));
+ }
+ }
+ printf("Avg bucket length %f\n", avg);
+ printf("Range of hash function: %d..%d\n", low, hi);
+}
+
+/*
+ * Given a string, this function allocates and returns a pointer to a
+ * symbol table record whose "symbol" pointer is reset to a position
+ * in the string table.
+ */
+
+#ifdef __USE_PROTOS
+Sym * zzs_new(char *text)
+#else
+Sym * zzs_new(text)
+char *text;
+#endif
+{
+ Sym *p;
+
+ if ( (p = (Sym *) calloc(1,sizeof(Sym))) == 0 )
+ {
+ fprintf(stderr,"Out of memory\n");
+ exit(1);
+ }
+ p->symbol = zzs_strdup(text);
+
+ return p;
+}
+
+/* create a new symbol table entry and add it to the symbol table */
+
+#ifdef __USE_PROTOS
+Sym * zzs_newadd(char *text)
+#else
+Sym * zzs_newadd(text)
+char *text;
+#endif
+{
+ Sym *p = zzs_new(text);
+ if ( p != NULL ) zzs_add(text, p);
+ return p;
+}
+
+/* Add a string to the string table and return a pointer to it.
+ * Bump the pointer into the string table to next avail position.
+ */
+
+#ifdef __USE_PROTOS
+char * zzs_strdup(char *s)
+#else
+char * zzs_strdup(s)
+register char *s;
+#endif
+{
+ register char *start=strp;
+
+ while ( *s != '\0' )
+ {
+ if ( strp >= &(strings[strsize-2]) )
+ {
+ fprintf(stderr, "sym: string table overflow (%d chars)\n", strsize);
+ exit(-1);
+ }
+ *strp++ = *s++;
+ }
+ *strp++ = '\0';
+
+ return( start );
+}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/support/sym/template.h b/BaseTools/Source/C/VfrCompile/Pccts/support/sym/template.h new file mode 100644 index 0000000000..ee6e665e34 --- /dev/null +++ b/BaseTools/Source/C/VfrCompile/Pccts/support/sym/template.h @@ -0,0 +1,41 @@ +/* T e m p l a t e F o r S y m b o l T a b l e M a n a g e r */
+
+/* define some hash function */
+#ifndef HASH
+#define HASH(p, h) while ( *p != '\0' ) h = (h<<1) + *p++;
+#endif
+
+/* minimum symbol table record */
+typedef struct _sym {
+ char *symbol;
+ struct _sym *next, *prev, **head, *scope;
+ unsigned int hash;
+ } Sym, *SymPtr;
+
+#ifdef __USE_PROTOS
+void zzs_init(int, int);
+void zzs_done(void);
+void zzs_add(char *, Sym *);
+Sym *zzs_get(char *);
+void zzs_del(Sym *);
+void zzs_keydel(char *);
+Sym **zzs_scope(Sym **);
+Sym *zzs_rmscope(Sym **);
+void zzs_stat(void);
+Sym *zzs_new(char *);
+Sym *zzs_newadd(char *);
+char *zzs_strdup(char *);
+#else
+void zzs_init();
+void zzs_done();
+void zzs_add();
+Sym *zzs_get();
+void zzs_del();
+void zzs_keydel();
+Sym **zzs_scope();
+Sym *zzs_rmscope();
+void zzs_stat();
+Sym *zzs_new();
+Sym *zzs_newadd();
+char *zzs_strdup();
+#endif
|