/// <summary> /// Gets the size (in bytes) of the data type passed to the function and returns the value. All data types, including primitive, /// type definitions, enumeations and structures can be evaluated, so it will be neccessary to pass in the HeaderData data set /// to use to check for the appropriate extracted data types, such as type definitions and structures that were defined in the header. /// </summary> /// <param name="HeaderAccess"></param> /// <param name="strDataTypeName"></param> /// <returns></returns> public static int SizeOfDataType(DataAccess HeaderAccess, string strDataTypeName) { try { int iDataSizeBytes = 0; if (DataAccess.PrimDataTypes.IsPrimitiveDataType(strDataTypeName)) { iDataSizeBytes = DataAccess.PrimDataTypes[strDataTypeName]; } else if (HeaderAccess.TypeDefExists(strDataTypeName)) { CHeaderDataSet.tblTypeDefsRow rowTypeDef = HeaderAccess.GetTypeDef(strDataTypeName); iDataSizeBytes = rowTypeDef.DataSize; } else if (HeaderAccess.StructExists(strDataTypeName)) { CHeaderDataSet.tblStructuresRow rowStruct = HeaderAccess.GetStruct(strDataTypeName); iDataSizeBytes = rowStruct.DataSize; }//end if return(iDataSizeBytes); } catch (Exception err) { ErrorHandler.ShowErrorMessage(err, "Error in SizeOfDataType function of ExtractorUtils class."); return(0); } }
/// <summary> /// Retrieves a set of FieldData rows in the Fields data table in the Header Data Set object linked to the DataAccess class that are contained /// in the structure/union specified in the function's StructName parameter. Each field in a structure/union will be keyed by the name of the /// structure/union concatenated with the index of the field. /// </summary> /// <param name="strStructName"></param> /// <returns></returns> public CHeaderDataSet.tblFieldsRow[] GetStructFields(string strStructName) { try { CHeaderDataSet.tblStructuresRow rowStruct = GetStruct(strStructName); if (rowStruct == null) { return(null); } CHeaderDataSet.tblFieldsRow[] rowFields = new CHeaderDataSet.tblFieldsRow[rowStruct.FieldCount]; for (int iFieldIndex = 0; iFieldIndex < rowFields.Length; iFieldIndex++) { rowFields[iFieldIndex] = FieldsTable.FindByFieldKey(rowStruct.StructName + "_" + iFieldIndex.ToString()); }//next iFieldIndex return(rowFields); } catch (Exception err) { ErrorHandler.ShowErrorMessage(err, "Error in GetStructFields function of DataAccess class."); return(null); } }
/// <summary> /// Loads all controls in the form that display information specific to the selected structure in the Structures /// listbox. /// </summary> private void LoadStructInfo() { try { CHeaderDataSet.tblStructuresRow rowStruct = m_HeaderAccess.GetStruct(lbStructs.Items[lbStructs.SelectedIndex].ToString()); lblStructName.Text = rowStruct.StructName; lblStructSize.Text = rowStruct.DataSize.ToString(); lblStructFieldCount.Text = rowStruct.FieldCount.ToString(); lblStructElements.Text = rowStruct.Elements.ToString(); if (rowStruct.StructUnion == 1) { lblStructNameHdr.Text = "Structure Name"; lblStructSizeHdr.Text = "Structure Size (Bytes)"; } else { lblStructNameHdr.Text = "Union Name"; lblStructSizeHdr.Text = "Union Size (Bytes)"; }//end if } catch (Exception err) { ErrorHandler.ShowErrorMessage(err, "Error in LoadStructInfo function of frmCHeaderExtract form."); } }
/// <summary> /// Retrieves the row in the Structures data table in the Header Data Set object linked to the DataAccess class with the name specified /// in the function's StructName parameter. /// </summary> /// <param name="strStructName"></param> /// <returns></returns> public CHeaderDataSet.tblStructuresRow GetStruct(string strStructName) { try { CHeaderDataSet.tblStructuresRow rowStruct = StructuresTable.FindByStructName(strStructName); return(rowStruct); } catch (Exception err) { ErrorHandler.ShowErrorMessage(err, "Error in GetStruct function of DataAccess class."); return(null); } }
/// <summary> /// Generates JSON formatted data structures a set of structures and their associated fields and exports the data to a JSON file /// specified in the FileName parameter. This export file will contain the relevant information for each structure and be in a format /// that will allow for it to be loaded into a web page (such as the StructInfo.html page of the CHeaderParser program) or any /// other program that can consume and process JSON formatted data. /// The Structure/Union JSON export file will be in the following JSON format: /// "structs": [ { "structname", "structdata": { "datasize", "fieldcount", "elements", /// "fields": [ { "offset", "fieldtypename", "fieldname", /// "fieldindex", "datasize", "elements" } ] } }] /// </summary> /// <param name="aryStructNames">An array of strings, containing the names of each struct to export.</param> /// <param name="strFileName">The full name and path of the struture/union export data file. It will either be a JSON file or JS file /// containing all the JSON data assigned to a global variable.</param> /// <param name="exportType">Indicates whether the export file will be generated so that it can be loaded into a page hosted /// either locally or on a web server. If an export data file is to be generated that is to be used in a locally hosted web file, then /// a javascript file will be generated that will load the entire exported JSON data structure into a global variable. When the a web /// file hosted on a server is used, the data will be exported to a standard JSON formatted data file that can be consumed by the /// server hosted web application.</param> public bool ExportStructs(string[] aryStructNames, string strFileName, WebExportTypeEnum exportType) { try { CHeaderDataSet.tblStructuresRow[] aryStructs = new CHeaderDataSet.tblStructuresRow[aryStructNames.Length]; for (int i = 0; i < aryStructNames.Length; i++) { aryStructs[i] = m_HeaderAccess.GetStruct(aryStructNames[i]); } return(ExportStructs(aryStructs, strFileName, exportType)); } catch (Exception err) { ErrorHandler.ShowErrorMessage(err, "Error in ExportStructs Overload 2 function of DataExport class."); return(false); } }
/// <summary> /// Queries the data type associated with the field with the specified key passed to the function. The linked data type record will be returned /// by the function. Depending on what type of data type is associated with the field, will determine whether a structure data row, typedef data row /// or primitive data object is returned by the function. Primtive data types will not be stored in the Header Data Set and will have its data returned /// from the Global Primitive data object. /// </summary> /// <param name="strFieldKey"></param> /// <returns></returns> public object QueryFieldTypeDataByKey(string strFieldKey) { try { CHeaderDataSet.tblFieldsRow rowField = FieldsTable.FindByFieldKey(strFieldKey); if (rowField == null) { return(null); } switch ((FieldTypeEnum)rowField.FieldType) { case FieldTypeEnum.Primitive: case FieldTypeEnum.Enum: case FieldTypeEnum.Pointer: object[] aryPrimTypeData = new object[] { rowField.FieldTypeName, DataAccess.PrimDataTypes[rowField.FieldTypeName] }; return(aryPrimTypeData); case FieldTypeEnum.TypeDef: CHeaderDataSet.tblTypeDefsRow rowTypeDef = TypeDefsTable.FindByTypeDefName(rowField.FieldTypeName); return(rowTypeDef); case FieldTypeEnum.Structure: CHeaderDataSet.tblStructuresRow rowStruct = StructuresTable.FindByStructName(rowField.FieldTypeName); return(rowStruct); } ; return(null); } catch (Exception err) { ErrorHandler.ShowErrorMessage(err, "Error in QueryFieldTypeDataByKey function of DataAccess class."); return(null); } }
/// <summary> /// Adds a row to the Structures data table in the Header Data Set object linked to the DataAccess class using the data contained in the /// StructData object passed to the function. The StructData object will contain all the required information needed to create a structure record /// in the Structures table. /// </summary> /// <param name="sdStruct"></param> /// <returns></returns> public bool AddStructRow(StructData sdStruct) { try { CHeaderDataSet.tblStructuresRow rowStruct = StructuresTable.NewtblStructuresRow(); rowStruct.StructName = sdStruct.StructName; rowStruct.StructUnion = (byte)sdStruct.StructUnion; rowStruct.FieldCount = sdStruct.Fields.Count; rowStruct.Elements = sdStruct.Elements; rowStruct.DataSize = sdStruct.DataSize; StructuresTable.AddtblStructuresRow(rowStruct); return(true); } catch (Exception err) { ErrorHandler.ShowErrorMessage(err, "Error in AddStructRow function of DataAccess class."); return(false); } }
private void lbStructs_SelectedIndexChanged(object sender, EventArgs e) { try { if (m_CancelEvents.ListBoxIndexChanged) { return; } if (lbStructs.SelectedIndex != -1) { //Loads all the information of the fields contained in the selected structure into the fields grid control. CHeaderDataSet.tblFieldsViewDataTable tblFieldsView = dsHeaderDataView.tblFieldsView; tblFieldsView.Rows.Clear(); CHeaderDataSet.tblFieldsRow[] aryStructFields = m_HeaderAccess.GetStructFields(lbStructs.Items[lbStructs.SelectedIndex].ToString()); foreach (CHeaderDataSet.tblFieldsRow rowField in aryStructFields) { CHeaderDataSet.tblFieldsViewRow rowFieldView = tblFieldsView.NewtblFieldsViewRow(); for (int i = 0; i < tblFieldsView.Columns.Count; i++) { if (m_HeaderAccess.FieldsTable.Columns.Contains(tblFieldsView.Columns[i].ColumnName)) { rowFieldView[i] = rowField[tblFieldsView.Columns[i].ColumnName]; } else if (tblFieldsView.Columns[i].ColumnName == "DataType") { switch ((FieldTypeEnum)rowField.FieldType) { case FieldTypeEnum.Enum: rowFieldView[i] = "enum"; break; case FieldTypeEnum.TypeDef: rowFieldView[i] = "typedef"; break; case FieldTypeEnum.Structure: CHeaderDataSet.tblStructuresRow rowStruct = m_HeaderAccess.GetStruct(rowFieldView.FieldTypeName); if (rowStruct != null) { if (m_HeaderAccess.GetStruct((rowFieldView.FieldTypeName)).StructUnion == 1) { rowFieldView[i] = "struct"; } else { rowFieldView[i] = "union"; } } else { rowFieldView[i] = "struct/union"; } break; case FieldTypeEnum.Primitive: rowFieldView[i] = "primitive"; break; case FieldTypeEnum.Pointer: rowFieldView[i] = "pointer"; break; } ; //end switch }//end if }//next i tblFieldsView.AddtblFieldsViewRow(rowFieldView); }//next rowField //Loads all controls in the form that display information specific to the selected structure in the Structures //listbox. LoadStructInfo(); }//end if } catch (Exception err) { ErrorHandler.ShowErrorMessage(err, "Error in lbStructs_SelectedIndexChanged function of frmCHeaderExtract form."); } }