public void TtranUnionPointersStructures()
{
UnionType ut = factory.CreateUnionType("foo", null);
var str1 = new StructureType()
{
Fields =
{
{ 0, PrimitiveType.Word32 },
{ 4, PrimitiveType.Int32 },
},
};
var str2 = new StructureType()
{
Fields =
{
{ 0, PrimitiveType.Real32 },
{ 4, PrimitiveType.Word32 },
},
};
var eq1 = new EquivalenceClass(factory.CreateTypeVariable(), str1);
var eq2 = new EquivalenceClass(factory.CreateTypeVariable(), str2);
ut.AddAlternative(new Pointer(eq1, 32));
ut.AddAlternative(new Pointer(eq2, 32));
var trans = new TypeTransformer(factory, null, null);
var ptr = (Pointer)ut.Accept(trans);
var eq = (EquivalenceClass)ptr.Pointee;
Assert.AreEqual(
"(struct (0 real32 r0000) (4 int32 dw0004))",
eq.DataType.ToString());
}
protected override void RunTest(Program program, string outputFileName)
{
ExpressionNormalizer aen = new ExpressionNormalizer(program.Architecture.PointerType);
aen.Transform(program);
EquivalenceClassBuilder eq = new EquivalenceClassBuilder(factory, store);
eq.Build(program);
#if OLD
DataTypeBuilder dtb = new DataTypeBuilder(factory, store, program.Architecture);
TraitCollector coll = new TraitCollector(factory, store, dtb, program);
coll.CollectProgramTraits(program);
dtb.BuildEquivalenceClassDataTypes();
#else
TypeCollector coll = new TypeCollector(factory, store, program);
coll.CollectTypes();
store.BuildEquivalenceClassDataTypes(factory);
#endif
TypeVariableReplacer tvr = new TypeVariableReplacer(store);
tvr.ReplaceTypeVariables();
TypeTransformer trans = new TypeTransformer(factory, store, program);
trans.Transform();
using (FileUnitTester fut = new FileUnitTester(outputFileName))
{
foreach (Procedure proc in program.Procedures.Values)
{
proc.Write(false, fut.TextWriter);
fut.TextWriter.WriteLine();
}
store.Write(fut.TextWriter);
fut.AssertFilesEqual();
}
}
protected override void RunTest(Program program, string outputFileName)
{
Exception theEx = null;
try
{
RunTestCore(program);
}
catch (Exception ex)
{
theEx = ex;
}
try
{
TypeTransformer trans = new TypeTransformer(factory, store, program);
trans.Transform();
}
catch (Exception ex)
{
theEx = ex;
}
using (FileUnitTester fut = new FileUnitTester(outputFileName))
{
if (theEx != null)
{
fut.TextWriter.WriteLine(theEx.Message);
fut.TextWriter.WriteLine(theEx.StackTrace);
}
WriteTestResults(program, fut.TextWriter);
fut.AssertFilesEqual();
}
}
public void TtranUnionPointersStructuresWithDifferentSizes()
{
UnionType ut = factory.CreateUnionType("foo", null);
var str1 = new StructureType(12)
{
Fields =
{
{ 0, PrimitiveType.Word32 },
{ 4, PrimitiveType.Int32 },
},
};
var str2 = new StructureType(16)
{
Fields =
{
{ 0, PrimitiveType.Real32 },
{ 4, PrimitiveType.Word32 },
},
};
var eq1 = new EquivalenceClass(factory.CreateTypeVariable(), str1);
var eq2 = new EquivalenceClass(factory.CreateTypeVariable(), str2);
ut.AddAlternative(new Pointer(eq1, 32));
ut.AddAlternative(new Pointer(eq2, 32));
var trans = new TypeTransformer(factory, null, null);
var dt = ut.Accept(trans);
Assert.AreEqual(
"(union \"foo\" ((ptr32 Eq_1) u0) ((ptr32 Eq_2) u1))",
dt.ToString());
}
public void HasNoCoincidentFields()
{
StructureType s = new StructureType(null, 0);
s.Fields.Add(4, new TypeVariable(1));
s.Fields.Add(5, PrimitiveType.Word16);
Assert.AreEqual(2, s.Fields.Count);
TypeTransformer trans = new TypeTransformer(factory, null, null);
Assert.IsFalse(trans.HasCoincidentFields(s));
}
public void Transform_IgnoreAllNulls_ResultWithEmptyProperties()
{
var transformer = new TypeTransformer(typeof(NullClassFixture), true, null);
var tranObj = transformer.Transform(new NullClassFixture());
Assert.Equal(typeof(NullClassFixture).Name, tranObj.TypeTag);
Assert.Empty(tranObj.Properties);
}
public void HasCoincidentFields()
{
StructureType s = new StructureType(null, 0);
s.Fields.Add(4, new TypeVariable(1));
s.Fields.Add(4, PrimitiveType.Word16);
Assert.AreEqual(2, s.Fields.Count);
TypeTransformer trans = new TypeTransformer(factory, null, null);
Assert.IsTrue(trans.HasCoincidentFields(s));
}
public void TtranSimplify2()
{
UnionType u = new UnionType(null, null);
u.Alternatives.Add(PrimitiveType.Word32);
u.Alternatives.Add(new Pointer(PrimitiveType.Real32, 4));
TypeTransformer trans = new TypeTransformer(factory, store, null);
DataType dt = u.Accept(trans);
Assert.AreEqual("(ptr real32)", dt.ToString());
}
public void SetupPreStages(Program prog)
{
aen = new ExpressionNormalizer(prog.Platform.PointerType);
eqb = new EquivalenceClassBuilder(prog.TypeFactory, prog.TypeStore);
dtb = new DataTypeBuilder(prog.TypeFactory, prog.TypeStore, prog.Platform);
tvr = new TypeVariableReplacer(prog.TypeStore);
trans = new TypeTransformer(prog.TypeFactory, prog.TypeStore, prog);
ctn = new ComplexTypeNamer();
}
private void _DatabaseExplorer_ChangedSelection(object sender, ExplorerControl.SelectionChangedEventArgs e)
{
_DagColumnDefinitions.ItemsSource = null;
_DagTableAssociations.ItemsSource = null;
_TxtTableDescription.IsEnabled = false;
_TxtTableDescription.Text = _TxtColumnDescription.Text = "";
if (e.SelectionType != ExplorerControl.Selection.None)
{
_DagConfigurations.ItemsSource = e.Database.Configuration;
switch (e.Database.TargetDb)
{
case DbProvider.Sqlite:
type_transformer = new SqliteTypeTransformer();
break;
case DbProvider.MySQL:
type_transformer = new MySqlTypeTransformer();
break;
}
ColumnDbType.ItemsSource = type_transformer.DbTypes();
DataContext = e.Database;
NetTypes = new ObservableCollection <string>(DefaultNetTypes);
foreach (var type in e.Database.Enumeration)
{
NetTypes.Add(type.Name);
}
ColumnNetType.ItemsSource = NetTypes;
//_TabEnums.DataContext = e.Database.Enumeration;
}
if (e.SelectionType == ExplorerControl.Selection.TableItem)
{
_DagColumnDefinitions.ItemsSource = e.Table.Column;
_tabTableSql.DataContext = e.Table;
//_tabTable.IsSelected = true;
_TxtTableDescription.IsEnabled = true;
_TxtTableDescription.DataContext = e.Table;
_DagTableAssociations.ItemsSource = e.Database.GetAssociations(e.Table);
}
else if (e.SelectionType == ExplorerControl.Selection.Database)
{
//_tabConfig.IsSelected = true;
}
UpdateTitle();
}
public void TtranUserStruct()
{
var t1 = new StructureType("T1", 4, true);
var t2 = new StructureType("T2", 0, true)
{
Fields = { { 0, t1 } }
};
var ttran = new TypeTransformer(factory, store, null);
var dt = t2.Accept(ttran);
Assert.AreSame(t2, dt, "Should not affect user-defined types");
}
public void TtranNonUserStruct()
{
var t1 = new StructureType("T1", 4, true);
var t2 = new StructureType("T2", 0, false)
{
Fields = { { 0, t1 } }
};
var ttran = new TypeTransformer(factory, store, null);
var dt = t2.Accept(ttran);
Assert.AreSame(t1, dt, "Should reduce fields at offset 0 ");
}
public void SetupPreStages(Program program)
{
foreach (var f in userDefinedGlobals)
{
program.GlobalFields.Fields.Add(f);
}
aen = new ExpressionNormalizer(program.Platform.PointerType);
eqb = new EquivalenceClassBuilder(program.TypeFactory, program.TypeStore);
dtb = new DataTypeBuilder(program.TypeFactory, program.TypeStore, program.Platform);
tvr = new TypeVariableReplacer(program.TypeStore);
trans = new TypeTransformer(program.TypeFactory, program.TypeStore, program);
ctn = new ComplexTypeNamer();
}
protected override void RunTest(Program program, string outputFileName)
{
var listener = new FakeDecompilerEventListener();
ExpressionNormalizer aen = new ExpressionNormalizer(program.Architecture.PointerType);
aen.Transform(program);
EquivalenceClassBuilder eq = new EquivalenceClassBuilder(factory, store, listener);
eq.Build(program);
#if OLD
DataTypeBuilder dtb = new DataTypeBuilder(factory, store, program.Architecture);
TraitCollector coll = new TraitCollector(factory, store, dtb, program);
coll.CollectProgramTraits(program);
sktore.BuildEquivalenceClassDataTypes(factory);
#else
TypeCollector coll = new TypeCollector(factory, store, program, listener);
coll.CollectTypes();
store.BuildEquivalenceClassDataTypes(factory);
#endif
TypeVariableReplacer tvr = new TypeVariableReplacer(store);
tvr.ReplaceTypeVariables();
Exception theEx = null;
try
{
TypeTransformer trans = new TypeTransformer(factory, store, program);
trans.Transform();
} catch (Exception ex)
{
theEx = ex;
}
using (FileUnitTester fut = new FileUnitTester(outputFileName))
{
if (theEx != null)
{
fut.TextWriter.WriteLine(theEx.Message);
fut.TextWriter.WriteLine(theEx.StackTrace);
}
foreach (Procedure proc in program.Procedures.Values)
{
proc.Write(false, fut.TextWriter);
fut.TextWriter.WriteLine();
}
store.Write(fut.TextWriter);
fut.AssertFilesEqual();
}
}
public void TtranUnion()
{
UnionType t = factory.CreateUnionType("foo", null);
t.Alternatives.Add(new UnionAlternative(PrimitiveType.Word32));
t.Alternatives.Add(new UnionAlternative(PrimitiveType.Word32));
t.Alternatives.Add(new UnionAlternative(PrimitiveType.Word32));
t.Alternatives.Add(new UnionAlternative(PrimitiveType.Word32));
TypeTransformer trans = new TypeTransformer(factory, null, null);
PrimitiveType dt = (PrimitiveType) t.Accept(trans);
Assert.AreEqual("word32", dt.ToString());
t.Alternatives.Add(PrimitiveType.Real32);
t.Alternatives.Add(PrimitiveType.Int32);
DataType d = t.Accept(trans);
Assert.AreEqual("(union \"foo\" (int32 u0) (real32 u1))", d.ToString());
}
/// <summary>
/// Performs type analysis and rewrites program based on the inferred information.
/// </summary>
/// <remarks>
/// For instance, all MemoryAccesses will be converted to structure field
/// accesses or array accesses as appropriate.
/// </remarks>
/// <param name="program"></param>
public void RewriteProgram(Program program)
{
factory = program.TypeFactory;
store = program.TypeStore;
aen = new ExpressionNormalizer(program.Platform.PointerType);
eqb = new EquivalenceClassBuilder(factory, store);
#if OLD
dtb = new DataTypeBuilder(factory, store, program.Platform);
trco = new TraitCollector(factory, store, dtb, program);
#else
tyco = new TypeCollector(program.TypeFactory, program.TypeStore, program);
#endif
//dpa = new DerivedPointerAnalysis(factory, store, program.Architecture);
tvr = new TypeVariableReplacer(store);
trans = new TypeTransformer(factory, store,program, eventListener);
ctn = new ComplexTypeNamer();
ter = new TypedExpressionRewriter(program);
// RestrictProcedures(program, 0, 1, true); // Re-enable this for debugging
eventListener.ShowStatus("Gathering primitive datatypes from instructions.");
aen.Transform(program);
eqb.Build(program);
#if OLD
eventListener.ShowStatus("Collecting datatype usage traits.");
trco.CollectProgramTraits(program);
eventListener.ShowStatus("Building equivalence classes.");
dtb.BuildEquivalenceClassDataTypes();
#else
eventListener.ShowStatus("Collecting data types");
tyco.CollectTypes();
store.BuildEquivalenceClassDataTypes(factory);
#endif
//dpa.FollowConstantPointers(prog);
tvr.ReplaceTypeVariables();
eventListener.ShowStatus("Transforming datatypes.");
var ppr = new PtrPrimitiveReplacer(factory, store, program);
ppr.ReplaceAll();
trans.Transform();
ctn.RenameAllTypes(store);
store.Dump();
eventListener.ShowStatus("Rewriting expressions.");
ter.RewriteProgram(program);
}
public void HasCoincidentUnion()
{
var eq = new EquivalenceClass(
new TypeVariable(42),
new UnionType(null, null,
PrimitiveType.SegPtr32, PrimitiveType.Word16));
var s = new StructureType(null, 0)
{
Fields =
{
{ 0, eq },
{ 0, PrimitiveType.SegmentSelector }
}
};
TypeTransformer trans = new TypeTransformer(factory, null, null);
Assert.IsTrue(trans.HasCoincidentFields(s));
}
public void MergeIdenticalStructureFields()
{
StructureType s = factory.CreateStructureType(null, 0);
s.Fields.Add(4, new TypeVariable(1));
s.Fields.Add(4, new TypeVariable(1));
s.Fields.Add(4, new TypeVariable(1));
s.Fields.Add(4, new TypeVariable(1));
s.Fields[0].DataType = PrimitiveType.Int16;
s.Fields[1].DataType = PrimitiveType.Int16;
s.Fields[2].DataType = PrimitiveType.Int16;
s.Fields[3].DataType = PrimitiveType.Int16;
Assert.AreEqual(4, s.Fields.Count);
TypeTransformer trans = new TypeTransformer(factory, null, null);
StructureType sNew = trans.MergeStructureFields(s);
Assert.AreEqual(1, sNew.Fields.Count);
Assert.AreEqual("int16", sNew.Fields[0].DataType.ToString());
}
public void Transform_CheckIgnore_PropertyNotInResult()
{
var numProp = PropertyFinder.FromExpression <NullClassFixture>(f => f.Num);
var tranDic = new Dictionary <PropertyInfo, IPropertyTransformer>
{
[numProp] = new PropertyTransformerFixture
{
ShouldIgnore = true
}
};
var transformer = new TypeTransformer(typeof(NullClassFixture), false, tranDic);
var tranObj = transformer.Transform(new NullClassFixture());
Assert.DoesNotContain(tranObj.Properties, x => x.Name == nameof(NullClassFixture.Num));
}
protected override void RunTest(Program program, string outputFileName)
{
ExpressionNormalizer aen = new ExpressionNormalizer(program.Architecture.PointerType);
aen.Transform(program);
EquivalenceClassBuilder eq = new EquivalenceClassBuilder(factory, store);
eq.Build(program);
#if OLD
DataTypeBuilder dtb = new DataTypeBuilder(factory, store, program.Architecture);
TraitCollector coll = new TraitCollector(factory, store, dtb, program);
coll.CollectProgramTraits(program);
sktore.BuildEquivalenceClassDataTypes(factory);
#else
TypeCollector coll = new TypeCollector(factory, store, program, new FakeDecompilerEventListener());
coll.CollectTypes();
store.BuildEquivalenceClassDataTypes(factory);
#endif
TypeVariableReplacer tvr = new TypeVariableReplacer(store);
tvr.ReplaceTypeVariables();
Exception theEx = null;
try
{
TypeTransformer trans = new TypeTransformer(factory, store, program);
trans.Transform();
} catch (Exception ex)
{
theEx = ex;
}
using (FileUnitTester fut = new FileUnitTester(outputFileName))
{
if (theEx != null)
{
fut.TextWriter.WriteLine(theEx.Message);
fut.TextWriter.WriteLine(theEx.StackTrace);
}
foreach (Procedure proc in program.Procedures.Values)
{
proc.Write(false, fut.TextWriter);
fut.TextWriter.WriteLine();
}
store.Write(fut.TextWriter);
fut.AssertFilesEqual();
}
}
public void HasCoincidentUnion()
{
var eq = new EquivalenceClass(
new TypeVariable(42),
new UnionType(null, null,
PrimitiveType.SegPtr32, PrimitiveType.Word16));
var s = new StructureType(null, 0)
{
Fields =
{
{ 0, eq },
{ 0, PrimitiveType.SegmentSelector }
}
};
TypeTransformer trans = new TypeTransformer(factory, null, null);
Assert.IsTrue(trans.HasCoincidentFields(s));
}
public string Print(CXXFunctionInfo info, CXXFileType fileType)
{
var sb = new StringBuilder();
var returnTypeStr = TypeTransformer.TransformType(info.Type);
var parameterStr = PrintParameters(info, fileType);
info.ForAttribute <AsyncAttribute>(attr =>
{
parameterStr += $", std::function<void({(info.Type.Native != typeof(void) ? returnTypeStr : string.Empty)})> Callback";
returnTypeStr = "void";
});
sb.AppendLine($"{(info.IsStatic ? "static " : string.Empty)}{returnTypeStr} {NameTransformer.TransformName(info, info.Name, NameContext.Method)}({parameterStr})", 1);
return(sb.ToString());
}
public void SetupPreStages(Program program)
{
var listener = new FakeDecompilerEventListener();
foreach (var f in userDefinedGlobals)
{
program.GlobalFields.Fields.Add(f);
}
foreach (var s in imageSegments.Values)
{
program.SegmentMap.Segments.Add(s.Address, s);
}
aen = new ExpressionNormalizer(program.Platform.PointerType);
eqb = new EquivalenceClassBuilder(program.TypeFactory, program.TypeStore, listener);
dtb = new DataTypeBuilder(program.TypeFactory, program.TypeStore, program.Platform);
tvr = new TypeVariableReplacer(program.TypeStore);
trans = new TypeTransformer(program.TypeFactory, program.TypeStore, program);
ctn = new ComplexTypeNamer();
}
public void TtranUnion()
{
UnionType ut = factory.CreateUnionType("foo", null);
ut.AddAlternative(PrimitiveType.Word32);
ut.AddAlternative(PrimitiveType.Word32);
ut.AddAlternative(PrimitiveType.Word32);
ut.AddAlternative(PrimitiveType.Word32);
TypeTransformer trans = new TypeTransformer(factory, null, null);
PrimitiveType dt = (PrimitiveType)ut.Accept(trans);
Assert.AreEqual("word32", dt.ToString());
ut.AddAlternative(PrimitiveType.Real32);
ut.AddAlternative(PrimitiveType.Int32);
// TypeTransformer.Transform() clear some state (TypeTransformer.visitedTypes) between iterations.
trans = new TypeTransformer(factory, null, null);
DataType d = ut.Accept(trans);
Assert.AreEqual("(union \"foo\" (int32 u0) (real32 u1))", d.ToString());
}
private void RunTestCore(Program program)
{
var listener = new FakeDecompilerEventListener();
var aen = new ExpressionNormalizer(program.Architecture.PointerType);
aen.Transform(program);
var eq = new EquivalenceClassBuilder(factory, store, listener);
eq.Build(program);
var coll = new TypeCollector(factory, store, program, listener);
coll.CollectTypes();
store.BuildEquivalenceClassDataTypes(factory);
var tvr = new TypeVariableReplacer(store);
tvr.ReplaceTypeVariables();
var trans = new TypeTransformer(factory, store, program);
trans.Transform();
}
public void Transform_CheckPropertyTransformer()
{
var numProp = PropertyFinder.FromExpression <NullClassFixture>(f => f.Num);
var tranDic = new Dictionary <PropertyInfo, IPropertyTransformer>
{
[numProp] = new PropertyTransformerFixture
{
ShouldIgnore = false,
FixtureName = "AAA",
FixtureValue = "BBB",
NeedDestructure = true
}
};
var transformer = new TypeTransformer(typeof(NullClassFixture), false, tranDic);
var tranObj = transformer.Transform(new NullClassFixture());
Assert.Equal(typeof(NullClassFixture).Name, tranObj.TypeTag);
Assert.Contains(tranObj.Properties,
x => x.Name == "AAA" &&
x.Value.Equals("BBB") &&
x.NeedsDestruct);
}
public override async Task <Database> GenerateDdl()
{
await Task.Run(() => {
var mwb_xml = new XmlDocument();
if (xml_format)
{
mwb_xml.Load(mwb_file_location);
}
else
{
using (var mwb_archive = ZipFile.OpenRead(mwb_file_location)) {
var zip_mwb = mwb_archive.GetEntry("document.mwb.xml");
if (zip_mwb == null)
{
throw new FileNotFoundException("Could not find the 'document.mwb.xml' inside the specified MWB file.");
}
using (var stream = zip_mwb.Open()) {
mwb_xml.Load(stream);
}
}
}
var xml_db_schema = mwb_xml.SelectSingleNode(@"/data
/value[@struct-name='workbench.Document']
/value[@content-struct-name='workbench.physical.Model']
/value[@struct-name='workbench.physical.Model']
/value[@struct-name='db.mysql.Catalog']
/value[@content-struct-name='db.mysql.Schema']
/value[@struct-name='db.mysql.Schema']" );
var xml_tables = xml_db_schema.SelectNodes(@"
value[@content-struct-name='db.mysql.Table']
/value" );
database.Name = xml_db_schema.SelectSingleNode("value[@key='name']").InnerText;
database.TargetDb = DbProvider.MySQL;
//database.Name = Path.GetFileNameWithoutExtension(connection.DataSource);
// Get the tables.
foreach (XmlNode xml_table in xml_tables)
{
var name_node = xml_table.SelectSingleNode("value[@key=\"name\"]");
var table = new Table()
{
Name = name_node.InnerText
};
var xml_columns = xml_table.SelectNodes(@"value[@key='columns']/value");
foreach (XmlNode xml_column in xml_columns)
{
var column = new Column()
{
Name = xml_column.SelectSingleNode(@"value[@key='name']").InnerText,
Description = xml_column.SelectSingleNode(@"value[@key='comment']").InnerText,
DefaultValue = xml_column.SelectSingleNode(@"value[@key='defaultValue']").InnerText,
};
var auto_increment = xml_column.SelectSingleNode(@"value[@key='autoIncrement']").InnerText;
column.IsAutoIncrement = (auto_increment == "0" || auto_increment == null) ? false : true;
var length = xml_column.SelectSingleNode(@"value[@key='length']").InnerText;
column.DbLength = (length == "-1" || length == null) ? 0 : Convert.ToInt32(length);
var nullable = xml_column.SelectSingleNode(@"value[@key='isNotNull']").InnerText;
column.Nullable = (nullable == "0" || nullable == null) ? true : false;
var db_type = xml_column.SelectSingleNode(@"link[@struct-name='db.SimpleDatatype']");
if (db_type != null)
{
column.DbType = db_type.InnerText.Replace("com.mysql.rdbms.mysql.datatype.", "").ToUpper();
}
else
{
db_type = xml_column.SelectSingleNode(@"link[@struct-name='db.UserDatatype']");
if (db_type != null)
{
column.DbType = db_type.InnerText.Replace("com.mysql.rdbms.mysql.userdatatype.", "").ToUpper();
}
else
{
throw new Exception("Unknown data type for column '" + column.Name + "' in table '" + table.Name + "'.");
}
}
try {
column.NetType = TypeTransformer.DbToNetType(column.DbType);
} catch {
throw new Exception("Unknown data type for column '" + column.Name + "' in table '" + table.Name + "'.");
}
column.IsPrimaryKey = column.IsAutoIncrement;
table.Column.Add(column);
}
database.Table.Add(table);
}
});
return(database);
}
public SqlTableCreateGenerator(Database database, TypeTransformer type_transformer)
{
this.database = database;
this.type_transformer = type_transformer;
}
public override async Task <Database> GenerateDdl()
{
await Task.Run(() => {
connection.Open();
database.Name = Path.GetFileNameWithoutExtension(connection.DataSource);
// Get the tables.
using (var command = connection.CreateCommand()) {
command.CommandText = "SELECT tbl_name FROM sqlite_master WHERE type = 'table'";
using (var reader = command.ExecuteReader()) {
while (reader.Read())
{
var table = new Table();
table.Name = reader.GetString(0);
if (table.Name == "sqlite_sequence")
{
continue;
}
database.Table.Add(table);
}
}
}
// Get default Pragma configurations.
using (var command = connection.CreateCommand()) {
foreach (var config in SqlitePragmaConfigurations.Configurations)
{
string name = config.Name.Replace("sqlite.pragma.", "");
command.CommandText = "PRAGMA " + name;
using (var reader = command.ExecuteReader()) {
reader.Read();
try {
database.Configuration.Add(new Configuration()
{
Name = config.Name,
Value = reader[name].ToString(),
Description = config.Description
});
} catch { }
}
}
}
foreach (var table in database.Table)
{
// Get the columns
using (var command = connection.CreateCommand()) {
command.CommandText = "PRAGMA table_info(" + table.Name + ")";
using (var reader = command.ExecuteReader()) {
while (reader.Read())
{
var typ = reader["type"].ToString();
var column = new Column()
{
Name = reader["name"].ToString(),
IsPrimaryKey = Convert.ToBoolean(reader["pk"]),
Nullable = !Convert.ToBoolean(reader["notnull"]),
DbType = reader["type"].ToString(),
NetType = TypeTransformer.DbToNetType(reader["type"].ToString()),
};
if (column.IsPrimaryKey && column.DbType.ToLower() == "integer")
{
column.IsPrimaryKey = true;
}
table.Column.Add(column);
}
}
}
// Get the indexes.
using (var command = connection.CreateCommand()) {
command.CommandText = "SELECT name, tbl_name FROM sqlite_master WHERE type = 'index' AND tbl_name = @TableName";
Utilities.addDbParameter(command, "@TableName", table.Name);
using (var reader = command.ExecuteReader()) {
while (reader.Read())
{
var index = new Index()
{
Name = reader.GetString(0),
Table = database.Table.First(t => t.Name == table.Name)
};
table.Index.Add(index);
}
}
}
if (table.Index.Count == 0)
{
continue;
}
using (var command = connection.CreateCommand()) {
var columns = new List <IndexColumn>();
foreach (var index in table.Index)
{
columns.Clear();
// Using a parameter here instead of a hard value seems to cause SQL syntax errors...
command.CommandText = "PRAGMA index_info ( " + index.Name + " )";
using (var reader = command.ExecuteReader()) {
while (reader.Read())
{
index.IndexColumn.Add(new IndexColumn()
{
Name = reader["name"].ToString()
});
}
}
}
}
}
//CREATE UNIQUE INDEX "main"."Test" ON "MangaTitles" ("Manga_id" ASC)
connection.Close();
});
return(database);
}
public void SetupPreStages(Program prog)
{
aen = new ExpressionNormalizer(prog.Platform.PointerType);
eqb = new EquivalenceClassBuilder(prog.TypeFactory, prog.TypeStore);
dtb = new DataTypeBuilder(prog.TypeFactory, prog.TypeStore, prog.Platform);
tvr = new TypeVariableReplacer(prog.TypeStore);
trans = new TypeTransformer(prog.TypeFactory, prog.TypeStore, prog);
ctn = new ComplexTypeNamer();
}
public void SetupPreStages(Program program)
{
foreach (var f in userDefinedGlobals)
{
program.GlobalFields.Fields.Add(f);
}
foreach (var s in imageSegments.Values)
{
program.SegmentMap.Segments.Add(s.Address, s);
}
aen = new ExpressionNormalizer(program.Platform.PointerType);
eqb = new EquivalenceClassBuilder(program.TypeFactory, program.TypeStore);
dtb = new DataTypeBuilder(program.TypeFactory, program.TypeStore, program.Platform);
tvr = new TypeVariableReplacer(program.TypeStore);
trans = new TypeTransformer(program.TypeFactory, program.TypeStore, program);
ctn = new ComplexTypeNamer();
}
public void TtranUserStruct()
{
var t1 = new StructureType("T1", 4, true);
var t2 = new StructureType("T2", 0, true)
{
Fields = { { 0, t1 } }
};
var ttran = new TypeTransformer(factory, store, null);
var dt = t2.Accept(ttran);
Assert.AreSame(t2, dt, "Should not affect user-defined types");
}
public void TtranNonUserStruct()
{
var t1 = new StructureType("T1", 4, true);
var t2 = new StructureType("T2", 0, false)
{
Fields = { { 0, t1 } }
};
var ttran = new TypeTransformer(factory, store, null);
var dt = t2.Accept(ttran);
Assert.AreSame(t1, dt, "Should reduce fields at offset 0 ");
}
private DataType parseAndResolve(string file)
{
loadingProgress.Tick();
Module ast = getAstForFile(file);
if (ast == null)
{
failedToParse.Add(file);
return null;
}
else
{
DataType type = new TypeTransformer(ModuleTable, this).VisitModule(ast);
loadedFiles.Add(file);
return type;
}
}
public void Setup()
{
factory = new TypeFactory();
store = new TypeStore();
trans = new TypeTransformer(factory, store, null);
}
/// <summary>
/// Bind a name to this scope, including destructuring assignment.
/// </summary>
public void Bind(Analyzer analyzer, Exp target, DataType rvalue, BindingKind kind)
{
if (target is Identifier)
{
this.Bind(analyzer, (Identifier) target, rvalue, kind);
}
else if (target is PyTuple)
{
this.Bind(analyzer, ((PyTuple) target).values, rvalue, kind);
}
else if (target is PyList)
{
this.Bind(analyzer, ((PyList) target).elts, rvalue, kind);
}
else if (target is AttributeAccess)
{
var attr = (AttributeAccess) target;
DataType targetType = transformExpr(analyzer, attr.Expression, this);
setAttr(analyzer, attr, rvalue, targetType);
}
else if (target is ArrayRef)
{
ArrayRef sub = (ArrayRef) target;
DataType valueType = transformExpr(analyzer, sub.array, this);
var xform = new TypeTransformer(this, analyzer);
transformExprs(analyzer, sub.subs, this);
if (valueType is ListType)
{
ListType t = (ListType) valueType;
t.setElementType(UnionType.Union(t.eltType, rvalue));
}
}
else if (target != null)
{
analyzer.putProblem(target, "invalid location for assignment");
}
}
public void Setup()
{
factory = new TypeFactory();
store = new TypeStore();
trans = new TypeTransformer(factory, store, null);
}
public static void transformExprs(Analyzer analyzer, List<Slice> exprs, State s)
{
var x = new TypeTransformer(s, analyzer);
foreach (var e in exprs)
{
e.Accept(x);
}
}
