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 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());
}
