public override object visitStructDef(StructDef structDef, WritableScope s) { WritableScope membersScope = WritableScope.create(structDef.symbol); structDef.symbol.membersScope = membersScope; return(scan(structDef.members, new CompoundScope(membersScope, s))); }
public void StructToClass(StreamWriter sw, string structNamespace, StructDef str, AbiDef abi) { sw.WriteLine("using Newtonsoft.Json;"); sw.WriteLine("using Ditch.EOS;"); sw.WriteLine("using Ditch.Core.Models;"); sw.WriteLine("using Ditch.EOS.Models;"); sw.WriteLine(); sw.WriteLine($"namespace {structNamespace}"); sw.WriteLine("{"); var inden = new string(' ', 4); sw.WriteLine($"{inden}[JsonObject(MemberSerialization.OptIn)]"); sw.WriteLine($"{inden}public class {str.Name.ToTitleCase()}{(string.IsNullOrEmpty(str.Base) ? string.Empty : $" : {str.Base.ToTitleCase()}")}"); sw.WriteLine($"{inden}{{"); foreach (var field in str.Fields) { sw.WriteLine($"{inden}{inden}[JsonProperty(\"{field.Name}\")]"); sw.WriteLine($"{inden}{inden}public {GetType(field.Type, abi)} {field.Name.ToTitleCase()} {{get; set;}}"); sw.WriteLine(); } sw.WriteLine($"{inden}}}"); sw.WriteLine("}"); }
public Construct VisitStructDef(StructDef node) { // Create the body buffer list. List <LlvmType> body = new List <LlvmType>(); // Create a buffer dictionary for the symbol. Dictionary <string, LlvmType> symbolProperties = new Dictionary <string, LlvmType>(); // Map the body's properties onto the body. foreach (StructDefProperty property in node.Body) { // Visit the kind. this.VisitKind(property.Kind); // Pop the type off the stack. LlvmType type = this.typeStack.Pop(); // Append it to the body. body.Add(type); // Append it to the symbol's properties dictionary. symbolProperties.Add(property.Identifier, type); } // Create the struct. LlvmType @struct = this.module.CreateStruct(node.Identifier, body.ToArray()); // Append the resulting struct onto the stack. this.typeStack.Push(@struct); // Return the node. return(node); }
public void LoadData(string fileName, StructDef def) { var dataFile = new DataFile(fileName, def); _dataFiles.Add(dataFile); LoadDataFile(dataFile); }
public override void Visit(StructDef n) { n.type = AST.STRUCT; List <Tuple <string, int> > tuples = new List <Tuple <string, int> >(); PlusScope(); foreach (AST ast in n.declarings) { ast.accept(this); if (ast is SymDeclaring) { SymDeclaring symDeclaring = ast as SymDeclaring; tuples.Add(new Tuple <string, int>(symDeclaring.id, GetType(ast))); } else if (ast is FuncDecl) { FuncDecl funcDecl = ast as FuncDecl; SymDeclaring symDeclaring = funcDecl.declaring as SymDeclaring; tuples.Add(new Tuple <string, int>(symDeclaring.id, GetType(funcDecl.declaring))); } } MinusScope(); SymReferencing current = n.structType as SymReferencing; StructDic.Add(current.id, tuples); }
[Test] public void FieldGroup() { StructFile structFile = new StructParser().LoadStructs("struct a { repeat(8) { u8; } }"); StructDef structDef = structFile.Structs[0]; Assert.AreEqual(1, structDef.Fields[0].ChildFields.Count); }
[Test] public void StructWithAttributes() { StructFile structFile = new StructParser().LoadStructs("[filemask=\"*.bmp\"] struct BITMAPFILEHEADER { }"); StructDef structDef = structFile.Structs[0]; Assert.AreEqual("*.bmp", structDef.FileMask); }
private void ParseStrcut(string namespace_, StructDeclarationSyntax structSyntax, SemanticModel semanticModel) { var structDef = new StructDef(); structDef.Internal = structSyntax; structDef.Namespace = namespace_; structDef.Name = structSyntax.Identifier.ValueText; var fullName = namespace_ + "." + structDef.Name; { var partial = definitions.Structs.FirstOrDefault(x => x.Namespace + "." + x.Name == fullName); if (partial != null) { structDef = partial; } } if (TypesNotParsed.Contains(fullName)) { return; } // Summary var declaredSymbol = semanticModel.GetDeclaredSymbol(structSyntax); var xml = declaredSymbol?.GetDocumentationCommentXml(); structDef.Summary = SummaryComment.Parse(xml); ParseTypeDeclaration(structDef, structSyntax, semanticModel); definitions.Structs.Add(structDef); }
ushort GetStructDef(Type type, Metadata metadata, Metadata[] fields) { var index = Schema.structs.Count; var structDef = new StructDef(); Schema.structs.Add(structDef); structDef.metadata = metadata; var baseType = type.GetBaseSchemaType(); if (baseType != null) structDef.base_def = GetTypeDef(baseType); var i = 0; foreach (var field in type.GetSchemaFields()) { var fieldDef = new FieldDef { id = field.Id, metadata = fields[i++], type = GetTypeDef(field.GetSchemaType()) }; structDef.fields.Add(fieldDef); } return (ushort) index; }
public override void LoadData(BinaryReader reader, StructInstance instance) { StructDef structDef = GetIncludedStruct(); if (structDef.FieldLike) { instance.PushAddedCellHandler(cell => cell.Tag = Tag); } bool oldHidden = instance.HideAddedCells(_hidden); try { structDef.LoadInstanceData(instance, reader.BaseStream); } finally { if (structDef.FieldLike) { instance.PopAddedCellHandler(); } instance.HideAddedCells(oldHidden); } if (GetBoolAttribute("replace")) { instance.SetNodeName(structDef.Name); } }
[Test] public void ParseSingleFieldStruct() { StructParser parser = new StructParser(); StructFile structFile = parser.LoadStructs("struct BITMAPINFOHEADER { u32 biSize; }"); StructDef structDef = structFile.Structs[0]; Assert.AreEqual(1, structDef.Fields.Count); Assert.AreEqual("biSize", structDef.Fields[0].Tag); }
protected void define_struct(string name, Action act) { _curStructDef = new StructDef { Name = name }; act(); _curProcessDef.DataTypes.AddType(_curStructDef); _curStructDef = null; }
public override void Visit(StructDef n) { plusScope(); foreach (AST ast in n.declarings) { ast.accept(this); } minusScope(); }
private StructSymbol makeStructSymbol(StructDef structDef, Symbol owner) { StructSymbol ssym = new StructSymbol(structDef.name, owner, null); ssym.type = new StructType(ssym); structDef.symbol = ssym; return(ssym); }
public override object visitStructDef(StructDef structDef, WritableScope enclScope) { StructSymbol ssym = makeStructSymbol(structDef, enclScope.owner); if (check.checkUnique(structDef.Pos, ssym, enclScope)) { enclScope.enter(ssym); } return(null); }
[Test] public void ParseSingleEmptyStruct() { StructParser parser = new StructParser(); StructFile structFile = parser.LoadStructs("struct BITMAPINFOHEADER { }"); Assert.AreEqual(1, structFile.Structs.Count); StructDef structDef = structFile.Structs[0]; Assert.AreEqual("BITMAPINFOHEADER", structDef.Name); }
public StructWindow(int pid, IntPtr address, StructDef struc) { InitializeComponent(); this.AddEscapeToClose(); this.SetTopMost(); _pid = pid; _address = address; _struct = struc; }
static void WriteVariableRecursive(SymFile symFile, string name, uint address, TypeInfo typeInfo) { if (typeInfo.isFake) { return; } BaseType baseType = typeInfo.typeDef.baseType; uint arrayLength = 1; //bool isArray = IsArray(typeInfo.typeDef); bool isArray = Array.IndexOf(typeInfo.typeDef.derivedTypes, DerivedType.Array) >= 0; bool isPointer = Array.IndexOf(typeInfo.typeDef.derivedTypes, DerivedType.Pointer) >= 0; if (isArray) { int dims = typeInfo.dims.Length; foreach (uint d in typeInfo.dims) { arrayLength *= d; } } arrayLength = Math.Max(1, arrayLength); uint arrayEntrySize = Math.Max(1, typeInfo.size / arrayLength); // Only cap the array length after getting the arrayEntrySize. arrayLength = Math.Min(arrayLength, maxArrayLength); for (int i = 0; i < arrayLength; i++) { uint arrayAddress = address + (arrayEntrySize * (uint)i); string arrayName = name; if (isArray) { arrayName += "[" + i.ToString() + "]"; } if (baseType == BaseType.StructDef && !isPointer) { StructDef structDef = symFile.m_structs[typeInfo.tag]; foreach (StructMember member in structDef.members) { uint memberAddress = arrayAddress + unchecked ((uint)member.typedValue.value); string memberName = arrayName + "." + member.name; WriteVariableRecursive(symFile, memberName, memberAddress, member.typeInfo); } } else { WriteVariable(symFile, arrayName, arrayAddress, typeInfo, isPointer); } } }
private void BuildDefs() { var defs = definitions.Value <JObject>("defs"); recordHeaderDef = (StructDef)BuildDef((JObject)defs["MainRecordHeader"]); groupHeaderDef = (StructDef)BuildDef((JObject)defs["GroupRecordHeader"]); foreach (var(key, src) in defs) { defMap[key] = BuildDef((JObject)src); } definitions.Remove("defs"); GC.Collect(); }
[Test] public void ParseFieldWithAttributes() { StructParser parser = new StructParser(); StructFile structFile = parser.LoadStructs("struct BITMAPFILEHEADER { str [len=2] bfType; }"); StructDef structDef = structFile.Structs[0]; Assert.AreEqual(1, structDef.Fields.Count); Assert.IsInstanceOfType(typeof(StrField), structDef.Fields [0]); StrField field = (StrField)structDef.Fields[0]; Assert.AreEqual("bfType", field.Tag); Assert.AreEqual("2", field.GetExpressionAttribute("len").ToString()); }
private void DoLoadChildren(StructInstance instance, InstanceTreeNode parent, Stream stream, long?offset, int count) { StructInstance lastChild = instance.LastChild; string groupName = GetStringAttribute("group"); if (groupName != null) { GroupContainer container = new GroupContainer(parent, groupName); parent.AddChild(container); parent = container; } if (count == 0) { return; } StructDef childDef = GetStructAttribute("struct"); if (childDef == null) { childDef = _structDef; } StructInstance childInstance; bool followChildren = GetBoolAttribute("followchildren"); if (offset.HasValue) { childInstance = new StructInstance(childDef, parent, stream, offset.Value); } else { bool firstFollowChildren = followChildren && lastChild != parent; childInstance = new StructInstance(childDef, parent, stream, lastChild, firstFollowChildren); } parent.AddChild(childInstance); if (count > 1) { childInstance.SequenceIndex = 0; } for (int i = 1; i < count; i++) { var nextInstance = new StructInstance(childDef, parent, stream, childInstance, followChildren); parent.AddChild(nextInstance); nextInstance.SequenceIndex = i; childInstance = nextInstance; } }
/// <summary> /// Get the definition of internal task data structure (all variables) /// Warning: there are no required fields in the internal data schema. So any variable, even the required ones, can be skipped /// in an xml document. /// </summary> /// <returns></returns> public virtual StructDef GetInternalDataSchema() { if (ParentProcess == null) { throw new Exception(); } StructDef sd = new StructDef(); sd.ParentTypeSet = ParentProcess.DataTypes; foreach (VariableDef vd in Variables) { VariableDef vd2 = new VariableDef(vd); vd2.IsRequired = false; sd.Members.Add(vd2); } return(sd); }
public static void ValidationTest() { TypeSet ts = new TypeSet(); StructDef sd = new StructDef(); sd.ParentTypeSet = ts; sd.Name = "T1"; sd.Members.Add(new MemberDef("F1", "string", false, false)); sd.Members.Add(new MemberDef("F2", "int", true, true)); DataObject dob = new DataObject(); dob["F1"] = 399; List<int> lst = new List<int>(); lst.AddRange(new int[] {1, 2, 3, 4}); dob["F2"] = lst; dob["F3"] = null; dob.Validate(sd); }
public void StructToClass(string outDirPath, string structNamespace, StructDef str, AbiDef abi) { FileStream fs = null; StreamWriter sw = null; try { fs = new FileStream($"{outDirPath}{str.Name.ToTitleCase()}.cs", FileMode.OpenOrCreate); sw = new StreamWriter(fs); StructToClass(sw, structNamespace, str, abi); } finally { sw?.Dispose(); fs?.Dispose(); } }
/// <summary> /// Get task output data definition /// </summary> /// <returns></returns> public virtual StructDef GetOutputDataSchema() { if (ParentProcess == null) { throw new Exception(); } StructDef sd = new StructDef(); sd.ParentTypeSet = ParentProcess.DataTypes; foreach (VariableDef vd in Variables) { if (vd.VariableDir == VariableDef.Dir.Out || vd.VariableDir == VariableDef.Dir.InOut) { sd.Members.Add(vd); } } return(sd); }
public override void Visit(StructDef n) { plusScope(); foreach (AST ast in n.declarings) { if (ast is SymDeclaring) { SymDeclaring sym = ast as SymDeclaring; InitiationTable[GetKey(sym.id)] = 1; } else { ast.accept(this); } } SymReferencing current = n.structType as SymReferencing; StructDic.Remove(current.id); minusScope(); }
public override Type visitStructDef(StructDef structDef, Environment env) { Environment newEnv = new Environment { scope = new CompoundScope(structDef.symbol.membersScope, env.scope), parent = env, enclStruct = structDef.symbol }; for (var i = 0; i < structDef.members.Count; i++) { Tree member = structDef.members[i]; if (member.Tag == Tag.FUNC_DEF) { FuncDef funcDef = (FuncDef)member; visitFuncDef(funcDef, newEnv); } } return(null); }
/// <summary> /// Generates a struct definition with the specified name and fields. /// If the struct is to contain no fields pass null for the fields parameter. /// </summary> /// <param name="name">The name of the struct to be created.</param> /// <param name="fields">Optional list of fields. Pass null if the struct has no fields.</param> /// <returns>Root node for this struct definition's AST.</returns> public static Node Generate(string name, IReadOnlyList <StructFieldDef> fields) { if (string.IsNullOrWhiteSpace(name)) { throw new ArgumentException(nameof(name)); } if (fields != null && fields.Count == 0) { throw new ArgumentException("pass null for no struct fields"); } var typeDef = new TypeDef(); typeDef.AddChild(new Identifier(name)); var structDef = new StructDef(); var defStart = new OpenDelimiter(BinaryDelimiterType.Brace); if (fields != null) { foreach (var field in fields) { var id = new Identifier(field.Name); id.AddChild(new TypeName(field.TypeName)); if (field.Tag != null) { id.AddChild(new Tag(field.Tag)); } defStart.AddChild(id); } } defStart.AddClosingDelimiter(); structDef.AddChild(defStart); typeDef.AddChild(structDef); return(typeDef); }
public override void Visit(StructDef n) { emit("{\n"); if (n.declarings.Count > 0) { AST first = n.declarings[0]; foreach (AST ast in n.declarings) { if (first != ast) { emit("\n"); } ast.accept(this); if (ast is SymDeclaring) { emit(";"); } } } emit("}"); }
public StructViewer(int pid, IntPtr address, StructDef struc) { InitializeComponent(); _struct = struc; treeStruct.Model = _model; treeStruct.ContextMenu = menuStruct; GenericViewMenu.AddMenuItems(copyMenuItem.MenuItems, treeStruct); try { FieldValue[] values; _struct.Offset = address; _struct.IOProvider = new ProcessMemoryIO(pid); _struct.Structs = Program.Structs; values = _struct.Read(); _model.Nodes.Add(new StructNode(new FieldValue { Name = "Struct", FieldType = FieldType.StringUTF16, Value = string.Empty })); foreach (FieldValue val in values) { this.AddNode(_model.Nodes[0], val); } treeStruct.Root.Children[0].IsExpanded = true; } catch (Exception ex) { PhUtils.ShowException("Unable to view the struct", ex); this.Error = true; } }
public override void LoadData(BinaryReader reader, StructInstance instance) { int offset = (int)reader.BaseStream.Position; int len; try { len = GetExpressionAttribute("len").EvaluateInt(instance); } catch (OverflowException) { throw new LoadDataException("Blob size is larger than Int32"); } if (offset + len > reader.BaseStream.Length) { throw new LoadDataException("Blob size " + len + " exceeds stream length"); } if (len < 0) { throw new LoadDataException("Blob size " + len + " is negative"); } var decodedSizeExpr = GetExpressionAttribute("decodedsize"); int decodedSize = decodedSizeExpr != null?decodedSizeExpr.EvaluateInt(instance) : -1; string encoding = GetStringAttribute("encoding"); BlobDecoder blobDecoder = FindBlobEncoding(instance, encoding); BlobCell cell = new BlobCell(this, reader.BaseStream, offset, len, blobDecoder, decodedSize); instance.AddCell(cell, _hidden); instance.RegisterCellSize(cell, len); reader.BaseStream.Position += len; StructDef structDef = GetStructAttribute("struct"); if (structDef != null) { instance.AddChildSeed(new BlobChildSeed(structDef, cell)); } }
public void StructDefUnitTest() { try { StructDef structDef = new StructDef( new List <AST>() { new IntDcl("pinPower"), new FuncDecl(new VoidDcl("Power"), new List <SymDeclaring>() { new IntDcl("value") }, new List <AST>() { new Assigning(new SymReferencing("pinPower"), new SymReferencing("value")) }, null) }); structDef.structType = new SymReferencing("pin"); SymbolTableFilling symbolTableFilling = new SymbolTableFilling(); structDef.accept(symbolTableFilling); Dictionary <Tuple <string, string>, int> actual = AST.SymbolTable; Dictionary <Tuple <string, string>, int> expected = new Dictionary <Tuple <string, string>, int>() { { new Tuple <string, string>("11", "pinPower"), 2 }, { new Tuple <string, string>("11", "Power"), 0 }, { new Tuple <string, string>("111", "value"), 2 } }; Assert.IsTrue(ObjectCompare(actual, expected), "Struct Def faild"); } finally { AST.SymbolTable.Clear(); } }
public ImageField(StructDef structDef) : base(structDef) { }
public StructDef define(String name) { StructDef sdef = new StructDef(name); this.definedTypes.Add(name, sdef); return sdef; }
public GlobalField(StructDef structDef) : base(structDef) { }
public BlobField(StructDef structDef) : base(structDef, "len", false) { }
public DosDateTimeField(StructDef structDef) : base(structDef) { }
public NodenameField(StructDef structDef) : base(structDef, "name", false) { }
public WhileField(StructDef structDef) : base(structDef, "expr", true) { }
public MessageField(StructDef structDef, bool error) : base(structDef, "text", false) { _error = error; }
public UnixTimeField(StructDef structDef) : base(structDef) { }
public IncludeField(StructDef structDef) : base(structDef, "struct", false) { }
public BitsField(StructDef structDef, int size) : base(structDef, size, true) { }
public RepeatField(StructDef structDef) : base(structDef, "count", true) { }
public ElseField(StructDef structDef) : base(structDef, null, true) { }
public SeekField(StructDef structDef, bool relative) : base(structDef, "offset", false) { _relative = relative; }
public SwitchField(StructDef structDef) : base(structDef, "expr", true) { }
public BreakField(StructDef structDef) : base(structDef) { }
public AlignField(StructDef structDef) : base(structDef, "bytes", false) { }
public AssertField(StructDef structDef) : base(structDef, "expr", false) { }
public BlobChildSeed(StructDef def, BlobCell cell) { _def = def; _cell = cell; }
public ElseIfField(StructDef structDef) : base(structDef, "expr", true) { }
public StrField(StructDef structDef, bool wide, bool requireNullTerminated) : base(structDef) { _wide = wide; _requireNullTerminated = requireNullTerminated; }
public ChildField(StructDef structDef, bool isSibling) : base(structDef) { _isSibling = isSibling; }
public IntField(StructDef structDef, int size, bool unsigned, bool hex) : base(structDef, size, unsigned) { _hex = hex; }
public StructField CreateField(StructDef structDef, string name, AttributeRegistry registry) { FieldAlias alias; if (_aliasRegistry.TryGetValue(name, out alias)) { StructField baseField = CreateField(structDef, alias.BaseName, registry); foreach(StructParser.Attribute attr in alias.Attrs) registry.SetFieldAttribute(baseField, attr.Key, attr.Value, attr.Position); return baseField; } switch(name) { case "str": return new StrField(structDef, false, false); case "cstr": return new StrField(structDef, false, true); case "wstr": return new StrField(structDef, true, false); case "child": return new ChildField(structDef, false); case "sibling": return new ChildField(structDef, true); case "seek": return new SeekField(structDef, false); case "skip": return new SeekField(structDef, true); case "rewind": return new RewindField(structDef); case "repeat": return new RepeatField(structDef); case "if": return new IfField(structDef); case "elif": return new ElseIfField(structDef); case "else": return new ElseField(structDef); case "while": return new WhileField(structDef); case "include": return new IncludeField(structDef); case "assert": return new AssertField(structDef); case "bitfield": return new BitfieldField(structDef); case "nodename": return new NodenameField(structDef); case "switch": return new SwitchField(structDef); case "case": return new CaseField(structDef, false); case "default": return new CaseField(structDef, true); case "unixtime": return new UnixTimeField(structDef); case "dosdatetime": return new DosDateTimeField(structDef); case "global": return new GlobalField(structDef); case "local": return new CalcField(structDef, true); case "calc": return new CalcField(structDef, false); case "align": return new AlignField(structDef); case "blob": return new BlobField(structDef); case "image": return new ImageField(structDef); case "float": return new FloatField(structDef); case "break": return new BreakField(structDef); case "i": return new IntField(structDef, 0, false, false); case "u": return new IntField(structDef, 0, true, false); case "x": return new IntField(structDef, 0, true, true); case "enum": return new EnumField(structDef, 0); case "message": return new MessageField(structDef, false); case "error": return new MessageField(structDef, true); } int size; if (name.EndsWith("8")) { size = 1; name = name.Substring(0, name.Length - 1); } else if (name.EndsWith("16") || name.EndsWith("32") || name.EndsWith("64")) { size = name.EndsWith("16") ? 2 : name.EndsWith("32") ? 4 : 8; name = name.Substring(0, name.Length - 2); } else throw new Exception("Unknown field type " + name); switch(name) { case "i": return new IntField(structDef, size, false, false); case "u": return new IntField(structDef, size, true, false); case "x": return new IntField(structDef, size, true, true); case "enum": return new EnumField(structDef, size); case "set": return new SetField(structDef, size); case "bits": return new BitsField(structDef, size); } throw new Exception("Unknown field type " + name); }
protected StructDef GetTaskInternalDataSchema() { StructDef sd = new StructDef(); sd.ParentTypeSet = ProcessTask.ParentProcess.DataTypes; foreach (VariableDef vd in ProcessTask.TaskVariables) { if (vd.VariableDir == VariableDef.Dir.In || vd.VariableDir == VariableDef.Dir.InOut) { sd.Members.Add(vd); } else { VariableDef vd2 = new VariableDef(vd); vd2.IsRequired = false; sd.Members.Add(vd2); } } return sd; }
public RewindField(StructDef structDef) : base(structDef) { }
public BitfieldField(StructDef structDef) : base(structDef, "size", true) { }
/// <summary> /// Get the definition of task output data /// </summary> /// <returns></returns> public StructDef GetTaskOutputDataSchema() { if (ParentProcess == null) throw new Exception(); StructDef sd = new StructDef(); sd.ParentTypeSet = ParentProcess.DataTypes; foreach (VariableDef vd in TaskVariables) { if (vd.VariableDir == VariableDef.Dir.Out || vd.VariableDir == VariableDef.Dir.InOut) { sd.Members.Add(vd); } } return sd; }