public override ExpressionTarget ParseExpression(HlCompilation compilation, HlUnaryOp expr)
{
ExpressionTarget target = compilation.Parse(expr.Left);
HlTypeDefinition tDef = target.TypeDefinition ??
compilation.TypeSystem.GetType(compilation.Root, HLBaseTypeNames.s_UintTypeName);
string funcName = tDef.GetFinalStaticFunction(expr.OperationType.ToString());
return(InvocationExpressionCompiler.ParseFunctionInvocation(
compilation,
new HlInvocationOp(
new HlValueOperand(
new HlTextToken(
HlTokenType.OpWord,
funcName,
0
)
),
new[] { expr.Left }
),
1,
funcName,
"JSR"
));
}
public ExpressionTarget(string resultAddress, bool isAddress, HlTypeDefinition def, bool isPointer)
{
ResultAddress = resultAddress;
IsAddress = isAddress;
IsPointer = isPointer;
TypeDefinition = def;
}
public void Redirect(
string instance,
HlTypeDefinition instanceType,
HlMemberDefinition memberDef,
bool writeProlog = true)
{
WriteProlog = writeProlog;
InstanceType = instanceType;
MemberDefinition = memberDef;
if (memberDef != null)
{
Left = new HlValueOperand(
new HlTextToken(
HlTokenType.OpWord,
InstanceType.GetFinalMemberName(
memberDef
), //$"FUN_{tdef.Name}_{tdef.Constructor.Name}",
0
)
);
}
Instance = instance;
}
public HlMemberNotFoundEvent(HlTypeDefinition type) : base(
$"Can not Find Member by given query in type '{type.Name}'",
ErrorEventKeys.s_HlMemberNotFound,
false
)
{
}
public HlMemberNotFoundEvent(HlTypeDefinition type, string name) : base(
$"Can not Find Member '{name}' in type '{type.Name}'",
ErrorEventKeys.s_HlMemberNotFound,
false
)
{
}
public MemberNotImplementedErrorEvent(HlTypeDefinition type, HlMemberDefinition member) : base(
$"FunctionType '{type.Name}' does not implement member '{member.Name}'",
ErrorEventKeys.s_HlMemberNotImplemented,
false
)
{
}
public override bool ContainsDefinition(HlCompilation compilation, HlUnaryOp e)
{
HlTypeDefinition tDef = e.GetResultType(compilation) ??
compilation.TypeSystem.GetType(compilation.Root, HLBaseTypeNames.s_UintTypeName);
return(tDef.HasMember(e.Type.ToString()));
}
public ExpressionTarget Compile(HlCompilation compilation, HlInvocationOp expr)
{
if (expr.ParameterList.Length != 2)
{
EventManager <ErrorEvent> .SendEvent(
new FunctionArgumentMismatchEvent(
"Invalid Arguments. Expected offset_of(type, member)"
)
);
}
HlTypeDefinition type = compilation.TypeSystem.GetType(
compilation.Root,
expr.ParameterList[0].ToString()
);
uint off = type.GetOffset(expr.ParameterList[1].ToString());
string v = compilation.GetTempVar(off);
return(new ExpressionTarget(
v,
true,
compilation.TypeSystem.GetType(
compilation.Root,
HLBaseTypeNames.s_UintTypeName
)
));
}
public ConstantData(string name, string finalName, string value, HlTypeDefinition tdef, bool isVisible)
{
UseCount = 0;
InitContent = null;
Value = value;
m_Name = name;
m_FinalName = finalName;
TypeDefinition = tdef;
IsVisible = isVisible;
}
public ExpressionTarget(string resultAddress, bool isAddress, HlTypeDefinition def)
: this(
resultAddress,
isAddress,
def,
false
)
{
//ResultAddress = resultAddress;
//IsAddress = isAddress;
//TypeDefinition = def;
}
public static void WriteInlineConstructorInvocationProlog(
HlCompilation compilation,
HlTypeDefinition tdef,
HlFuncDefOperand fdef)
{
if (!NeedsConstructorInvocationProlog(tdef))
{
return;
}
for (int i = fdef.FunctionDefinition.
Arguments.Length -
1;
i >= 0;
i--)
{
IHlToken valueArgument = fdef.FunctionDefinition.
Arguments[i];
compilation.EmitterResult.Emit(
$"POP",
$"{compilation.GetFinalName( ( valueArgument as VariableDefinitionToken ).Name.ToString() )}"
);
}
compilation.EmitterResult.Emit($"POP", $"{compilation.GetFinalName( "this" )}");
WriteConstructorInvocationProlog(
compilation,
tdef,
compilation.GetFinalName("this")
);
compilation.EmitterResult.Emit($"PUSH", $"{compilation.GetFinalName( "this" )}");
for (int i = 0;
i <
fdef.FunctionDefinition.
Arguments.Length;
i++)
{
IHlToken valueArgument = fdef.FunctionDefinition.
Arguments[i];
compilation.EmitterResult.Emit(
$"PUSH",
$"{compilation.GetFinalName( ( valueArgument as VariableDefinitionToken ).Name.ToString() )}"
);
}
}
public VariableData(
string name,
string finalName,
string content,
HlTypeDefinition tdef,
VariableDataEmitFlags emFlags)
{
UseCount = 0;
DataType = ExternalDataType.Variable;
m_Name = name;
m_FinalName = finalName;
Size = ( uint )(content?.Length ?? 1);
InitContent = content;
TypeDefinition = tdef;
m_EmitFlags = emFlags;
}
public VariableData(
string name,
string finalName,
uint dataSize,
HlTypeDefinition tdef,
VariableDataEmitFlags emFlags,
ExternalDataType dt = ExternalDataType.Variable)
{
UseCount = 0;
DataType = dt;
InitContent = null;
Size = dataSize;
m_Name = name;
m_FinalName = finalName;
TypeDefinition = tdef;
m_EmitFlags = emFlags;
}
public static bool NeedsConstructorInvocationProlog(HlTypeDefinition tdef)
{
bool processed = false;
foreach (HlFunctionDefinition tdefAbstractFunction in tdef.OverridableFunctions)
{
HlFunctionDefinition test =
(HlFunctionDefinition)tdef.GetPrivateOrPublicMember(tdefAbstractFunction.Name);
if (test.IsVirtual || test.IsOverride)
{
processed = true;
}
}
return(processed);
}
public FunctionDefinitionToken(
IHlToken name,
IHlToken retType,
IHlToken[] args,
IHlToken[] mods,
IHlToken[] subtokens,
int start,
HlTypeDefinition parent = null,
HlFunctionType functionType = HlFunctionType.Function) : base(
HlTokenType.OpFunctionDefinition,
subtokens,
start
)
{
FunctionType = functionType;
Parent = parent;
FunctionName = name;
FunctionReturnType = retType;
m_Modifiers = mods.ToList();
Arguments = args;
Block = subtokens;
}
public StaticInstanceMemberAccessEvent(HlTypeDefinition type, HlMemberDefinition member) : base(
$"Accessing Instance Function '{member.Name}' in type '{type.Namespace.FullName}::{type.Name}' as static function. Passing an instance of '{type.Namespace.FullName}::{type.Name}' is required",
WarningEventKeys.s_StaticInstanceMemberAccess
)
{
}
public IExternalData[] ProcessImport(HlCompilation compilation, string input)
{
int tagLen = "link".Length + 1;
if (input.Length < tagLen)
{
EventManager <ErrorEvent> .SendEvent(new InvalidLinkImporterArgumentsEvent( input ));
return(new IExternalData[0]);
}
string cmd = input.Remove(0, tagLen);
LinkerInfo info = LinkerInfo.Load(cmd);
foreach (KeyValuePair <string, AddressItem> label in info.Labels)
{
if (label.Key.StartsWith("SFUN_"))
{
string raw = label.Key.Remove(0, "SFUN_".Length);
int idx = raw.IndexOf("_");
string name = raw.Substring(0, idx);
HlTypeDefinition tdef = compilation.TypeSystem.HasType(compilation.Root, name)
? compilation.TypeSystem.GetType(compilation.Root, name)
: compilation.TypeSystem.CreateEmptyType(
compilation.Root,
name,
true,
false,
false
);
tdef.AddMember(
new HlExternalFunctionDefinition(
compilation.TypeSystem,
compilation.Root,
raw.Remove(0, idx + 1),
label.Key,
new List <IHlToken>
{
new HlTextToken(
HlTokenType.OpPublicMod,
"public",
0
),
new HlTextToken(
HlTokenType.OpStaticMod,
"static",
0
)
}
)
);
}
else if (label.Key.StartsWith("ADFUN_"))
{
string raw = label.Key.Remove(0, "ADFUN_".Length);
int idx = raw.IndexOf("_");
string name = raw.Substring(0, idx);
HlTypeDefinition tdef = compilation.TypeSystem.HasType(compilation.Root, name)
? compilation.TypeSystem.GetType(compilation.Root, name)
: compilation.TypeSystem.CreateEmptyType(
compilation.Root,
name,
true,
false,
false
);
tdef.AddMember(
new HlExternalFunctionDefinition(
compilation.TypeSystem,
compilation.Root,
raw.Remove(0, idx + 1),
label.Key,
new List <IHlToken>
{
new HlTextToken(
HlTokenType.OpPublicMod,
"public",
0
),
new HlTextToken(
HlTokenType.OpAbstractMod,
"abstract",
0
),
}
)
);
}
else if (label.Key.StartsWith("DFUN_"))
{
string raw = label.Key.Remove(0, "DFUN_".Length);
int idx = raw.IndexOf("_");
string name = raw.Substring(0, idx);
HlTypeDefinition tdef = compilation.TypeSystem.HasType(compilation.Root, name)
? compilation.TypeSystem.GetType(compilation.Root, name)
: compilation.TypeSystem.CreateEmptyType(
compilation.Root,
name,
true,
false,
false
);
tdef.AddMember(
new HlExternalFunctionDefinition(
compilation.TypeSystem,
compilation.Root,
raw.Remove(0, idx + 1),
label.Key,
new List <IHlToken>
{
new HlTextToken(
HlTokenType.OpPublicMod,
"public",
0
),
}
)
);
}
else if (label.Key.StartsWith("VDFUN_"))
{
string raw = label.Key.Remove(0, "VDFUN_".Length);
int idx = raw.IndexOf("_");
string name = raw.Substring(0, idx);
HlTypeDefinition tdef = compilation.TypeSystem.HasType(compilation.Root, name)
? compilation.TypeSystem.GetType(compilation.Root, name)
: compilation.TypeSystem.CreateEmptyType(
compilation.Root,
name,
true,
false,
false
);
tdef.AddMember(
new HlExternalFunctionDefinition(
compilation.TypeSystem,
compilation.Root,
raw.Remove(0, idx + 1),
label.Key,
new List <IHlToken>
{
new HlTextToken(
HlTokenType.OpPublicMod,
"public",
0
),
new HlTextToken(
HlTokenType.OpVirtualMod,
"virtual",
0
)
}
)
);
}
}
return(info.Labels.
Select(
x => (IExternalData) new LinkedData(
x.Key,
x.Value,
ExternalDataType.Function
)
).
Concat(
info.DataSectionHeader.Select(
x => (IExternalData) new LinkedData(
x.Key,
x.Value,
ExternalDataType.Variable
)
)
).
ToArray());
}
public override ExpressionTarget ParseExpression(
HlCompilation compilation,
HlMemberAccessOp expr,
ExpressionTarget outputTarget)
{
string tmpVar;
ExpressionTarget lType = compilation.Parse(expr.Left);
if (lType.ResultAddress == "%%TYPE%%")
{
if (expr.MemberName is HlInvocationOp invoc)
{
HlMemberDefinition data = null;
bool writeProlog = invoc.Left.ToString() == "new";
if (invoc.Left.ToString() == "new" || invoc.Left.ToString() == "base")
{
data = lType.TypeDefinition.StaticConstructor;
}
else
{
data = lType.TypeDefinition.GetPrivateOrPublicMember(invoc.Left.ToString());
}
if (lType.TypeDefinition.IsAbstract &&
writeProlog &&
data == lType.TypeDefinition.StaticConstructor)
{
EventManager <ErrorEvent> .SendEvent(
new AbstractConstructorCallEvent( lType.TypeDefinition )
);
}
if (data != null && !data.IsStatic)
{
EventManager <WarningEvent> .SendEvent(
new StaticInstanceMemberAccessEvent(
lType.TypeDefinition,
data
)
);
}
invoc.Redirect(null, lType.TypeDefinition, data, writeProlog);
ExpressionTarget t = compilation.Parse(invoc, outputTarget).
CopyIfNotNull(compilation, outputTarget);
return(t);
}
else
{
HlMemberDefinition data =
lType.TypeDefinition.GetPrivateOrPublicMember(expr.MemberName.ToString());
string funcName =
lType.TypeDefinition.
GetFinalMemberName(data); //$"FUN_{lType.TypeDefinition.Name}_{expr.MemberName}";
if (data.IsStatic && data is HlPropertyDefinition propDef)
{
funcName = compilation.GetFinalName(funcName);
}
if (!data.IsStatic)
{
EventManager <WarningEvent> .SendEvent(
new StaticInstanceMemberAccessEvent(
lType.TypeDefinition,
data
)
);
}
if (outputTarget.ResultAddress != null)
{
compilation.EmitterResult.Emit("LOAD", funcName, outputTarget.ResultAddress);
return(outputTarget);
}
return(new ExpressionTarget(
funcName,
true,
compilation.TypeSystem.GetType(
compilation.Root,
HLBaseTypeNames.s_UintTypeName
),
false
));
}
}
string containerName = expr.MemberName.ToString();
if (expr.MemberName is HlInvocationOp inv)
{
if (lType.TypeDefinition.HasMember(inv.Left.ToString()) &&
lType.TypeDefinition.GetPrivateOrPublicMember(inv.Left.ToString()) is HlPropertyDefinition)
{
containerName = inv.Left.ToString();
}
else
{
HlMemberDefinition data = lType.TypeDefinition.GetPrivateOrPublicMember(inv.Left.ToString());
inv.Redirect(
lType.ResultAddress,
lType.TypeDefinition,
data
);
ExpressionTarget tVal = compilation.Parse(inv, outputTarget);
ExpressionTarget t = tVal.CopyIfNotNull(compilation, outputTarget);
return(t);
}
}
else if (expr.MemberName is HlArrayAccessorOp arr &&
lType.TypeDefinition.GetPrivateOrPublicMember(arr.Left.ToString()) is HlPropertyDefinition)
{
containerName = arr.Left.ToString();
}
uint off = HlTypeDefinition.RecursiveGetOffset(
lType.TypeDefinition,
0,
0,
containerName.Split('.')
);
string tmpOff = compilation.GetTempVar(off);
if (lType.IsPointer)
{
tmpVar = compilation.GetTempVarCopy(lType.ResultAddress);
}
else
{
tmpVar = compilation.GetTempVarLoad(lType.ResultAddress);
}
compilation.EmitterResult.Emit($"ADD", tmpVar, tmpOff);
compilation.ReleaseTempVar(tmpOff);
HlMemberDefinition mdef = null;
if (expr.Left.ToString() == "this")
{
mdef = HlTypeDefinition.RecursiveGetPrivateOrPublicMember(
lType.TypeDefinition,
0,
containerName.Split('.')
);
}
else
{
mdef = HlTypeDefinition.RecursiveGetPublicMember(
lType.TypeDefinition,
0,
containerName.Split('.')
);
}
if (mdef is HlPropertyDefinition pdef)
{
if (outputTarget.ResultAddress != null)
{
compilation.EmitterResult.Emit($"DREF", tmpVar, outputTarget.ResultAddress);
compilation.ReleaseTempVar(tmpVar);
return(outputTarget);
}
return(new ExpressionTarget(tmpVar, true, pdef.PropertyType, true));
}
if (mdef is HlFunctionDefinition fdef)
{
if (outputTarget.ResultAddress != null)
{
compilation.EmitterResult.Emit($"DREF", tmpVar, outputTarget.ResultAddress);
compilation.ReleaseTempVar(tmpVar);
return(outputTarget);
}
return(new ExpressionTarget(tmpVar, true, fdef.ReturnType, true));
}
return(new ExpressionTarget());
}
public static bool WriteConstructorInvocationProlog(
HlCompilation compilation,
HlTypeDefinition tdef,
string ret)
{
bool processed = false;
foreach (HlFunctionDefinition tdefAbstractFunction in tdef.OverridableFunctions)
{
HlFunctionDefinition test =
( HlFunctionDefinition )tdef.GetPrivateOrPublicMember(tdefAbstractFunction.Name);
if (test.IsVirtual || test.IsOverride)
{
processed = true;
uint off = tdef.GetOffset(tdefAbstractFunction.Name);
compilation.EmitterResult.Store(
$"; Applying Function Pointer: {test.Name} Offset from Begin: {off}"
);
string tmp =
compilation.GetTempVarLoad(off.ToString());
string implementingFunction = tdef.GetFinalMemberName(test);
compilation.EmitterResult.Emit("ADD", tmp, ret);
string instanceFuncPtr = tmp; //compilation.GetTempVarLoad( tmp );
//string check = compilation.GetTempVarDref( tmp );
//string endLbl = HlCompilation.GetUniqueName( $"{tdef.Name}_prolog" );
//compilation.EmitterResult.Emit( $"BNZ", check, endLbl );
string func =
compilation.GetTempVarLoad(implementingFunction);
string tmpPtr = compilation.GetTempVarLoad(func);
compilation.EmitterResult.Emit("CREF", tmpPtr, instanceFuncPtr);
compilation.ReleaseTempVar(instanceFuncPtr);
compilation.ReleaseTempVar(func);
compilation.ReleaseTempVar(tmpPtr);
//compilation.EmitterResult.Store( $".{endLbl}" );
}
else if (!tdef.IsAbstract)
{
EventManager <ErrorEvent> .SendEvent(
new MemberNotImplementedErrorEvent(
tdef,
tdefAbstractFunction
)
);
}
else
{
EventManager <WarningEvent> .SendEvent(
new MemberNotImplementedWarningEvent(
tdef,
tdefAbstractFunction
)
);
}
}
return(processed);
}
public override ExpressionTarget ParseExpression(
HlCompilation compilation,
HlVarOperand expr,
ExpressionTarget outputTarget)
{
if (compilation.ConstValTypes.Contains(expr.Value.ToString()))
{
return(new ExpressionTarget(
expr.Value.ToString(),
true,
compilation.TypeSystem.GetType(
compilation.Root,
HLBaseTypeNames.s_UintTypeName
)
).
CopyIfNotNull(compilation, outputTarget));
}
string varAddr;
if (compilation.ContainsVariable(expr.Value.ToString()))
{
VariableData v = compilation.GetVariable(expr.Value.ToString());
varAddr = v.GetFinalName();
return(new ExpressionTarget(
varAddr,
true,
v.TypeDefinition,
!v.TypeDefinition.IsValueType ||
v.IsPointer
).CopyIfNotNull(compilation, outputTarget));
}
if (compilation.FunctionMap.Contains(expr.Value.ToString()))
{
varAddr = expr.Value.ToString();
return(new ExpressionTarget(varAddr, true, null));
}
if (compilation.TypeSystem.HasType(compilation.Root, expr.Value.ToString()))
{
HlTypeDefinition tdef = compilation.TypeSystem.GetType(compilation.Root, expr.Value.ToString());
return(new ExpressionTarget("%%TYPE%%", false, tdef, false));
}
if (compilation.ExternalSymbols.Any(x => x.GetName() == expr.Value.ToString()))
{
return(new ExpressionTarget(
compilation.ExternalSymbols.
First(x => x.GetName() == expr.Value.ToString()).
GetFinalName(),
false,
compilation.TypeSystem.GetType(
compilation.Root,
HLBaseTypeNames.s_UintTypeName
)
));
}
EventManager <ErrorEvent> .SendEvent(new HlVariableNotFoundEvent( expr.Value.ToString(), false ));
return(new ExpressionTarget());
}
public override ExpressionTarget ParseExpression(HlCompilation compilation, HlVarDefOperand expr)
{
if (expr.VariableDefinition.Modifiers.All(x => x.Type != HlTokenType.OpConstMod))
{
string asmVarName = expr.VariableDefinition.Name.ToString();
if (compilation.ContainsLocalVariable(asmVarName))
{
EventManager <ErrorEvent> .SendEvent(new DuplicateVarDefinitionEvent( asmVarName ));
}
HlTypeDefinition vdef = m_TypeSystem.GetType(
compilation.Root,
expr.VariableDefinition.TypeName.ToString()
);
uint arrSize = expr.VariableDefinition.Size?.ToString().ParseUInt() ?? 1;
if (arrSize != 1)
{
vdef = new ArrayTypeDefintion(compilation.Root, vdef, arrSize);
}
HlExpression init = expr.Initializer.FirstOrDefault();
if (vdef.GetSize() > 1)
{
if (init is HlVarOperand vo)
{
}
}
compilation.CreateVariable(
asmVarName,
arrSize,
vdef,
expr.VariableDefinition.Modifiers.Any(
x => x.Type == HlTokenType.OpPublicMod
)
? VariableDataEmitFlags.Visible
: VariableDataEmitFlags.None
);
if (init != null)
{
if (init is HlValueOperand vOp &&
vOp.Value.Type == HlTokenType.OpStringLiteral)
{
ExpressionTarget svar = new ExpressionTarget(
compilation.GetFinalName(asmVarName),
true,
vdef
);
string content = vOp.Value.ToString();
VariableDataEmitFlags emFlags = vdef is CStringTypeDefinition
? VariableDataEmitFlags.CStyle
: VariableDataEmitFlags.None;
if (expr.VariableDefinition.Modifiers.Any(x => x.Type == HlTokenType.OpPackedMod))
{
emFlags |= VariableDataEmitFlags.Packed;
}
compilation.CreateVariable(asmVarName, content, vdef, emFlags);
return(new ExpressionTarget(
svar.ResultAddress,
true,
vdef
));
}
}
ExpressionTarget dvar = new ExpressionTarget(
compilation.GetFinalName(asmVarName),
true,
vdef
);
if (init != null)
{
ExpressionTarget initVal = compilation.Parse(init, dvar);
ExpressionTarget initRet = initVal.CopyIfNotNull(compilation, dvar);
compilation.ReleaseTempVar(initVal.ResultAddress);
return(initRet);
}
return(dvar);
}
else
{
string asmVarName = expr.VariableDefinition.Name.ToString();
if (compilation.ConstValTypes.Contains(asmVarName))
{
EventManager <ErrorEvent> .SendEvent(new DuplicateConstVarDefinitionEvent( asmVarName ));
}
compilation.ConstValTypes.Set(
asmVarName,
new ConstantValueItem()
{
Value = expr.VariableDefinition.InitializerExpression.
FirstOrDefault()?.
ToString(),
IsPublic = expr.VariableDefinition.Modifiers.Any(
x => x.Type == HlTokenType.OpPublicMod
),
IsInternal = expr.VariableDefinition.Modifiers.Any(
x => x.Type == HlTokenType.OpInternalMod
)
}
);
return(new ExpressionTarget(
asmVarName,
true,
compilation.TypeSystem.GetType(
compilation.Root,
expr.VariableDefinition.TypeName.ToString()
)
));
}
EventManager <ErrorEvent> .SendEvent(new DynamicVariablesNotSupportedEvent());
return(new ExpressionTarget());
}
public override ExpressionTarget ParseExpression(HlCompilation compilation, HlInvocationOp expr)
{
string target = expr.Left.ToString();
if (m_CtFuncCollection.IsCompiletimeFunction(target))
{
return(m_CtFuncCollection.Compile(target, compilation, expr));
}
bool isInternalFunc = compilation.FunctionMap.Contains(target);
IExternalData externalSymbol =
compilation.ExternalSymbols.FirstOrDefault(
x => x.GetName() == target &&
x.DataType == ExternalDataType.Function
);
//if (expr.Instance == null &&
// expr.MemberDefinition == null &&
// expr.InstanceType != null &&
// target == "new")
//{
// ExpressionTarget instance = compilation.Parse(expr.ParameterList[0]);
// HlTypeDefinition tdef = expr.InstanceType;
// ExpressionTarget ret = new ExpressionTarget(
// instance.ResultAddress,
// true,
// tdef,
// true
// );
// if(SettingsManager.GetSettings<HlCompilerSettings>().ConstructorPrologMode == HlTypeConstructorPrologMode.Outline)
// WriteConstructorInvocationProlog(compilation, tdef, ret.ResultAddress);
// return ret;
//}
if (expr.Instance == null &&
expr.InstanceType != null)
{
if (expr.MemberDefinition == expr.InstanceType.StaticConstructor)
{
ExpressionTarget instance = compilation.Parse(expr.ParameterList[0]);
HlTypeDefinition tdef = expr.InstanceType;
ExpressionTarget ret = new ExpressionTarget(
instance.ResultAddress,
true,
tdef,
true
);
if (expr.WriteProlog &&
SettingsManager.GetSettings <HlCompilerSettings>().ConstructorPrologMode ==
HlTypeConstructorPrologMode.Outline)
{
WriteConstructorInvocationProlog(compilation, tdef, ret.ResultAddress);
}
expr.Redirect(ret.ResultAddress, tdef, tdef.StaticConstructor, expr.WriteProlog);
ParseExpression(
compilation,
expr
);
return(ret);
}
else
{
int l = (expr.MemberDefinition as HlFunctionDefinition).ParameterTypes.Length;
if (isInternalFunc)
{
compilation.FunctionMap.Get(target).SetUsed();
}
else
{
externalSymbol?.SetUsed();
}
return(ParseFunctionInvocation(compilation, expr, l, target, "JSR"));
}
}
if (compilation.TypeSystem.HasType(compilation.Root, target))
{
string var = HlCompilation.GetUniqueName("static_alloc");
HlTypeDefinition tdef = compilation.TypeSystem.GetType(compilation.Root, target);
uint size = tdef.GetSize();
compilation.CreateVariable(var, size, tdef, VariableDataEmitFlags.None);
string finalName = compilation.GetFinalName(var);
ExpressionTarget ret = new ExpressionTarget(
compilation.GetTempVarLoad(finalName),
true,
tdef,
true
);
if (SettingsManager.GetSettings <HlCompilerSettings>().ConstructorPrologMode ==
HlTypeConstructorPrologMode.Outline)
{
WriteConstructorInvocationProlog(compilation, tdef, ret.ResultAddress);
}
if (tdef.StaticConstructor != null)
{
expr.Redirect(ret.ResultAddress, tdef, tdef.StaticConstructor);
ParseExpression(
compilation,
expr
);
}
return(ret);
}
if (expr.Instance != null &&
expr.MemberDefinition is HlFunctionDefinition fdef)
{
if (fdef.IsVirtual || fdef.IsAbstract || fdef.IsOverride)
{
uint i = expr.InstanceType.GetOffset(fdef.Name);
string init = i.ToString();
string tmp = compilation.GetTempVarLoad(init);
compilation.EmitterResult.Emit("ADD", tmp, expr.Instance);
compilation.EmitterResult.Emit("DREF", tmp, tmp);
int targetLength = fdef.ParameterTypes != null
? fdef.ParameterTypes.Length
: expr.ParameterList.Length;
externalSymbol?.SetUsed();
ExpressionTarget t = ParseFunctionInvocation(compilation, expr, targetLength, tmp, "JSREF");
compilation.ReleaseTempVar(tmp);
return(t);
}
else if (!isInternalFunc && externalSymbol == null)
{
string funcEmit = target;
int targetLength = fdef.ParameterTypes?.Length ?? expr.ParameterList.Length;
if (expr.InstanceType != null &&
expr.InstanceType.StaticConstructor == expr.MemberDefinition &&
expr.WriteProlog &&
SettingsManager.GetSettings <HlCompilerSettings>().ConstructorPrologMode ==
HlTypeConstructorPrologMode.Inline)
{
funcEmit = expr.InstanceType.GetInternalConstructor(compilation);
}
return(ParseFunctionInvocation(compilation, expr, targetLength, funcEmit, "JSR"));
}
}
if (isInternalFunc)
{
string funcEmit = target;
FunctionData fData = compilation.FunctionMap.Get(target);
int targetLength = fData.ParameterCount;
//if (!expr.WriteProlog && SettingsManager.GetSettings < HlCompilerSettings >().ConstructorPrologMode ==
// HlTypeConstructorPrologMode.Inline )
//{
// funcEmit = expr.MemberDefinition.
//}
if (expr.InstanceType != null &&
expr.InstanceType.StaticConstructor == expr.MemberDefinition &&
expr.WriteProlog &&
SettingsManager.GetSettings <HlCompilerSettings>().ConstructorPrologMode ==
HlTypeConstructorPrologMode.Inline)
{
funcEmit = expr.InstanceType.GetInternalConstructor(compilation);
}
fData.SetUsed();
return(ParseFunctionInvocation(compilation, expr, targetLength, funcEmit, "JSR").
Cast(
compilation.TypeSystem.GetType(
compilation.Root,
fData?.ReturnType ?? HLBaseTypeNames.s_UintTypeName
)
));
}
if (externalSymbol != null)
{
string funcEmit = (externalSymbol as LinkedData)?.Info.Address.ToString() ?? target;
FunctionData fData = externalSymbol as FunctionData;
int targetLength = (externalSymbol as FunctionData)?.ParameterCount ?? expr.ParameterList.Length;
if (expr.InstanceType != null &&
expr.InstanceType.StaticConstructor == expr.MemberDefinition &&
expr.WriteProlog &&
SettingsManager.GetSettings <HlCompilerSettings>().ConstructorPrologMode ==
HlTypeConstructorPrologMode.Inline)
{
funcEmit = expr.InstanceType.GetInternalConstructor(compilation);
}
externalSymbol.SetUsed();
return(ParseFunctionInvocation(compilation, expr, targetLength, funcEmit, "JSR").
Cast(compilation.TypeSystem.GetType(
compilation.Root,
fData?.ReturnType ?? HLBaseTypeNames.s_UintTypeName
)));
}
//if (isInternalFunc || externalSymbol != null)
//{
// string funcEmit = externalSymbol is LinkedData l ? l.Info.Address.ToString() : target;
// int targetLength = isInternalFunc
// ? compilation.FunctionMap.Get(target).ParameterCount
// : (externalSymbol as FunctionData)?.ParameterCount ??
// expr.ParameterList.Length;
// //if (!expr.WriteProlog && SettingsManager.GetSettings < HlCompilerSettings >().ConstructorPrologMode ==
// // HlTypeConstructorPrologMode.Inline )
// //{
// // funcEmit = expr.MemberDefinition.
// //}
// return ParseFunctionInvocation(compilation, expr, targetLength, funcEmit, "JSR");
//}
if (compilation.ContainsVariable(target) ||
compilation.ConstValTypes.Contains(target))
{
foreach (HlExpression parameter in expr.ParameterList)
{
ExpressionTarget ttVal = compilation.Parse(parameter);
ExpressionTarget tt = ttVal.MakeAddress(compilation);
compilation.EmitterResult.Emit(
$"PUSH",
tt.ResultAddress
);
compilation.ReleaseTempVar(tt.ResultAddress);
compilation.ReleaseTempVar(ttVal.ResultAddress);
}
if (compilation.ContainsVariable(target))
{
compilation.EmitterResult.Emit($"JSREF", compilation.GetFinalName(target));
}
else
{
compilation.EmitterResult.Emit($"JSREF", target);
}
ExpressionTarget tempReturn = new ExpressionTarget(
compilation.GetTempVarPop(),
true,
compilation.TypeSystem.GetType(
compilation.Root,
HLBaseTypeNames.s_UintTypeName
)
);
return(tempReturn);
}
EventManager <ErrorEvent> .SendEvent(new FunctionNotFoundEvent( target ));
return(new ExpressionTarget());
}
public MemberNotImplementedWarningEvent(HlTypeDefinition type, HlMemberDefinition member) : base(
$"Ignoring unimplemented member '{member.Name}' in abstract type '{type.Namespace.FullName}::{type.Name}'",
WarningEventKeys.s_HlMemberNotImplemented
)
{
}
