public string CreateNfaRule(ParseTreeNode node) { string ruleName = node.FindTokenAndGetText(); if (_partNumber.ContainsKey(ruleName)) { string parts = ""; int number = _partNumber[ruleName]; for (int i = 0; i <= number; i++) { if (parts != "") { parts += ", "; } parts += "Get" + ruleName.Replace('-', '_') + i + "(rulenames)"; } _partNumber.Remove(ruleName); return("\t\tpublic State Get" + ruleName.Replace('-', '_') + "(List<string> rulenames)\r\n" + "\t\t{\r\n" + "\t\t\trulenames.Insert(0, \"" + node.FindTokenAndGetText() + "\");\r\n" + "\t\t\tState rule = State.NoCloneAlternation(" + parts + ");\r\n" + "\t\t\trule = OnMarkRule(rule, rulenames);\r\n" + "\t\t\trulenames.RemoveAt(0);\r\n" + "\t\t\treturn rule;\r\n" + "\t\t}\r\n"); } return(""); }
public string CreateNfaRulePart(ParseTreeNode node) { ParseTreeNode elements = null; foreach (var child in node.ChildNodes) { if (child.Term.Name == "elements") { elements = child; } } var nodeName = node.FindTokenAndGetText(); int number = 0; if (_partNumber.ContainsKey(nodeName)) { number = _partNumber[nodeName] + 1; } _partNumber[nodeName] = number; return("\t\tpublic State Get" + node.FindTokenAndGetText().Replace('-', '_') + number + "(List<string> rulenames)\r\n" + "\t\t{\r\n" + "\t\t\tState rule = " + CreateAlternation(elements.ChildNodes[0], true) + ";\r\n" + "\t\t\treturn rule;\r\n" + "\t\t}\r\n"); }
/// <summary> /// /// </summary> /// <param name="node"></param> /// <param name="index"></param> /// private void ChildrenNodesRetrevial(ParseTreeNode node, ref int index) { if (node.ChildNodes.Count > 0) { foreach (var item in node.ChildNodes) { ChildrenNodesRetrevial(item, ref index); } } else if (node.FindTokenAndGetText() != null) { _cSharpCode[index] = _cSharpCode[index] + node.FindTokenAndGetText() + " "; } }
private static string GetParseTreeNodeText(ParseTreeNode parseTreeNode) { if (parseTreeNode == null) { return(string.Empty); } // We cannot use FindTokenAndGetText always because it will give us only the text of the root node in // case of complex expressions. So we have to do that: if (parseTreeNode.ChildNodes.Count > 0) { var result = new StringBuilder(); foreach (var node in parseTreeNode.ChildNodes) { int offset = node.Span.Location.Position - parseTreeNode.Span.Location.Position; if (result.Length < offset) { result.Append(' ', offset - result.Length); } result.Append(GetParseTreeNodeText(node)); } return(result.ToString()); } return(parseTreeNode.FindTokenAndGetText() ?? string.Empty); }
///Translate a constant number (Int32 or Double) private ILanguageExpression translate_Constant_Number(ParseTreeNode node) { var numberText = node.FindTokenAndGetText(); Int32 intNumber; if (Int32.TryParse(numberText, out intNumber)) { return(ValuePrimitive <MathematicaScalar> .Create( GMacRootAst.ScalarType, MathematicaScalar.Create(SymbolicUtils.Cas, intNumber) )); } Double doubleNumber; if (Double.TryParse(numberText, out doubleNumber)) { return(ValuePrimitive <MathematicaScalar> .Create( GMacRootAst.ScalarType, MathematicaScalar.Create(SymbolicUtils.Cas, doubleNumber) )); } return(CompilationLog.RaiseGeneratorError <ILanguageExpression>("Constant number not recognized", node)); }
// this is where data is initially passed to the item public override void Init(AstContext context, ParseTreeNode treeNode) { string sVal = treeNode.FindTokenAndGetText(); base.Init(context, treeNode); var nodes = treeNode.GetMappedChildNodes(); var functionOrProperty = AddChild("FunctionOrId", nodes[0]); if (functionOrProperty is SelectFunctionNode) { _TheFunction = (SelectFunctionNode)functionOrProperty; } else if (functionOrProperty is SelectPropertyNode) { _PropNode = (SelectPropertyNode)functionOrProperty; } else { throw new Exception("Unmanaged type in selectmemberaccessnode"); } if (nodes.Count > 1) { var child = AddChild("Queue", nodes[1]); string sval = nodes[1].FindTokenAndGetText(); if (child is LeftObjectNode) { _queue = (LeftObjectNode)child; } } }
private IExpression BuildCharvalExpression(ParseTreeNode node) { var charval = node.FindTokenAndGetText(); //.Replace("\\", "\\\\"); charval = charval.Substring(1, charval.Length - 2); return(new CharvalExpression(this, charval)); }
private void PerformFor(string for_var_name, ParseTreeNode enter, ParseTreeNode action, ParseTreeNode statements) { int sum = action.FindTokenAndGetText() == "++" ? 1 : -1; while (true) { object exp = Scope.Solve(enter); if (exp == null || !(exp is bool) || !(bool)exp) { return; } DoStatements(statements); if (Signal == Signal.BREAK) { break; } Scope.AutoSum(for_var_name, sum); Signal = Signal.NORMAL; } Signal = Signal.NORMAL; }
internal static bool DrawAST(ParseTreeNode id) { if (id.ChildNodes.Count == 1) { string func_name = id.FindTokenAndGetText(); List <ScopeMember> functs = Program.Global.GetFunctions(func_name); if (functs.Count != 0) { foreach (var f in functs) { string fname = f.Name + f.GetHashCode(); ASTImageCreator imgCreator = new ASTImageCreator(f.Root, Program.ImagePath, fname, Function: true); Logger.AddImg(imgCreator.GetAsImage64()); } return(true); } else { Logger.AddError(id, "No existe ninguna función con ese nombre"); } } return(false); }
public override void Init(ParsingContext context, ParseTreeNode treeNode) { base.Init(context, treeNode); Node = treeNode; if (treeNode.ChildNodes.Count >= 2) { ParseTreeNode targetNode = treeNode.ChildNodes[0]; ParseTreeNode argumentsNode = treeNode.ChildNodes[1]; if (treeNode.ChildNodes.Count == 4) { RefrerenceElement = AddChild("Reference", treeNode.ChildNodes[0]); targetNode = treeNode.ChildNodes[2]; argumentsNode = treeNode.ChildNodes[3]; } TargetRef = AddChild("Target", targetNode); Arguments = AddChild("Args", argumentsNode); string text = ""; if (targetNode.Term.Name == "identifier") { text += targetNode.FindTokenAndGetText(); } else { text += TargetRef.AsString; } if (targetNode.Term.FlagIsSet(TermFlags.IsOperator)) { text += targetNode.Term.Name; } _targetName = text; AsString = "Call " + _targetName; } }
private static AggregationFunction ToAggregationFunction(ParseTreeNode node) { var text = node.FindTokenAndGetText().ToLower(); switch (text) { case "количество": case "count": return(AggregationFunction.Count); case "сумма": case "sum": return(AggregationFunction.Sum); case "минимум": case "min": return(AggregationFunction.Min); case "максимум": case "max": return(AggregationFunction.Max); case "среднее": case "avg": return(AggregationFunction.Avg); default: throw new InvalidOperationException(string.Format("Invalid aggregation function {0}", text)); } }
//----------------------------------------- public void CreateDefinedRulesList(ParseTreeNode node, List<string> rulenames) { foreach (var child in node.ChildNodes) CreateDefinedRulesList(child, rulenames); if (node.Term.Name == "newrulename") rulenames.Add(node.FindTokenAndGetText()); }
public static BaijiType BuildMapKeyType(ParseTreeNode mapKeyTypeNode) { var baseTypeKeyword = mapKeyTypeNode.FindTokenAndGetText(); var bType = ConvertBaseTypeKeywordToBaseType(baseTypeKeyword); var type = new BaseType(bType); return(type); }
// Build a variable reference (the "v" in "v = 1" void BuildVariableReference(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var e = new VariableReference(parentExpression, currentNode.FindToken().Convert()); e.Name = currentNode.FindTokenAndGetText(); e.ParentExpression = parentExpression; parentExpression.ChildExpressions.Add(e); }
public void CreateUsedRulesList(ParseTreeNode node, List <string> rulenames) { foreach (var child in node.ChildNodes) { CreateUsedRulesList(child, rulenames); } if (node.Term.Name == "rulename") { var rulename = node.FindTokenAndGetText(); if (rulenames.Find((fromList) => { return(fromList == rulename); }) == null) { rulenames.Add(node.FindTokenAndGetText()); } } }
private static TeLiteralNumber TranslateLiteralNumber(ParseTreeNode exprNode) { exprNode.Assert(TextExpressionDslParseNodeNames.LiteralNumber); var numberText = exprNode.FindTokenAndGetText(); return(new TeLiteralNumber(numberText)); }
private static TeLiteralString TranslateSqString(ParseTreeNode exprNode) { exprNode.Assert(TextExpressionDslParseNodeNames.SqString); return(new TeLiteralString( exprNode.FindTokenAndGetText().QuoteLiteralToValue() )); }
private static SqlBinaryOperator ToBinaryOperator(ParseTreeNode node) { var operatorText = node.FindTokenAndGetText().ToLower(); switch (operatorText) { case "and": case "и": return(SqlBinaryOperator.And); case "or": case "или": return(SqlBinaryOperator.Or); case "+": return(SqlBinaryOperator.Plus); case "-": return(SqlBinaryOperator.Minus); case "=": return(SqlBinaryOperator.Eq); case ">": return(SqlBinaryOperator.GreaterThan); case "<": return(SqlBinaryOperator.LessThan); case ">=": return(SqlBinaryOperator.GreaterThanOrEqual); case "<=": return(SqlBinaryOperator.LessThanOrEqual); case "like": case "подобно": return(SqlBinaryOperator.Like); case "<>": case "!=": return(SqlBinaryOperator.Neq); case "*": return(SqlBinaryOperator.Mult); case "/": return(SqlBinaryOperator.Div); case "%": return(SqlBinaryOperator.Remainder); default: throw new InvalidOperationException(string.Format("unexpected binary operator [{0}]", operatorText)); } }
public override void Init(AstContext context, ParseTreeNode treeNode) { base.Init(context, treeNode); //TODO: units conversion _Value = decimal.Parse(treeNode.FindTokenAndGetText(), CultureInfo.InvariantCulture); AsString = string.Format( CultureInfo.InvariantCulture, "{0:G}m", _Value ); }
//public string CreateNfaRules(ParseTreeNode node) //{ // string result = ""; // foreach (var child in node.ChildNodes) // result += CreateNfaRulePart(child); // foreach (var child in node.ChildNodes) // result += CreateNfaRule(child); // return result; //} //public string CreateNfaRule(ParseTreeNode node) //{ // string ruleName = node.FindTokenAndGetText(); // if (_partNumber.ContainsKey(ruleName)) // { // string parts = ""; // int number = _partNumber[ruleName]; // for (int i = 0; i <= number; i++) // { // if (parts != "") // parts += ", "; // parts += "Get" + ruleName.Replace('-', '_') + i + "(rulenames)"; // } // _partNumber.Remove(ruleName); // return "\t\tpublic State Get" + ruleName.Replace('-', '_') + "(List<string> rulenames)\r\n" + // "\t\t{\r\n" + // "\t\t\trulenames.Insert(0, \"" + node.FindTokenAndGetText() + "\");\r\n" + // "\t\t\tState rule = State.NoCloneAlternation(" + parts + ");\r\n" + // "\t\t\trule = OnMarkRule(rule, rulenames);\r\n" + // "\t\t\trulenames.RemoveAt(0);\r\n" + // "\t\t\treturn rule;\r\n" + // "\t\t}\r\n"; // } // return ""; //} //public string CreateNfaRulePart(ParseTreeNode node) //{ // ParseTreeNode elements = null; // foreach (var child in node.ChildNodes) // if (child.Term.Name == "elements") // elements = child; // var nodeName = node.FindTokenAndGetText(); // int number = 0; // if (_partNumber.ContainsKey(nodeName)) // number = _partNumber[nodeName] + 1; // _partNumber[nodeName] = number; // return "\t\tpublic State Get" + node.FindTokenAndGetText().Replace('-', '_') + number + "(List<string> rulenames)\r\n" + // "\t\t{\r\n" + // "\t\t\tState rule = " + CreateAlternation(elements.ChildNodes[0], true) + ";\r\n" + // "\t\t\treturn rule;\r\n" + // "\t\t}\r\n"; //} //public string CreateAlternation(ParseTreeNode node, bool change) //{ // int count = 0; // string result = ""; // foreach (var child in node.ChildNodes) // { // if (result != "") // result += ","; // //result += CreateConcatanation(child, change); // result += CreateSubstraction(child, change); // count++; // } // if (count > 1) // result = "State.NoCloneAlternation(" + result + ")"; // return result; //} //public string CreateSubstraction(ParseTreeNode node, bool change) //{ // List<string> items = new List<string>(); // foreach (var child in node.ChildNodes) // items.Add(CreateConcatanation(child, change)); // if (items.Count == 1) // return items[0]; // if (items.Count == 2) // return "State.Substract(" + items[0] + "," + items[1] + ")"; // throw new NotImplementedException(); // //return CreateConcatanation(node.FirstChild, change); //} //public string CreateConcatanation(ParseTreeNode node, bool change) //{ // List<string> items = new List<string>(); // foreach (var child in node.ChildNodes) // items.Add(CreateRepeation(child)); // string result = ""; // foreach (var item in items) // { // if (result != "") // result += ","; // result += item; // } // if (items.Count > 1) // { // if (change) // result = "State.NoCloneConcatanation(OnChangeConcatanation(rulenames," + result + "))"; // else // result = "State.NoCloneConcatanation(" + result + ")"; // } // return result; //} //public string CreateRepeation(ParseTreeNode node) //{ // if (node.ChildNodes[0].ChildNodes.Count == 0) // return CreateElement(node.ChildNodes[1]); // return CreateRepeat(node); //} //public string CreateRepeat(ParseTreeNode node) //{ // string repeatChar = "*"; // int repeat1 = -1, repeat2 = -1; // var repeat = node.ChildNodes[0].ChildNodes[0]; // if (repeat.ChildNodes.Count == 1) // { // repeat2 = repeat1 = int.Parse(repeat.ChildNodes[0].FindTokenAndGetText()); // } // else if (repeat.ChildNodes.Count >= 3) // { // if (repeat.ChildNodes[0].ChildNodes.Count != 0) // repeat1 = int.Parse(repeat.ChildNodes[0].FindTokenAndGetText()); // repeatChar = repeat.ChildNodes[1].FindTokenAndGetText(); // if (repeat.ChildNodes[2].ChildNodes.Count != 0) // repeat2 = int.Parse(repeat.ChildNodes[2].FindTokenAndGetText()); // } // string result = null; // if (repeatChar == "*") // { // result = "State.Repeat(" + repeat1 + "," + repeat2 + "," + CreateElement(node.ChildNodes[1]) + ")"; // } // else if (repeatChar == "#") // { // if (repeat2 != -1) // throw new NotImplementedException(); // result = "State.NoCloneRepeatBy(" + CreateElement(node.ChildNodes[1]) + ", GetCOMMA(rulenames))"; // if (repeat1 <= 0) // result = "State.NoCloneOption(" + result + ")"; // if (repeat1 > 1) // result = "State.Repeat(" + repeat1 + "," + repeat2 + "," + result + ")"; // } // else // throw new NotImplementedException(); // return result; //} //public string CreateElement(ParseTreeNode node) //{ // switch (node.ChildNodes[0].Term.Name) // { // case "rulename": // return "Get" + node.ChildNodes[0].FindTokenAndGetText().Replace('-', '_') + "(rulenames)"; // case "group": // return "(" + CreateAlternation(node.ChildNodes[0].ChildNodes[1], false) + ")"; // case "option": // return "State.NoCloneOption(" + CreateAlternation(node.ChildNodes[0].ChildNodes[1], false) + ")"; // case "numval": // return CreateNumval(node.ChildNodes[0]); // case "charval": // return CreateCharval(node.ChildNodes[0]); // case "func": // return CreateFunc(node.ChildNodes[0]); // } // throw new InvalidProgramException(); //} //public string CreateNumval(ParseTreeNode node) //{ // if (node.ChildNodes[1].FirstChild.Term.Name == "hexval") // { // var hexval = node.ChildNodes[1].FirstChild; // var hexdig1 = "0" + hexval.FirstChild.FindTokenAndGetText(); // if (hexval.ChildNodes.Count == 1) // return hexdig1; // var op = hexval.ChildNodes[1].FindTokenAndGetText(); // if (op == "-") // return "(" + hexdig1 + ".To(0x" + // hexval.ChildNodes[1].LastChild.FindTokenAndGetText() + "))"; // if (op == ".") // { // var hexvalpointstart = hexval.ChildNodes[1].FirstChild; // string arr = hexdig1 + ","; // foreach (var hexval1 in hexvalpointstart.ChildNodes) // arr += "0x" + hexval1.LastChild.FindTokenAndGetText() + ","; // return "(State)(new byte[] {" + arr + "})"; // } // return hexdig1; // } // throw new InvalidProgramException("Dec and Binary const not implemented"); //} //public string CreateCharval(ParseTreeNode node) //{ // return "FromString(" + node.FindTokenAndGetText().Replace("\\", "\\\\") + ",rulenames)"; //} //public string CreateFunc(ParseTreeNode node) //{ // string args = ""; // foreach (var funcarg in node.ChildNodes[3].ChildNodes) // { // if (args != "") // args += ","; // args += CreateAlternation(funcarg.ChildNodes[0], false); // } // return node.ChildNodes[1].FindTokenAndGetText() + "(" + args + ")"; //} //----------------------------------------- public void CreateDefinedRulesList(ParseTreeNode node, List <string> rulenames) { foreach (var child in node.ChildNodes) { CreateDefinedRulesList(child, rulenames); } if (node.Term.Name == "newrulename") { rulenames.Add(node.FindTokenAndGetText()); } }
public override void Init(AstContext context, ParseTreeNode treeNode) { base.Init(context, treeNode); //TODO: units conversion _Value=decimal.Parse(treeNode.FindTokenAndGetText(), CultureInfo.InvariantCulture); AsString=string.Format( CultureInfo.InvariantCulture, "{0:G}m", _Value ); }
private void BuildRuleExpressions(ParseTreeNode node) { var ruleName = node.FindTokenAndGetText(); var rule = rules.ContainsKey(ruleName) ? rules[ruleName] : rules[ruleName] = new AlternationExpression(); ParseTreeNode elements = null; foreach (var child in node.ChildNodes) if (child.Term.Name == "elements") elements = child; rule.Add( BuildAlternationExpression(elements.ChildNodes[0])); }
private static string GetNodeScript(ParseTreeNode node, int NodeId) { string script = ""; script += $"{NodeId} [label=\"{node.Term}"; string tokenText = node.FindTokenAndGetText(); if (!string.IsNullOrEmpty(tokenText) && node.ChildNodes.Count == 0) { script += $" [{tokenText}]"; } script += "\"];"; return(script); }
private object GetExpValue(ParseTreeNode node) { if (node == null) { return(null); } string curr_content = node.FindTokenAndGetText(); switch (node.Term.Name) { case "IDENTIFICADOR": return(GetVar(curr_content)?.Value); case "NUMERO": bool accepted = double.TryParse(curr_content, out double cont); return(accepted ? (object)cont : null); case "CADENA": return(curr_content.Replace("\"", "")); case "LOGICO_TRUE": return(true); case "LOGICO_FALSE": return(false); case "LLAMADA_FUNCION": return(Raise(node, this)); case "EXPRESION": case "OPERANDO": case "OPERACION": { int childCount = node.ChildNodes.Count; switch (childCount) { //Operando unico case 1: return(GetExpValue(node.ChildNodes[0])); //Operando unario (-, !) case 2: return(Resolve(node.ChildNodes[0].FindTokenAndGetText(), GetExpValue(node.ChildNodes[1]), node)); //Operando binario (+, -, *, /, %, ^, ~, >, <, >=, <=, ==, !=, &&, ||, |&) case 3: return(Resolve(GetExpValue(node.ChildNodes[0]), node.ChildNodes[1].FindTokenAndGetText(), GetExpValue(node.ChildNodes[2]), node)); } } break; } return(null); }
public string declaracionDeClase(ParseTreeNode nodo, List <ParseTreeNode> nodos, int i) { string salida = ""; var acceso = nodo.FindTokenAndGetText(); var palabraReservada = nodos[i + 3].FindTokenAndGetText(); var nombreClase = nodos[i + 4].FindTokenAndGetText(); if (this.lexicConfig.reservadas.Contains(nombreClase)) { salida = "El nombre de la clase [" + nombreClase + "] esta usando una palabra reservada \r\n" + getErrorLine(acceso + " " + palabraReservada + " " + nombreClase, "Estas usando como nombre de clase una palabra que pertenece " + " al lenguaje JAVA. Intenta cambiarla"); } return(salida); }
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode) { if (!parseNode.FindTokenAndGetText().StartsWith("$")) { parseNode.AstNode = new LiteralValueNode(); ((LiteralValueNode)parseNode.AstNode).Init(context, parseNode); return; } base.Init(context, parseNode); template = parseNode.Token.ValueString; tokenText = parseNode.Token.Text; templateSettings = parseNode.Term.AstConfig.Data as StringTemplateSettings; ParseSegments(context); AsString = "\"" + template + "\" (templated string)"; }
private static UnaryOperator ToUnaryOperator(ParseTreeNode node) { var text = node.FindTokenAndGetText().ToLower(); switch (text) { case "not": case "не": return(UnaryOperator.Not); case "-": return(UnaryOperator.Negation); default: throw new InvalidOperationException(string.Format("unexpected unary operator [{0}]", text)); } }
internal static void AddError(ParseTreeNode node, String message) { Token token = node.FindToken(); int line = 0; int col = 0; if (token != null) { line = token.Location.Line; col = token.Location.Column; } message = "[" + node.FindTokenAndGetText() + "] " + message; Logs?.Add(new LogMessage(ErrorLevel.Error, new SourceLocation(0, line, col), message, null)); }
// this is where data is initially passed to the item public override void Init(AstContext context, ParseTreeNode treeNode) { string sVal = treeNode.FindTokenAndGetText(); base.Init(context, treeNode); var nodes = treeNode.GetMappedChildNodes(); property = treeNode; if (nodes.Count > 1) { var child = AddChild("Queue", nodes[1]); string sval = nodes[1].FindTokenAndGetText(); if (child is LeftObjectNode) { _queue = (LeftObjectNode)child; } } }
private void BuildRuleExpressions(ParseTreeNode node) { var ruleName = node.FindTokenAndGetText(); var rule = rules.ContainsKey(ruleName) ? rules[ruleName] : rules[ruleName] = new AlternationExpression(); ParseTreeNode elements = null; foreach (var child in node.ChildNodes) { if (child.Term.Name == "elements") { elements = child; } } rule.Add( BuildAlternationExpression(elements.ChildNodes[0])); }
public string declaracionDeArreglo(ParseTreeNode nodo, List <ParseTreeNode> nodos, int i) { string salida = ""; var tipoArreglo = nodo.FindTokenAndGetText(); var corcheteA = nodos[i + 3].FindTokenAndGetText(); var corcheteC = nodos[i + 4].FindTokenAndGetText(); var identificador = nodos[i + 5].FindTokenAndGetText(); var igual = nodos[i + 6].FindTokenAndGetText(); var nuevo = nodos[i + 7].FindTokenAndGetText(); var tipoArregloAsignado = nodos[i + 8].FindTokenAndGetText(); var line = tipoArreglo + " " + corcheteA + " " + corcheteC + " " + identificador + " " + igual + " " + nuevo + " " + tipoArregloAsignado; if (tipoArreglo != tipoArregloAsignado) { salida = "El arreglo [" + identificador + "] no puede inicializarse con el tipo [" + tipoArregloAsignado + "] \r\n" + getErrorLine(line, "El arreglo se esta incializando con diferente tipo"); } return(salida); }
/// <summary> /// Compare two parse tree nodes and return true only if the contents of the whole trees match /// </summary> /// <param name="node1"></param> /// <param name="node2"></param> /// <returns></returns> public static bool IsSameParseTreeNode(this ParseTreeNode node1, ParseTreeNode node2) { var stack1 = new Stack <ParseTreeNode>(); var stack2 = new Stack <ParseTreeNode>(); stack1.Push(node1); stack2.Push(node2); while (stack1.Count > 0) { node1 = stack1.Pop(); node2 = stack2.Pop(); if (ReferenceEquals(node1, null) || ReferenceEquals(node2, null)) { return(false); } if (ReferenceEquals(node1, node2)) { return(true); } if (node1.ChildNodes.Count != node2.ChildNodes.Count) { return(false); } if (node1.FindTokenAndGetText() != node2.FindTokenAndGetText()) { return(false); } for (var i = 0; i < node1.ChildNodes.Count; i++) { stack1.Push(node1.ChildNodes[i]); stack2.Push(node2.ChildNodes[i]); } } return(true); }
/// <summary> /// /// </summary> /// <param name="node"></param> private void FlowConditionalStatements(ParseTreeNode node) { bool first = true; int index = 0; for (int i = 0; i < node.ChildNodes.Count; i++) { if (first) { _cSharpCode.Add(node.FindTokenAndGetText() + "("); index = _cSharpCode.Count - 1; first = false; } else { foreach (var item in node.ChildNodes[i].ChildNodes) { ChildrenNodesRetrevial(item, ref index); } } } }
private static DatePart ToDatePart(ParseTreeNode node) { var text = node.FindTokenAndGetText().ToLower(); switch (text) { case "год": case "year": return(DatePart.Year); case "квартал": case "quarter": return(DatePart.Quarter); case "месяц": case "month": return(DatePart.Month); case "неделя": case "week": return(DatePart.Week); case "день": case "day": return(DatePart.Day); case "час": case "hour": return(DatePart.Hour); case "минута": case "minute": return(DatePart.Minute); default: throw new InvalidOperationException("Unexpected date part literal " + node); } }
ConstantExpressionAst BuildDecimalIntegerLiteralAst(ParseTreeNode parseTreeNode) { VerifyTerm(parseTreeNode, this._grammar.decimal_integer_literal); var matches = Regex.Match(parseTreeNode.FindTokenAndGetText(), this._grammar.decimal_integer_literal.Pattern, RegexOptions.IgnoreCase); string digits = matches.Groups[this._grammar.decimal_digits.Name].Value; string typeSuffix = matches.Groups[this._grammar.numeric_type_suffix.Name].Value; string longTypeSuffix = matches.Groups[this._grammar.long_type_suffix.Name].Value; string multiplier = matches.Groups[this._grammar.numeric_multiplier.Name].Value; // The type of an integer literal is determined by its value, the presence or absence of long-type-suffix, and the // presence of a numeric-multiplier (§2.3.5.1.3). object value; if (typeSuffix == string.Empty) { // For an integer literal with no long-type-suffix // • If its value can be represented by type int (§4.2.3), that is its type; // • Otherwise, if its value can be represented by type long (§4.2.3), that is its type. if (!ParseIntOrLongLiteral(digits, multiplier, NumberStyles.Integer, out value)) { decimal decimalValue; double doubleValue; if (decimal.TryParse(digits, out decimalValue)) // • Otherwise, if its value can be represented by type decimal (§2.3.5.1.2), that is its type. value = NumericMultiplier.Multiply(decimalValue, multiplier); else if (double.TryParse(digits, out doubleValue)) // • Otherwise, it is represented by type double (§2.3.5.1.2). value = NumericMultiplier.Multiply(doubleValue, multiplier); else // For PowerShell compatibility throw an error here instead of saturating the double to infinity. throw new OverflowException(string.Format("The integer literal {0} is too large.", matches.Value)); } } else if (longTypeSuffix != string.Empty) { // For an integer literal with long-type-suffix long longValue; // • If its value can be represented by type long (§4.2.3), that is its type; if (long.TryParse(digits, out longValue)) value = NumericMultiplier.Multiply(longValue, multiplier); else // • Otherwise, that literal is ill formed. throw new ArithmeticException(string.Format("The integer literal {0} is invalid because it does not fit into a long.", matches.Value)); } else { // The spec doesn't explicitly mention this case, but it seems to be handled // similar to a long suffix. decimal decimalValue; if (decimal.TryParse(digits, out decimalValue)) value = NumericMultiplier.Multiply(decimalValue, multiplier); else throw new ArithmeticException(string.Format("The integer literal {0} is invalid because it does not fit into a decimal.", matches.Value)); } return new ConstantExpressionAst(new ScriptExtent(parseTreeNode), value); }
ConstantExpressionAst BuildHexadecimalIntegerLiteralAst(ParseTreeNode parseTreeNode) { VerifyTerm(parseTreeNode, this._grammar.hexadecimal_integer_literal); var matches = Regex.Match(parseTreeNode.FindTokenAndGetText(), this._grammar.hexadecimal_integer_literal.Pattern, RegexOptions.IgnoreCase); string value = matches.Groups[this._grammar.hexadecimal_digits.Name].Value; return new ConstantExpressionAst(new ScriptExtent(parseTreeNode), Convert.ToInt32(value, 16)); }
ConstantExpressionAst BuildHexadecimalIntegerLiteralAst(ParseTreeNode parseTreeNode) { VerifyTerm(parseTreeNode, this._grammar.hexadecimal_integer_literal); var matches = Regex.Match(parseTreeNode.FindTokenAndGetText(), this._grammar.hexadecimal_integer_literal.Pattern, RegexOptions.IgnoreCase); string digits = matches.Groups[this._grammar.hexadecimal_digits.Name].Value; string multiplier = matches.Groups[this._grammar.numeric_multiplier.Name].Value; object value; // Hex literals can only be int or long. if (!ParseIntOrLongLiteral(digits, multiplier, NumberStyles.AllowHexSpecifier, out value)) throw new OverflowException(string.Format("The integer literal {0} is too large.", matches.Value)); return new ConstantExpressionAst(new ScriptExtent(parseTreeNode), value); }
private IExpression BuildCharvalExpression(ParseTreeNode node) { var charval = node.FindTokenAndGetText();//.Replace("\\", "\\\\"); charval = charval.Substring(1, charval.Length - 2); return new CharvalExpression(this, charval); }
public string CreateCharval(ParseTreeNode node) { return "FromString(" + node.FindTokenAndGetText().Replace("\\", "\\\\") + ",rulenames)"; }
StringConstantExpressionAst BuildVerbatimStringLiteralAst(ParseTreeNode parseTreeNode) { VerifyTerm(parseTreeNode, this._grammar.verbatim_string_literal); var matches = Regex.Match(parseTreeNode.FindTokenAndGetText(), this._grammar.verbatim_string_literal.Pattern, RegexOptions.IgnoreCase); string value = matches.Groups[this._grammar.verbatim_string_characters.Name].Value; return new StringConstantExpressionAst(new ScriptExtent(parseTreeNode), value, StringConstantType.SingleQuoted); }
ConstantExpressionAst BuildDecimalIntegerLiteralAst(ParseTreeNode parseTreeNode) { VerifyTerm(parseTreeNode, this._grammar.decimal_integer_literal); var matches = Regex.Match(parseTreeNode.FindTokenAndGetText(), this._grammar.decimal_integer_literal.Pattern, RegexOptions.IgnoreCase); string digits = matches.Groups[this._grammar.decimal_digits.Name].Value; string typeSuffix = matches.Groups[this._grammar.numeric_type_suffix.Name].Value; string longTypeSuffix = matches.Groups[this._grammar.long_type_suffix.Name].Value; string multiplier = matches.Groups[this._grammar.numeric_multiplier.Name].Value; // The type of an integer literal is determined by its value, the presence or absence of long-type-suffix, and the // presence of a numeric-multiplier (§2.3.5.1.3). object value; if (typeSuffix == string.Empty) { // For an integer literal with no long-type-suffix int intValue; long longValue; decimal decimalValue; double doubleValue; // Note: TryParse will only ever return false here if the conversion overflows because // all other conditions are impossible when the supplied string consists only of digits. if (int.TryParse(digits, out intValue)) // • If its value can be represented by type int (§4.2.3), that is its type; value = NumericMultiplier.Multiply(intValue, multiplier); else if (long.TryParse(digits, out longValue)) // • Otherwise, if its value can be represented by type long (§4.2.3), that is its type. value = NumericMultiplier.Multiply(longValue, multiplier); else if (decimal.TryParse(digits, out decimalValue)) // • Otherwise, if its value can be represented by type decimal (§2.3.5.1.2), that is its type. value = decimalValue; else if (double.TryParse(digits, out doubleValue)) // • Otherwise, it is represented by type double (§2.3.5.1.2). value = doubleValue; else // For PowerShell compatibility throw an error here instead of saturating the double to infinity. throw new OverflowException(string.Format("The integer literal {0} is too large.", matches.Value)); } else if (longTypeSuffix != string.Empty) { // For an integer literal with long-type-suffix long longValue; // • If its value can be represented by type long (§4.2.3), that is its type; if (long.TryParse(digits, out longValue)) value = NumericMultiplier.Multiply(longValue, multiplier); else // • Otherwise, that literal is ill formed. throw new ArithmeticException(string.Format("The integer literal {0} is invalid because it does not fit into a long.", matches.Value)); } else { throw new NotImplementedException("Decimal type suffix not yet implemented"); } return new ConstantExpressionAst(new ScriptExtent(parseTreeNode), value); }
ConstantExpressionAst BuildHexadecimalIntegerLiteralAst(ParseTreeNode parseTreeNode) { VerifyTerm(parseTreeNode, this._grammar.hexadecimal_integer_literal); var matches = Regex.Match(parseTreeNode.FindTokenAndGetText(), this._grammar.hexadecimal_integer_literal.Pattern, RegexOptions.IgnoreCase); string digits = matches.Groups[this._grammar.hexadecimal_digits.Name].Value; string multiplier = matches.Groups[this._grammar.numeric_multiplier.Name].Value; object value = NumericMultiplier.Multiply(Convert.ToInt32(digits, 16), multiplier); return new ConstantExpressionAst(new ScriptExtent(parseTreeNode), value); }
/// <summary> /// /// </summary> /// <param name="node"></param> private void FlowConditionalStatements(ParseTreeNode node) { bool first = true; int index = 0; for (int i = 0; i < node.ChildNodes.Count; i++) { if (first) { _cSharpCode.Add(node.FindTokenAndGetText() + "("); index = _cSharpCode.Count - 1; first = false; } else { foreach (var item in node.ChildNodes[i].ChildNodes) { ChildrenNodesRetrevial(item, ref index); } } } }
public string CreateNfaRulePart(ParseTreeNode node) { ParseTreeNode elements = null; foreach (var child in node.ChildNodes) if (child.Term.Name == "elements") elements = child; var nodeName = node.FindTokenAndGetText(); int number = 0; if (_partNumber.ContainsKey(nodeName)) number = _partNumber[nodeName] + 1; _partNumber[nodeName] = number; return "\t\tpublic State Get" + node.FindTokenAndGetText().Replace('-', '_') + number + "(List<string> rulenames)\r\n" + "\t\t{\r\n" + "\t\t\tState rule = " + CreateAlternation(elements.ChildNodes[0], true) + ";\r\n" + "\t\t\treturn rule;\r\n" + "\t\t}\r\n"; }
private ConstantExpressionAst BuildDoubleRealLiteralAst(ParseTreeNode parseTreeNode, Group multiplier) { string digits = parseTreeNode.FindTokenAndGetText(); if (multiplier.Success) { digits = RemoveMatchedString(digits, multiplier); } double value; if (!double.TryParse(digits, NumberStyles.AllowExponent | NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out value)) { throw new OverflowException(string.Format("The real literal {0} is too large.", digits)); } if (multiplier.Success) { value *= NumericMultiplier.GetValue(multiplier.Value); } return new ConstantExpressionAst(new ScriptExtent(parseTreeNode), value); }
// Build a variable reference (the "v" in "v = 1" void BuildVariableReference(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var e = new VariableReference(parentExpression, currentNode.FindToken().Convert()); e.Name = currentNode.FindTokenAndGetText(); e.ParentExpression = parentExpression; parentExpression.ChildExpressions.Add(e); }
private static string GetParseTreeNodeText(ParseTreeNode parseTreeNode) { if (parseTreeNode == null) { return string.Empty; } // We cannot use FindTokenAndGetText always because it will give us only the text of the root node in // case of complex expressions. So we have to do that: if (parseTreeNode.ChildNodes.Count > 0) { var result = new StringBuilder(); foreach (var node in parseTreeNode.ChildNodes) { int offset = node.Span.Location.Position - parseTreeNode.Span.Location.Position; if (result.Length < offset) { result.Append(' ', offset - result.Length); } result.Append(GetParseTreeNodeText(node)); } return result.ToString(); } return parseTreeNode.FindTokenAndGetText() ?? string.Empty; }
public override void Init(AstContext context, ParseTreeNode parseNode) { Operator = parseNode.FindTokenAndGetText(); }
public string Translate(ParseTreeNode node) { string res = null; switch (Type) { case Types.AsIs: res = Convert.ToString(node.FindTokenAndGetText()); break; case Types.AsIsTitleCase: res = ToTitleCase(Convert.ToString(node.FindTokenAndGetText())); break; case Types.ConstantReplacement: res = ConstantReplacement; break; case Types.DictionaryReplacement: string replacement; ReplacementDict.TryGetValue(node.FindTokenAndGetText(),out replacement); res = replacement; break; case Types.CustomFunction: res = Convert.ToString(TranslateFunction.Invoke(node)); break; } if (res == null) return res; //add space if necessary var terminal = node.Term as Terminal; if (terminal == null) return res; if (terminal.SkipsWhitespaceAfter)res += " "; return res; }
private object ProcessNode(ParseTreeNode node, string fxName) { object result = null; switch (node.Term.Name) { case "function_expression": fxName = node.ChildNodes[0].FindTokenAndGetText().TrimStart('@'); var fxParams = (List<object>)ProcessNode(node.ChildNodes[1], fxName); var args = new TextFunctionPipelineArgs() { FunctionName = fxName, Args = fxParams.ToArray(), CustomFunctionHandlers = _fxCustomHandlers }; if (_fxHandlerLookup.ContainsKey(fxName)) { var fx = _fxHandlerLookup[fxName]; fx.ProcessFunction(args); } else { // Send to the ProcessTextFunction pipeline.... CorePipeline.Run("ProcessTextFunction", args); // Save reference to the handling processor... if (args.FunctionHandled && args.HandledBy != null) _fxHandlerLookup.Add(fxName, args.HandledBy); } if (args.FunctionHandled) result = args.Result; else result = "'@" + fxName + "' function is not recognized."; break; case "argument_list_par": case "argument_list_opt": if (node.ChildNodes.Count == 0) return new List<object>(); else result = ProcessNode(node.FirstChild, fxName); break; case "argument_list": var parameters = new List<object>(); foreach (var p in node.ChildNodes) { var pValue = ProcessNode(p, fxName); if (pValue != null) parameters.Add(pValue); } result = parameters; break; case "bin_op_expression": var b_operand1 = ProcessNode(node.ChildNodes[0], fxName); var b_operand2 = ProcessNode(node.ChildNodes[2], fxName); var b_op = node.ChildNodes[1].FindTokenAndGetText(); result = EvaluateOperation(b_operand1, b_op, b_operand2); break; case "parenthesized_expression": result = ProcessNode(node.ChildNodes[0], fxName); break; case "unary_expression": var u_op = node.FindTokenAndGetText(); var u_operand = ProcessNode(node.ChildNodes[1], fxName); result = EvaluateUnaryOperation(u_op, u_operand); break; case "StringLiteral": // Remove the surrounding quotes (") var s = node.FindTokenAndGetText(); s = ResolveExpressionVariables(s); // resolve embedded field variables result = s.Length > 2 ? s.Substring(1, s.Length - 2) : string.Empty; break; case "guid_variable": result = _variables[node.FindTokenAndGetText()]; break; case "Number": var n = node.FindTokenAndGetText(); if (n.Contains(".")) result = decimal.Parse(n); else result = int.Parse(n); break; case "true": case "True": result = true; break; case "false": case "False": result = false; break; case "null": result = null; break; default: throw new Exception(string.Format("Unhandled argument type: [{0}][{1}]", node.Term.Name, node.FindTokenAndGetText())); } return result; }
ConstantExpressionAst BuildRealLiteralAst(ParseTreeNode parseTreeNode) { VerifyTerm(parseTreeNode, this._grammar.real_literal); var matches = Regex.Match(parseTreeNode.FindTokenAndGetText(), this._grammar.real_literal.Pattern, RegexOptions.IgnoreCase); Group multiplier = matches.Groups[this._grammar.numeric_multiplier.Name]; Group decimalTypeSuffix = matches.Groups[this._grammar.decimal_type_suffix.Name]; if (decimalTypeSuffix.Success) { return BuildDecimalRealLiteralAst(parseTreeNode, multiplier, decimalTypeSuffix); } return BuildDoubleRealLiteralAst(parseTreeNode, multiplier); }
public override void Init(AstContext context, ParseTreeNode parseNode) { Value = Php54Utils.StringToInteger(parseNode.FindTokenAndGetText()); }
TokenKind SelectTokenKind(ParseTreeNode parseTreeNode) { if (!(parseTreeNode.Term is Terminal)) throw new InvalidOperationException(parseTreeNode.ToString()); var text = parseTreeNode.FindTokenAndGetText(); switch (text) { case "=": return TokenKind.Equals; case "+=": return TokenKind.PlusEquals; case "-=": return TokenKind.MinusEquals; case "*=": return TokenKind.MultiplyEquals; case "/=": return TokenKind.DivideEquals; case "%=": return TokenKind.RemainderEquals; default: throw new NotImplementedException(parseTreeNode.ToString()); } }
public static string GetMessage(ParseTreeNode node, string message) { return string.Format(@"ParseTreeNode: {0}, Error: {1}", node.FindTokenAndGetText(), message); }
private ConstantExpressionAst BuildDecimalRealLiteralAst(ParseTreeNode parseTreeNode, Group multiplier, Group decimalTypeSuffix) { string digits = parseTreeNode.FindTokenAndGetText(); if (multiplier.Success) { digits = RemoveMatchedString(digits, multiplier); } digits = RemoveMatchedString(digits, decimalTypeSuffix); decimal value; if (!decimal.TryParse(digits, NumberStyles.AllowExponent | NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out value)) { throw new OverflowException(string.Format("Bad numeric constant: {0}.", parseTreeNode.FindTokenAndGetText())); } if (multiplier.Success) { value *= NumericMultiplier.GetValue(multiplier.Value); } return new ConstantExpressionAst(new ScriptExtent(parseTreeNode), value); }
public void CreateUsedRulesList(ParseTreeNode node, List<string> rulenames) { foreach (var child in node.ChildNodes) CreateUsedRulesList(child, rulenames); if (node.Term.Name == "rulename") { var rulename = node.FindTokenAndGetText(); if (rulenames.Find((fromList) => { return fromList == rulename; }) == null) rulenames.Add(node.FindTokenAndGetText()); } }
ExpressionAst BuildExpandableStringLiteralAst(ParseTreeNode parseTreeNode) { var matches = Regex.Match(parseTreeNode.FindTokenAndGetText(), this._grammar.expandable_string_literal.Pattern, RegexOptions.IgnoreCase); string value = matches.Groups[this._grammar.expandable_string_characters.Name].Value + matches.Groups[this._grammar.dollars.Name].Value ; var ast = new ExpandableStringExpressionAst(new ScriptExtent(parseTreeNode), value, StringConstantType.DoubleQuoted); if (ast.NestedExpressions.Any()) { return ast; } return new StringConstantExpressionAst(new ScriptExtent(parseTreeNode), value, StringConstantType.DoubleQuoted); }
public override void Init(AstContext context, ParseTreeNode parseNode) { var StringWithQuotes = parseNode.FindTokenAndGetText(); UnquotedString = Php54Utils.FullStringUnquote(StringWithQuotes); Interpolate = (StringWithQuotes[0] == '"'); }
private static T FindTokenAndGetValue <T>(this ParseTreeNode node) { try { return(node.FindToken().ValueString.As <T>()); } catch { throw node.GetException($"Invalid token '{node.FindTokenAndGetText()}'. Expected a token of type {typeof(T)}"); } }
/// <summary> /// /// </summary> /// <param name="node"></param> /// <param name="index"></param> /// private void ChildrenNodesRetrevial(ParseTreeNode node, ref int index) { if (node.ChildNodes.Count > 0) { foreach (var item in node.ChildNodes) { ChildrenNodesRetrevial(item, ref index); } } else if (node.FindTokenAndGetText() != null) { _cSharpCode[index] = _cSharpCode[index] + node.FindTokenAndGetText() + " "; } }