public override ExpressionTarget ParseExpression( HlCompilation compilation, HlUnaryOp expr, ExpressionTarget outputTarget) { ExpressionTarget targetVal = compilation.Parse( expr.Left ); ExpressionTarget target = targetVal.MakeAddress(compilation); if (target.TypeDefinition.Name != HLBaseTypeNames.s_FloatTypeName) { EventManager <WarningEvent> .SendEvent( new UnaryMinusExpressionInvalidEvent( "Unary inversion is only possible with signed types and floats, performing this instruction on other types may yield undefined results." ) ); } if (outputTarget.ResultAddress == target.ResultAddress) { compilation.EmitterResult.Emit("INV.F", outputTarget.ResultAddress); return(outputTarget); } else { compilation.EmitterResult.Emit("INV.F", target.ResultAddress, outputTarget.ResultAddress); ExpressionTarget ret = target.CopyIfNotNull(compilation, outputTarget); compilation.ReleaseTempVar(target.ResultAddress); return(ret); } }
public override ExpressionTarget ParseExpression( HlCompilation compilation, HlUnaryOp expr, ExpressionTarget outputTarget) { ExpressionTarget targetVal = compilation.Parse( expr.Left ); ExpressionTarget target = targetVal. MakeAddress(compilation); string tmp = compilation.GetTempVar(~( uint )0); compilation.EmitterResult.Emit($"XOR", target.ResultAddress, tmp); ExpressionTarget ret = target.CopyIfNotNull(compilation, outputTarget); compilation.ReleaseTempVar(tmp); compilation.ReleaseTempVar(target.ResultAddress); return(ret); }
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 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()); }