/// <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;
}
}
