protected override void DoGenerate(CilEmitter emitter)
{
ILabel whileLabel = emitter.GenerateLabel();
logicalExpr.EmitRValue(emitter);
after.EmitJumpIfFalse();
whileLabel.Emit();
statement.Generate(emitter, whileLabel, begin);
begin.EmitJump();
/*
*
* logicalExpression.jumping(0, after)
*
* create label
*
* emit label
*
* stmt.Gen(label, begin)
*
* emit goto begin
*
*/
}
public ControlFlowDesigner(ILGenerator ilGenerator)
{
_ilEmitter = new CilEmitter(ilGenerator);
IntoBranch = false;
_endBranchLabel = _ilEmitter.DefineLabel();
}
public ArrayDesigner(CilEmitter ilEmitter, Type elementType, int elementsCount)
{
_ilEmitter = ilEmitter;
_ilEmitter
.Emit(OpCodes.Ldc_I4, elementsCount)
.Emit(OpCodes.Newarr, elementType);
}
protected override void DoGenerate(CilEmitter emitter)
{
callExpr.EmitRValue(emitter);
if (callExpr.ReturnType != typeof(void))
{
emitter.EmitPop();
}
}
public override void EmitRValue(CilEmitter emitter)
{
expression.EmitRValue(emitter);
emitter.EmitUnaryOp("-");
throw new NotImplementedException();
}
public override void EmitRValue(CilEmitter emitter)
{
foreach (Expression param in parameters)
{
param.EmitRValue(emitter); // Make sure the parameters are on the stack.
}
symbol.Function.EmitCall();
}
protected override void DoGenerate(CilEmitter emitter)
{
expression.EmitRValue(emitter);
if (expression.ReturnType != typeof(void))
{
emitter.EmitPop();
}
}
protected override void DoGenerate(CilEmitter emitter)
{
printInt.Function = emitter.GetWriteFunction(typeof(int));
printFloat.Function = emitter.GetWriteFunction(typeof(float));
printChar.Function = emitter.GetWriteFunction(typeof(char));
printBool.Function = emitter.GetWriteFunction(typeof(bool));
scanF.Function = emitter.GetReadLineFunction();
}
public override void EmitRValue(CilEmitter emitter)
{
if (symbol.Variable == null)
{
Error("Use of undeclared variable");
}
symbol.Variable.EmitValue();
}
protected override void DoGenerate(CilEmitter emitter)
{
valueExpr.EmitRValue(emitter);
if (valueExpr.ReturnType == typeof(string))
{
emitter.EmitParse(variableUseExpr.ReturnType);
}
variableUseExpr.EmitAssignment();
}
public override void EmitRValue(CilEmitter emitter)
{
valueExpr.EmitRValue(emitter);
if (valueExpr.ReturnType == typeof(string))
{
emitter.EmitParse(variableUseExpr.ReturnType);
}
variableUseExpr.EmitAssignment();
variableUseExpr.EmitRValue(emitter);
}
protected override void DoGenerate(CilEmitter emitter)
{
ILabel doEnd = emitter.GenerateLabel();
statement.Generate(emitter, begin, doEnd);
doEnd.Emit();
logicalExpr.EmitRValue(emitter);
begin.EmitJumpIfTrue();
}
protected override void DoGenerate(CilEmitter emitter)
{
ILabel contentsLabel = emitter.GenerateLabel();
emitter.EmitBool(true);
after.EmitJumpIfFalse();
contentsLabel.Emit();
contents.Generate(emitter, contentsLabel, begin);
begin.EmitJump();
}
// Traverses the tree and generates output code
public void Generate(CilEmitter emitter)
{
emitter.BeginProgram();
ILabel begin = emitter.GenerateLabel();
ILabel end = emitter.GenerateLabel();
begin.Emit();
root.Generate(emitter, begin, end);
end.Emit();
emitter.WriteExecutable();
}
private void PerformTranslation(LexicalAnalyser lexer, CilEmitter emitter, ILogger treeLogger) {
using (lexer) {
Parser parser = new Parser(lexer);
SyntaxTree syntaxTree = parser.Parse();
syntaxTree.Log(treeLogger);
syntaxTree.Generate(emitter);
}
}
public ImmutableArray <Diagnostic> Emit(string moduleName, string[] references, string outputPath)
{
var parseDiagnostics = this.SyntaxTrees.SelectMany(st => st.Diagnostics);
var diagnostics = parseDiagnostics.Concat(this.GlobalScope.Diagnostics).ToImmutableArray();
if (diagnostics.Any())
{
return(diagnostics);
}
var program = this.GetProgram();
return(CilEmitter.Emit(program, moduleName, references, outputPath));
}
protected override void DoGenerate(CilEmitter emitter)
{
symbol.Variable = emitter.EmitLocalVarDeclaration(symbol.Name, symbol.VariableType);
if (initialValue != null)
{
initialValue.EmitRValue(emitter);
if (initialValue.ReturnType == typeof(string))
{
emitter.EmitParse(symbol.VariableType);
}
symbol.Variable.EmitAssignment();
}
}
protected override void DoGenerate(CilEmitter emitter)
{
ILabel ifLabel = emitter.GenerateLabel();
ILabel elseLabel = emitter.GenerateLabel();
logicalExpression.EmitRValue(emitter);
elseLabel.EmitJumpIfFalse();
ifLabel.Emit();
ifStatement.Generate(emitter, ifLabel, after);
after.EmitJump();
elseLabel.Emit();
elseStatement.Generate(emitter, elseLabel, after);
}
public override void EmitRValue(CilEmitter emitter)
{
if (!prefix)
{
variableExpr.EmitRValue(emitter);
}
variableExpr.EmitRValue(emitter);
emitter.EmitInt32(1);
emitter.EmitBinaryOperator(add ? "+" : "-");
variableExpr.EmitAssignment();
if (prefix)
{
variableExpr.EmitRValue(emitter);
}
}
public void Translate() {
ILogger lexicalLogger = CreateLogger(LogLexer);
ILogger treeLogger = CreateLogger(LogSyntaxTree);
LexicalAnalyser lexer = new LexicalAnalyser(sourceFilepath, lexicalLogger);
CilEmitter emitter = new CilEmitter(programName);
try {
PerformTranslation(lexer, emitter, treeLogger);
}
catch (ParseException exc) {
Console.WriteLine("Error during translation : \n" + exc.Message);
}
finally {
lexicalLogger.Flush();
treeLogger.Flush();
}
}
protected override void DoGenerate(CilEmitter emitter)
{
ILabel comparisonLabel = emitter.GenerateLabel();
ILabel contentsLabel = emitter.GenerateLabel();
variable = emitter.EmitLocalVarDeclaration("STEPS_LOOP_VAR" + stepCountExpr.lexline + "_" + stepCountExpr.lexline, typeof(int));
stepCountExpr.EmitRValue(emitter);
variable.EmitAssignment();
comparisonLabel.Emit();
variable.EmitValue();
emitter.EmitInt32(0);
emitter.EmitComparison(">");
after.EmitJumpIfFalse();
contentsLabel.Emit();
statement.Generate(emitter, contentsLabel, comparisonLabel);
variable.EmitValue();
emitter.EmitInt32(1);
emitter.EmitBinaryOperator("-");
variable.EmitAssignment();
comparisonLabel.EmitJump();
/*
*
* logicalExpression.jumping(0, after)
*
* create label
*
* emit label
*
* stmt.Gen(label, begin)
*
* emit goto begin
*
*/
}
protected override void DoGenerate(CilEmitter emitter)
{
if (first == Statement.Null)
{
second.Generate(emitter, begin, after);
}
else if (second == Statement.Null)
{
first.Generate(emitter, begin, after);
}
else
{
// Create new label between the two statements
ILabel midpoint = emitter.GenerateLabel();
first.Generate(emitter, begin, midpoint);
midpoint.Emit();
second.Generate(emitter, midpoint, after);
}
}
protected override void DoGenerate(CilEmitter emitter)
{
ILabel contentsLabel = emitter.GenerateLabel();
logicalExpr.EmitRValue(emitter); // Generate rvalue from logical expression.
after.EmitJumpIfFalse(); // Skip the if body if false
contentsLabel.Emit();
contents.Generate(emitter, contentsLabel, after);
/*
* generate new label
*
* call logicalExpr.Jumping(0, after) to have it generate the jumping code.
*
* emitLabel(new label);
*
* stmt.Gen(label, after);
*
*/
}
public override void EmitRValue(CilEmitter emitter)
{
emitter.EmitDouble(value);
}
protected override void EmitOperator(CilEmitter emitter)
{
emitter.EmitComparison(comparisonOperator);
}
protected abstract void EmitOperator(CilEmitter emitter);
public override void EmitRValue(CilEmitter emitter)
{
lhs.EmitRValue(emitter);
rhs.EmitRValue(emitter);
EmitOperator(emitter);
}
public abstract void EmitRValue(CilEmitter emitter);
protected virtual void DoGenerate(CilEmitter emitter)
{
}
public void Generate(CilEmitter emitter, ILabel begin, ILabel after)
{
this.begin = begin;
this.after = after;
DoGenerate(emitter);
}
