public IEmitVal Local(string name, IEmitType type)
{
var sym = GenSym(name);
_span.WriteLine(
"{0};",
((IEmitTypeCPP) type).Declare(sym));
return new EmitValCPP(Target, sym, type);
}
public IEmitField AddPublicField(IEmitType type, string name)
{
_publicSize = Align( _publicSize, type.Alignment );
_publicAlign = Math.Max( _publicAlign, type.Alignment );
_publicSize += type.Size;
_publicFieldsSpan.WriteLine("{0};",
((IEmitTypeCPP)type).Declare(name));
return new EmitFieldCPP(name, type);
}
public IEmitVal GetBuiltinField(IEmitVal obj, string fieldName, IEmitType fieldType)
{
return Defer((b) => b.GetBuiltinField(Un(obj), fieldName, Un(fieldType)));
}
public IEmitVal GetBuiltinField(
IEmitVal obj,
string fieldName,
IEmitType fieldType)
{
return new EmitValCPP(
Target,
string.Format("({0}.{1})", obj, fieldName),
fieldType);
}
public void WriteParameter(
IEmitType type,
string name,
bool first,
Span span)
{
if (!first)
span.Write(",");
span.WriteLine();
span.Write(((IEmitTypeCPP) type).Declare(name));
}
public EmitTargetCPP()
{
_voidType = new EmitTypeCPP(this, "void {0}", 0, 0, null);
}
public IEmitVal BuiltinApp(
IEmitType type,
string template,
IEmitVal[] args)
{
var valString = args == null ? template :
string.Format(template, args);
if (type == null || (type == Target.VoidType))
{
_span.WriteLine("{0};", valString);
return null;
}
return new EmitValCPP(
Target,
valString,
type);
}
public EmitMethodCPP(
EmitClassCPP clazz,
string prefix,
string name,
string cconv,
IEmitType resultType,
Span headerSpan,
Span sourceSpan)
{
_class = clazz;
_name = name;
_cconv = cconv;
_resultType = resultType;
_headerSpan = headerSpan;
_sourceSpan = sourceSpan;
_headerSpan.Write( "static " );
_headerParamsSpan = CreateSignatureSpan(
_name,
_headerSpan);
_headerSpan.WriteLine(";");
_fullName = prefix + _name;
_sourceParamsSpan = CreateSignatureSpan(
prefix + _name,
_sourceSpan);
_sourceSpan.WriteLine();
_sourceSpan.WriteLine("{");
_bodySpan = _sourceSpan.IndentSpan();
_sourceSpan.WriteLine("}");
_thisParameter = (EmitValCPP) AddParameter(
Target.Pointer( clazz ),
"self" );
_entryBlock = new EmitBlockCPP(this, _bodySpan.InsertSpan());
}
public IEmitVal BuiltinApp(IEmitType type, string template, IEmitVal[] args)
{
return Defer((b) => b.BuiltinApp(Un(type), template, Un(args)));
}
public IEmitVal CastRawPointer(IEmitVal val, IEmitType type)
{
return Defer((b) => b.CastRawPointer(Un(val), Un(type)));
}
public IEmitVal Array(IEmitType elementType, IEmitVal[] elements)
{
return Defer((b) => b.Array(Un(elementType), Un(elements)));
}
private IEmitType Un(IEmitType type)
{
if (type is LazyEmitType)
{
return ((LazyEmitType)type).Type;
}
return type;
}
public IEmitVal Local(string name, IEmitType type)
{
return Defer((b) => b.Local(name, Un(type)));
}
public IEmitMethod CreateMethod(IEmitType resultType, string name)
{
_publicSpan.WriteLine();
_sourceSpan.WriteLine();
return new EmitMethodCPP(
this,
string.Format("{0}::", _name),
name,
"__stdcall",
resultType,
_publicSpan.InsertSpan(),
_sourceSpan.InsertSpan());
}
public IEmitVal GetNullPointer(IEmitType type)
{
return new EmitValCPP(this, "nullptr", type);
}
public EmitFieldCPP(
string name,
IEmitType type)
{
_name = name;
_type = type;
}
public IEmitType Pointer(IEmitType type)
{
return new EmitTypeCPP(this, "*{0}", 4, 4, (IEmitTypeCPP) type);
}
public IEmitVal AddParameter(IEmitType type, string name)
{
bool first = _parameters.Count == 0;
var param = new EmitValCPP(Target, name, type);
_parameters.Add(param);
WriteParameter(type, name, first, _headerParamsSpan);
WriteParameter(type, name, first, _sourceParamsSpan);
return param;
}
public EmitValCPP(
EmitTargetCPP target,
string name,
IEmitType type,
bool isOwnAddress = false )
{
_target = target;
_name = name;
_type = type;
_isOwnAddress = isOwnAddress;
}
public IEmitVal Array(
IEmitType elementType,
IEmitVal[] elements)
{
var span = new Span();
span.WriteLine("{");
foreach (var e in elements)
{
span.WriteLine("\t{0},", e);
}
span.Write("}");
return new EmitValCPP(
Target,
span.ToString(),
Target.Array(elementType, elements.Length),
true);
}
public IEmitVal CastRawPointer(IEmitVal val, IEmitType type)
{
var ty = type ?? Target.Pointer( Target.GetBuiltinType( "unsigned char" ) );
return new EmitValCPP(
Target,
string.Format( "(({0}) {1})", ty, val ),
ty);
}
public IEmitType Array(IEmitType type, int length)
{
return new EmitTypeCPP(this, "{0}[]", type.Size * (UInt32) length, type.Alignment, (EmitTypeCPP)type);
}
public static IEmitVal Array(
this IEmitBlock block,
IEmitType elementType,
IEnumerable<IEmitVal> elements)
{
return block.Array(elementType, elements.ToArray());
}
