/** * <summary>Called when adding a child to a parse tree * node.</summary> * * <param name='node'>the parent node</param> * <param name='child'>the child node, or null</param> * * <exception cref='ParseException'>if the node analysis * discovered errors</exception> */ public override void Child(Production node, Node child) { switch (node.Id) { case (int) IrfConstants.IRF_DOCUMENT: ChildIrfDocument(node, child); break; case (int) IrfConstants.ROOT_NODE: ChildRootNode(node, child); break; case (int) IrfConstants.USER_NODE: ChildUserNode(node, child); break; case (int) IrfConstants.PLAYER_NOTE_NODE: ChildPlayerNoteNode(node, child); break; case (int) IrfConstants.PLAYER_NAME_ATTRIBUTE: ChildPlayerNameAttribute(node, child); break; case (int) IrfConstants.NOTE_TEXT_ATTRIBUTE: ChildNoteTextAttribute(node, child); break; case (int) IrfConstants.TIMESTAMP_ATTRIBUTE: ChildTimestampAttribute(node, child); break; case (int) IrfConstants.CLASSIFICATION_ATTRIBUTE: ChildClassificationAttribute(node, child); break; } }
/** * Analyzes a parse tree node by traversing all it's child nodes. * The tree traversal is depth-first, and the appropriate * callback methods will be called. If the node is a production * node, a new production node will be created and children will * be added by recursively processing the children of the * specified production node. This method is used to process a * parse tree after creation. * * @param node the parse tree node to process * * @return the resulting parse tree node * * @throws ParserLogException if the node analysis discovered * errors */ public Node Analyze(Node node) { ParserLogException log = new ParserLogException(); node = Analyze(node, log); if (log.Count > 0) { throw log; } return node; }
public override void Enter(Node node) { switch ((ExpressionConstants)node.Id) { case ExpressionConstants.MEMBER_EXPRESSION: this.EnterMemberExpression(); break; case ExpressionConstants.FIELD_PROPERTY_EXPRESSION: this.EnterFieldPropertyExpression(); break; } }
/** * <summary>Called when adding a child to a parse tree * node.</summary> * * <param name='node'>the parent node</param> * <param name='child'>the child node, or null</param> * * <exception cref='ParseException'>if the node analysis * discovered errors</exception> */ public override void Child(Production node, Node child) { switch (node.Id) { case (int) CommandGrammarConstants.COMMANDS: ChildCommands(node, child); break; case (int) CommandGrammarConstants.COMMAND: ChildCommand(node, child); break; case (int) CommandGrammarConstants.EXPRESSION: ChildExpression(node, child); break; } }
public override Node Exit(Node node) { switch ((ExpressionConstants)node.Id) { case ExpressionConstants.IDENTIFIER: this.ExitIdentifier((Token)node); break; case ExpressionConstants.FIELD_PROPERTY_EXPRESSION: this.ExitFieldPropertyExpression(); break; } return node; }
public STBlock(Node blockLiteral, Context context, Compiler compiler) { Compiler = compiler; OuterContext = context; Context = new LocalContext(context, true); BlockLiteral = blockLiteral; BlockArgumentNames = new string[0]; LocalVariableNames = new string[0]; int i = 1; Node blockParams = null; if (blockLiteral[i].Name == "block_params") blockParams = blockLiteral[i++]; if (blockLiteral[i].Name == "sequence") { Sequence = blockLiteral[i++]; if (Sequence[0].Name == "var_def") { List<string> varNames = new List<string>(); var vardef = Sequence[0]; for (int j = 1, max = vardef.Count; j < max; ++j) { if (vardef[j].Name == "VAR_DELIM") break; var varName = (vardef[j] as Token).Image; varNames.Add (varName); Context.Declare(varName); } LocalVariableNames = varNames.ToArray(); } } if (blockParams != null) { var parms = blockParams; List<string> parmNames = new List<string>(); for (int j = 0, max = parms.Count; j < max; ++j) { var child = parms[j]; if (child.Name == "VAR_DELIM") break; var parmName = (parms[++j] as Token).Image; parmNames.Add (parmName); Context.Declare(parmName); } BlockArgumentNames = parmNames.ToArray(); } }
private static Formule formuleFromPred(Node pred) { Node actualPred = pred.GetChildAt(0); String strPred = formule_str.Substring(actualPred.StartColumn - 1, actualPred.EndColumn - actualPred.StartColumn + 1); List<Formule> args = new List<Formule>(); if (String.Equals(pred.Name, "PRED1")) { Node arg1 = pred.GetChildAt(2).GetChildAt(0); args.Add(new Formule( String.Equals(arg1.Name, "VAR") ? Formule.Formule_Type.variable : Formule.Formule_Type.constante, "" + formule_str[arg1.StartColumn - 1], null)); return new Formule(Formule.Formule_Type.predicat, strPred, args); } else if(String.Equals(pred.Name, "PRED2")) { Node arg1 = pred.GetChildAt(2).GetChildAt(0); Node arg2 = pred.GetChildAt(4).GetChildAt(0); args.Add(new Formule( String.Equals(arg1.Name, "VAR") ? Formule.Formule_Type.variable : Formule.Formule_Type.constante, "" + formule_str[arg1.StartColumn-1], null)); args.Add(new Formule( String.Equals(arg2.Name, "VAR") ? Formule.Formule_Type.variable : Formule.Formule_Type.constante, "" + formule_str[arg2.StartColumn-1], null)); return new Formule(Formule.Formule_Type.predicat, strPred, args); } else /* PRED3 */ { Node arg1 = pred.GetChildAt(2).GetChildAt(0); Node arg2 = pred.GetChildAt(4).GetChildAt(0); Node arg3 = pred.GetChildAt(6).GetChildAt(0); args.Add(new Formule( String.Equals(arg1.Name, "VAR") ? Formule.Formule_Type.variable : Formule.Formule_Type.constante, "" + formule_str[arg1.StartColumn - 1], null)); args.Add(new Formule( String.Equals(arg2.Name, "VAR") ? Formule.Formule_Type.variable : Formule.Formule_Type.constante, "" + formule_str[arg2.StartColumn - 1], null)); args.Add(new Formule( String.Equals(arg3.Name, "VAR") ? Formule.Formule_Type.variable : Formule.Formule_Type.constante, "" + formule_str[arg3.StartColumn - 1], null)); return new Formule(Formule.Formule_Type.predicat, strPred, args); } }
/** * <summary>Called when adding a child to a parse tree * node.</summary> * * <param name='node'>the parent node</param> * <param name='child'>the child node, or null</param> * * <exception cref='ParseException'>if the node analysis * discovered errors</exception> */ public virtual void ChildBranch(Production node, Node child) { node.AddChild(child); }
/** * <summary>Called when entering a parse tree node.</summary> * * <param name='node'>the node being entered</param> * * <exception cref='ParseException'>if the node analysis * discovered errors</exception> */ public override void Enter(Node node) { switch (node.Id) { case (int) IrfConstants.LT: EnterLt((Token) node); break; case (int) IrfConstants.GT: EnterGt((Token) node); break; case (int) IrfConstants.EQUAL: EnterEqual((Token) node); break; case (int) IrfConstants.QUOTE: EnterQuote((Token) node); break; case (int) IrfConstants.PLAYER_NOTES: EnterPlayerNotes((Token) node); break; case (int) IrfConstants.PLAYER_NOTE_SET: EnterPlayerNoteSet((Token) node); break; case (int) IrfConstants.USER_NAME: EnterUserName((Token) node); break; case (int) IrfConstants.PLAYER_NOTE: EnterPlayerNote((Token) node); break; case (int) IrfConstants.PLAYER_NAME: EnterPlayerName((Token) node); break; case (int) IrfConstants.NOTE_TEXT: EnterNoteText((Token) node); break; case (int) IrfConstants.TIMESTAMP: EnterTimestamp((Token) node); break; case (int) IrfConstants.CLASSIFICATION: EnterClassification((Token) node); break; case (int) IrfConstants.NUMBER: EnterNumber((Token) node); break; case (int) IrfConstants.QUOTED_STRING: EnterQuotedString((Token) node); break; case (int) IrfConstants.IDENTIFIER: EnterIdentifier((Token) node); break; case (int) IrfConstants.IRF_DOCUMENT: EnterIrfDocument((Production) node); break; case (int) IrfConstants.ROOT_NODE: EnterRootNode((Production) node); break; case (int) IrfConstants.USER_NODE: EnterUserNode((Production) node); break; case (int) IrfConstants.PLAYER_NOTE_NODE: EnterPlayerNoteNode((Production) node); break; case (int) IrfConstants.PLAYER_NAME_ATTRIBUTE: EnterPlayerNameAttribute((Production) node); break; case (int) IrfConstants.NOTE_TEXT_ATTRIBUTE: EnterNoteTextAttribute((Production) node); break; case (int) IrfConstants.TIMESTAMP_ATTRIBUTE: EnterTimestampAttribute((Production) node); break; case (int) IrfConstants.CLASSIFICATION_ATTRIBUTE: EnterClassificationAttribute((Production) node); break; } }
/** * <summary>Called when adding a child to a parse tree * node.</summary> * * <param name='node'>the parent node</param> * <param name='child'>the child node, or null</param> * * <exception cref='ParseException'>if the node analysis * discovered errors</exception> */ public virtual void ChildUserNode(Production node, Node child) { node.AddChild(child); }
/** * <summary>Called when adding a child to a parse tree * node.</summary> * * <param name='node'>the parent node</param> * <param name='child'>the child node, or null</param> * * <exception cref='ParseException'>if the node analysis * discovered errors</exception> */ public virtual void ChildTimestampAttribute(Production node, Node child) { node.AddChild(child); }
/** * <summary>Called when adding a child to a parse tree * node.</summary> * * <param name='node'>the parent node</param> * <param name='child'>the child node, or null</param> * * <exception cref='ParseException'>if the node analysis * discovered errors</exception> */ public virtual void ChildLines(Production node, Node child) { node.AddChild(child); }
/** * <summary>Called when adding a child to a parse tree * node.</summary> * * <param name='node'>the parent node</param> * <param name='child'>the child node, or null</param> * * <exception cref='ParseException'>if the node analysis * discovered errors</exception> */ public virtual void ChildOrigin(Production node, Node child) { node.AddChild(child); }
/** * Sets the parent node. * * @param parent the new parent node */ internal void SetParent(Node parent) { this.parent = parent; }
/** * <summary>Called when adding a child to a parse tree * node.</summary> * * <param name='node'>the parent node</param> * <param name='child'>the child node, or null</param> * * <exception cref='ParseException'>if the node analysis * discovered errors</exception> */ public virtual void ChildIrfDocument(Production node, Node child) { node.AddChild(child); }
/** * <summary>Called when adding a child to a parse tree * node.</summary> * * <param name='node'>the parent node</param> * <param name='child'>the child node, or null</param> * * <exception cref='ParseException'>if the node analysis * discovered errors</exception> */ public virtual void ChildSymbols(Production node, Node child) { node.AddChild(child); }
/** * <summary>Called when entering a parse tree node.</summary> * * <param name='node'>the node being entered</param> * * <exception cref='ParseException'>if the node analysis * discovered errors</exception> */ public override void Enter(Node node) { switch (node.Id) { case (int) PicoConstants.MOV: EnterMov((Token) node); break; case (int) PicoConstants.ADD: EnterAdd((Token) node); break; case (int) PicoConstants.SUB: EnterSub((Token) node); break; case (int) PicoConstants.MUL: EnterMul((Token) node); break; case (int) PicoConstants.DIV: EnterDiv((Token) node); break; case (int) PicoConstants.BEQ: EnterBeq((Token) node); break; case (int) PicoConstants.BGT: EnterBgt((Token) node); break; case (int) PicoConstants.IN: EnterIn((Token) node); break; case (int) PicoConstants.OUT: EnterOut((Token) node); break; case (int) PicoConstants.JSR: EnterJsr((Token) node); break; case (int) PicoConstants.RTS: EnterRts((Token) node); break; case (int) PicoConstants.STOP: EnterStop((Token) node); break; case (int) PicoConstants.ORG: EnterOrg((Token) node); break; case (int) PicoConstants.EQUALS: EnterEquals((Token) node); break; case (int) PicoConstants.LEFT_PAREN: EnterLeftParen((Token) node); break; case (int) PicoConstants.RIGHT_PAREN: EnterRightParen((Token) node); break; case (int) PicoConstants.HASH: EnterHash((Token) node); break; case (int) PicoConstants.COLON: EnterColon((Token) node); break; case (int) PicoConstants.COMMA: EnterComma((Token) node); break; case (int) PicoConstants.SIGN: EnterSign((Token) node); break; case (int) PicoConstants.NUMBER: EnterNumber((Token) node); break; case (int) PicoConstants.IDENTIFIER: EnterIdentifier((Token) node); break; case (int) PicoConstants.ENTER: EnterEnter((Token) node); break; case (int) PicoConstants.PROGRAM: EnterProgram((Production) node); break; case (int) PicoConstants.SEPARATOR: EnterSeparator((Production) node); break; case (int) PicoConstants.SYMBOLS: EnterSymbols((Production) node); break; case (int) PicoConstants.SYMBOL: EnterSymbol((Production) node); break; case (int) PicoConstants.INTEGER: EnterInteger((Production) node); break; case (int) PicoConstants.ORIGIN: EnterOrigin((Production) node); break; case (int) PicoConstants.LINES: EnterLines((Production) node); break; case (int) PicoConstants.LINE: EnterLine((Production) node); break; case (int) PicoConstants.INSTRUCTION: EnterInstruction((Production) node); break; case (int) PicoConstants.MOVE: EnterMove((Production) node); break; case (int) PicoConstants.ARITHMETIC: EnterArithmetic((Production) node); break; case (int) PicoConstants.BRANCH: EnterBranch((Production) node); break; case (int) PicoConstants.IO: EnterIo((Production) node); break; case (int) PicoConstants.CALL: EnterCall((Production) node); break; case (int) PicoConstants.RETURN: EnterReturn((Production) node); break; case (int) PicoConstants.END: EnterEnd((Production) node); break; case (int) PicoConstants.MOVE_ARGS: EnterMoveArgs((Production) node); break; case (int) PicoConstants.ARITHMETIC_ARGS: EnterArithmeticArgs((Production) node); break; case (int) PicoConstants.BRANCH_ARGS: EnterBranchArgs((Production) node); break; case (int) PicoConstants.IOARGS: EnterIoargs((Production) node); break; case (int) PicoConstants.END_ARGS: EnterEndArgs((Production) node); break; case (int) PicoConstants.ARG12: EnterArg12((Production) node); break; case (int) PicoConstants.ARG34: EnterArg34((Production) node); break; case (int) PicoConstants.ARG123: EnterArg123((Production) node); break; case (int) PicoConstants.ARG1234: EnterArg1234((Production) node); break; case (int) PicoConstants.ARG1: EnterArg1((Production) node); break; case (int) PicoConstants.ARG2: EnterArg2((Production) node); break; case (int) PicoConstants.ARG3: EnterArg3((Production) node); break; case (int) PicoConstants.ARG4: EnterArg4((Production) node); break; } }
/** * <summary>Called when adding a child to a parse tree * node.</summary> * * <param name='node'>the parent node</param> * <param name='child'>the child node, or null</param> * * <exception cref='ParseException'>if the node analysis * discovered errors</exception> */ public virtual void ChildSeparator(Production node, Node child) { node.AddChild(child); }
/** * <summary>Called when adding a child to a parse tree * node.</summary> * * <param name='node'>the parent node</param> * <param name='child'>the child node, or null</param> * * <exception cref='ParseException'>if the node analysis * discovered errors</exception> */ public virtual void ChildReturn(Production node, Node child) { node.AddChild(child); }
/** * <summary>Called when adding a child to a parse tree * node.</summary> * * <param name='node'>the parent node</param> * <param name='child'>the child node, or null</param> * * <exception cref='ParseException'>if the node analysis * discovered errors</exception> */ public virtual void ChildProgram(Production node, Node child) { node.AddChild(child); }
/** * <summary>Called when exiting a parse tree node.</summary> * * <param name='node'>the node being exited</param> * * <returns>the node to add to the parse tree, or * null if no parse tree should be created</returns> * * <exception cref='ParseException'>if the node analysis * discovered errors</exception> */ public override Node Exit(Node node) { switch (node.Id) { case (int) IrfConstants.LT: return ExitLt((Token) node); case (int) IrfConstants.GT: return ExitGt((Token) node); case (int) IrfConstants.EQUAL: return ExitEqual((Token) node); case (int) IrfConstants.QUOTE: return ExitQuote((Token) node); case (int) IrfConstants.PLAYER_NOTES: return ExitPlayerNotes((Token) node); case (int) IrfConstants.PLAYER_NOTE_SET: return ExitPlayerNoteSet((Token) node); case (int) IrfConstants.USER_NAME: return ExitUserName((Token) node); case (int) IrfConstants.PLAYER_NOTE: return ExitPlayerNote((Token) node); case (int) IrfConstants.PLAYER_NAME: return ExitPlayerName((Token) node); case (int) IrfConstants.NOTE_TEXT: return ExitNoteText((Token) node); case (int) IrfConstants.TIMESTAMP: return ExitTimestamp((Token) node); case (int) IrfConstants.CLASSIFICATION: return ExitClassification((Token) node); case (int) IrfConstants.NUMBER: return ExitNumber((Token) node); case (int) IrfConstants.QUOTED_STRING: return ExitQuotedString((Token) node); case (int) IrfConstants.IDENTIFIER: return ExitIdentifier((Token) node); case (int) IrfConstants.IRF_DOCUMENT: return ExitIrfDocument((Production) node); case (int) IrfConstants.ROOT_NODE: return ExitRootNode((Production) node); case (int) IrfConstants.USER_NODE: return ExitUserNode((Production) node); case (int) IrfConstants.PLAYER_NOTE_NODE: return ExitPlayerNoteNode((Production) node); case (int) IrfConstants.PLAYER_NAME_ATTRIBUTE: return ExitPlayerNameAttribute((Production) node); case (int) IrfConstants.NOTE_TEXT_ATTRIBUTE: return ExitNoteTextAttribute((Production) node); case (int) IrfConstants.TIMESTAMP_ATTRIBUTE: return ExitTimestampAttribute((Production) node); case (int) IrfConstants.CLASSIFICATION_ATTRIBUTE: return ExitClassificationAttribute((Production) node); } return node; }
void IBlockVisitor.VisitStatement(Node statement) { Compiler.EvaluateStatement(statement, Context); }
/** * <summary>Called when adding a child to a parse tree * node.</summary> * * <param name='node'>the parent node</param> * <param name='child'>the child node, or null</param> * * <exception cref='ParseException'>if the node analysis * discovered errors</exception> */ public virtual void ChildClassificationAttribute(Production node, Node child) { node.AddChild(child); }
/** * <summary>Called when adding a child to a parse tree * node.</summary> * * <param name='node'>the parent node</param> * <param name='child'>the child node, or null</param> * * <exception cref='ParseException'>if the node analysis * discovered errors</exception> */ public virtual void ChildMoveArgs(Production node, Node child) { node.AddChild(child); }
/** * <summary>Called when adding a child to a parse tree * node.</summary> * * <param name='node'>the parent node</param> * <param name='child'>the child node, or null</param> * * <exception cref='ParseException'>if the node analysis * discovered errors</exception> */ public override void Child(Production node, Node child) { switch (node.Id) { case (int) PicoConstants.PROGRAM: ChildProgram(node, child); break; case (int) PicoConstants.SEPARATOR: ChildSeparator(node, child); break; case (int) PicoConstants.SYMBOLS: ChildSymbols(node, child); break; case (int) PicoConstants.SYMBOL: ChildSymbol(node, child); break; case (int) PicoConstants.INTEGER: ChildInteger(node, child); break; case (int) PicoConstants.ORIGIN: ChildOrigin(node, child); break; case (int) PicoConstants.LINES: ChildLines(node, child); break; case (int) PicoConstants.LINE: ChildLine(node, child); break; case (int) PicoConstants.INSTRUCTION: ChildInstruction(node, child); break; case (int) PicoConstants.MOVE: ChildMove(node, child); break; case (int) PicoConstants.ARITHMETIC: ChildArithmetic(node, child); break; case (int) PicoConstants.BRANCH: ChildBranch(node, child); break; case (int) PicoConstants.IO: ChildIo(node, child); break; case (int) PicoConstants.CALL: ChildCall(node, child); break; case (int) PicoConstants.RETURN: ChildReturn(node, child); break; case (int) PicoConstants.END: ChildEnd(node, child); break; case (int) PicoConstants.MOVE_ARGS: ChildMoveArgs(node, child); break; case (int) PicoConstants.ARITHMETIC_ARGS: ChildArithmeticArgs(node, child); break; case (int) PicoConstants.BRANCH_ARGS: ChildBranchArgs(node, child); break; case (int) PicoConstants.IOARGS: ChildIoargs(node, child); break; case (int) PicoConstants.END_ARGS: ChildEndArgs(node, child); break; case (int) PicoConstants.ARG12: ChildArg12(node, child); break; case (int) PicoConstants.ARG34: ChildArg34(node, child); break; case (int) PicoConstants.ARG123: ChildArg123(node, child); break; case (int) PicoConstants.ARG1234: ChildArg1234(node, child); break; case (int) PicoConstants.ARG1: ChildArg1(node, child); break; case (int) PicoConstants.ARG2: ChildArg2(node, child); break; case (int) PicoConstants.ARG3: ChildArg3(node, child); break; case (int) PicoConstants.ARG4: ChildArg4(node, child); break; } }
/** * <summary>Called when adding a child to a parse tree * node.</summary> * * <param name='node'>the parent node</param> * <param name='child'>the child node, or null</param> * * <exception cref='ParseException'>if the node analysis * discovered errors</exception> */ public virtual void ChildNoteTextAttribute(Production node, Node child) { node.AddChild(child); }
private string GetTitle(Node node) { // Join together the value of the token as well as the FreeLine (if present) return string.Join(" ", GetChildValues(node).Cast<string>().ToArray()); }
/** * <summary>Called when adding a child to a parse tree * node.</summary> * * <param name='node'>the parent node</param> * <param name='child'>the child node, or null</param> * * <exception cref='ParseException'>if the node analysis * discovered errors</exception> */ public virtual void ChildPlayerNameAttribute(Production node, Node child) { node.AddChild(child); }
private static Formule parseNode(Node n) { if(String.Equals(n.Name, "FORMULE")) { Node child1 = n.GetChildAt(0); List<Formule> list = new List<Formule>(); if (String.Equals(child1.Name, "NOT")) { if (n.GetChildAt(1).GetChildAt(0).Name == "PREDICAT") /* Le not s'applique seulement au predicat qui le suit */ { Formule f = parseNode(n.GetChildAt(1)); return f.encapsuleNot(); } else /* Le not s'applique sur tout le reste de la formule */ { list.Add(parseNode(n.GetChildAt(1))); return new Formule(Formule.Formule_Type.neg, "empty", list); } } else if(String.Equals(child1.Name, "FORALL")) { Node varNode = n.GetChildAt(1); list.Add(new Formule(Formule.Formule_Type.variable, ""+formule_str[varNode.StartColumn-1], null)); list.Add(parseNode(n.GetChildAt(2))); return new Formule(Formule.Formule_Type.forall, "empty", list); } else if(String.Equals(child1.Name, "EXISTS")) { Node varNode = n.GetChildAt(1); list.Add(new Formule(Formule.Formule_Type.variable, "" + formule_str[varNode.StartColumn-1], null)); list.Add(parseNode(n.GetChildAt(2))); return new Formule(Formule.Formule_Type.exists, "empty", list); } else if(String.Equals(child1.Name, "PREDICAT")) { Node pred = child1.GetChildAt(0); Formule formPred = formuleFromPred(pred); if(n.GetChildCount() == 1) { return formPred; } else { Node child2 = n.GetChildAt(1); Node connecteur = child2.GetChildAt(0); Formule.Formule_Type type; if (String.Equals(connecteur.Name, "AND")) type = Formule.Formule_Type.and; else if (String.Equals(connecteur.Name, "OR")) type = Formule.Formule_Type.or; else /* IMPLY */ type = Formule.Formule_Type.impl; list.Add(formPred); list.Add(parseNode(child2.GetChildAt(1))); return new Formule(type, "empty", list); } } else /* equals "(" */ { Node child3 = n.GetChildAt(2); Node connecteur = child3.GetChildAt(0); if(connecteur.Name == "RIGHT_PAREN") { return parseNode(n.GetChildAt(1)); } /* Si connecteur */ Formule.Formule_Type type; if (String.Equals(connecteur.Name, "AND")) type = Formule.Formule_Type.and; else if (String.Equals(connecteur.Name, "OR")) type = Formule.Formule_Type.or; else /* IMPLY */ type = Formule.Formule_Type.impl; list.Add(parseNode(n.GetChildAt(1))); list.Add(parseNode(child3.GetChildAt(1))); return new Formule(type, "empty", list); } } Console.WriteLine("Erreur cas inconnu FormuleFactory"); return null; }
/** * <summary>Called when adding a child to a parse tree * node.</summary> * * <param name='node'>the parent node</param> * <param name='child'>the child node, or null</param> * * <exception cref='ParseException'>if the node analysis * discovered errors</exception> */ public virtual void ChildInteger(Production node, Node child) { node.AddChild(child); }