private async Task GetReady()
{
Worker = new WebWorkerClient();
var AssembellyNames = "[";
foreach (var Asm in Monsajem_Incs.Assembly.Assembly.AllAppAssemblies)
{
AssembellyNames += $"'{Asm.GetName().Name}.dll',";
}
if (Monsajem_Incs.Assembly.Assembly.AllAppAssemblies.Length > 0)
{
AssembellyNames = AssembellyNames.Substring(0, AssembellyNames.Length - 1);
}
AssembellyNames += "]";
var Location = Window.window.Location;
await Worker.Run($"self.MN={{}};self.MN.AssemblyFilenames={AssembellyNames};self.MN.baseUrl = '{Location.Protocol}//{Location.Hostname}:{Location.Port}/_framework/';");
var Ready = Worker.GetMessage();
await Worker.Run(WebWorkerJs);
await Ready;
}
private void AsmWriteString(string cadenaAImprimir) // FixMe: arreglar cadena vacia
{
// ToDo: terminar implementacion
/*
* Implementacion para Linux x86_64 (64 bits)
* Para imprimir es necesario almacenar el string en memoria.
* En esta implementacion se guarda el string en el stack para pasarla
* como argumento a la subrutina writeString.
* De esta forma la longitud de la cadena no está limitada a la longitud
* de los registros, no es necesario incluir otro archivo (biblioteca),
* ni se necesita declarar un buffer en .data
*/
cadenaAImprimir += '\n';
cadenaAImprimir = cadenaAImprimir.Invertir();
string cadenaAux = "";
int longitud = cadenaAImprimir.Length;
int iteraciones = longitud / 8;
int pushCont = iteraciones;
if (longitud % 8 != 0)
{
cadenaAux = ToAsciiHex(cadenaAImprimir.Substring(0, longitud % 8));
cadenaAImprimir = cadenaAImprimir.Substring(longitud % 8, longitud - longitud % 8);
pushCont++;
Asm.WriteLine("mov rax, 0x" + cadenaAux);
Asm.WriteLine("push rax");
}
for (int i = 0; i < iteraciones; i++)
{
cadenaAux = ToAsciiHex(cadenaAImprimir.Substring(i * 8, 8));
Asm.WriteLine("mov rax, 0x" + cadenaAux);
Asm.WriteLine("push rax");
}
Asm.WriteLine("mov rax, rsp"); // Direccion de la cadena, tope del stack
Asm.WriteLine("mov rbx, " + longitud);
Asm.WriteLine("mov rcx, " + pushCont);
Asm.WriteLine("call writeString");
}
private void GetAllModel()
{
foreach (Part pt in Session.GetSession().Parts)
{
string name = pt.Name;
if (ParentAssmblieInfo.IsParent(pt))
{
ParentAssmblieInfo parent = ParentAssmblieInfo.GetAttribute(pt);
switch (parent.Type)
{
case PartType.ASM:
Asm.Add(new ASMModel(pt));
break;
case PartType.EDM:
Edm.Add(new EDMModel(pt));
break;
case PartType.Electrode:
ElectrodeModel eleModel = new ElectrodeModel(pt);
Electrode.Add(eleModel);
break;
case PartType.Work:
Work.Add(new WorkModel(pt));
break;
default:
Other.Add(pt);
break;
}
}
else
{
Other.Add(pt);
}
}
}
/// <summary>编译汇编程序</summary>
/// <param name="file"></param>
/// <param name="showCmd"></param>
/// <returns></returns>
public Int32 Assemble(String file, Boolean showCmd)
{
var lstName = GetListPath(file);
var objName = GetObjPath(file);
// 如果文件太新，则不参与编译
var obj = (objName + ".o").AsFile();
if (!Check(file, obj))
{
return(-2);
}
obj.DirectoryName.EnsureDirectory(false);
var cmd = OnAssemble(file);
if (showCmd)
{
Console.Write("汇编参数：");
Console.ForegroundColor = ConsoleColor.Magenta;
Console.WriteLine(cmd);
Console.ResetColor();
}
var sb = new StringBuilder();
sb.Append(cmd);
sb.AppendFormat(" \"{0}\" -o \"{1}.o\"", file, objName);
// 先删除目标文件
if (obj.Exists)
{
obj.Delete();
}
return(Asm.Run(sb.ToString(), 100, WriteLog));
}
private void AsmEvaluarCondicion(string operador, string etiequeta, int numEtiqueta)
{
Asm.WriteLine("cmp rax, rbx");
switch (operador)
{
case "<":
Asm.Write("jnl ");
AsmSaltosCondicionales(etiequeta, numEtiqueta);
break;
case "<=":
Asm.Write("jnle ");
AsmSaltosCondicionales(etiequeta, numEtiqueta);
break;
case ">":
Asm.Write("jng ");
AsmSaltosCondicionales(etiequeta, numEtiqueta);
break;
case ">=":
Asm.Write("jng ");
AsmSaltosCondicionales(etiequeta, numEtiqueta);
break;
case "==":
Asm.Write("jne ");
AsmSaltosCondicionales(etiequeta, numEtiqueta);
break;
case "!=":
Asm.Write("je ");
AsmSaltosCondicionales(etiequeta, numEtiqueta);
break;
}
//Asm.Write("jmp ");
//AsmSaltosCondicionales(etiequeta, numEtiqueta);
}
protected void VariableAssignment(Address aVariableName, string aOpEquals, object aValue)
{
string size;
switch (aValue)
{
case uint _:
size = "dword";
Asm.Emit(OpCode.Mov, size, aVariableName.AddPrefix(Compiler.GetPrefixForVar), aValue);
break;
case Register aValueReg:
size = aValueReg.RegSize;
Asm.Emit(OpCode.Mov, size, aVariableName.AddPrefix(Compiler.GetPrefixForVar), aValue);
break;
case string _:
//TODO: verify this
aValue = $"{Compiler.GetPrefixForConst}{aValue}";
Asm.Emit(OpCode.Mov, aVariableName.AddPrefix(Compiler.GetPrefixForVar), aValue);
break;
}
}
/// <summary>
/// Reboot the system.
/// We can reset the system, oddly enough, through the keyboard IO port
/// </summary>
public static void Reboot()
{
// Disable interrupts
Asm.CLI();
// Clear all keyboard buffers (output and command buffers)
byte temp;
do
{
temp = IO.ReadByte(IO.Port.KB_controller_commands);
if ((temp & 0x01) != 0)
{
IO.ReadByte(IO.Port.KB_data_port); // Empty keyboard buffer
}
} while ((temp & 0x02) != 0);
// Reset the system
IO.WriteByte(IO.Port.KB_controller_commands, 0xFE);
// Halt the system (in case reset didn't work)
Asm.HLT();
}
/// <summary>
/// Gets the requested type.
/// </summary>
/// <param name="typeName"></param>
/// <returns></returns>
public Type GetType(string typeName)
{
Load();
if (!typeName.Contains('.') && !string.IsNullOrEmpty(DefaultNamespace))
{
typeName = string.Format(CultureInfo.InvariantCulture, "{0}.{1}", DefaultNamespace, typeName);
}
if (Types.ContainsKey(typeName))
{
return(Types[typeName]);
}
var t = Asm.GetType(typeName);
if (t == null)
{
throw new DynException(ErrTypeLoad, typeName, AsmName);
}
Types.Add(t.FullName, t);
return(t);
}
/// <summary>在程序集中查找类型</summary>
/// <param name="typeName"></param>
/// <returns></returns>
Type GetTypeInternal(String typeName)
{
var type = Asm.GetType(typeName);
if (type != null)
{
return(type);
}
// 如果没有包含圆点，说明其不是FullName
if (!typeName.Contains("."))
{
var types = Asm.GetTypes();
if (types != null && types.Length > 0)
{
foreach (var item in types)
{
if (item.Name == typeName)
{
return(item);
}
}
}
// 遍历所有类型，包括内嵌类型
foreach (var item in TypeXs)
{
if (item.Name == typeName)
{
return(item);
}
}
}
return(null);
}
/// <summary>
/// Loads in the new dll
/// </summary>
public void LoadDll()
{
var path = $@"../../../../{ProjectName}/bin/Debug/netcoreapp2.1/{ProjectName}.dll";
Asm = Assembly.Load(File.ReadAllBytes(path));
foreach (var type in Asm.GetExportedTypes())
{
if (Screen == null)
{
break;
}
if (type.FullName == Screen.GetType().ToString())
{
// We found our gamelogic type, set our dynamic types logic, and state
var oldScreen = Screen;
Screen = Activator.CreateInstance(type);
oldScreen?.Destroy();
break;
}
}
}
public float MasTermino()
{
float A = Termino();
int tipoPredominante = TipoPredominante;
if (GETClasificacion() == operadorTermino)
{
string operador = GETContenido();
MATCH(operadorTermino);
float t = Termino();
Log.Write(operador + " ");
Asm.WriteLine("pop rbx");
Asm.WriteLine("pop rax");
if (EvaluaExpresion(t) > TipoPredominante)
{
TipoPredominante = EvaluaExpresion(t);
}
if (tipoPredominante > TipoPredominante)
{
TipoPredominante = tipoPredominante;
}
if (operador == "+")
{
Asm.WriteLine("add rax, rbx");
Asm.WriteLine("push rax");
return(A + t);
}
else
{
Asm.WriteLine("sub rax, rbx");
Asm.WriteLine("push rbx");
return(A - t);
}
}
return(A + 0f);
}
public static void ShowAllTypeInfo()
{
Console.WriteLine("1 - Common types information\n");
Assembly myAsm = Assembly.GetExecutingAssembly();
Type[] myAsmTypes = myAsm.GetTypes();
Console.WriteLine("My assembly has {0} types:", myAsmTypes.Length);
string[] myAsmTypesNames = new string[myAsmTypes.Length];
for (int i = 0; i < myAsmTypes.Length; i++)
{
myAsmTypesNames[i] = myAsmTypes[i].Name;
}
string sMyAsmTypesNames = string.Join(", ", myAsmTypesNames);
Console.WriteLine(sMyAsmTypesNames);
// Referenced assemblies
#region Properties init
int refAsmsNum = 0;
int allTypesNum = 0;
int RefTypesCount = 0;
int ValTypesCount = 0;
int InterTypesCount = 0;
Type MaxCntMethType = null;
int MaxCntMethTypeNums = 0;
MethodInfo MaxLenNameMeth = null;
int MaxLenNameMethNum = 0;
MethodInfo MaxCntParMeth = null;
int MaxCntParMethNum = 0;
#endregion
Assembly[] refAssemblies = AppDomain.CurrentDomain.GetAssemblies();
refAsmsNum = refAssemblies.Length;
List <Type> allTypes = new List <Type>();
foreach (Assembly Asm in refAssemblies)
{
allTypes.AddRange(Asm.GetTypes());
}
allTypesNum = allTypes.Count;
foreach (var t in allTypes)
{
if (t.IsClass)
{
RefTypesCount++;
}
if (t.IsValueType)
{
ValTypesCount++;
}
if (t.IsInterface)
{
InterTypesCount++;
}
//MaxCntMethType
if (t.GetMethods().Length > MaxCntMethTypeNums)
{
MaxCntMethType = t;
MaxCntMethTypeNums = t.GetMethods().Length;
}
//MaxLenNameMeth & MaxCntParMeth
MethodInfo[] TempMethods = t.GetMethods();
foreach (var m in TempMethods)
{
if (m.Name.Length > MaxLenNameMethNum)
{
MaxLenNameMethNum = m.Name.Length;
MaxLenNameMeth = m;
}
//MaxCntParMeth
if (m.GetParameters().Length > MaxCntParMethNum)
{
MaxCntParMethNum = m.GetParameters().Length;
MaxCntParMeth = m;
}
}
}
Console.WriteLine($@"
Referenced assemblies: {refAsmsNum}
Ref assemblies sum types: {allTypesNum}
Referenced types: {RefTypesCount}
Value types: {ValTypesCount}
Interface types: {InterTypesCount}
Max count methods type: {MaxCntMethType.Name}
Max length name method: {MaxLenNameMeth.Name}
Max count parameters method: {MaxCntParMeth.Name}
");
Console.WriteLine("\nPress any key to return back into menu");
Console.ReadKey();
}
protected void RegAssignToMemory(string aOpOpenBracket, Register aTargetRegisterRoot, string aOpCloseBracket, string aOpEquals, Register source)
{
Asm.Emit(OpCode.Mov, source.RegSize, new Address(aTargetRegisterRoot), source);
}
public static unsafe uint Increment(uint *location)
{
Asm.LOCK();
Asm.INC(location);
return(*location);
}
protected void Goto(string aGotoKeyword, string aLabelName)
{
string xLabelName = Compiler.GetFullName(aLabelName, true);
Asm.Emit(OpCode.Jmp, $"{xLabelName}");
}
protected void VariableAssignToMemory(string aOpOpenBracket, Register aTargetRegisterRoot, string aOpCloseBracket, string aOpEquals, Address source)
{
source.AddPrefix(Compiler.CurrentNamespace);
Asm.Emit(OpCode.Mov, "dword", new Address(aTargetRegisterRoot), source);
}
[Emitter(typeof(Reg32), typeof(OpEquals), typeof(Int32u))] // EAX = 0
protected void RegAssignNum(Register aDestReg, string aEquals, object aVal)
{
Asm.Emit(OpCode.Mov, aDestReg, aVal);
}
public TAttribute GetCustomAttribute <TAttribute>()
{
return(Asm.GetCustomAttribute <TAttribute>());
}
protected void PopConst(string aOpMinus, string value)
{
Asm.Emit(OpCode.Pop, $"{Compiler.CurrentNamespace}_Const_{value}");
}
protected void RegAssignVarAddress(Register aReg, string aEquals, string aVal)
{
string xValue = Compiler.GetFullName(aVal);
Asm.Emit(OpCode.Mov, aReg, xValue);
}
protected void RegAssignVar(Register aReg, string aEquals, Address aVal)
{
// TODO: Do this better? Use Compiler.GetFullName() so things are consistent.
aVal.AddPrefix(Compiler.CurrentNamespace);
Asm.Emit(OpCode.Mov, aReg, aReg.RegSize, aVal);
}
protected void RegAssignConst(Register aReg, string aEquals, string aVal)
{
string xValue = Compiler.GetFullName($"Const_{aVal}");
Asm.Emit(OpCode.Mov, aReg, xValue);
}
[Emitter(typeof(Reg32), typeof(OpEquals), typeof(Reg32))] // EAX = EBX
protected void RegAssigReg(Register aDestReg, string aEquals, Register aSrcReg)
{
Asm.Emit(OpCode.Mov, aDestReg, aSrcReg);
}
protected void PopVar(string aOpPlus, Address value)
{
// TODO: Do this better? Use Compiler.GetFullName() so things are consistent.
value.AddPrefix(Compiler.CurrentNamespace);
Asm.Emit(OpCode.Pop, value);
}
protected void ZeroParamOp(OpCode aOpCode)
{
Asm.Emit(aOpCode);
}
protected void PopAddr(string aOpPlus, string value)
{
Asm.Emit(OpCode.Pop, $"{Compiler.CurrentNamespace}_{value}");
}
protected void PushValue(string aOp, object aReg)
{
Asm.Emit(OpCode.Push, aReg);
}
protected void IntegerAssignToMemory(string aOpOpenBracket, Register aTargetRegisterRoot, string aOpCloseBracket, string aOpEquals, object source)
{
Asm.Emit(OpCode.Mov, "dword", new Address(aTargetRegisterRoot), source);
}
/// <summary>在程序集中查找类型</summary>
/// <param name="typeName"></param>
/// <returns></returns>
Type GetTypeInternal(String typeName)
{
var type = Asm.GetType(typeName);
if (type != null)
{
return(type);
}
// 如果没有包含圆点，说明其不是FullName
if (!typeName.Contains("."))
{
try
{
var types = Asm.GetTypes();
if (types != null && types.Length > 0)
{
foreach (var item in types)
{
if (item.Name == typeName)
{
return(item);
}
}
}
}
catch (ReflectionTypeLoadException ex)
{
if (XTrace.Debug)
{
//XTrace.WriteException(ex);
XTrace.WriteLine("加载[{0}]{1}的类型时发生个{2}错误！", this, Location, ex.LoaderExceptions.Length);
foreach (var item in ex.LoaderExceptions)
{
XTrace.WriteException(item);
}
}
return(null);
}
catch (Exception ex)
{
if (XTrace.Debug)
{
XTrace.WriteException(ex);
}
return(null);
}
// 遍历所有类型，包括内嵌类型
foreach (var item in Types)
{
if (item.Name == typeName)
{
return(item);
}
}
}
return(null);
}
protected void PopValue(string aOp, object aReg)
{
Asm.Emit(OpCode.Pop, aReg);
}
