public LocalVariable(AstVariableDeclaration declaration, bool isFunctionParameter, int stackIndex, SourceMapEntry sourceMapEntry) : base(declaration)
{
// Set our extended properties
StackIndex = stackIndex;
SourceMapEntry = sourceMapEntry;
IsFunctionParameter = isFunctionParameter;
}
protected void Initialize(AstVariableDeclaration declaration)
{
// Set our properties
Declaration = declaration;
// Initialize by name and type.
Initialize(Declaration.Name, Declaration.TypeName, Declaration.TypeDescriptions);
}
/// <summary>
/// Initializes the variable with a given declaration, parsing all relevant type information and associating the appropriate value parser.
/// </summary>
/// <param name="declaration">The ast variable declaration which constitutes the solidity declaration of the variable we wish to interface with.</param>
public BaseVariable(AstVariableDeclaration declaration)
{
// Set our properties
Declaration = declaration;
BaseType = VarTypes.ParseTypeComponents(Declaration.TypeName.TypeDescriptions.TypeString).baseType;
GenericType = VarTypes.GetGenericType(BaseType);
ValueParser = VarTypes.GetVariableObject(Declaration.TypeName, VariableLocation);
}
public LocalVariable(AstVariableDeclaration declaration, bool isFunctionParameter, int stackIndex, SourceMapEntry sourceMapEntry)
{
// Set our extended properties
StackIndex = stackIndex;
SourceMapEntry = sourceMapEntry;
IsFunctionParameter = isFunctionParameter;
// Initialize by name and type.
Initialize(declaration);
}
public void WriteVariableDeclaration(AstVariableDeclaration a)
{
var flags = a.Variables.Count <<
(int)AstVariableModifier.Shift |
(int)(a.Modifier & AstVariableModifier.Mask);
Write7BitEncodedInt(flags);
Write(a.Type);
foreach (var v in a.Variables)
{
WriteIdentifier(v.Name);
Write(v.OptionalValue);
}
}
Statement CompileVariableDeclaration(AstVariableDeclaration e)
{
DataType dt = null;
switch (e.Type.ExpressionType)
{
case AstExpressionType.Var:
{
if (e.Variables.Count != 1)
{
Log.Error(e.Source, ErrorCode.E0000, "Implicitly-typed variables cannot have multiple declarators");
dt = DataType.Invalid;
}
else if (e.Variables[0].OptionalValue == null)
{
Log.Error(e.Source, ErrorCode.E3400, "Variable declarations using 'var' must provide an initial value");
dt = DataType.Invalid;
}
if (e.Modifier == AstVariableModifier.Const)
{
Log.Error(e.Source, ErrorCode.E0000, "Implicitly-typed variables cannot be constant");
dt = DataType.Invalid;
}
break;
}
default:
{
dt = NameResolver.GetType(Namescope, e.Type);
break;
}
}
Variable root = null;
Variable next = null;
foreach (var v in e.Variables)
{
VerifyVariableName(v.Name.Source, v.Name.Symbol);
Expression initValue = null;
if (v.OptionalValue != null)
{
initValue = CompileExpression(v.OptionalValue);
if (e.Modifier == 0 &&
initValue is NewObject &&
e.Type.ExpressionType != AstExpressionType.Var &&
initValue.ReturnType.Equals(dt) &&
dt.BuiltinType == 0)
{
Log.Warning3(e.Source, ErrorCode.W3401, "Variable can be implicitly typed using 'var'");
}
if (dt != null)
{
initValue = CompileImplicitCast(e.Source, dt, initValue);
}
else
{
dt = initValue.ReturnType;
}
if (e.Modifier == AstVariableModifier.Const)
{
Compiler.ConstantFolder.TryMakeConstant(ref initValue);
}
}
var var = new Variable(v.Name.Source, Function, v.Name.Symbol, dt,
(VariableType)e.Modifier,
initValue);
CurrentVariableScope.Variables[v.Name.Symbol] = var;
next = root == null
? root = var
: next.Next = var;
}
return(new VariableDeclaration(root));
}
public StateVariable(AstVariableDeclaration declaration) : base(declaration)
{
}
public StateVariable(AstVariableDeclaration declaration)
{
// Initialize by declaration
Initialize(declaration);
}
