public CTFTStream(CTFScope scope, List <CTFAssignmentExpression> lcae) { foreach (CTFAssignmentExpression cae in lcae) { string name = cae.GetFullName(); switch (name) { case "id": id = cae.Src.Calculate(); break; case "event.header": eventHeader = cae.GetType(scope); break; case "packet.context": PacketContext = cae.GetType(scope); break; case "event.context": eventContext = cae.GetType(scope); break; default: throw new CTFException(); } } }
public CTFTEvent(CTFScope scope, List <CTFAssignmentExpression> lcae) { foreach (CTFAssignmentExpression cae in lcae) { string tname = cae.GetName(); switch (tname) { case "name": Name = cae.Src.GetValue().GetString(); break; case "id": Id = (uint)cae.Src.Calculate(); break; case "stream_id": stream_id = cae.Src.Calculate(); break; case "loglevel": loglevel = cae.Src.Calculate(); break; case "fields": Fields = cae.GetType(scope); break; default: throw new CTFException(); } } }
private CTFFile Parse(TokParser tp) { for (;;) { switch (tp.Token.Id) { case Token.EnumId.CLOCK: Clock = new CTFTClock(ParseAEList(tp)); break; case Token.EnumId.EVENT: CTFTEvent ce = new CTFTEvent(scope, ParseAEList(tp)); Events.Add(ce.Id, ce); break; case Token.EnumId.STREAM: stream = new CTFTStream(scope, ParseAEList(tp)); break; case Token.EnumId.ENV: env = new CTFTEnv(ParseAEList(tp)); break; case Token.EnumId.TRACE: trace = new CTFTTrace(scope, ParseAEList(tp)); break; case Token.EnumId.TYPEALIAS: tp.Next(); List <CTFTypeSpecifier> cds = CTFITypeSpecifier.ParseList(scope, tp); if (cds == null) { throw new CTFException(); } tp.MustBe(Token.EnumId.TYPE_ASSIGNMENT); List <CTFTypeSpecifier> cds2 = CTFITypeSpecifier.ParseList(scope, tp); CTFDeclarator cd = CTFDeclarator.Parse(tp); CTFType.AddType(scope, cds, cds2, cd); break; case Token.EnumId.STRUCT: CTFITypeSpecifier.ParseTypeSpecifier(scope, tp); break; case Token.EnumId.EOF: return(this); case Token.EnumId.TERM: tp.Next(); // Skip it break; default: throw new CTFException(); } } }
public CTFVariantType(CTFScope scope, CTFVaraintSpecifier vs) { tag = vs.Cue.GetName(); elems = new CTFVElem[vs.List.Count]; int i = 0; foreach (CTFStructOrVariantDeclaration cd in vs.List) { CTFType ct = GetType(scope, cd.List); string name = cd.Cd.Name; elems[i++] = new CTFVElem(name, ct); } }
public static CTFStructType GetStructType(CTFScope scope, List <CTFStructOrVariantDeclaration> list, int align) { if (list == null) { return(new CTFStructType()); } int count = list.Count; // Is it OK ? List <CTFSElem> lelems = new List <CTFSElem>(); Dictionary <string, CTFStructType> subtypes = new Dictionary <string, CTFStructType>(); bool hasVariants = false; foreach (CTFStructOrVariantDeclaration csvd in list) { CTFType ctfType = GetType(scope, csvd.List); CTFDeclarator cd = csvd.Cd; // can be name or array, arry can have dynamic size if (cd.Cue != null) { // It is array if (cd.Cue.IsNumber()) { lelems.Add(new CTFSSElem(cd.Name, ctfType, cd.Cue.Calculate())); } else // dynamic array with local variable size { int j; if (!FindName(cd.Cue.GetName(), lelems, out j)) { throw new CTFException(); } lelems.Add(new CTFDSElem(cd.Name, ctfType, j)); } } else { if (ctfType is CTFVariantType) { CTFVariantType variantType = (CTFVariantType)ctfType; hasVariants = true; variantType.Process(subtypes, lelems, align); } else { lelems.Add(new CTFSElem(cd.Name, ctfType)); } } } return(hasVariants ? new CTFVariantStructType(subtypes, lelems, align) : new CTFStructType(lelems, align)); }
public CTFTTrace(CTFScope scope, List <CTFAssignmentExpression> lcae) { foreach (CTFAssignmentExpression cae in lcae) { string name = cae.GetFullName(); switch (name) { case "major": major = cae.Src.Calculate(); break; case "minor": minor = cae.Src.Calculate(); break; case "uuid": uuid = cae.Src.GetValue().GetString(); break; case "byte_order": switch (cae.Src.GetValue().GetString()) { case "le": msb = false; break; case "be": msb = true; break; default: throw new CTFException(); } break; case "packet.header": Header = cae.GetType(scope); break; default: throw new CTFException(); } } }
internal static void AddType(CTFScope scope, List <CTFTypeSpecifier> cds, List <CTFTypeSpecifier> cds2, CTFDeclarator cd) { // used by typealias CTFType ct = GetType(scope, cds); if (cds2 != null) { // Special case (unsigned long and so on) string name = FullName(cds2); CTFSymbol cs = new CTFSymbol(name, ct); scope.AddType(cs); } if (cd != null) { CTFSymbol cs = new CTFSymbol(cd.Name, ct); scope.AddType(cs); } }
internal static CTFTypeSpecifier Parse(CTFScope scope, TokParser tp) { string name = null; List <CTFStructOrVariantDeclaration> list = null; if (!tp.Match(Token.EnumId.STRUCT)) { return(null); } if (tp.Token.Id == Token.EnumId.IDEN) { name = tp.Token.Buffer; tp.Next(); } if (tp.Match(Token.EnumId.LCURL)) { list = CTFStructOrVariantDeclaration.ParseList(scope, tp); tp.MustBe(Token.EnumId.RCURL); } int align = 0; if (tp.Match(Token.EnumId.ALIGN)) { tp.MustBe(Token.EnumId.LPAREN); CTFUnaryExpression cue = CTFUnaryExpression.Parse(tp); tp.MustBe(Token.EnumId.RPAREN); align = cue.Calculate(); } CTFType ct = CTFType.GetStructType(scope, name, list, align); return(new CTFStructSpecifier(ct)); }
public CTFPacketReader(CTFType tracePacketHeader, CTFType packetContext) { this.tracePacketHeader = tracePacketHeader; this.packetContext = packetContext; }
public CTFVElem(string name, CTFType ct) { this.Name = name; this.ct = ct; }
public CTFEventReader(CTFType streamEventHeader, CTFType streamEventContext, Dictionary <uint, CTFTEvent> events) { this.streamEventHeader = streamEventHeader; this.streamEventContext = streamEventContext; this.events = events; }
public CTFDSElem(string name, CTFType ctfType, int pos) : base(name, ctfType) { this.pos = pos; }
public CTFSSElem(string name, CTFType ctfType, int length) : base(name, ctfType) { this.length = length; }
public CTFSElem(string name, CTFType ctfType) { this.Name = name; this.CtfType = ctfType; }
public CTFEnumType(CTFScope scope, CTFEnumSpecifier ces) { ctfType = GetType(scope, ces.Cds); elems = ces.List.ToArray(); }
public CTFNTypeSpecifier(string name, CTFType ct) { this.name = name; this.ct = ct; }
public CTFRecord(CTFType type, object[] array) { ct = (CTFStructType)type; this.array = array; }
public CTFSymbol(string name, CTFType type) { this.Name = name; CtfType = type; }
public CTFStructSpecifier(CTFType cftType) { ct = cftType; }