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