/// <summary> /// accessor: accessor_name '[' accessor_key ']'; /// </summary> /// <param name="node"></param> /// <param name="element"></param> /// <returns></returns> private INode Accessor(PegNode node, Element element) { var ident = node.GetAsString(Src); var key = node.next_.GetAsString(Src).Replace("'", ""); var el = element.NearestAs<Element>(ident); if (el!=null) { var prop = el.GetAs<Property>(key); if (((INode)prop) != null) return prop.Value; } return new Anonymous(""); }
public static void PegNodeToXmlRecurse(PegNode pn, string text, XmlWriter xml) { var name = pn.id_ > 0 ? Enum.GetName(typeof (EUPnPContentDirectorySearch), pn.id_) : "Node"; xml.WriteStartElement(name); xml.WriteAttributeString("match", pn.GetAsString(text)); if (pn.child_ != null) { PegNodeToXmlRecurse(pn.child_, text, xml); } xml.WriteEndElement(); if (pn.next_ != null) { PegNodeToXmlRecurse(pn.next_, text, xml); } }
public override string TreeNodeToString(PegNode node) { string label = base.TreeNodeToString(node); if (node.id_ == (int)ESpecialNodes.eAnonymousNode) { string value = node.GetAsString(src_); if (value.Length < 32) label += " <" + value + ">"; else label += " <" + value.Substring(0, 29) + "...>"; } return label; }
void SetLimit(PegNode limitNode, ref int limit, ref string limitInto) { switch (limitNode.id_) { case (int)EPegGrammar.numeric_limit: limit = Int32.Parse(limitNode.GetAsString(src_)); return; case (int)EPegGrammar.into_variable: limitInto = limitNode.GetAsString(src_); return; default: Debug.Assert(false); return; } }
internal static double Eval(PegNode node, string src, TextWriter errOut) { switch ((Ecalc0_tree)node.id_) { case Ecalc0_tree.Calc: { double res=0; for (node = node.child_; node != null; node = node.next_) { res = Eval(node, src, errOut); } Console.WriteLine("-->{0}<--", res); return res; } case Ecalc0_tree.Assign: { double res = Eval(node.child_.next_, src, errOut); string ident = node.child_.GetAsString(src); variables[ident] = res; Console.WriteLine("{0}={1}", ident, res); return res; } case Ecalc0_tree.Sum: case Ecalc0_tree.Prod: { double res = Eval(node.child_,src,errOut); for (PegNode op = node.child_.next_; op != null; op = node.next_) { node = op.next_; switch (op.GetAsString(src)) { case "+": res += Eval(node, src, errOut); break; case "-": res -= Eval(node, src, errOut); break; case "*": res *= Eval(node, src, errOut); break; case "/": res /= Eval(node, src, errOut); break; default: Debug.Assert(false); break; } } return res; } case Ecalc0_tree.Number: { double res; double.TryParse(node.GetAsString(src),out res); return res; } case Ecalc0_tree.Call: { double res = Eval(node.child_.next_, src, errOut); string operation=node.child_.GetAsString(src).ToLower(); switch (operation) { case "sin": return Math.Sin(res); case "cos": return Math.Cos(res); case "tan": return Math.Tan(res); case "sqrt": return Math.Sqrt(res); case "abs": return Math.Abs(res); case "acos": return Math.Acos(res); case "asin": return Math.Asin(res); case "atan": return Math.Atan(res); case "ceiling": return Math.Ceiling(res); case "cosh": return Math.Cosh(res); case "exp": return Math.Exp(res); case "floor":return Math.Floor(res); case "log": return Math.Log10(res); case "sinh": return Math.Sinh(res); case "tanh": return Math.Tanh(res); default: errOut.WriteLine( "ERROR from CALCOTreeEval: function '{0}' not supported", operation); return 0; } } case Ecalc0_tree.ident: { string ident = node.GetAsString(src); if (variables.ContainsKey(ident)) return variables[ident]; else return 0; } case (Ecalc0_tree)ESpecialNodes.eAnonymousNode: { if( node.GetAsString(src)=="print" ) { foreach(var v in variables) { Console.WriteLine("{0,-20}{1}",v.Key,v.Value); } } return 0; } } return 0; }
/// <summary> /// variable: '@' [-_a-zA-Z0-9]+; /// </summary> /// <param name="node"></param> /// <returns></returns> private INode Variable(PegNode node) { return new Variable(node.GetAsString(Src)); }
void LinkToGenericParam(PegNode n) { Debug.Assert(n.id_ == (int)EPegGrammar.rule_ref); string refName = n.GetAsString(normalizeTree_.c_.src_); PegNode genericParam = FindGenericParam(refName); if (genericParam != null) { PegNode genericCall = new NormalizeTree.GenericCall(genericParam, n); PUtils.ReplaceNode(n, genericCall); } }
/// <summary> /// expressions: operation_expressions / space_delimited_expressions / [-a-zA-Z0-9_%*/.&=:,#+? \[\]()]+ ; /// </summary> /// <param name="node"></param> /// <param name="elementBlock"></param> /// <returns></returns> private IEnumerable<INode> Expressions(PegNode node, ElementBlock elementBlock) { // Expression switch (node.id_.ToEnLess()) { case EnLess.operation_expressions: return OperationExpressions(node.child_, elementBlock).ToList(); case EnLess.space_delimited_expressions: return SpaceDelimitedExpressions(node.child_, elementBlock).ToList(); default: if (node.child_ == null) //CatchAll return new List<INode> { new Anonymous(node.GetAsString(Src)) }; return Expressions(node.child_, elementBlock); } }
/// <summary> /// number: '-'? [0-9]* '.' [0-9]+ / '-'? [0-9]+; /// </summary> /// <param name="node"></param> /// <returns></returns> private INode Number(PegNode node) { var val = float.Parse(node.GetAsString(Src), NumberFormatInfo.InvariantInfo); var unit = ""; node = node.next_; if (node != null && node.id_.ToEnLess() == EnLess.unit) unit = node.GetAsString(Src); return new Number(unit, val); }
/// <summary> /// import : ws '@import' S import_url medias? s ';' ; /// </summary> /// <param name="node"></param> /// <param name="element"></param> private void Import(PegNode node, Element element) { var path = node.GetAsString(Src); if(node.child_ != null){ path = node.child_.GetAsString(Src); } path = path.Replace("\"", "").Replace("'", ""); //TODO: F**k around with pah to make it absolute relative if(HttpContext.Current!=null) { path = HttpContext.Current.Server.MapPath(path); } if(File.Exists(path)) { var engine = new Engine(File.ReadAllText(path), null); element.Rules.AddRange(engine.Parse().Root.Rules); } }
/// <summary> /// keyword: [-a-zA-Z]+ !ns; /// </summary> /// <param name="node"></param> /// <param name="element"></param> /// <returns></returns> private INode Keyword(PegNode node, Element element) { return new Keyword(node.GetAsString(Src)); }
/// <summary> /// fonts : font (s ',' s font)+ ; /// </summary> /// <param name="node"></param> /// <param name="element"></param> /// <returns></returns> private INode Fonts(PegNode node, Element element) { var fonts = new List<Literal>(); while (node!=null) { if (node.child_ != null) fonts.Add(new String(node.child_.GetAsString(Src))); else fonts.Add(new Keyword(node.GetAsString(Src))); node = node.next_; } return new FontFamily(fonts.ToArray()); }
/// <summary> /// function: function_name arguments ; /// </summary> /// <param name="node"></param> /// <param name="element"></param> /// <returns></returns> private INode Function(PegNode node, Element element) { var funcName = node.GetAsString(Src); var arguments = Arguments(node.next_, element); return new Function(funcName, arguments); }
/// <summary> /// declaration: standard_declaration / catchall_declaration ; /// </summary> /// <param name="node"></param> /// <param name="element"></param> private void Declaration(PegNode node, Element element) { if (node.id_.ToEnLess() == EnLess.standard_declaration) { node = node.child_; var name = node.GetAsString(Src).Replace(" ", ""); if (name.Substring(0, 1) == "@") { var property = new Variable(name, Expressions(node.next_, element)); element.Add(property); } else { var property = new Property(name, Expressions(node.next_, element)); element.Add(property); } } else if (node.id_.ToEnLess() == EnLess.catchall_declaration) { /* node = node.child_; var name = node.GetAsString(Src).Replace(" ", ""); element.Add(new Property(name));*/ //TODO: Should I be doing something here? } }
void LinkSemanticFunctions(PegNode n) { Debug.Assert(n.id_ == (int)EPegGrammar.rule_ref); string semanticFunction = n.GetAsString(normalizeTree_.c_.src_); if (normalizeTree_.setRules_.Contains(semanticFunction)) return; //was a rule reference PegNode method; bool isLocal; PegNode semBlock = normalizeTree_.FindSemanticBlock(FindSemanticFunctionInTree, semanticFunction, n, out method, out isLocal); if (semBlock != null) { var semanticFuncWithContext = new NormalizeTree.SemanticVarOrFuncWithContext((int)EPegGeneratorNodes.SemanticFunctionWithContext, semBlock, method, n, isLocal); normalizeTree_.c_.semanticInfoNodes_.Add(method); PUtils.ReplaceNode(n, semanticFuncWithContext); } else { normalizeTree_.c_.errOut_.WriteLine(normalizeTree_.c_.sErrorPrefix + "ERROR: no rule found and no semantic function <" + semanticFunction + "> found in semantic block candidates"); normalizeTree_.bOk_ = false; } }
bool FindSemanticFunctionInTree(PegNode n, string semanticFunction, ref PegNode memberName) { if (n == null) return false; if (n.id_ == (int)EPegGrammar.member_name && n.parent_.id_ == (int)EPegGrammar.sem_func_header) { string thisMemberName = n.GetAsString(normalizeTree_.c_.src_); Debug.Assert(thisMemberName.Length > 0); if ( thisMemberName == semanticFunction || thisMemberName[0] == '@' && thisMemberName.Substring(1) == semanticFunction) { memberName = n; return true; } } return FindSemanticFunctionInTree(n.child_, semanticFunction, ref memberName) || FindSemanticFunctionInTree(n.next_, semanticFunction, ref memberName); }
/// <summary> /// declaration: standard_declaration / catchall_declaration ; /// </summary> /// <param name="node"></param> /// <param name="elementBlock"></param> private void Declaration(PegNode node, ElementBlock elementBlock) { var name = node.GetAsString(Src).Replace(" ", ""); var nextNode = node.next_; if(nextNode == null){ // TODO: emit warning: empty declaration // return; } if (nextNode.ToEnLess() == EnLess.comment) nextNode = nextNode.next_; var values = Expressions(nextNode, elementBlock); var property = name.StartsWith("@") ? new Variable(name, values) : new Property(name, values); elementBlock.Add(property); }
/// <summary> /// operation_expressions: expression (operator expression)+; /// </summary> /// <param name="node"></param> /// <param name="element"></param> /// <returns></returns> private IList<INode> OperationExpressions(PegNode node, Element element) { var lessNodes = new List<INode> {Expression(node.child_, element)}; node = node.next_; //Tail while (node != null) { switch (node.id_.ToEnLess()) { case EnLess.@operator: lessNodes.Add(new Operator(node.GetAsString(Src))); break; case EnLess.expression: lessNodes.Add(Expression(node.child_, element)); break; } node = node.next_; } return lessNodes; }
/// <summary> /// entity : function / fonts / accessor / keyword / variable / literal ; /// </summary> /// <param name="node"></param> /// <param name="elementBlock"></param> /// <returns></returns> private INode Entity(PegNode node, ElementBlock elementBlock) { switch (node.id_.ToEnLess()) { case EnLess.literal: return Entity(node.child_, elementBlock); case EnLess.number: return Number(node); case EnLess.color: return Color(node); case EnLess.variable: return Variable(node); case EnLess.accessor: return Accessor(node.child_, elementBlock); case EnLess.fonts: return Fonts(node); case EnLess.keyword: return Keyword(node); case EnLess.function: return Function(node, elementBlock); case EnLess.cursors: return Cursors(node); default: return new Anonymous(node.GetAsString(Src)); } }
/// <summary> /// selector : (s select element s)+ arguments? ; /// </summary> /// <param name="node"></param> /// <returns></returns> private IList<Element> Selector(PegNode node) { var elements = new List<Element>(); while (node != null) { if (node.id_.ToEnLess() != EnLess.select) throw new ParsingException("Selectors must be something"); { var selector = node.GetAsString(Src).Replace(" ", ""); node = node.next_; var name = node.GetAsString(Src); elements.Add(new Element(name, selector)); } node = node.next_; } return elements; }
/// <summary> /// keyword: [-a-zA-Z]+ !ns; /// </summary> /// <param name="node"></param> /// <returns></returns> private INode Keyword(PegNode node) { return new Keyword(node.GetAsString(Src)); }
bool FindIntoVariableInTree(PegNode n, string intoVariable, ref PegNode variable) { if (n == null) return false; if (n.id_ == (int)EPegGrammar.variable) { string varName = n.GetAsString(c_.src_); Debug.Assert(varName.Length > 0); if ( varName == intoVariable || varName[0] == '@' && varName.Substring(1) == intoVariable) { variable = n; return true; } } return FindIntoVariableInTree(n.child_, intoVariable, ref variable) || FindIntoVariableInTree(n.next_, intoVariable, ref variable); }
/// <summary> /// operation_expressions: expression (operator expression)+; /// </summary> /// <param name="node"></param> /// <param name="elementBlock"></param> /// <returns></returns> private IEnumerable<INode> OperationExpressions(PegNode node, ElementBlock elementBlock) { yield return Expression(node.child_, elementBlock); node = node.next_; //Tail while (node != null) { switch (node.id_.ToEnLess()) { case EnLess.@operator: yield return new Operator(node.GetAsString(Src), elementBlock); break; case EnLess.expression: yield return Expression(node.child_, elementBlock); break; case EnLess.comment: node.ToString(); break; } node = node.next_; } }
/// <summary> /// arguments : '(' s argument s (',' s argument s)* ')'; /// </summary> /// <param name="node"></param> /// <param name="element"></param> /// <returns></returns> private IList<INode> Arguments(PegNode node, Element element) { var args = new List<INode>(); while (node != null) { switch (node.id_.ToEnLess()) { case EnLess.color: args.Add(Color(node, element)); break; case EnLess.number: args.Add(Number(node, element)); break; case EnLess.@string: args.Add(new String(node.GetAsString(Src))); break; case EnLess.keyword: args.Add(new Keyword(node.GetAsString(Src))); break; default: args.Add(new Anonymous(node.GetAsString(Src))); break; } node = node.next_; } return args; }
public Token(PegNode peg, string src) { _src = src; PegNode = peg; TokenType = (EnLess)Enum.Parse(typeof(EnLess), PegNode.id_.ToString()); Text = PegNode.GetAsString(src); Start = peg.match_.posBeg_; End = peg.match_.posEnd_-1; }
void LinkIntoVariables(PegNode n) { Debug.Assert(n.id_ == (int)EPegGrammar.into_variable); string intoVariable = n.GetAsString(c_.src_); PegNode variable; bool isLocal; PegNode semBlock = FindSemanticBlock(FindIntoVariableInTree, intoVariable, n, out variable, out isLocal); if (semBlock != null) { var intoVarWithContext = new NormalizeTree.SemanticVarOrFuncWithContext((int)EPegGeneratorNodes.IntoVarWithContext, semBlock, variable, n, isLocal); c_.semanticInfoNodes_.Add(variable); PUtils.ReplaceNode(n, intoVarWithContext); Debug.Assert(intoVarWithContext.parent_ != null); if (intoVarWithContext.parent_.id_ == (int)EPegGrammar.lower_limit && intoVarWithContext.parent_.parent_.id_ == (int)EPegGrammar.repetition_range) { var r = intoVarWithContext.parent_.parent_ as PegGrammarParser.TRange; Debug.Assert(r != null); r.lowerIntoVar = intoVarWithContext; } else if (intoVarWithContext.parent_.id_ == (int)EPegGrammar.upper_limit && intoVarWithContext.parent_.parent_.id_ == (int)EPegGrammar.repetition_range) { var r = intoVarWithContext.parent_.parent_ as PegGrammarParser.TRange; Debug.Assert(r != null); r.upperIntoVar = intoVarWithContext; } } else { c_.errOut_.WriteLine(c_.sErrorPrefix + "ERROR: into variable <" + intoVariable + "> not found in semantic block candidates"); bOk_ = false; } }