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