📄 ruby.stg
字号:
# <description>case <LA(k)> <edges; separator="\n"> <if(eotPredictsAlt)><\n> else alt<decisionNumber> = <eotPredictsAlt> <endif>end>>dfaEdgeSwitch(labels, targetState)::=<<<if(PARSER)>when <labels:{:<it>}; separator=","><\n><else>when <labels:{<it>}; separator=","><\n><endif> <targetState>>>// C y c l i c D F A/** The code to initiate execution of a cyclic DFA; this is used * in the rule to predict an alt just like the fixed DFA case. * The <name> attribute is inherited via the parser, lexer, ... */dfaDecision(decisionNumber,description)::=<<alt<decisionNumber> = DFA<decisionNumber>.predict(@input)>>/** Generate the tables and support code needed for the DFAState object * argument. Unless there is a semantic predicate (or syn pred, which * become sem preds), all states should be encoded in the state tables. * Consequently, cyclicDFAState/cyclicDFAEdge,eotDFAEdge templates are * not used except for special DFA states that cannot be encoded as * a transition table. */cyclicDFA(dfa)::=<<DFA<dfa.decisionNumber> = DFA.new( [<dfa.eot; wrap="\n ", separator=",", null="-1">], [<dfa.eof; wrap="\n ", separator=",", null="-1">], [<dfa.min; wrap="\n ", separator=",", null="0">], [<dfa.max; wrap="\n ", separator=",", null="0">], [<dfa.accept; wrap="\n ", separator=",", null="-1">], [<dfa.special; wrap="\n ", separator=",", null="-1">], [ <dfa.transition:{s | [<s; wrap="\n ", separator=",", null="-1">]}; separator=",\n", null=""> ])>>/** A special state in a cyclic DFA; special means has a semantic predicate * or it's a huge set of symbols to check. */cyclicDFAState(decisionNumber,stateNumber,edges,needErrorClause,semPredState)::=<< raise "cyclicDFAState not yet implemented">>/** Just like a fixed DFA edge, test the lookahead and indicate what * state to jump to next if successful. Again, this is for special * states. */cyclicDFAEdge(labelExpr, targetStateNumber, edgeNumber, predicates)::=<<s = <targetStateNumber> if (<labelExpr>) <if(predicates)>&& (<predicates>)<endif><\n>>>/** An edge pointing at end-of-token; essentially matches any char; * always jump to the target. */eotDFAEdge(targetStateNumber,edgeNumber, predicates)::=<<s = <targetStateNumber><\n>>>// D F A E X P R E S S I O N SandPredicates(left,right)::= "(<left> && <right>)"orPredicates(operands)::=<<(<operands; separator=" || ">)>>notPredicate(pred)::= "!(<evalPredicate(...)>)"evalPredicate(pred,description)::= "(<pred>)"evalSynPredicate(pred,description)::= "<pred>()"/** * It's not really clear that decisionNumber and stateNumber are available here */lookaheadTest(atom,k,atomAsInt)::=<<<if(LEXER)>look_ahead<decisionNumber>_<stateNumber> == <atom><else>look_ahead<decisionNumber>_<stateNumber> == :<atom><endif>>>/** Sometimes a lookahead test cannot assume that LA(k) is in a temp variable * somewhere. Must ask for the lookahead directly. */isolatedLookaheadTest(atom,k,atomAsInt) ::=<<<if(LEXER)><LA(k)> == <atom><else><LA(k)> == :<atom><endif>>>/** * It's not really clear that decisionNumber and stateNumber are available here */lookaheadRangeTest(lower,upper,k,rangeNumber,lowerAsInt,upperAsInt)::=<<<if(LEXER)>(look_ahead<decisionNumber>_<stateNumber> \>= <lower> && look_ahead<decisionNumber>_<stateNumber> \<= <upper>)<else>(TOKENS[look_ahead<decisionNumber>_<stateNumber>] \>= <lowerAsInt> && TOKENS[look_ahead<decisionNumber>_<stateNumber>] \<= <upperAsInt>)<endif>>>isolatedLookaheadRangeTest(lower,upper,k,rangeNumber,lowerAsInt,upperAsInt) ::=<<<if(LEXER)>(<LA(k)> \>= <lower> && <LA(k)> \<= <upper>)<else>(TOKENS[<LA(k)>] \>= <lowerAsInt> && TOKENS[<LA(k)>] \<= <upperAsInt>)<endif>>>setTest(ranges) ::=<<<ranges; separator=" || ">>>// A T T R I B U T E SparameterAttributeRef(attr)::=<< ---- parameterAttributeRef ---- attr: <attr> ---- /parameterAttributeRef ---->>scopeAttributeRef(scope,attr,index,negIndex)::=<< ---- scopeAttributeRef ---- scope: <scope> attr: <attr> index: <index> negIndex: <negIndex> ---- /scopeAttributeRef ---->>/** $x is either global scope or x is rule with dynamic scope; refers * to stack itself not top of stack. This is useful for predicates * like {$function.size()>0 && $function::name.equals("foo")}? */isolatedDynamicScopeRef(scope)::=<< ---- isolatedDynamicScopeRef ---- scope: <scope> ---- /isolatedDynamicScopeRef ---->>/** reference an attribute of rule; might only have single return value */ruleLabelRef(referencedRule,scope,attr)::=<< ---- ruleLabelRef ---- referencedRule: <referenceRule> scope: <scope> attr: <attr> ---- /ruleLabelRef ---->>returnAttributeRef(ruleDescriptor,attr)::=<< ---- returnAttributeRef ---- ruleDescriptor: <ruleDescriptor> attr: <attr> ---- /returnAttributeRef ---->>/** How to translate $tokenLabel */tokenLabelRef(label)::= "_<label>"/** ids+=ID {$ids} or e+=expr {$e} */listLabelRef(label)::= "list_<label>"// not sure the next are the right approach; and they are evaluated early;// they cannot see TREE_PARSER or PARSER attributes for example. :(tokenLabelPropertyRef_text(scope,attr)::= "_<scope>.text"tokenLabelPropertyRef_type(scope,attr)::= "_<scope>.token_type"tokenLabelPropertyRef_line(scope,attr)::= "_<scope>.line"tokenLabelPropertyRef_pos(scope,attr) ::= "_<scope>.pos"tokenLabelPropertyRef_channel(scope,attr)::= "_<scope>.channel"tokenLabelPropertyRef_index(scope,attr)::= "_<scope>.index"tokenLabelPropertyRef_tree(scope,attr)::= "----- tokenLablePropertyRef_tree / ----"ruleLabelPropertyRef_start(scope,attr)::=<< ---- ruleLabelPropertyRef_start ---- scope: <scope> attr: <attr> ---- /ruleLabelPropertyRef_start ---->>ruleLabelPropertyRef_stop(scope,attr)::=<< ---- ruleLabelPropertyRef_stop ---- scope: <scope> attr: <attr> ---- /ruleLabelPropertyRef_stop ---->>ruleLabelPropertyRef_tree(scope,attr)::=<< ---- ruleLabelPropertyRef_tree ---- scope: <scope> attr: <attr> ---- /ruleLabelPropertyRef_tree ---->>ruleLabelPropertyRef_text(scope,attr)::=<< ---- ruleLabelPropertyRef_text ---- scope: <scope> attr: <attr> ---- /ruleLabelPropertyRef_text ---->>ruleLabelPropertyRef_st(scope,attr)::=<< ---- ruleLabelPropertyRef_st ---- scope: <scope> attr: <attr> ---- /ruleLabelPropertyRef_st ---->>/** Isolated $RULE ref ok in lexer as it's a Token */lexerRuleLabel(label)::=<< ---- lexerRuleLabel ---- label: <label> ---- /lexerRuleLabel ---->>lexerRuleLabelPropertyRef_type(scope,attr)::=<< ---- lexerRuleLabelPropertyRef_type ---- scope: <scope> attr: <attr> ---- /lexerRuleLabelPropertyRef_type ---->>lexerRuleLabelPropertyRef_line(scope,attr)::=<< ---- lexerRuleLabelPropertyRef_line ---- scope: <scope> attr: <attr> ---- /lexerRuleLabelPropertyRef_line ---->>lexerRuleLabelPropertyRef_pos(scope,attr)::=<< ---- lexerRuleLabelPropertyRef_pos ---- scope: <scope> attr: <attr> ---- /lexerRuleLabelPropertyRef_pos ---->>lexerRuleLabelPropertyRef_channel(scope,attr)::=<< ---- lexerRuleLabelPropertyRef_channel ---- scope: <scope> attr: <attr> ---- /lexerRuleLabelPropertyRef_channel ---->>lexerRuleLabelPropertyRef_index(scope,attr)::=<< ---- lexerRuleLabelPropertyRef_index ---- scope: <scope> attr: <attr> ---- /lexerRuleLabelPropertyRef_index ---->>lexerRuleLabelPropertyRef_text(scope,attr)::=<< ---- lexerRuleLabelPropertyRef_text ---- scope: <scope> attr: <attr> ---- /lexerRuleLabelPropertyRef_text ---->>// Somebody may ref $template or $tree or $stop within a rule:rulePropertyRef_start(scope,attr)::=<< ---- rulePropertyRef_start ---- scope: <scope> attr: <attr> ---- /rulePropertyRef_start ---->>rulePropertyRef_stop(scope,attr)::=<< ---- rulePropertyRef_stop ---- scope: <scope> attr: <attr> ---- /rulePropertyRef_stop ---->>rulePropertyRef_tree(scope,attr)::=<< ---- rulePropertyRef_tree ---- scope: <scope> attr: <attr> ---- /rulePropertyRef_tree ---->>rulePropertyRef_text(scope,attr)::=<< ---- rulePropertyRef_text ---- scope: <scope> attr: <attr> ---- /rulePropertyRef_text ---->>rulePropertyRef_st(scope,attr)::=<< ---- rulePropertyRef_st ---- scope: <scope> attr: <attr> ---- /rulePropertyRef_st ---->>/** How to execute an action *//** TODO: add syntactic predicate & bactracking gates **/execAction(action)::=<<<action>>>// M I S C (properties, etc...)codeFileExtension()::=".rb"true()::= "true"false()::= "false"///////////// --------------------------- private templates --------------------------------bitset()::=<< ---- bitset ---- name: <it.name> inName: <it.inName> bits: <it.bits> tokenIndex: <it.tokenIndex> ---- /bitset ---->>element() ::= "<it.el>"plainBlock(decls, alts, description) ::=<<<decls><alts>>>switchBlock(description, decisionNumber, maxAlt, alts, decls, decision) ::=<<# <description>alt<decisionNumber> = <maxAlt><decls><decision>case alt<decisionNumber> <alts:switchCase(); separator="\n">end>>switchCase() ::=<<when <i> <it>>>LA(k) ::=<<<if(LEXER)>@input.look_ahead(<k>)<else>look_ahead(<k>)<endif>>>synpred(name) ::= <<def <name> start = @input.mark() @backtracking += 1 <name>_fragment() @backtracking -= 1 success = !@failed @input.rewind(start) @failed = false return successend>>parameterScope(scope) ::= <<<scope.attributes:{<it.decl>}; separator=", ">>>⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -