public void loadfile() { Natives = new Dictionary <uint, Tuple <Stack.DataType, Stack.DataType[]> >(); string file = Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), "nativeinfo.dat"); if (!File.Exists(file)) { return; } Stream natfile = File.OpenRead(file); IO.Reader reader = new IO.Reader(natfile, true); while (natfile.Position < natfile.Length) { uint native = reader.ReadUInt32(); Stack.DataType returntype = Types.getatindex(reader.ReadByte()); byte count = reader.ReadByte(); Stack.DataType[] param = new Stack.DataType[count]; for (byte i = 0; i < count; i++) { param[i] = Types.getatindex(reader.ReadByte()); } Natives.Add(native, new Tuple <Stack.DataType, Stack.DataType[]>(returntype, param)); } }
public void loadfile() { Natives = new Dictionary <ulong, Tuple <Stack.DataType, Stack.DataType[]> >(); Stream natfile; string file = Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), "x64nativeinfo.dat"); if (File.Exists(file)) { natfile = File.OpenRead(file); } else { natfile = new MemoryStream(Properties.Resources.x64nativeinfo); } IO.Reader reader = new IO.Reader(natfile, false); while (natfile.Position < natfile.Length) { ulong native = reader.ReadUInt64(); Stack.DataType returntype = Types.getatindex(reader.ReadByte()); byte count = reader.ReadByte(); Stack.DataType[] param = new Stack.DataType[count]; for (byte i = 0; i < count; i++) { param[i] = Types.getatindex(reader.ReadByte()); } Natives.Add(native, new Tuple <Stack.DataType, Stack.DataType[]>(returntype, param)); } }
public Native UpdateNative(ulong hash, Stack.DataType returns, params Stack.DataType[] param) { Native native = null; lock (Program.ThreadLock) { if (!TryGetValue(hash, out native)) { throw new Exception("Unknown Native: " + hash.ToString("X")); } native.Return = returns.LongName(); for (int i = 0; i < param.Length; ++i) { if (native.Params[i].Vardiac) { break; } if (native.Params[i].StackType.IsUnknown()) { native.Params[i].Type = param[i].LongName(); } } } return(native); }
public void updatenative(uint hash, Stack.DataType returns, params Stack.DataType[] param) { lock (Program.ThreadLock) { if (!Natives.ContainsKey(hash)) { Natives.Add(hash, new Tuple <Stack.DataType, Stack.DataType[]>(returns, param)); return; } } Stack.DataType curret = Natives[hash].Item1; Stack.DataType[] curpar = Natives[hash].Item2; if (Types.gettype(curret).precedence < Types.gettype(returns).precedence) { curret = returns; } for (int i = 0; i < curpar.Length; i++) { if (Types.gettype(curpar[i]).precedence < Types.gettype(param[i]).precedence) { curpar[i] = param[i]; } } Natives[hash] = new Tuple <Stack.DataType, Stack.DataType[]>(curret, curpar); }
public bool SetTypeAtIndex(uint index, Stack.DataType type) { Stack.DataType prev = Vars[(int)index].DataType; if (!type.IsUnknown() && (prev.IsUnknown() || prev.LessThan(type))) { Vars[(int)index].DataType = type; return(true); } return(false); }
public void UpdateNativeReturnType(ulong hash, Stack.DataType datatype) { if (Program.X64npi.UpdateRetType(hash, datatype) && NativeXRef.ContainsKey(hash)) { foreach (Function f in NativeXRef[hash]) { f.Dirty = true; } } }
public void UpdateNativeParameter(ulong hash, Stack.DataType type, int index) { if (Program.X64Npi.UpdateParam(hash, type, index)) { foreach (var f in _nativeXRef[hash]) { f.Dirty = true; } } }
public void UpdateNativeReturnType(ulong hash, Stack.DataType dataType) { if (Program.X64Npi.UpdateRetType(hash, dataType) && _nativeXRef.ContainsKey(hash)) { foreach (var f in _nativeXRef[hash]) { f.Dirty = true; } } }
public void UpdateStaticType(uint index, Stack.DataType dataType) { Stack.DataType prev = Statics.GetTypeAtIndex(index); if (Statics.SetTypeAtIndex(index, dataType)) { foreach (Function f in Functions) { f.Dirty = true; } } }
public void updaterettype(uint hash, Stack.DataType returns, bool over = false) { if (!Natives.ContainsKey(hash)) { return; } if (Types.gettype(Natives[hash].Item1).precedence < Types.gettype(returns).precedence || over) { Natives[hash] = new Tuple <Stack.DataType, Stack.DataType[]>(returns, Natives[hash].Item2); } }
public bool updateparam(uint hash, Stack.DataType type, int paramindex) { if (!Natives.ContainsKey(hash)) { return(false); } Stack.DataType[] paramslist = Natives[hash].Item2; paramslist[paramindex] = type; Natives[hash] = new Tuple <Stack.DataType, Stack.DataType[]>(Natives[hash].Item1, paramslist); return(true); }
public bool SetTypeAtIndex(uint index, Stack.DataType type) { var prev = _vars[(int)index].DataType; if (!type.IsUnknown() && (prev.IsUnknown() || prev.Precedence() < type.Precedence())) { _vars[(int)index].DataType = type; return(true); } return(false); }
public bool UpdateRetType(ulong hash, Stack.DataType returns, bool over = false) { lock (Program.ThreadLock) { Native native; if (TryGetValue(hash, out native) && !native.ReturnParam.FixedType) { if (native.ReturnParam.StackType.Precedence() < returns.Precedence()) { native.ReturnParam.Type = returns.LongName(); return(true); } } return(false); } }
public bool UpdateParam(ulong hash, Stack.DataType type, int index) { lock (Program.ThreadLock) { Native native; if (TryGetValue(hash, out native) && !native.Vardiac && index < native.Params.Count) { Param p = native.Params[index]; if (p.StackType.Precedence() < type.Precedence() && !p.FixedType) { p.Type = type.LongName(); return(true); } } return(false); } }
public static string Represent(int value, Stack.DataType type) { switch (type) { case Stack.DataType.Float: return(BitConverter.ToSingle(BitConverter.GetBytes(value), 0).ToString() + "f"); case Stack.DataType.Bool: break; //return value == 0 ? "false" : "true"; //still need to fix bools case Stack.DataType.FloatPtr: case Stack.DataType.IntPtr: case Stack.DataType.StringPtr: case Stack.DataType.UnkPtr: return("NULL"); } return(value.ToString()); }
public void updateparam(ulong hash, Stack.DataType type, int paramindex) { if (!Natives.ContainsKey(hash)) { return; } Stack.DataType[] paramslist = Natives[hash].Item2; if (paramindex >= paramslist.Length) { Stack.DataType[] Old = paramslist; paramslist = new Stack.DataType[paramindex + 1]; for (int i = 0; i < Old.Length; i++) { paramslist[i] = Old[i]; } } paramslist[paramindex] = type; Natives[hash] = new Tuple <Stack.DataType, Stack.DataType[]>(Natives[hash].Item1, paramslist); }
public static string Represent(long value, Stack.DataType type) { switch (type) { case Stack.DataType.Float: return(BitConverter.ToSingle(BitConverter.GetBytes(value), 0).ToString() + "f"); case Stack.DataType.Bool: return(value == 0 ? "false" : "true"); // still need to fix bools case Stack.DataType.FloatPtr: case Stack.DataType.IntPtr: case Stack.DataType.StringPtr: case Stack.DataType.UnkPtr: return("NULL"); } if (value > Int32.MaxValue && value <= UInt32.MaxValue) { return(((int)((uint)value)).ToString()); } return(value.ToString()); }
public string TypeToString(Stack.DataType type) { return(Types.gettype(type).singlename); }
public void SetTypeAtIndex(uint index, Stack.DataType type) { Vars[(int)index].DataType = type; }