public int Visit(VariableStatement statement)
{
var initializerType = statement.Initializer?.Accept(_inference);
var type = statement.Type ?? initializerType;
var typePrim = type as PrimitiveType;
if (statement.Type == null && typePrim != null && (typePrim.Type == Primitive.CharOrLarger || typePrim.Type == Primitive.ShortOrLarger))
{
type = new PrimitiveType(Primitive.Int);
}
FrameResource resource;
if (!_scope.TryDefine(statement.Name, type, out resource))
{
throw new Exception(); // TODO
}
if (statement.Initializer != null)
{
if (initializerType != null && !initializerType.IsAssignableTo(type, checkConst: false))
{
throw new Exception(); // TODO
}
var initializerResource = statement.Initializer.Accept(this);
_context.Emit(new Instruction(Opcode.Mov, resource.Operand, initializerResource.Operand));
initializerResource.Dispose();
}
return(0);
}
public IVariableStatement Build()
{
if (m_expression == null)
{
throw new InvalidOperationException(FormattableStringEx.I($"The initializer expression was not specified. Did you forget to call Initializer method?"));
}
if (m_name == null)
{
throw new InvalidOperationException(FormattableStringEx.I($"The name was not specified. Did you forget to call Initializer method?"));
}
var nodeFlags = m_isConst ? NodeFlags.Const : NodeFlags.None;
if (m_visibility == DScript.Visibility.Export || m_visibility == DScript.Visibility.Public)
{
nodeFlags |= NodeFlags.Export;
}
var result = new VariableStatement(
m_name,
m_expression,
type: m_type,
flags: nodeFlags);
if (m_visibility == DScript.Visibility.Public)
{
result.WithPublicDecorator();
}
return(result);
}
public override void VisitVariableStatement(VariableStatement variableDeclaration)
{
if (variableDeclaration.Modifiers?.Contains(SyntaxKind.DeclareKeyword) == true)
{
Visit(variableDeclaration.Declarations);
}
}
public virtual Statement visit(VariableStatement variableStatement)
{
variableStatement.declarations =
(VariableDeclaration[])visitExpressionArray(variableStatement.declarations);
return(variableStatement);
}
public object VisitVariableStatement(VariableStatement statement)
{
scope.Declare(statement.Name);
Resolve(statement.Initializer);
scope.Define(statement.Name);
return(null);
}
public object VisitVariableStatement(VariableStatement statement)
{
var value = Evaluate(statement.Initializer);
environment.Define(statement.Name, value);
return(null);
}
public override object Walk(VariableStatement node)
{
object result = null;
foreach (var variableDeclaration in node.VariableDeclarations)
{
result = variableDeclaration.Accept(this);
}
return(result);
}
public virtual object Walk(VariableStatement node)
{
if (Enter(node))
{
foreach (var variableDeclaration in node.VariableDeclarations)
{
variableDeclaration.Accept(this);
}
}
Exit(node);
return(null);
}
private static void __Execute(atom.Trace context, int level, VariableStatement data, string file, bool isShowPrivate)
{
if (__IsEnabled(data, isShowPrivate))
{
var a_Context = data.GetDescendants().OfType <Identifier>()?.First();
if (a_Context != null)
{
context.
SetComment(__GetType(data, "variable"), "[[[Data Type]]]").
SetUrl(file, __GetLine(a_Context, a_Context.Pos.Value), __GetPosition(a_Context, a_Context.Pos.Value)).
Send(NAME.SOURCE.PREVIEW, NAME.TYPE.VARIABLE, level, a_Context.IdentifierStr, "...");
}
}
}
/// <summary>
/// If the variable statement is exported, then it becomes an ambient. Since we want to
/// annotate each declaration with the original position, each declaration is printed
/// as a separate statement
/// </summary>
public override void VisitVariableStatement(VariableStatement node)
{
var declarations = node.DeclarationList.Declarations;
for (var i = 0; i < declarations.Count; i++)
{
AppendSingleVariableStatementAndForceAmbient(node, declarations[i]);
// All new statements get an ending semicolon but the last one. That one is added by the caller of this method.
if (i != declarations.Count - 1)
{
AppendSeparatorToken(Writer.NoNewLine());
}
}
}
public VariableStatement ParseVariableStatement()
{
var varStatement = new VariableStatement {
Token = Next()
};
Match(TokenType.Var);
varStatement.VariableDeclarations.Add(ParseVariableDeclaration());
while (Next().Is(TokenType.Comma))
{
Match(TokenType.Comma);
varStatement.VariableDeclarations.Add(ParseVariableDeclaration());
}
Match(TokenType.SemiColon);
return(varStatement);
}
public int Visit(VariableStatement statement)
{
_writer.Write("var ");
_writer.Write(statement.Name);
if (statement.Type != null)
{
_writer.Write(": ");
_writer.Write(statement.Type);
}
if (statement.Initializer != null)
{
_writer.Write(" = ");
statement.Initializer.Accept(this);
}
_writer.Write(";");
return(0);
}
private static List <CodeItem> MapVariable(VariableStatement variable)
{
var declarator = variable.DeclarationList.Declarations.First();
if (declarator.Initializer != null)
{
switch (declarator.Initializer.Kind)
{
case SyntaxKind.FunctionExpression:
return(FunctionMapperJS.MapFunctionExpression(declarator, _control));
case SyntaxKind.ArrowFunction:
return(FunctionMapperJS.MapArrowFunctionExpression(declarator, _control));
case SyntaxKind.NewExpression:
return(FunctionMapperJS.MapNewExpression(declarator, _control));
default:
break;
}
}
if (variable.Parent.Kind != SyntaxKind.SourceFile)
{
return(new List <CodeItem>());
}
var item = BaseMapperJS.MapBase <CodeItem>(variable, declarator.IdentifierStr, _control);
item.Kind = CodeItemKindEnum.Variable;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
return(new List <CodeItem> {
item
});
}
public virtual bool Enter(VariableStatement node)
{
return(true);
}
public VariableStatement ParseVariableStatement()
{
var varStatement = new VariableStatement { Token = Next() };
Match(TokenType.Var);
varStatement.VariableDeclarations.Add(ParseVariableDeclaration());
while (Next().Is(TokenType.Comma))
{
Match(TokenType.Comma);
varStatement.VariableDeclarations.Add(ParseVariableDeclaration());
}
Match(TokenType.SemiColon);
return varStatement;
}
public void VisitVariableStatement(VariableStatement variableStatement)
{
foreach (VariableDeclaration vd in variableStatement.Variables)
VisitVariableDeclaration(vd);
}
public string VisitVariableStatement(VariableStatement variableStatement)
{
throw new NotImplementedException();
}
public virtual Statement visit(VariableStatement statement)
{
return(statement);
}
public int Visit(VariableStatement statement)
{
if (statement.Definitions.Count == 1)
{
var def = statement.Definitions[0];
var targetType = def.Type;
var valueIdent = def.Value as IdentifierExpression;
if (valueIdent != null)
{
var valueType = GetType(valueIdent.Name);
if (valueType != null)
{
if (targetType.IsResizable && (valueType.IsArray && !valueType.IsResizable))
{
Declare(def.Name, def.Type);
// Vector def = arrayIdent;
var result = ArrayToResizable(valueIdent.Name);
_writer.WriteLine("Vector {0} = {1};", def.Name, result);
return(0);
}
if ((targetType.IsArray && !targetType.IsResizable) && valueType.IsResizable)
{
Declare(def.Name, def.Type);
// arrayType[] def = vectorIdent;
var result = ResizableToArray(valueIdent.Name, def.Type);
_writer.WriteLine("{0} {1} = {2};", targetType, def.Name, result);
return(0);
}
}
}
var valueCast = def.Value as CastExpression;
if (valueCast != null && targetType.IsResizable)
{
var valueType = valueCast.Type;
if (valueType.IsResizable && targetType.Name == valueType.Name)
{
valueType = new ScriptType(valueType.Name, valueType.ArrayDimensions);
Declare(def.Name, def.Type);
// resizable arrayType[] def = (resizable arrayType[])arrayExpr;
var result = ArrayToResizable(valueType, valueCast.Value);
_writer.WriteLine("Vector {0} = {1};", def.Name, result);
return(0);
}
}
}
if (statement.Final)
{
_writer.Write("final ");
}
if (statement.BaseType.IsResizable)
{
var def = statement.Definitions.Single();
Declare(def.Name, def.Type);
_writer.Write("Vector ");
_writer.Write(def.Name);
if (def.Value == null)
{
_writer.WriteLine(";");
return(0);
}
_writer.Write(" = ");
if (def.Value is NewExpression)
{
_writer.WriteLine("new Vector();");
}
else
{
def.Value.Accept(this);
_writer.WriteLine(";");
}
return(0);
}
_writer.Write(statement.BaseType);
_writer.Write(" ");
var first = true;
foreach (var definition in statement.Definitions)
{
Declare(definition.Name, definition.Type);
if (!first)
{
_writer.Write(", ");
}
first = false;
_writer.Write(definition.Name);
var i = statement.BaseType.ArrayDimensions;
while (definition.Type.ArrayDimensions > i++)
{
_writer.Write("[]");
}
if (definition.Value != null)
{
_writer.Write(" = ");
definition.Value.Accept(this);
}
}
_writer.WriteLine(";");
return(0);
}
public virtual object Walk(VariableStatement node)
{
if (Enter(node))
{
foreach (var variableDeclaration in node.VariableDeclarations)
{
variableDeclaration.Accept(this);
}
}
Exit(node);
return null;
}
public override object Walk(VariableStatement node)
{
object result = null;
foreach (var variableDeclaration in node.VariableDeclarations)
{
result = variableDeclaration.Accept(this);
}
return result;
}
public virtual bool Enter(VariableStatement node)
{
return true;
}
public virtual void Exit(VariableStatement node)
{
}
public int Visit(VariableStatement statement)
{
throw new NotSupportedException(ExpressionsOnly);
}
public override void Exit(VariableStatement node)
{
level--;
}
public override bool Enter(VariableStatement node)
{
Print("VariableStatement");
level++;
return(true);
}
public override bool Enter(VariableStatement node)
{
Print("VariableStatement");
level++;
return true;
}
public CSharpSyntaxNode Convert(VariableStatement node)
{
return(SyntaxFactory
.LocalDeclarationStatement(node.DeclarationList.ToCsNode <VariableDeclarationSyntax>())
.AddModifiers(node.Modifiers.ToCsNodes <SyntaxToken>()));
}
public virtual void Exit(VariableStatement node)
{
}
public Statement Visit(VariableStatement statement)
{
var initializer = statement.Initializer?.Accept(this);
return(new VariableStatement(statement.Start, statement.End, statement.Name, statement.Type, initializer));
}
public override void VisitVariableStatement(VariableStatement variableDeclaration)
{
Visit(variableDeclaration.Declarations);
}
public virtual TStmt Visit(VariableStatement statement)
{
statement.Initializer.Accept(this);
return(default(TStmt));
}
public override void Exit(VariableStatement node)
{
level--;
}
public virtual void VisitVariableStatement(VariableStatement variableDeclaration)
{
}
