private SJumpStatement ParseJumpStatement(Queue <PMatchedData> matchedData) { var currTokens = matchedData.Dequeue().GetTokens(); SJumpStatement result; if (currTokens[0].TokenType == PTokenType.Return) { if (currTokens.Length > 1) { var returnExpression = new SExpression(GetText(currTokens, 1, currTokens.Length - 1)); result = new SJumpStatement(returnExpression, ParseStatement(matchedData)); } else { result = new SJumpStatement("return", ParseStatement(matchedData)); } result.Visible = false; _returnJumps.Add(result); } else { result = new SJumpStatement(GetText(currTokens, 0, currTokens.Length - 1), ParseStatement(matchedData)); if (currTokens[0].TokenType == PTokenType.Goto) { foreach (var statement in _labels) { if (statement.CodeString == result.TargetIdentifier) { result.SetTargetStatement(statement); return(result); } } _gotoJumps.Add(result); } else if (currTokens[0].TokenType == PTokenType.Break) { _breakJumps.Add(result); } else if (currTokens[0].TokenType == PTokenType.Continue) { _continueJumps.Add(result); } else { throw new ArgumentException("matchedData does not represent a valid jump statement!", nameof(matchedData)); } } result.Visible = false; return(result); }
public SExpression GetSExpression() { SExpression result = new SExpression(); result.Name = Name; result.Items = new List <SNodeBase>(); result.Items.Add(fp_polygon.GetPointList(Polygon)); return(result); }
public void CommaToken() { SExpression size = new SExpression(SExpression.FormatType.Size); SExpression under = size.AddChild(new SExpression(SExpression.FormatType.Under)); under.AddChild(new SString("bad,arg")); under.AddChild(new SString("test")); size.AddChild(new SString(",")); size.AddChild(new SString("test2")); Parser.parse(size); }
Serialisable Value() { var a = Conjunct(); while (lxr.tok == Sym.AND) { Next(); a = new SExpression(a, SExpression.Op.And, Conjunct()); } return(a); }
Serialisable Conjunct() { var a = Item(); while (lxr.tok == Sym.OR) { Next(); a = new SExpression(a, SExpression.Op.Or, Item()); } return(a); }
public void isEmptyTest() { SExpression root = new SExpression(SExpression.FormatType.Document); Assert.IsTrue(root.isEmpty()); SExpression statement = root.AddChild(new SExpression(SExpression.FormatType.Statement)); Assert.IsFalse(root.isEmpty()); Assert.IsTrue(statement.isEmpty()); }
private void CloseExpression(int x, int y) { if (current == root) { throw new Exception(string.Format("Too many close parenthesis characters ')' at line {0} column {1} ", y, x)); } current.xEndPos = x; current.yEndPos = y; current.type = current.NumberOfChildren > 0 ? SexType.Compound : SexType.Null; current = current.parent; }
public override SExpression GetSExpression() { SExpression result = new SExpression(); result.Name = "fp_poly"; result.Items = new List <SNodeBase>(); result.Items.Add(GetPointList(Polygon)); result.Items.Add(new SExpression("layer", layer)); result.Items.Add(new SExpression("width", width)); return(result); }
public void SaveToFile(string filename) { //filename = Path.ChangeExtension(filename, "kicad_mod"); if (!filename.EndsWith(".kicad_mod")) { filename = filename + ".kicad_mod"; } SExpression RootNode = GetSExpression(false); RootNode.WriteToFile(filename); }
// e.g (layers F.Cu F.Paste F.Mask) public void ParseLayers(SNodeBase node) { Layers.Clear(); if ((node is SExpression) && ((node as SExpression).Name == "layers")) { SExpression expr = node as SExpression; foreach (SNodeAtom atom in expr.Items) { AddLayer(atom.Value); } } }
public SExpression GetSExpression() { SExpression result; result = new SExpression("net", new List <SNodeBase>() { new SNodeAtom(Number), new SNodeAtom(Name) }); return(result); }
public void CommaFirst() { SExpression size = new SExpression(SExpression.FormatType.Size); size.AddChild(new SString(",")); SExpression under = size.AddChild(new SExpression(SExpression.FormatType.Under)); under.AddChild(new SString("test1")); under.AddChild(new SString("test2")); size.AddChild(new SString(",")); size.AddChild(new SString("test3")); Parser.parse(size); }
public static fp_text Parse(SNodeBase node) { fp_text result = new fp_text(); if ((node is SExpression) && ((node as SExpression).Name == "fp_text")) { SExpression expr = node as SExpression; result.Type = (expr.Items[0] as SNodeAtom).Value; result.Value = (expr.Items[1] as SNodeAtom).Value; int index = 2; while (index < expr.Items.Count) { if (expr.Items[index] is SExpression) { SExpression sub = expr.Items[index] as SExpression; if (sub.Name == "at") { result.position = Position.Parse(sub); } else if (sub.Name == "effects") { result.effects = TextEffects.Parse(sub); } else if (sub.Name == "layer") { result.layer = Layer.ParseLayer(sub); } } else { SNodeAtom atom = expr.Items[index] as SNodeAtom; if (atom.Value == "hide") { result.visible = false; } } index++; } return(result); } else { return(null); // error } }
public SExpression GetSexpression() { SExpression result = new SExpression(); result.Name = "lib"; result.Items = new List <SNodeBase>(); result.Items.Add(new SExpression("name", Name)); result.Items.Add(new SExpression("type", Type)); result.Items.Add(new SExpression("uri", Uri)); result.Items.Add(new SExpression("options", Options)); result.Items.Add(new SExpression("descr", Description)); return(result); }
private static SExpression EvalList(Lambda lambda, SExpression tail, Context ctx) { var scope = lambda.Context.Push(); SExpression args = lambda.Head; while (args is List) { scope.Store((args as List).Head as Name, EvalExpr((tail as List).Head, ctx)); args = (args as List).Tail; tail = (tail as List).Tail; } scope.Store(args as Name, EvalExpr(tail, ctx)); return(EvalExpr(lambda.Tail, scope)); }
private async Task <SData> EvalExpressionAsync(SExpression exp, Dictionary <string, SData> variables) { SData result = null; switch (exp.ExpType) { case SExpressionType.Value: result = await ConvertToSDataAsync(exp.Value, exp.ReturnType); break; case SExpressionType.Var: if (!variables.TryGetValue(exp.Var, out var variable)) { throw new EvalException($"Variable {exp.Var} is not found in parameters."); } result = variable; break; case SExpressionType.Func: var method = typeof(SFunctions).GetMethod(exp.FuncName); if (method == null) { throw new EvalException($"{exp.FuncName} is not a valid function name."); } var args = new List <SData>(); foreach (var argExp in exp.FuncArgs) { args.Add(await EvalExpressionAsync(argExp, variables)); } try { result = (SData)method.Invoke(null, args.ToArray <object>()); } catch (Exception e) { throw new EvalException($"Eval error when invoking function {exp.FuncName}.", e); } break; } return(await Task.FromResult(result)); }
public bool SaveToFile(string Filename) { RootNode = new SExpression(); RootNode.Name = "fp_lib_table"; RootNode.Items = new List <SNodeBase>(); foreach (LibEntry lib in Entries) { RootNode.Items.Add(lib.GetSexpression()); } // RootNode.WriteToFile(Filename); return(true); }
public static SExpression GetPointList(List <PointF> polygon) { SExpression result = new SExpression(); result.Name = "pts"; result.Items = new List <SNodeBase>(); // close poly? foreach (PointF p in polygon) { result.Items.Add(new SExpression("xy", new List <SNodeBase> { new SNodeAtom(p.X), new SNodeAtom(p.Y) })); } return(result); }
Serialisable Term() { if (lxr.tok == Sym.MINUS || lxr.tok == Sym.PLUS || lxr.tok == Sym.NOT) { var op = SExpression.Op.Plus; switch (lxr.tok) { case Sym.MINUS: op = SExpression.Op.UMinus; break; case Sym.NOT: op = SExpression.Op.Not; break; case Sym.PLUS: Next(); return(Term()); } Next(); return(new SExpression(Term(), op, Serialisable.Null)); } var a = Factor(); while (lxr.tok == Sym.TIMES || lxr.tok == Sym.DIVIDE) { SExpression.Op op = SExpression.Op.And; switch (lxr.tok) { case Sym.TIMES: op = SExpression.Op.Times; break; case Sym.DIVIDE: op = SExpression.Op.Divide; break; } Next(); a = new SExpression(a, op, Factor()); } if (lxr.tok == Sym.IS) { Next(); Mustbe(Sym.NULL); return(new SExpression(a, SExpression.Op.Eql, Serialisable.Null)); } if (lxr.tok == Sym.IN) { Next(); return(new SInPredicate(a, Value())); } return(a); }
public static LibEntry Parse(SExpression root_node) { LibEntry result = null; if (root_node.Name == "lib") { result = new LibEntry(); int index = 0; // while (index < root_node.Items.Count) { SNodeBase node = root_node.Items[index]; SExpression sub = node as SExpression; switch (sub.Name) { case "name": result.Name = sub.GetString(); break; case "type": result.Type = sub.GetString(); break; case "uri": result.Uri = sub.GetString(); break; case "options": result.Options = sub.GetString(); break; case "descr": result.Description = sub.GetString(); break; } index++; } return(result); } else { return(null); // error } }
public SExpression GetSExpression() { SExpression result = new SExpression(); result.Name = "layers"; result.Items = new List <SNodeBase>(); string[] temp = ToString().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); //foreach (LayerDescriptor desc in Layers) foreach (string s in temp) { result.Items.Add(new SNodeAtom(s)); } return(result); }
public override IDatum Evaluate(Vector list, ScopedEnvironment env) { if (list.Length < 1) { throw new ArgumentException("MACRO is missing arguments."); } // lambda evaluated SExpression exp = Evaluator.Eval(list[0], env) as SExpression; Func <Vector, ScopedEnvironment, IDatum> func = (largs, lenv) => { //var arglist = largs.CDR(); // since macro just wraps a lambda, but since lambda always // evaluates it's arguments before invoking it's body expression, // we want to wrap the parameters in [quote]'s so that we // end with the same original arguments var data = new List <IDatum>(); //data.Add(largs[0]); for (var i = 0; i < largs.Length; i++) { var quoted = new List <IDatum>(); quoted.Add(new Symbol("quote")); quoted.Add(largs[i]); data.Add(new Vector(quoted.ToArray())); } var expand = new Vector(data.ToArray()); // evaluate lambda with [quote]d args. // the result should be some code. // 'expansion' should use the env from when // the macro was declared. This is because // expansion of macros shouldn't depend // on where they are expanded, such as in // nested lambda's. var result = exp.Evaluate(expand, env); // we then want to evaluate the returned code. // evaluate with the most recent environment return(Evaluator.Eval(result, lenv)); }; return(new SExpression(func)); }
public static Module LoadFromFile(string filename) { //TODO SExpression RootNode = new SExpression(); RootNode.LoadFromFile(filename); if ((RootNode != null) && (RootNode.Name == "module")) { return(Parse(RootNode)); } else { // error("Expected 'module'"); return(null); } }
Serialisable OneVal() { Serialisable a = Term(); while (lxr.tok == Sym.PLUS || lxr.tok == Sym.MINUS) { SExpression.Op op = SExpression.Op.Or; switch (lxr.tok) { case Sym.PLUS: op = SExpression.Op.Plus; break; case Sym.MINUS: op = SExpression.Op.Minus; break; } Next(); a = new SExpression(a, op, Term()); } return(a); }
public override SExpression GetSExpression() { SExpression result = new SExpression(); result.Name = "fp_line"; result.Items = new List <SNodeBase>(); result.Items.Add(new SExpression("start", new List <SNodeBase> { new SNodeAtom(start.X), new SNodeAtom(start.Y) })); result.Items.Add(new SExpression("end", new List <SNodeBase> { new SNodeAtom(end.X), new SNodeAtom(end.Y) })); result.Items.Add(new SExpression("layer", layer)); result.Items.Add(new SExpression("width", width)); return(result); }
public static fp_arc Parse(SExpression sexpr) { fp_arc result = new fp_arc(); if (sexpr.Name == "fp_arc") { foreach (SNodeBase sub in sexpr.Items) { if (sub is SExpression) { SExpression node = sub as SExpression; switch (node.Name) { case "start": result.start = node.GetPointF(); break; case "end": result.end = node.GetPointF(); break; case "angle": result.angle = node.GetFloat(); break; case "layer": result.layer = Layer.ParseLayer(node); break; case "width": result.width = node.GetFloat(); break; } } } return(result); } else { return(null); // error } }
private SLabeledStatement ParseLabeledStatement(Queue <PMatchedData> matchedData) { var currTokens = matchedData.Dequeue().GetTokens(); var labelName = currTokens[0].TokenCode; SExpression caseExpression = null; var labeled = ParseStatement(matchedData); if (labelName == "case") { caseExpression = new SExpression(GetText(currTokens, 1, currTokens.Length - 1)); } if (labeled == null) { throw new InvalidOperationException("error: label at end of compound statement!"); } var result = new SLabeledStatement(labelName, caseExpression, labeled); if (labelName == "case" || labelName == "default") { _caseLabels.Add(result); } else { int i; for (i = 0; i < _gotoJumps.Count; i++) { if (_gotoJumps[i].TargetIdentifier == labelName) { _gotoJumps[i].SetTargetStatement(result); _gotoJumps.RemoveAt(i); return(result); } } _labels.Add(result); } return(result); }
private SSwitchStatement ParseSwitchStatement(Queue <PMatchedData> matchedData) { var currTokens = matchedData.Dequeue().GetTokens(); int i; if (currTokens[0].TokenType != PTokenType.Switch) { throw new ArgumentException("matchedData should start with a switch statement!", nameof(matchedData)); } var conditionExpression = new SExpression(GetText(currTokens, 2, currTokens.Length - 1)); var switchCases = new List <SLabeledStatement>(); var switchStatement = ParseStatement(matchedData); var nextStatement = switchStatement.NextStatement; for (i = 0; i < _caseLabels.Count; i++) { if (switchStatement.Contains(_caseLabels[i])) { _caseLabels[i].Visible = false; switchCases.Add(_caseLabels[i]); _caseLabels.RemoveAt(i); i--; } } var result = new SSwitchStatement(conditionExpression, switchStatement, switchCases.ToArray(), nextStatement); for (i = 0; i < _breakJumps.Count; i++) { if (switchStatement.Contains(_breakJumps[i])) { _breakJumps[i].Visible = false; _breakJumps[i].SetTargetStatement(result.NextStatement as SLabeledStatement); _breakJumps.RemoveAt(i); i--; } } return(result); }
public static LibrarySpec Parse(SExpression root_node) { LibrarySpec result = new LibrarySpec(); foreach (SExpression node in root_node.Items) { switch (node.Name) { case "logical": result.Name = node.GetValue(); break; case "uri": result.Uri = node.GetValue(); break; } } return(result); }
public SExpression GetSExpression() { SExpression result = new SExpression(); result.Name = "dimension"; result.Items = new List <SNodeBase>(); result.Items.Add(new SNodeAtom(length)); result.Items.Add(new SExpression("width", width)); result.Items.Add(new SExpression("layer", layer)); // text result.Items.Add(caption.GetSExpression()); foreach (DimensionFeature feature in Features) { result.Items.Add(feature.GetSExpression()); } return(result); }