// FILE. . . . . d:/hak/hlt/src/hlt/osf/hoot/sources/HootRules.grm // EDIT BY . . . Hassan Ait-Kaci // ON MACHINE. . Hak-Laptop // STARTED ON. . Mon May 6 10:29:54 2019 /** * @version Last modified on Fri Sep 13 16:26:24 2019 by hak * @author Hassan Aït-Kaci * @copyright © by the author */ /* ************************************************************************ */ /* **************************** GRAMMAR RULES ***************************** */ /* ************************************************************************ */ %% /** * HootProgram is the grammar's start symbol. It denotes a HOOT * program, which consists in an optional sequence of Statement * constructs. */ HootProgram : Statements_opt ; /** * A Statements_opt is a possibly empty sequence of * Statement constructs. */ Statements_opt : // Empty programs are ok. */ | Statements_opt Statement ; /** * A Statement consists of a StatementType followed by * an end of statement marker EndOfStatement. */ Statement : StatementType EndOfStatement ; /** * EndOfStatement denotes the end of a statement. Upon * reading the end of statement marker EOS, the statement * just parsed is processed by HOOT and errors that may have occurred * are reported. In interactive mode, it also triggers a prompt for * additional statements. In case of syntax error, error recovery skips * all input from the error-causing token until the next * end-of-statement marker EOS. */ EndOfStatement : { commitParse(); } EOS ; /** * A StatementType is the main language unit; it is an element * of the sequence of statements that make up a HOOT program being * parsed. It can be one of the following: * * */ StatementType : // Empty statements are ok. */ | PragmaStatement | SortDeclarationStatement | HootExpression | error ; SortDeclarationStatement : IsaDeclarationStatement { setLocation(); processIsaDeclaration($1.lhs,$1.rhs); } // | SortNameDeclarationStatement // { // setLocation(); // processtSortNameDeclaration($1.symbols); // } ; IsaDeclarationStatement : SortSymbols ISA SortSymbols { $$.lhs = $1.symbols; $$.rhs = $3.symbols; } ; // SortNameDeclarationStatement // : DECLARESORTS SortSymbols // { // $$.symbols = $2.symbols; // } // ; SortSymbol : IDENTIFIER ; SortSymbols : SortSymbol { $$.symbols = new Stack(); $$.symbols.push($1.svalue()); } | SortSymbol ',' SortSymbols { ($$.symbols = $3.symbols).push($1.svalue()); } ; HootExpression : // SortExpression // { // processSortExpression($1.expression); // } // | PsiTerm { processPsiTerm($1.tag,$1.sort,$1.keys,$1.subterms); } ; PsiTerm : TAG { $$.tag = $1.svalue(); $$.sort = new SymbolSortExpression("@",context); } // XML serialization: [ n:"hoot" l:"term" a:{tag=1/value} ] | UntaggedPsiTerm { $$.sort = $1.sort; $$.keys = $1.keys; $$.subterms = $1.subterms; } | TAG ':' UntaggedPsiTerm { $$.tag = $1.svalue(); $$.sort = $3.sort; $$.keys = $3.keys; $$.subterms = $3.subterms; } // XML serialization: [ n:"hoot" l:"term" a:{tag=1/value} c:(3[0]) ] ; UntaggedPsiTerm : SortExpression Body_opt { $$.sort = $1.expression; $$.keys = $2.keys; $$.subterms = $2.subterms; } // XML serialization: [ n:"hoot" l:"term" c:(1 2) ] ; Body_opt : /* empty */ | '(' SubTerms ')' { $$.keys = $2.keys; $$.subterms = $2.subterms; } ; SubTerms : SubTerm { $$.keys = new Stack(); $$.keys.push($1.key); $$.subterms = new Stack(); $$.subterms.push($1.psiterm); } | SubTerm ',' SubTerms { ($$.keys = $3.keys).push($1.key); ($$.subterms = $3.subterms).push($1.psiterm); } ; SubTerm : PsiTerm { $$.key = null; $$.psiterm = new RawPsiTerm($1.tag,$1.sort,$1.keys,$1.subterms); } | Feature ARROW PsiTerm { $$.key = $1.feature; $$.psiterm = new RawPsiTerm($3.tag,$3.sort,$3.keys,$3.subterms); } // XML serialization: [ n:"hoot" l:"feature" a:{name=1/value} c:(3) ] ; Feature : INTEGER { $$.feature = Integer.valueOf((int)$1.nvalue()); } | IDENTIFIER { $$.feature = $1.svalue(); } ; SortExpression : Constant { $$.expression = new ConstantSortExpression($1.constant); } | Sort { $$.expression = new SymbolSortExpression($1.svalue(),context); } | '{' SortList '}' { $$.expression = new DisjunctiveSort($2.sortList,context); } // XML serialization: [ n:"hoot" l:"disjunction" c:(2) ] | NOT SortExpression { $$.expression = new NotSortExpression($2.expression); } // XML serialization: [ n:"hoot" l:"not" c:(2) ] | SortExpression AND SortExpression { $$.expression = new AndSortExpression($1.expression,$3.expression); } // XML serialization: [ n:"hoot" l:"and" c:(1 3) ] | SortExpression OR SortExpression { $$.expression = new OrSortExpression($1.expression,$3.expression); } // XML serialization: [ n:"hoot" l:"or" c:(1 3) ] | SortExpression BUTNOT SortExpression { $$.expression = new ButnotSortExpression($1.expression,$3.expression); } // XML serialization: [ n:"hoot" l:"butnot" c:(1 3) ] | '(' SortExpression ')' { $$.expression = $2.expression.setParenthesized(true); } // XML serialization: [ n:"hoot" l:"parenthesis" c:(2) ] ; Constant : INTEGER { $$.constant = new IntegerConstant((int)$1.nvalue()); } | CHAR // should check that there's exactly one character! { $$.constant = new CharConstant($1.svalue().charAt(0)); } | FLOAT { $$.constant = new FloatConstant($1.nvalue()); } | STRING { $$.constant = new StringConstant($1.svalue()); } | BOOLEAN { $$.constant = new BooleanConstant($1.svalue() == "true" ? true : false); } // | 'null' // { $$.constant = Constant.NULL(); } ; Sort : TOP | BOTTOM | IDENTIFIER // XML serialization: [ n:"hoot" l:"sort" a:{symbol=1/value} ] ; SortList : Sort { ($$.sortList = new Stack()).push($1.svalue()); } | Sort ';' SortList { ($$.sortList = $3.sortList).push($1.svalue()); } ; // /** // * This non-terminal denotes statements used to define a global // * name associated to a ψ-term. // */ // DefinitionStatement // : DEF '=' PsiTerm // { // processDefinition($1.name,$3.psiterm); // } // ; /** * This node stands for a pragma statement which allows the user to * query state parameters or up some options using a few built-in * extra-language commands of the form %pragma where pragma is an identifier, * possibly followed by arguments. * *

