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;
}
