protected override ExpressionNode Copy_WithoutLinkedNodes(CompilerState State, CodeString Code, Func <ExpressionNode, ExpressionNode> Func)
{
var Ch = new ExpressionNode[Children.Length];
for (var i = 0; i < Children.Length; i++)
{
Ch[i] = Children[i].Copy(State, Code, Func);
if (Ch[i] == null)
{
return(null);
}
}
if (!Code.IsValid)
{
Code = this.Code;
}
return(new OpExpressionNode(Operator, Ch, Code, Flags));
}
public static bool GetIdAccess(CompilerState State, List <Modifier> Mods, out IdentifierAccess Ret)
{
var RetValue = true;
Ret = IdentifierAccess.Unknown;
for (var i = 0; i < Mods.Count; i++)
{
var Mod = Mods[i] as AccessModifier;
if (Mod == null)
{
State.Messages.Add(MessageId.NotExpected, Mods[i].Code);
RetValue = false;
continue;
}
Ret = Mod.Access;
}
return(RetValue);
}
public static bool GetCallConv(CompilerState State, List <Modifier> Mods, out CallingConvention Ret)
{
var RetValue = true;
Ret = CallingConvention.Unknown;
for (var i = 0; i < Mods.Count; i++)
{
var Mod = Mods[i] as CallingConventionModifier;
if (Mod == null)
{
State.Messages.Add(MessageId.NotExpected, Mods[i].Code);
RetValue = false;
continue;
}
Ret = Mod.CallingConvention;
}
return(RetValue);
}
public Assembly LoadAssemblyDesc(GlobalContainer Global, Stream Stream)
{
this.Global = Global;
this.State = Global.State;
Reader = new BinaryReader(Stream);
BeginningPos = Stream.Position;
var IdListPtr = Reader.ReadInt64() + BeginningPos;
var Name = ReadLEB128_String();
var DescName = ReadLEB128_String();
var Index = Global.LoadedAssemblies.Count;
CurrentAssembly = new Assembly(State, Name, DescName, Index);
CurrentAssembly.Random = Reader.ReadInt32();
Global.LoadedAssemblies.Add(CurrentAssembly);
ReadLEB128_Int();
var Scope = new AssemblyScope(Global, CurrentAssembly);
Global.GlobalNamespace.AddScope(Scope);
Global.Children.Add(Scope);
if (!ReadChildAssemblies(Global))
{
return(null);
}
var ContentPos = Stream.Position;
Stream.Seek(IdListPtr, SeekOrigin.Begin);
ReadIdRefs();
Stream.Seek(ContentPos, SeekOrigin.Begin);
ReadIdList(Scope, Global.GlobalNamespace);
Dereference();
UpdateIds();
return(CurrentAssembly);
}
public ExpressionNode Copy(CompilerState State, CodeString Code, Func <ExpressionNode, ExpressionNode> Func)
{
var Ret = Copy_WithoutLinkedNodes(State, Code, Func);
if (Ret == null)
{
return(null);
}
for (var i = 0; i < LinkedNodes.Count; i++)
{
var Node = LinkedNodes[i].Node.Copy(State, Code, Func);
if (Node == null)
{
return(null);
}
Ret.LinkedNodes.Add(new LinkedExprNode(Node, LinkedNodes[i].Flags));
}
return(Func(Ret));
}
public Preprocessor(IdContainer Container)
{
this.State = Container.State;
this.Container = Container;
}
protected override ExpressionNode Copy_WithoutLinkedNodes(CompilerState State, CodeString Code, Func <ExpressionNode, ExpressionNode> Func)
{
throw new ApplicationException();
}
protected override ExpressionNode Copy_WithoutLinkedNodes(CompilerState State, CodeString Code, Func <ExpressionNode, ExpressionNode> Func)
{
return(new StrExpressionNode(this.Code, Flags));
}
protected abstract ExpressionNode Copy_WithoutLinkedNodes(CompilerState State,
CodeString Code, Func <ExpressionNode, ExpressionNode> Func);
public bool AdjustSettings()
{
if (Language == null)
{
Language = new Languages.Zinnia.ZinniaLanguage();
}
if (Arch == null)
{
Arch = new x86.x86Architecture();
}
if (Format == AssemblyFormat.Unknown)
{
Format = AssemblyFormat.Application;
}
if (Format == AssemblyFormat.Application && Entry == null)
{
Entry = "Main";
}
if (DefaultLibs)
{
Assemblies.Add(new AssemblyPath("ZinniaCore", true));
Assemblies.Add(new AssemblyPath("BlitzMax", true));
}
if (Dir == null)
{
if (OutFile == null)
{
Dir = Directory.GetCurrentDirectory();
}
else
{
Dir = Path.GetDirectoryName(Path.GetFullPath(OutFile));
}
}
if (State == null)
{
State = new CompilerState(this, Arch, Language);
}
else
{
State.Messages.Messages.Clear();
State.Arch = Arch;
State.Language = Language;
}
State.Entry = Entry;
State.Format = ImageFormat.MSCoff;
OutDir = Path.Combine(Dir, ".zinnia");
if (!Directory.Exists(OutDir))
{
Directory.CreateDirectory(OutDir);
}
if (OutFile == null)
{
if (Format == AssemblyFormat.Object)
{
OutFile = Path.Combine(OutDir, "Assembly.o");
}
else if (Format == AssemblyFormat.Archive)
{
OutFile = Path.Combine(OutDir, "Assembly.a");
}
else if (Format == AssemblyFormat.Application)
{
OutFile = Path.Combine(OutDir, "Assembly.exe");
}
else
{
throw new ApplicationException();
}
}
if (ZinniaLib == null)
{
ZinniaLib = Path.Combine(OutDir, "Assembly.zlib");
}
if (AsmFile == null)
{
AsmFile = Path.Combine(OutDir, "Assembly.s");
}
if (ObjFile == null)
{
if (Format == AssemblyFormat.Object)
{
ObjFile = OutFile;
}
else
{
ObjFile = Path.Combine(OutDir, "Assembly.o");
}
}
return(true);
}
public CodeGenerator(CompilerState State)
{
this.State = State;
this.InsContainer = new InstructionContainer();
}
public ExpressionPlugin(PluginRoot Parent)
{
this.Parent = Parent;
this.Container = Parent.Container;
this.State = Parent.State;
}
public PluginRoot(IdContainer Container)
{
this.Container = Container;
this.State = Container.State;
}
public MTCompiler(CompilerState State, List <Identifier> Identifiers)
{
this.State = State;
this.Identifiers = Identifiers;
}
