/// <summary>
/// Reads a qualification followed by '@'.
/// </summary>
/// <returns></returns>
public string[] ParseQualification()
{
var qualifiers = new List<string>();
SerializedType[] typeArgs = null;
while (i < str.Length && !PeekAndDiscard('@'))
{
string name = ParseAtName();
if (name.StartsWith("?$"))
{
name = name.Substring(2);
namesSeen.Add(name);
var oldNames = namesSeen;
if (templateNamesSeen == null)
{
templateNamesSeen = new List<string> { name };
}
else
templateNamesSeen.Add(name);
namesSeen = templateNamesSeen;
typeArgs = ParseTemplateArguments().ToArray(); ///$TODO: what to do about these if they're nested?
namesSeen = oldNames;
}
else
{
namesSeen.Add(name);
}
qualifiers.Insert(0, name);
}
var tr = new TypeReference_v1
{
TypeName = qualifiers.Last(),
Scope = qualifiers.Take(qualifiers.Count - 1).ToArray(),
TypeArguments = typeArgs
};
return qualifiers.ToArray();
}
public TypeReference_v1 ParseStructure(List<Argument_v1> compoundArgs)
{
var q = ParseQualification();
var tr = new TypeReference_v1
{
TypeName = q.Last(),
Scope = q.Take(q.Length - 1).ToArray()
};
compoundArgs.Add(new Argument_v1 { Type = tr });
return tr;
}
private Argument_v1 ParseRegisterSequence(RegisterStorage reg, string type)
{
++idx;
string w2 = GetNextWord();
if (w2 == null)
return null;
RegisterStorage reg2;
if (!arch.TryGetRegister(w2, out reg2))
return null;
var seqArgName = reg.Name + "_" + reg2.Name;
var seqArgType = new TypeReference_v1 { TypeName = type };
var seqKind = new SerializedSequence();
seqKind.Registers = new Register_v1[]{
new Register_v1(reg.Name),
new Register_v1(reg2.Name)
};
return new Argument_v1(seqArgName, seqArgType, seqKind, false);
}
public int VisitTypeReference(TypeReference_v1 typeReference)
{
return(typedefs[typeReference.TypeName].Accept(this));
}
public bool VisitTypeReference(TypeReference_v1 typeReference)
{
throw new NotImplementedException();
}
private SerializedType Type()
{
var qual = CvQualifier();
switch (str[i++])
{
case 'v': return(new VoidType_v1());
case 'b': return(Qualify(PrimitiveType_v1.Bool(), qual));
case 'c': return(Qualify(PrimitiveType_v1.Char8(), qual));
case 'h': return(Qualify(PrimitiveType_v1.UChar8(), qual));
case 's': return(Qualify(PrimitiveType_v1.Int16(), qual));
case 't': return(Qualify(PrimitiveType_v1.UInt16(), qual));
case 'i': return(Qualify(PrimitiveType_v1.Int32(), qual));
case 'j': return(Qualify(PrimitiveType_v1.UInt32(), qual));
case 'l': return(Qualify(PrimitiveType_v1.Int64(), qual));
case 'm': return(Qualify(PrimitiveType_v1.UInt64(), qual));
case 'w': return(Qualify(PrimitiveType_v1.WChar16(), qual));
case 'f': return(Qualify(PrimitiveType_v1.Real32(), qual));
case 'd': return(Qualify(PrimitiveType_v1.Real64(), qual));
case 'F': --i; return(FunctionType());
case 'N': --i; return(CreateTypeReference(NestedName()));
case 'P':
var ptr = new PointerType_v1 {
DataType = Type(), PointerSize = ptrSize
};
AddSubstitution(ptr);
return(Qualify(ptr, qual));
case 'R':
var referent = Type();
var r = new ReferenceType_v1 {
Referent = referent, Size = ptrSize
};
return(Qualify(r, qual));
case 'S':
switch (str[i++])
{
case 't':
return(Qualify(new TypeReference_v1
{
Scope = new[] { "std" },
TypeName = Type().ToString(),
}, qual));
case 's':
return(Qualify(new TypeReference_v1
{
Scope = new[] { "std" },
TypeName = "string"
}, qual));
default:
int iStart = --i;
while (str[i] != '_')
{
++i;
}
++i;
var sub = str.Substring(iStart, i - iStart);
Debug.Print(sub);
return(Qualify((SerializedType)substitutions[sub], qual));
}
throw new NotImplementedException();
default:
--i;
if (char.IsDigit(str[i]))
{
var tref = new TypeReference_v1
{
TypeName = UnqualifiedName()
};
AddSubstitution(tref);
return(Qualify(tref, qual));
}
throw new NotImplementedException(string.Format("Unknown GCC type code '{0}' ({1}).", str[i], str.Substring(i)));
}
}
public DataType VisitTypeReference(TypeReference_v1 typeReference)
{
return(new TypeReference(typeReference.TypeName, null));
}
