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 ) { }