public IRType PresolveType(TypeDefData pTypeDefData) { if (pTypeDefData == null) { throw new ArgumentNullException("pTypeDefData"); } return(AssemblyFileLookup[pTypeDefData.CLIFile].Types[pTypeDefData.TableIndex]); }
internal void LoadStage2() { Console.WriteLine("================================================== Stage 2: {0} ==================================================", File.ReferenceName); for (int typeIndex = 0; typeIndex < Types.Count; ++typeIndex) { IRType type = Types[typeIndex]; TypeDefData typeDefData = File.TypeDefTable[typeIndex]; if (typeDefData.Extends.Type != TypeDefRefOrSpecIndex.TypeDefRefOrSpecType.TypeDef || typeDefData.Extends.TypeDef != null) { type.BaseType = AppDomain.PresolveType(typeDefData.Extends); } for (int fieldIndex = 0; fieldIndex < type.Fields.Count; ++fieldIndex) { IRField field = type.Fields[fieldIndex]; field.Type = AppDomain.PresolveType(typeDefData.FieldList[fieldIndex].ExpandedSignature); if (field.Type == null) { throw new Exception(); } } } for (int methodIndex = 0; methodIndex < Methods.Count; ++methodIndex) { IRMethod method = Methods[methodIndex]; MethodDefData methodDefData = File.MethodDefTable[methodIndex]; var mGenParams = File.GenericParamTable.Where(gp => gp.Owner.Type == TypeOrMethodDefIndex.TypeOrMethodDefType.MethodDef && gp.Owner.MethodDef == methodDefData).ToList(); for (int i = 0; i < mGenParams.Count; i++) { method.GenericParameters.Add(IRType.GetMVarPlaceholder(mGenParams[i].Number)); } method.ReturnType = AppDomain.PresolveType(methodDefData.ExpandedSignature.RetType); for (int parameterIndex = 0; parameterIndex < method.Parameters.Count; ++parameterIndex) { IRParameter parameter = method.Parameters[parameterIndex]; parameter.Type = AppDomain.PresolveType(methodDefData.ExpandedSignature.Params[parameterIndex]); } for (int localIndex = 0; localIndex < method.Locals.Count; ++localIndex) { IRLocal local = method.Locals[localIndex]; local.Type = AppDomain.PresolveType(methodDefData.Body.ExpandedLocalVarSignature.LocalVars[localIndex]); } } for (int methodIndex = 0; methodIndex < Methods.Count; ++methodIndex) { IRMethod method = Methods[methodIndex]; MethodDefData methodDefData = File.MethodDefTable[methodIndex]; if (methodDefData.ExpandedSignature.HasThis && !methodDefData.ExpandedSignature.ExplicitThis) { IRParameter implicitThis = new IRParameter(this); implicitThis.ParentMethod = method; implicitThis.Type = method.ParentType.IsValueType ? AppDomain.GetPointerType(method.ParentType) : method.ParentType; method.Parameters.Insert(0, implicitThis); } } }
/* NOT USED: Type Definition Arrays will now be handled in the same manner as non-array type definition declarations * /// <summary> * /// TODO * /// </summary> * /// <param name="strTypeDefAry"></param> * /// <returns></returns> * public object[] ExtractTypeDefArrayData(string strTypeDefAry) * { * try * { * CHeaderDataSet.tblTypeDefsDataTable dtTypeDefs = m_dsHeaderData.tblTypeDefs; * * object[] aryTypeDefAryVarData = null; * * string strAnalyze = strTypeDefAry.Trim(); * strAnalyze = strAnalyze.Replace("typedef", "").Replace(";", "").Trim(); * * string[] aryTypeDefAryStr = strAnalyze.Split(' '); * * //Extract TypeDef Variable Name * string strTypeDefName = aryTypeDefAryStr[0]; * * //Extract Typedef Array Declaration Name and Total Number of elements in the array. * int iTotalAryElements = ExtractorUtils.CalculateFieldElements(aryTypeDefAryStr[aryTypeDefAryStr.Length - 1]); * string strTypeDefAryName = aryTypeDefAryStr[aryTypeDefAryStr.Length - 1].Split('[')[0].Trim(); * * //Set the number of bytes associated with the array type definition which will then be linked to the array typedef declaration name. * //The number of bytes will be calculated by multiplying the number of bytes associated with the primitive derived type definition associated * //with the array type definition. * CHeaderDataSet.tblTypeDefsRow rowTypeDef = dtTypeDefs.FindByTypeDefName(strTypeDefName); * * if (rowTypeDef == null) * return null; * * int iSrcTypeDefBytes = rowTypeDef.DataSize; * int iDataSizeBytes = iTotalAryElements * iSrcTypeDefBytes; * * aryTypeDefAryVarData = new object[] { strTypeDefAryName, strTypeDefName, iTotalAryElements, iDataSizeBytes }; * * return aryTypeDefAryVarData; * } * catch (Exception err) * { * ErrorHandler.ShowErrorMessage(err, "Error in ExtractTypeDefArrayData function of TypeExtractor class."); * return null; * } * } */ #endregion #region Enumeration Extraction Functions /// <summary> /// Examines an enumeration declaration and extracts the appropriate information about the definition into a TypeDefData data object. Once /// the appropriate data is extracted from the enumeration string supplied to the function, the data can be loaded into the appropriate data table /// and have their data types be identified in declared variables in structures. /// </summary> /// <param name="strEnumDef"></param> /// <returns></returns> public TypeDefData ExtractEnumData(string strEnumDef) { try { TypeDefData tdEnum = null; string[] aryEnumDefStr = null; string strEnumName = ""; if (strEnumDef.StartsWith("enum")) { strEnumDef = strEnumDef.Replace("enum", "").Trim(); aryEnumDefStr = strEnumDef.Split('{'); strEnumName = aryEnumDefStr[0].Trim(); } else { aryEnumDefStr = strEnumDef.Split('}'); //Extract Enumeration Typedef Declaration Name strEnumName = aryEnumDefStr[aryEnumDefStr.Length - 1]; strEnumName = strEnumName.Replace(";", "").Trim(); }//end if int iTotalElements = 1; //If the enumeration is declared as an array, then the total number of elements in the array and data size of the enumeration array //will be calculated. The data size of an enumeration will be the data size of enumerations on the system multiplied by the number //of elements in the array. if (strEnumName.Contains('[') && strEnumName.Contains(']')) { iTotalElements = ExtractorUtils.CalculateFieldElements(strEnumName); strEnumName = strEnumName.Split('[')[0].Trim(); }//end if tdEnum = new TypeDefData() { TypeDefName = strEnumName, Elements = iTotalElements, DataSize = EnumSizeBytes * iTotalElements }; return(tdEnum); } catch (Exception err) { ErrorHandler.ShowErrorMessage(err, "Error in ExtractEnumData function of TypeExtractor class."); return(null); } }
internal void LoadStage1() { Console.WriteLine("================================================== Stage 1: {0} ==================================================", File.ReferenceName); foreach (TypeDefData typeDefData in File.TypeDefTable) { Types.Add(new IRType(this)); } foreach (FieldData fieldData in File.FieldTable) { Fields.Add(new IRField(this)); } foreach (MethodDefData methodDefData in File.MethodDefTable) { Methods.Add(new IRMethod(this)); } for (int typeIndex = 0; typeIndex < Types.Count; ++typeIndex) { IRType type = Types[typeIndex]; TypeDefData typeDefData = File.TypeDefTable[typeIndex]; type.Namespace = typeDefData.TypeNamespace; type.Name = typeDefData.TypeName; var genParams = File.GenericParamTable.Where(gp => gp.Owner.Type == TypeOrMethodDefIndex.TypeOrMethodDefType.TypeDef && gp.Owner.TypeDef == typeDefData).ToList(); for (int i = 0; i < genParams.Count; i++) { type.GenericParameters.Add(IRType.GetVarPlaceholder(genParams[i].Number)); } foreach (FieldData fieldData in typeDefData.FieldList) { IRField field = Fields[fieldData.TableIndex]; field.Name = fieldData.Name; field.ParentType = type; type.Fields.Add(field); } foreach (MethodDefData methodDefData in typeDefData.MethodList) { IRMethod method = Methods[methodDefData.TableIndex]; method.Name = methodDefData.Name; method.ParentType = type; method.IsStatic = (methodDefData.Flags & MethodAttributes.Static) == MethodAttributes.Static; type.Methods.Add(method); foreach (ParamData paramData in methodDefData.ParamList) { IRParameter parameter = new IRParameter(this); parameter.ParentMethod = method; method.Parameters.Add(parameter); } if (methodDefData.Body != null && methodDefData.Body.ExpandedLocalVarSignature != null) { method.MaximumStackDepth = methodDefData.Body.MaxStack; foreach (SigLocalVar sigLocalVar in methodDefData.Body.ExpandedLocalVarSignature.LocalVars) { IRLocal local = new IRLocal(this); local.ParentMethod = method; local.Index = (uint)method.Locals.Count; method.Locals.Add(local); } } } } for (int typeIndex = 0; typeIndex < Types.Count; ++typeIndex) { IRType type = Types[typeIndex]; TypeDefData typeDefData = File.TypeDefTable[typeIndex]; foreach (TypeDefData nestedTypeDefData in typeDefData.NestedClassList) { IRType nestedType = Types[nestedTypeDefData.TableIndex]; nestedType.Namespace = type.Namespace + "." + type.Name; type.NestedTypes.Add(nestedType); } } if (CORLibrary) { AppDomain.CacheCORTypes(this); } }
/// <summary> /// Examines a type definition declaration and extracts the appropriate information about the definition into a TypeDefData data object. The /// ExtractTypeDefData function will be used to extract type defintions derived from primitive data types and other type definitions, /// pointers (including functions) and enumerations. Union and Structure type definitions will be extracted using the ExtractStructData function /// of the StructExtractor class instead. Once the appropriate data is extracted from the type definition string supplied to the function, the data /// can be loaded into the appropriate data table and have their data types be identified in declared variables in structures. /// </summary> /// <param name="strTypeDef"></param> /// <returns></returns> public TypeDefData ExtractTypeDefData(string strTypeDef) { try { TypeDefData tdTypeDef = new TypeDefData(); //Checks to see if the type definition is defined as an array and verifies that the array contains only numeric values. If //non-numeric values are presented in the type definition array declaration, they are first converted to their numeric equivalents //before proceeding with extracting the type definition declaration. if (!strTypeDef.StartsWith("typedef enum") && !strTypeDef.StartsWith("enum")) { if (strTypeDef.Contains('[') && strTypeDef.Contains(']')) { if (!ExtractorUtils.IsNumericArray(strTypeDef)) { strTypeDef = ExtractorUtils.ConvertNonNumericElements(m_HeaderAccess, strTypeDef); } }//end if string strAnalyze = strTypeDef.Trim(); strAnalyze = strAnalyze.Replace("typedef", "").Replace(";", "").Replace("\n", "").Trim(); string[] aryTypeDefStr = strAnalyze.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); //Extract Primitive C++ Data Type Name string strTypeDefDataType = ""; for (int i = 0; i < aryTypeDefStr.Length - 1; i++) { strTypeDefDataType += aryTypeDefStr[i] + " "; } strTypeDefDataType = strTypeDefDataType.TrimEnd(); //Extract Typedef Declaration Name string strTypeDefName = aryTypeDefStr[aryTypeDefStr.Length - 1]; //Set the number of bytes associated with the primitive C++ data type which will then be linked to the typedef declaration name. int iDataSizeBytes = 0; if (!strTypeDefDataType.Contains("*") && !strTypeDefName.Contains("*")) { if (DataAccess.PrimDataTypes.IsPrimitiveDataType(strTypeDefDataType)) { //Locates the associated primitive data type associated with the type definition and set the data size of the type definition, according //to the data type. switch (strTypeDefDataType) { case "RMascii": case "RMbool": case "RMuint8": case "RMint8": case "char": case "unsigned char": case "signed char": case "bool": iDataSizeBytes = 1; break; case "RMuint16": case "RMint16": case "short": case "short int": case "unsigned short": case "unsigned short int": case "signed short": case "signed short int": case "wchar_t": iDataSizeBytes = 2; break; case "RMuint32": case "RMint32": case "RMnewOperatorSize": case "int": case "unsigned int": case "signed int": case "long": case "long int": case "signed long": case "signed long int": case "unsigned long": case "unsigned long int": case "float": iDataSizeBytes = 4; break; case "RMint64": case "RMuint64": case "RMreal": case "long long": case "unsigned long long": case "double": case "long double": iDataSizeBytes = 8; break; } ; //end switch } else { //If the data type of the type definition is associated with another type definition, then the type definition will be located and the //data size of the type definition which is the associated data type of the type definition will be assigned to the type definition being //extracted. CHeaderDataSet.tblTypeDefsRow rowTypeDef = m_HeaderAccess.GetTypeDef(strTypeDefDataType); if (rowTypeDef == null) { return(null); } iDataSizeBytes = rowTypeDef.DataSize; }//end if } else { if (strTypeDefName.Contains('*')) { strTypeDefName = strTypeDefName.Replace("*", ""); } //Pointers variables will always be set to the pre-defined size of the pointer length on the operating system, which is preset in the //program's settings by the user. iDataSizeBytes = PointerSizeBytes; }//end if int iTotalElements = 1; //If the type definition is declared as an array, then the total number of elements in the array and data size of the type definition array //will be calculated. The data size of a type definition will be the data size of the data type associated with the type definition multiplied //by the number of elements in the array. if (strTypeDefName.Contains('[') && strTypeDefName.Contains(']')) { iTotalElements = ExtractorUtils.CalculateFieldElements(strTypeDefName); strTypeDefName = strTypeDefName.Split('[')[0].Trim(); }//end if tdTypeDef.TypeDefName = strTypeDefName; tdTypeDef.Elements = iTotalElements; tdTypeDef.DataSize = iDataSizeBytes * iTotalElements; } else { //Enumerations and Enumeration TypeDefs handled by ExtractEnumData function. tdTypeDef = ExtractEnumData(strTypeDef); }//end if return(tdTypeDef); } catch (Exception err) { ErrorHandler.ShowErrorMessage(err, "Error in ExtractTypeDefData function of TypeExtractor class."); return(null); } }
/*OBSOLETE: Header Files will be loaded and parsed in the Parse button click event handler. * /// <summary> * /// Loads the data of all the header files set in the header file names textbox into the HeaderDeclareParser object in the form, * /// which will then make the header data files available for parsing and extracting their type definition and structure data. * /// </summary> * /// <param name="sender"></param> * /// <param name="e"></param> * private void btnLoadHeaderFiles_Click(object sender, EventArgs e) * { * try * { * DateTime datStart = DateTime.Now; * * if (txtHeaderFileNames.Text.Trim() == "") * { * MessageBox.Show("No header files set to be loaded!", "", MessageBoxButtons.OK, MessageBoxIcon.Information); * return; * }//end if * * m_Parser.ClearHeaderData(); * * string[] aryHeaderFileNames = txtHeaderFileNames.Text. * Split(new string[] { "\r\n", ",", ";" }, StringSplitOptions.RemoveEmptyEntries) * .Select(filename => filename.Trim()) * .Where(filename => File.Exists(filename)) * .ToArray(); * * foreach (string strHeaderFileName in aryHeaderFileNames) * { * m_Parser.AppendHeaderFromFile(strHeaderFileName); * }//next strHeaderFileName * * btnParse.Enabled = true; * * TimeSpan tsElapsed = DateTime.Now.Subtract(datStart); * * MessageBox.Show("Header files loaded into CHeaderDeclareParser object! The header files can now be parsed.", "Headers Loaded", * MessageBoxButtons.OK, MessageBoxIcon.Information); * * if (chbShowHdrLoadTime.Checked) * MessageBox.Show("Header Data File Loading Time: " + tsElapsed.TotalSeconds.ToString() + " seconds"); * } * catch (Exception err) * { * ErrorHandler.ShowErrorMessage(err, "Error in btnLoadHeaderFiles_Click function of frmCHeaderExtract form."); * } * } */ #endregion #region Header Parsing and Extraction Functions, Event Handlers /// <summary> /// When the Parse button is clicked, all header data files will be loaded into the HeaderDeclareParser object of the form and then /// will be parsed and have the desired information extracted from the file into data objects. The parser will extract all type definition, /// enumerations, structure and union information from the file and load them into their associated data objects in the data tables of a /// CHeaderDataSet data object. Once all the data in the header data file (or set of files) is parsed, the extracted data can be /// queried and displayed in the form or extracted to other data file formats. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void btnParse_Click(object sender, EventArgs e) { try { DateTime datStartTime = DateTime.Now; if (!LoadHeaderFiles()) { return; } this.Cursor = Cursors.WaitCursor; m_Parser.CurrentPos = 0; m_HeaderAccess.TypeDefsTable.Rows.Clear(); m_HeaderAccess.StructuresTable.Rows.Clear(); m_HeaderAccess.FieldsTable.Rows.Clear(); TypeExtractor.PointerSizeBytes = Convert.ToInt32(txtPointerSize.Text); TypeExtractor.EnumSizeBytes = Convert.ToInt32(txtEnumSize.Text); StructExtractor.PointerSizeBytes = Convert.ToInt32(txtPointerSize.Text); StructExtractor.EnumSizeBytes = Convert.ToInt32(txtEnumSize.Text); do { if (m_Parser.IsTypeDef()) { string strTypeDef = m_Parser.GetTypeDef(); TypeDefData tdData = m_typeExt.ExtractTypeDefData(strTypeDef); if (tdData != null) { m_HeaderAccess.AddTypeDefRow(tdData); } } else if (m_Parser.IsEnum()) { string strEnum = m_Parser.GetEnum(); TypeDefData tdEnum = m_typeExt.ExtractEnumData(strEnum); if (tdEnum != null) { m_HeaderAccess.AddTypeDefRow(tdEnum); } } else if (m_Parser.IsStruct()) { string strStruct = m_Parser.GetStructure(); StructData sdData = m_structExt.ExtractStructData(strStruct); if (sdData != null) { m_HeaderAccess.AddStructRow(sdData); m_HeaderAccess.AddFieldRows(sdData.Fields); }//end if } else { m_Parser.MoveNextItem(); }//end if } while (!m_Parser.EndOfFile); TimeSpan tsElapsed = DateTime.Now.Subtract(datStartTime); //Once the parsing operation completes successfully, all the structures/unions extracted from the header files will be initially //queried and loaded in the form. rbQryDisplayAll.Checked = true; btnQuery_Click(btnQuery, EventArgs.Empty); this.Cursor = Cursors.Default; MessageBox.Show("Header File Parsing Completed!", "Complete", MessageBoxButtons.OK, MessageBoxIcon.Information); if (chbShowParseTime.Checked) { MessageBox.Show("Parsing Time: " + tsElapsed.TotalSeconds.ToString() + " seconds"); } } catch (Exception err) { this.Cursor = Cursors.Default; ErrorHandler.ShowErrorMessage(err, "Error in btnParse_Click function of frmCHeaderExtract form."); } }