public Method CompileInstanceMethod(string text, IBehavior cls)
{
ModelParser parser = new ModelParser(text);
var methodmodel = parser.ParseMethod();
Method method = new Method(cls, methodmodel.Selector, text);
BytecodeCompiler compiler = new BytecodeCompiler(method);
compiler.CompileMethod(methodmodel);
return method;
}
public Block CompileBlock(string text)
{
ModelParser parser = new ModelParser(text);
var expr = parser.ParseBlock();
Block block = new Block(text);
BytecodeCompiler compiler = new BytecodeCompiler(block);
compiler.CompileExpression(expr);
return block;
}
public void CompileExpressions()
{
IList<ExpressionResult> results = ExpressionResult.LoadExpressionResults("Expressions.txt");
foreach (var result in results)
{
ModelParser parser = new ModelParser(result.Text);
Block block = new Block();
BytecodeCompiler compiler = new BytecodeCompiler(block);
compiler.CompileExpression(parser.ParseExpression());
result.ValidateBlock(block);
}
}
internal static void CompileFile(string filename)
{
ChunkReader chunkReader = new ChunkReader(filename);
CodeReader reader = new CodeReader(chunkReader);
CodeModel model = new CodeModel();
reader.Process(model);
foreach (var element in model.Elements)
{
Block block = new Block();
BytecodeCompiler compiler = new BytecodeCompiler(block);
element.Visit(compiler);
if (element is MethodModel && ((MethodModel)element).Body == null)
continue;
Assert.IsNotNull(block.ByteCodes);
}
}
internal static IClass CompileClass(string clsname, string[] varnames, string[] methods, string[] clsmethods)
{
Machine machine = new Machine();
IClass cls = machine.CreateClass(clsname);
if (varnames != null)
{
foreach (string varname in varnames)
{
cls.DefineInstanceVariable(varname);
}
}
if (methods != null)
{
foreach (string method in methods)
{
ModelParser parser = new ModelParser(method);
MethodModel model = parser.ParseMethod();
Method newmethod = new Method(cls, model.Selector, method);
BytecodeCompiler compiler = new BytecodeCompiler(newmethod);
compiler.CompileMethod(model);
cls.DefineInstanceMethod(newmethod);
}
}
if (clsmethods != null)
{
foreach (string method in clsmethods)
{
ModelParser parser = new ModelParser(method);
MethodModel model = parser.ParseMethod();
Method newmethod = new Method(cls, model.Selector, method);
BytecodeCompiler compiler = new BytecodeCompiler(newmethod);
compiler.CompileMethod(model);
cls.DefineClassMethod(newmethod);
}
}
return cls;
}
public void Setup()
{
this.block = new Block();
this.compiler = new BytecodeCompiler(this.block);
}
public void CompilePharoCoreRectangle()
{
ChunkReader chunkCoreReader = new ChunkReader(@"PharoCoreKernelObjects.st");
CodeReader coreReader = new CodeReader(chunkCoreReader);
ChunkReader chunkReader = new ChunkReader(@"PharoCoreRectangle.st");
CodeReader reader = new CodeReader(chunkReader);
CodeModel model = new CodeModel();
coreReader.Process(model);
reader.Process(model);
foreach (var element in model.Elements)
{
Block block = new Block();
BytecodeCompiler compiler = new BytecodeCompiler(block);
element.Visit(compiler);
if (element is MethodModel && ((MethodModel)element).Body == null)
continue;
Assert.IsNotNull(block.ByteCodes);
}
}
public override void Visit(BlockExpression expression)
{
Block newblock = new Block(null, this.block);
// TODO Review is the copy of argument and local names is needed
foreach (var parname in this.block.ParameterNames)
newblock.CompileArgument(parname);
foreach (var locname in this.block.LocalNames)
newblock.CompileLocal(locname);
if (expression.ParameterNames != null)
foreach (var parname in expression.ParameterNames)
newblock.CompileArgument(parname);
if (expression.LocalVariables != null)
foreach (var locname in expression.LocalVariables)
newblock.CompileLocal(locname);
var compiler = new BytecodeCompiler(newblock);
compiler.Visit(expression.Body);
this.block.CompileGetBlock(newblock);
}
