/// <summary>
/// Parse the specified context
/// evaluation is method
/// expr->func （formula）->cmp->add(sub)->mul(div)->app->facter
/// </summary>
/// <param name="ctx">ParserContext.</param>
/// <returns></returns>
public static SExpr Parse(ParseContext context)
{
SExpr expr = NewMethod(context);
context.ReadToken(TokenType.EOF);
return(expr);
}
public List <Instruction> PutFromReg(RegVRef src)
{
var code = new List <Instruction>();
FieldSRef addr = this.addr as FieldSRef;
if (addr == null)
{
if (this.addr.IsConstant())
{
addr = FieldSRef.Imm1();
}
else
{
addr = FieldSRef.ScratchInt();
code.AddRange(this.addr.FetchToField(addr));
}
}
code.Add(new Instruction
{
opcode = Opcode.MemWrite,
op1 = addr,
op2 = src,
imm1 = this.addr.IsConstant() ? this.addr : null,
});
return(code);
}
public static LispLiteral InterpreteSExpr(Context context, SExpr sExpr)
{
if (sExpr.Head is SymbolLiteral id)
{
if (context.Get(id.Value) is LispRuntimeFunction runtimeFunction)
{
return(Call(runtimeFunction, sExpr, context));
}
}
if (sExpr.Head is LispRuntimeFunction function)
{
return(Call(function, sExpr, context));
}
if (sExpr.Head is SExpr subExpr && sExpr.MoreThanOne())
{
var evaluatedSubExpr = InterpreteSExpr(context, subExpr);
var t = new SExpr(evaluatedSubExpr, sExpr.Tail.ToArray());
return(InterpreteSExpr(context, t));
}
// if (sExpr.Head is SExpr single && sExpr.Single())
// {
// return InterpreteSExpr(context, single);
// }
return(sExpr);
}
public List <Instruction> FetchToReg(RegVRef dest)
{
var code = new List <Instruction>();
FieldSRef addr = this.addr.AsDirectField();
if (addr == null)
{
if (this.addr.IsConstant())
{
addr = FieldSRef.Imm1();
}
else
{
addr = FieldSRef.ScratchInt();
code.AddRange(this.addr.FetchToField(addr));
}
}
code.Add(new Instruction
{
opcode = Opcode.MemRead,
op1 = addr,
dest = dest,
imm1 = this.addr.IsConstant() ? this.addr : null,
idx = this.addr.frame(),
});
return(code);
}
public _Function(SExpr sexp, TypeReference argumentType,
TypeReference resultType)
: base(sexp)
{
ArgumentType = argumentType;
ResultType = resultType;
}
public _Generic(SExpr sexp, Expression._Symbol typeName,
StrictList<TypeReference> typeParams)
: base(sexp)
{
TypeName = typeName;
TypeParams = typeParams;
}
public static LispLiteral Call(LispRuntimeFunction runtimeFunction, SExpr sexpr,
Context context)
{
var args = sexpr.Tail;
var result = runtimeFunction.Apply(context, args.ToArray());
return(result);
}
public static LispLiteral CONTEXT(Context context, params LispLiteral[] args)
{
SExpr c = new SExpr();
foreach (var ctx in context.Scope)
{
c.Add(new SymbolLiteral(ctx.Key));
}
return(c);
}
public void CdrTest()
{
var r = Test(@"(cdr (""a"" ""b"" ""c"" ))");
Assert.IsInstanceOf <SExpr>(r);
SExpr lst = r as SExpr;
Assert.AreEqual(2, lst.Elements.Count);
Assert.AreEqual("b", (lst.Elements[0] as StringLiteral).Value);
Assert.AreEqual("c", (lst.Elements[1] as StringLiteral).Value);
}
public Exchange(RegVRef source, RegVRef dest, PointerIndex frame, SExpr addr)
{
if (addr.AsDirectField() == null && !addr.IsConstant())
{
throw new ArgumentException("must be register field or constant", "addr");
}
this.source = source;
this.dest = dest;
this.frame = frame;
this.addr = addr;
}
public void TestLispInLisp()
{
string lispLisp = File.ReadAllText("lisp.lisp");
var r = Test(lispLisp);
Assert.IsInstanceOf <SExpr>(r);
SExpr result = r as SExpr;
Assert.AreEqual(2, result.Count);
Assert.AreEqual(13, result.Head.IntValue);
Assert.AreEqual(14, result.Tail.First().IntValue);
}
public void TestAssoc()
{
string assocLisp = File.ReadAllText("assoc.lisp");
var r = Test(assocLisp);
Assert.IsInstanceOf <SExpr>(r);
SExpr result = r as SExpr;
Assert.AreEqual(3, result.Count);
Assert.AreEqual(3, result.Head.IntValue);
Assert.AreEqual(4, result.Tail.First().IntValue);
Assert.AreEqual(5, result.Tail.Last().IntValue);
}
public void ConsTest()
{
var r = Test(@"(cons ""x"" (""a"" ""b"" ""c"" ))");
Assert.IsInstanceOf <SExpr>(r);
SExpr lst = r as SExpr;
Assert.AreEqual(4, lst.Elements.Count);
Assert.AreEqual(new List <string>()
{
"x", "a", "b", "c"
}, lst.Elements.Select(x => (x as StringLiteral).Value).ToList());
}
public void SetCdrTest()
{
var r = Test(@"
(set 'variable (""a"" ""b"" ""c"" ))
(cdr variable)
");
Assert.IsInstanceOf <SExpr>(r);
SExpr lst = r as SExpr;
Assert.AreEqual(2, lst.Elements.Count);
Assert.AreEqual(new List <string>()
{
"b", "c"
}, lst.Elements.Select(x => (x as StringLiteral).Value).ToList());
}
public static Expression Set(SExpr sexp, _Symbol variable, Expression value)
{
return new _Set (sexp, variable, value);
}
public static Expression Symbol(SExpr.Symbol symbol)
{
return new _Symbol (symbol);
}
public _Lambda(SExpr sexp, StrictList<VariableDefinition> parameters, Expression functionBody)
: base(sexp)
{
Parameters = parameters;
FunctionBody = functionBody;
}
public _If(SExpr sexp, Expression condition, Expression thenExpression,
Expression elseExpression)
: base(sexp)
{
Condition = condition;
ThenExpression = thenExpression;
ElseExpression = elseExpression;
}
public _Literal(SExpr.Literal literal)
: base(literal)
{
Literal = literal;
}
public ArithSExpr(SExpr S1, ArithSpec Op, SExpr S2)
{
this.S1 = S1;
this.Op = Op;
this.S2 = S2;
}
public HitRect(RectangleF rect, SExpr sexp)
{
Rect = rect;
SExp = sexp;
}
public TableItem(string fieldname, SExpr value)
{
this.fieldname = fieldname;
this.value = value;
}
public _Set(SExpr sexp, _Symbol variable, Expression value)
: base(sexp)
{
Variable = variable;
Value = value;
}
public _Symbol(SExpr.Symbol symbol)
: base(symbol)
{
Symbol = symbol;
}
public static Expression If(SExpr sexp, Expression condition, Expression thenExpression,
Expression elseExpression)
{
return new _If (sexp, condition, thenExpression, elseExpression);
}
public _Quoted(SExpr sexp, Expression quotedExpression)
: base(sexp)
{
QuotedExpression = quotedExpression;
}
public static Expression Application(SExpr sexp, Expression function,
StrictList<Expression> parameters)
{
return new _Application (sexp, function, parameters);
}
public VariableDefinition(SExpr sexp, Expression._Symbol name, TypeReference type)
: base(sexp)
{
Name = name;
Type = type;
}
public Expression(SExpr sexp)
: base(sexp)
{
}
public _Depiction(SExpr sexp)
{
SExpr = sexp;
}
public _Let(SExpr sexp, VariableDefinition variable, Expression value, Expression body)
: base(sexp)
{
Variable = variable;
Value = value;
Body = body;
}
public TableItem(char c, SExpr value)
{
this.fieldname = Program.CurrentProgram.charmap[c];
this.value = value;
}
public _LetRec(SExpr sexp, StrictList<Tuple<VariableDefinition, Expression>> definitions,
Expression body)
: base(sexp)
{
Definitions = definitions;
Body = body;
}
public bool IsPong(SExpr sx)
{
return sx != null && sx.Name == ":name";
}
public static TypeReference Function(SExpr sexp, TypeReference argumentType,
TypeReference resultType)
{
return new _Function (sexp, argumentType, resultType);
}
public ArithVSExpr(VExpr V1, ArithSpec Op, SExpr S2)
{
this.V1 = V1;
this.Op = Op;
this.S2 = S2;
}
public Return(SExpr sret)
{
sreturn = sret;
}
/// <summary>
/// Create a visual for a symbol S-expression.
/// </summary>
public static Visual Symbol(SExpr sexp)
{
return Label (((SExpr.Symbol)sexp).Name);
}
public MemVRef(SExpr addr, string datatype = null)
{
this.addr = addr;
this.datatype = datatype;
}
public Exchange(RegVRef reg, PointerIndex frame, SExpr addr) : this(reg, reg, frame, addr)
{
}
public static Expression Quoted(SExpr sexp, Expression quotedExpression)
{
return new _Quoted (sexp, quotedExpression);
}
public static Expression Lambda(SExpr sexp, StrictList<VariableDefinition> parameters,
Expression functionBody)
{
return new _Lambda (sexp, parameters, functionBody);
}
public _Application(SExpr sexp, Expression function,
StrictList<Expression> parameters)
: base(sexp)
{
Function = function;
Parameters = parameters;
}
public TypeReference(SExpr sexp)
: base(sexp)
{
}
public static Expression Let(SExpr sexp, VariableDefinition variable, Expression value,
Expression body)
{
return new _Let (sexp, variable, value, body);
}
public static TypeReference Generic(SExpr sexp, Expression._Symbol typeName,
StrictList<TypeReference> typeParams)
{
return new _Generic (sexp, typeName, typeParams);
}
public static Expression LetRec(SExpr sexp, StrictList<Tuple<VariableDefinition, Expression>> definitions,
Expression body)
{
return new _LetRec (sexp, definitions, body);
}
public static Expression Literal(SExpr.Literal literal)
{
return new _Literal (literal);
}
/// <summary>
/// Parse an S-expression and generate the AST.
/// </summary>
public static Expression Parse(SExpr sexp)
{
return SExprParser.Expr ().Parse (Input.FromSExpr (sexp));
}
public bool IsPong(SExpr sx)
{
return(sx != null && sx.Name == ":name");
}
} //TODO: Maybe sometimes loaded?
public ArrayVRef(string arrname, SExpr offset)
{
this.arrname = arrname;
this.offset = offset;
}
