private string GlobalNameOrDefault(GlobalDataItem_v2 sGlobal, Address address)
{
if (!string.IsNullOrWhiteSpace(sGlobal.Name))
{
return(sGlobal.Name);
}
return(UserGlobal.GenerateDefaultName(address));
}
private UserGlobal?LoadUserGlobal(GlobalDataItem_v2 sGlobal)
{
if (!arch !.TryParseAddress(sGlobal.Address, out var address))
{
return(null); // TODO: Emit warning?
}
if (sGlobal.DataType == null)
{
throw new ArgumentException("Missing required field DataType");
}
string name = GlobalNameOrDefault(sGlobal, address);
var ug = new UserGlobal(address, name, sGlobal.DataType !)
{
Comment = sGlobal.Comment,
};
return(ug);
}
private bool TryParseGlobal(string txtGlobal, out GlobalDataItem_v2 global)
{
global = null;
if (program == null || program.Platform == null)
{
return false;
}
// Attempt to parse the global declaration.
var usb = new UserSignatureBuilder(program);
global = usb.ParseGlobalDeclaration(txtGlobal);
return global != null;
}
/// <summary>
/// Given a C declaration, adds it to the symbol table
/// as a function or a type declaration.
/// </summary>
/// <param name="decl"></param>
public List<SerializedType> AddDeclaration(Decl decl)
{
var types = new List<SerializedType>();
var fndec = decl as FunctionDecl;
if (fndec != null)
{
return types;
}
IEnumerable<DeclSpec> declspecs = decl.decl_specs;
var isTypedef = false;
var scspec = decl.decl_specs[0] as StorageClassSpec;
if (scspec != null && scspec.Type == CTokenType.Typedef)
{
declspecs = decl.decl_specs.Skip(1);
isTypedef = true;
}
var ntde = new NamedDataTypeExtractor(platform, declspecs, this);
foreach (var declarator in decl.init_declarator_list)
{
var nt = ntde.GetNameAndType(declarator.Declarator);
var serType = nt.DataType;
var sSig = nt.DataType as SerializedSignature;
if (sSig != null)
{
if (sSig.ReturnValue != null)
{
sSig.ReturnValue.Kind = ntde.GetArgumentKindFromAttributes(
"returns", decl.attribute_list);
}
Procedures.Add(new Procedure_v1
{
Name = nt.Name,
Signature = sSig,
});
types.Add(sSig);
}
else if (!isTypedef)
{
var variable = new GlobalDataItem_v2
{
Name = nt.Name,
DataType = serType,
};
Variables.Add(variable);
types.Add(serType);
}
if (isTypedef)
{
//$REVIEW: should make sure that if the typedef already exists,
// then the types match but a real compiler would have validated that.
var typedef = new SerializedTypedef
{
Name = nt.Name,
DataType = serType
};
Types.Add(typedef);
//$REVIEW: do we really need to check for consistence?
NamedTypes[typedef.Name] = serType;
types.Add(serType);
}
}
return types;
}
public GlobalDataItem_v2 ModifyUserGlobal(Address address, SerializedType dataType, string name)
{
GlobalDataItem_v2 gbl;
if (!User.Globals.TryGetValue(address, out gbl))
{
gbl = new GlobalDataItem_v2()
{
Address = address.ToString(),
};
User.Globals.Add(address, gbl);
}
gbl.Name = name;
gbl.DataType = dataType;
this.ImageMap.RemoveItem(address);
var tlDeser = CreateTypeLibraryDeserializer();
var dt = dataType.Accept(tlDeser);
var size = GetDataSize(address, dt);
var item = new ImageMapItem
{
Address = address,
Size = size,
Name = name,
DataType = dt,
};
if (size != 0)
this.ImageMap.AddItemWithSize(address, item);
else
this.ImageMap.AddItem(address, item);
return gbl;
}