public override bool IsComplete(AsmContext ec)
{
if (RawAsm != null)
{
return(true);
}
if (UntypedDefaultValue != null &&
UntypedDefaultValue.LongLength > 0)
{
foreach (var xReference in (from item in UntypedDefaultValue
let xRef = item as NCAsm.ElementReference
where xRef != null
select xRef))
{
var xRef = ec.TryResolveReference(xReference);
if (xRef == null)
{
return(false);
}
else if (!xRef.IsComplete(ec))
{
return(false);
}
}
}
return(true);
}
public Comment(AsmContext aAssembler, string aText)
: base() //HACK
{
if (aText.StartsWith(";"))
{
aText = aText.TrimStart(';').TrimStart();
}
Text = String.Intern(aText);
}
public override void WriteData(AsmContext ec, Stream aOutput)
{
if (UntypedDefaultValue != null &&
UntypedDefaultValue.LongLength > 0)
{
//var xBuff = (byte[])Array.CreateInstance(typeof(byte), UntypedDefaultValue.LongLength * 4);
for (int i = 0; i < UntypedDefaultValue.Length; i++)
{
var xRef = UntypedDefaultValue[i] as ElementReference;
//byte[] xTemp;
if (xRef != null)
{
var xTheRef = ec.TryResolveReference(xRef);
if (xTheRef == null)
{
throw new Exception("Reference not found!");
}
if (!xTheRef.ActualAddress.HasValue)
{
Console.Write("");
}
aOutput.Write(BitConverter.GetBytes(xTheRef.ActualAddress.Value), 0, 4);
//xTemp = BitConverter.GetBytes();
}
else
{
if (UntypedDefaultValue[i] is int)
{
aOutput.Write(BitConverter.GetBytes((int)UntypedDefaultValue[i]), 0, 4);
//xTemp = BitConverter.GetBytes((int)UntypedDefaultValue[i]);
}
else
{
if (UntypedDefaultValue[i] is uint)
{
aOutput.Write(BitConverter.GetBytes((uint)UntypedDefaultValue[i]), 0, 4);
//xTemp = BitConverter.GetBytes((uint)UntypedDefaultValue[i]);
}
else
{
throw new Exception("Invalid value inside UntypedDefaultValue");
}
}
}
//Array.Copy(xTemp, 0, xBuff, i * 4, 4);
}
}
else
{
aOutput.Write(RawDefaultValue, 0, RawDefaultValue.Length);
}
}
public override void WriteText(AsmContext aAssembler, AssemblyWriter aOutput)
{
if (IsGlobal)
{
aOutput.Write("global ");
aOutput.WriteLine(QualifiedName);
}
aOutput.Write(QualifiedName);
aOutput.Write(":");
if (Comment.Length > 0)
{
aOutput.Write(" ;");
aOutput.Write(Comment);
}
}
public override void UpdateAddress(AsmContext ec, ref ulong xAddress)
{
if (Alignment > 0)
{
if (xAddress % Alignment != 0)
{
xAddress += Alignment - (xAddress % Alignment);
}
}
base.UpdateAddress(ec, ref xAddress);
if (RawDefaultValue != null)
{
xAddress += (ulong)RawDefaultValue.LongLength;
}
if (UntypedDefaultValue != null)
{
// TODO: what to do with 64bit target platforms? right now we only support 32bit
xAddress += (ulong)(UntypedDefaultValue.LongLength * 4);
}
}
public bool Resolve(AsmContext ec, out ulong aAddress)
{
//
if (mActualAddress != null)
{
aAddress = mActualAddress.Value;
return(true);
}
var xElement = DoResolve(ec, Name);
if (xElement != null)
{
if (xElement.ActualAddress.HasValue)
{
mActualAddress = (ulong)((long)xElement.ActualAddress.Value + Offset);
aAddress = mActualAddress.Value;
return(true);
}
}
aAddress = 0;
return(false);
}
public abstract bool IsComplete(AsmContext ec);
public override void UpdateAddress(AsmContext ec, ref ulong aAddress)
{
base.UpdateAddress(ec, ref aAddress);
}
public override void WriteData(AsmContext aAssembler, Stream aOutput)
{
throw new NotImplementedException("Method not implemented for instruction " + this.GetType().FullName.Substring(typeof(Instruction).Namespace.Length + 1));
}
private static BaseAssemblerElement DoResolve(AsmContext ec, string aName)
{
if (!mThreadId.HasValue)
{
mThreadId = Thread.CurrentThread.ManagedThreadId;
}
else
{
if (mThreadId.Value != Thread.CurrentThread.ManagedThreadId)
{
throw new Exception("Called from multiple threads");
}
}
mCacheLocker.EnterReadLock();
try {
if (mCache != null)
{
BaseAssemblerElement xTempResult;
if (mCache.TryGetValue(aName, out xTempResult))
{
return(xTempResult);
}
}
} finally {
mCacheLocker.ExitReadLock();
}
mCacheLocker.EnterWriteLock();
try {
if (mCache == null)
{
mCache = new Dictionary <string, BaseAssemblerElement>(StringComparer.InvariantCultureIgnoreCase);
int xMax = ec.AllAssemblerElementCount;
for (int i = 0; i < xMax; i++)
{
var xInstruction = ec.GetAssemblerElement(i);
var xLabel = xInstruction as Label;
if (xLabel != null)
{
mCache.Add(xLabel.QualifiedName, xLabel);
}
var xDataMember = xInstruction as DataMember;
if (xDataMember != null)
{
if (mCache.ContainsKey(xDataMember.Name))
{
Console.Write("");
}
mCache.Add(xDataMember.Name, xDataMember);
}
}
}
BaseAssemblerElement xTempResult;
if (mCache.TryGetValue(aName, out xTempResult))
{
return(xTempResult);
}
throw new Exception("Cannot resolve ElementReference to '" + aName + "'!");
//foreach(var xInstruction in aAssembler.Instructions ) {
// var xLabel = xInstruction as Label;
// if(xLabel!=null) {
// if(aName.Equals(xLabel.Name, StringComparison.InvariantCultureIgnoreCase)) {
// xTempResult = xLabel;
// break;
// }
// }
//}
//if (xTempResult == null) {
// foreach (var xDataMember in aAssembler.DataMembers) {
// if (aName.Equals(xDataMember.Name, StringComparison.InvariantCultureIgnoreCase)) {
// xTempResult = xDataMember;
// break;
// }
// }
//}
} finally {
mCacheLocker.ExitWriteLock();
}
}
public override void UpdateAddress(AsmContext aAssembler, ref ulong aAddress)
{
base.UpdateAddress(aAssembler, ref aAddress);
}
public abstract void WriteText(AsmContext ec, AssemblyWriter aOutput);
public abstract void WriteData(AsmContext ec, Stream aOutput);
public override bool IsComplete(AsmContext aAssembler)
{
return(true);
}
public override void WriteText(AsmContext ec, AssemblyWriter aOutput)
{
aOutput.Write(Value);
}
public override void WriteData(AsmContext ec, System.IO.Stream aOutput)
{
}
public AsmContext(string file)
{
IsFlat = false;
AssemblerWriter = new AssemblyWriter(file);
mCurrentInstance = this;
}
public override void WriteText(AsmContext aAssembler, AssemblyWriter aOutput)
{
aOutput.Write(Code);
}
public AsmContext(AssemblyWriter writer)
{
IsFlat = false;
AssemblerWriter = writer;
mCurrentInstance = this;
}
public override void WriteText(AsmContext ec, AssemblyWriter aOutput)
{
aOutput.Write(mMnemonic);
}
public override void WriteText(AsmContext ec, AssemblyWriter aOutput)
{
if (RawAsm != null)
{
aOutput.WriteLine(RawAsm);
return;
}
if (Labels != null)
{
aOutput.Write(Name);
foreach (string lb in Labels)
{
aOutput.WriteLine(" dw " + lb);
}
aOutput.WriteLine();
return;
}
if (ReferenceName != null)
{
aOutput.Write(Name);
aOutput.Write(" dw " + ReferenceName);
aOutput.WriteLine();
return;
}
if (FloatValue.HasValue)
{
aOutput.Write(Name);
aOutput.Write(" dd " + FloatValue.ToString().Replace(",", "."));
aOutput.WriteLine();
return;
}
if (StrVal != null)
{
if (IsGlobal)
{
aOutput.Write("global ");
aOutput.WriteLine(Name);
}
if (string.IsNullOrEmpty(StrVal))
{
aOutput.Write(Name);
aOutput.Write(" times 256 db 0");
return;
}
aOutput.Write(Name);
aOutput.Write(" db ");
//foreach (char c in StrVal)
//{
// if (c == '\r' || c == '\n')
// {
// if (!string.IsNullOrEmpty(last))
// strdecl+= "\"" + last + "\", ";
// strdecl += b[i].ToString();
// strdecl += ",";
// last = "";
// }
// else last += c + "";
// i++;
//}
//if (!string.IsNullOrEmpty(last))
// strdecl += "\"" + last + "\"";
//else strdecl = strdecl.Remove(strdecl.Length - 1, 1);
if (!verbatim)
{
StringHelper.WriteNormalizedString(StrVal, aOutput);
}
else
{
aOutput.Write("\"" + StringHelper.StringFromVerbatimLiteral(StrVal) + "\"");
}
if (!StrConst)
{
aOutput.WriteLine();
aOutput.Write("\t\t times " + (255 - StrVal.Length).ToString() + " db 0");
}
else
{
aOutput.Write(",0");
}
return;
}
if (RawDefaultValue != null)
{
if (RawDefaultValue.Length == 0)
{
aOutput.Write(Name);
aOutput.Write(":");
return;
}
if ((from item in RawDefaultValue
group item by item
into i
select i).Count() > 1 || RawDefaultValue.Length < 10)
{
if (IsGlobal)
{
aOutput.Write("global ");
aOutput.WriteLine(Name);
}
aOutput.Write(Name);
aOutput.Write(" db ");
for (int i = 0; i < (RawDefaultValue.Length - 1); i++)
{
aOutput.Write(RawDefaultValue[i]);
aOutput.Write(", ");
}
aOutput.Write(RawDefaultValue.Last());
}
else
{
//aOutputWriter.WriteLine("TIMES 0x50000 db 0");
if (IsGlobal)
{
aOutput.Write("global ");
aOutput.WriteLine(Name);
}
aOutput.Write(Name);
aOutput.Write(": TIMES ");
aOutput.Write(RawDefaultValue.Length);
aOutput.Write(" db ");
aOutput.Write(RawDefaultValue[0]);
}
return;
}
if (UntypedDefaultValue != null)
{
StringBuilder xSB = new StringBuilder();
if (IsGlobal)
{
aOutput.Write("global ");
aOutput.WriteLine(Name);
}
aOutput.Write(Name);
aOutput.Write(" dw ");
Func <object, string> xGetTextForItem = delegate(object aItem) {
var xElementRef = aItem as ElementReference;
if (xElementRef == null)
{
return((aItem ?? 0).ToString());
}
else
{
if (xElementRef.Offset == 0)
{
return(xElementRef.Name);
}
return(xElementRef.Name + " + " + xElementRef.Offset);
}
};
for (int i = 0; i < (UntypedDefaultValue.Length - 1); i++)
{
aOutput.Write(xGetTextForItem(UntypedDefaultValue[i]));
aOutput.Write(", ");
}
aOutput.Write(xGetTextForItem(UntypedDefaultValue.Last()));
return;
}
throw new Exception("Situation unsupported!");
}
public override bool IsComplete(AsmContext aAssembler)
{
throw new NotImplementedException("Method not implemented for instruction " + this.GetType().FullName.Substring(typeof(Instruction).Namespace.Length + 1));
}
public virtual void UpdateAddress(AsmContext ec, ref ulong aAddress)
{
StartAddress = aAddress;
}