* * The following is a list of pragmas we found useful. It is a partial * list as one could add whatever other pragma one deems useful. Not all * the pragmas listed below have been implemented yet (some are quite * tricky), but all those listed will be supported eventually. * *

*

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
PragmaEffect
%helpList this information.
%exitEnd the session and exit HOOT.
%include "file1" ... "filen"Read and process the contents of the n files in the specified order (names specified as quoted strings); n ≥ 1.
%encodeTrigger the bit-vector encoding of the current sort hierarchy.
%sortsDisplay all sorts as a bitcode array (must come after %encode.).
%definedList all the currently defined symbols.
%symbolsList all the known (built-in and defined) symbols
%automaticToggle on/off automatic sort encoding * at the first expression evaluation without prompting the user; * the default is to prompt the user.
%muteToggle on/off result displays.
%sizePrint the number of concepts in the sort hierarchy.
%height Print the * height of the sort hierarchy; that is, the length of the longest * is-a concept chain from {} to @.
%widthPrint the size of the widest * is-a concept cochain; that is, the size of the largest * set of mutually unrelated concepts in the hierarchy.
%children s Prints the set of immediate subconcepts of s; * in other words, the set of strict greatest lower bounds of * s.
%descendants s Print the set of all strict lower bounds of s; * in other words, the set of all subconcepts of s besides * itself nor {}, or {} if s is immediately * above {}.
%parents s Print the set of immediate superconcepts of s; * in other words, the set of strict least upper bounds of * s; besides @, or @ if * s is immediately below @.
%ancestors s Print the set of all superconcepts of s; in * other words, the set of all strict upper bounds of s besides * @, or @ if s is immediately below * @.
%enumsize n Set to n the size of disjunctive enumerations to * display (number of symbols before etc., ...). Default is * 10.
%isa s tReturn true if s * is a subconcept of t, and false otherwise.
%refreshErase the codes for * all known sorts (but not the sorts nor their is-a * relations). After this pragma has been invoked, new sort * declarations may then be added to those * previously recorded, and then the hierarchy may be reencoded * taking into account the new declared sorts.
%treeToggle on/off display of syntax tree.
%timingToggle on/off execution timing.
%gcForce immediate garbage collection.
%syntaxToggle on/off parser tracing.
%traceToggle on/off evaluation tracing.
*
*/ PragmaStatement : HELP_PRAGMA // %help { setLocation(); helpPragma(); } | EXIT_PRAGMA // %exit { setLocation(); HootMain.exit(); } | INCLUDE_PRAGMA FileList // %include { setLocation(); includeFiles($2.files); } | ENCODE_PRAGMA // %encode { setLocation(); displaySize(); encodeSorts(); } | EVAL_PRAGMA // %eval { setLocation(); PsiTerm.evaluateSorts(true); displayLine("*** Sort expression evaluation has been turned on..."); } | SORTS_PRAGMA // %sorts { setLocation(); displaySorts(); } | DEFINED_PRAGMA // %defined { setLocation(); // to do } | SYMBOLS_PRAGMA // %symbols { setLocation(); } | MUTE_PRAGMA // %mute { setLocation(); isMute = !isMute; display("Muted output has been turned "+(isMute ? "on" : "off")+"...\n"); if (isMute) displayLine("*** ..."); } | SIZE_PRAGMA // %size { setLocation(); displaySize(); } | HEIGHT_PRAGMA // %height { setLocation(); // to do } | WIDTH_PRAGMA // %width { setLocation(); // to do } | CHILDREN_PRAGMA SortExpression // %children { setLocation(); displayChildren($2.expression); } | DESCENDANTS_PRAGMA SortExpression // %descendants { setLocation(); showDescendants($2.expression); } | PARENTS_PRAGMA SortExpression // %parents { setLocation(); displayParents($2.expression); } | ANCESTORS_PRAGMA SortExpression // %ancestors { setLocation(); showAncestors($2.expression); } | ENUMSIZE_PRAGMA INTEGER // %enumsize { setLocation(); Decoded.setEnumSize((int)$2.nvalue()); } | ISA_PRAGMA SortExpression SortExpression // %isa { setLocation(); // to do } | REFRESH_PRAGMA // %refresh { setLocation(); Tag.clearKnownTags(); context.reset(); displayLine("*** The sort taxonomy has been cleared ("+ numberOfSorts(context.taxonomy().size())+" defined)"); } | TREE_PRAGMA // %tree { setLocation(); parseTreeType = (showTree = !showTree) ? COMPACT_TREE : NO_TREE; display("Parse tree display has been turned "+(showTree ? "on" : "off")+"...\n"); } | TIMING_PRAGMA // %timing { setLocation(); Context.toggleTiming(); displayLine("*** Processing timing has been turned "+(Context.isTiming() ? "on" : "off")+"..."); } | GC_PRAGMA // %gc { setLocation(); display("\n"); Misc.forceGC(!isMute,dm.getOutputStream()); } | SYNTAX_PRAGMA // %syntax { setLocation(); toggleTrace(); display("Parser trace has been turned "+(tracingIsOn() ? "on" : "off")+"...\n"); } | TRACE_PRAGMA // %trace { setLocation(); if (isMute) { display("Cannot trace evaluation in mute mode; turn mute mode off with '%mute.'"); break; } Context.toggleTracing(); display("Execution tracing has been turned "+(Context.isTracing() ? "on" : "off")+"...\n"); } | UNKNOWN_PRAGMA // %unknown { setLocation(); displayLine("*** Unknown pragma (ignored) - type '%help.' for known pragmas."); // displayLine("*** Unknown pragma: '%"+pragma+"' (ignored) - type '%help.' for known pragmas."); } ; // PragmaArguments_opt // : /* empty */ // | INTEGER // integer argument to a pragma %setenum // { // Decoded.setEnumSize((int)$1.nvalue()); // } // | FileList // { // $$.args = $1.files; // } // | SortExpression // argument to pragmas %parents, %ancestors, %children, %descendants, etc., ... // { // ($$.args = new Stack(1)).add($1.expression); // } // | SortExpression SortExpression // arguments to pragma %isa // { // ($$.args = new Stack(2)).add($1.expression); // $$.args.add($2.expression); // } // ; FileList : STRING { ($$.files = new Stack()).push($1.svalue()); } | STRING FileList { ($$.files = $2.files).push($1.svalue()); } ; %% /* ************************************************************************ */ /* ************************* END OF GRAMMAR RULES ************************* */ /* ************************************************************************ */