private string GenerateFunction(DefStatement defStatement)
{
var oldNameSpace = _currentNameSpace;
_currentNameSpace = defStatement;
var bodystatements = new StringBuilder();
bodystatements.Append($"push ebp\nmov ebp, esp\nsub esp, {defStatement.VarCounter * 4}\n");
foreach (var statement in defStatement.GetChildren())
{
//Console.WriteLine(statement.GetType() + statement.Row.ToString() + ':' + statement.Column.ToString());
bodystatements.Append(GenerateCode(statement));
bodystatements.Append('\n');
}
bodystatements.Append($"add esp, {defStatement.VarCounter * 4}\nmov esp, ebp\npop ebp\n");
bodystatements.Append($"ret {defStatement.Args.Count * 4}\n");
_currentNameSpace = oldNameSpace;
_functionProtoNames.Add(string.Format(ProtoTemplate, defStatement.Name));
_functions.Add(string.Format(ProcTemplate, defStatement.Name, bodystatements.ToString()));
return("\n");
}
public override void BeforeVisit(DefStatement node)
{
base.BeforeVisit(node);
var initializers = (from varDef in node.VariableDefs
where varDef.InitializerExpression != null
select varDef.Symbol.GetSetExpression(ExpressionAnalyzer.Analyze(_analysisContext, varDef.InitializerExpression))).ToList();
_result = initializers.Count > 0 ? (Expression)Expression.Block(initializers) : Expression.Constant(null);
}
private void CompileDefStmt(DefStatement stmt, Scope scope)
{
scope = new Scope {
Out = scope, LocalTable = new LocalTable(), Self = stmt, Line = 0
};
var instructionSet = new InstructionSet();
instructionSet.SetLabel($"{InstructionType.LabelDef}:{stmt.Name.Value}");
for (int i = 0; i < stmt.Parameters.Count; i++)
{
scope.LocalTable.SetLCL(stmt.Parameters[i].Value, scope.LocalTable.Depth);
}
CompileBlockStatement(instructionSet, stmt.BlockStatement, scope, scope.LocalTable);
EndInstructions(instructionSet);
InstructionSets.Add(instructionSet);
}
public object GetMethod(StoneObject self, int index)
{
DefStatement defStatement = this.MethodDefinitions[index];
return(new Function(defStatement.Parameters, defStatement.Body, this.Environment, defStatement.Size, self));
}
public void AddFunction(DefStatement f)
{
FuncList.Add(f);
}
private DefStatement ParseDefMethodStatement()
{
var stmt = new DefStatement {
Token = CurToken
};
NextToken();
switch (CurToken.Type)
{
case TokenType.Ident:
if (PeekTokenIs(TokenType.Dot))
{
stmt.Receiver = new Identifier {
Token = CurToken, Value = CurToken.Literal
};
NextToken();
if (!ExpectPeek(TokenType.Ident))
{
return(null);
}
stmt.Name = new Identifier {
Token = CurToken, Value = CurToken.Literal
};
}
else
{
stmt.Name = new Identifier {
Token = CurToken, Value = CurToken.Literal
};
}
break;
case TokenType.Self:
stmt.Receiver = new SelfExpression {
Token = CurToken
};
NextToken();
if (ExpectPeek(TokenType.Ident))
{
return(null);
}
stmt.Name = new Identifier {
Token = CurToken, Value = CurToken.Literal
};
break;
default:
return(null);
}
if (PeekTokenIs(TokenType.Assign))
{
stmt.Name.Value = stmt.Name.Value + "=";
NextToken();
}
if (PeekTokenAtSameLine())
{
if (!ExpectPeek(TokenType.LParen))
{
return(null);
}
stmt.Parameters = ParseParameters();
}
else
{
stmt.Parameters = new List <Identifier>();
}
stmt.BlockStatement = ParseBlockStatement();
return(stmt);
}
