internal override IEnumerable <NameExpression> Walk() { List <NameExpression> freeVariables = new List <NameExpression>(); foreach (Statement statement in Statements) { freeVariables.AddRange(statement.Walk()); } // The Walk() call will have populated all variables in LetStatements // For function definitions, we need a special handling for overloads DeclaredVariables = Statements .Where(statement => statement is Definition && !(statement is FunctionDefinition)) .Select(statement => (statement as Definition).DeclaredVariable) .ToList(); List <FunctionDefinition> functions = Statements .Where(statement => statement is FunctionDefinition) .Select(statement => statement as FunctionDefinition) .ToList(); Overloads = Compiler.GenerateOverloads(functions); DeclaredVariables.AddRange(Overloads.Select(o => o.variable)); Compiler.MatchVariables(freeVariables, DeclaredVariables); return(freeVariables); }
/// <summary> /// Rename all our guys in our internal statements. /// </summary> /// <param name="originalName"></param> /// <param name="newName"></param> public void RenameBlockVariables(string originalName, string newName) { #if false // And remove any declarations. When we rename, we are doing it because this block // is being made to look like an already existing other block - so the variable will // have been declared over there already. var decl = DeclaredVariables.Where(d => d.RawValue == originalName).FirstOrDefault(); if (decl != null) { Remove(decl); } #else // Rename the declared variables as requested. While these variables may be used again, // they need to appear here or if the combine fails, they will not be declared (and they // will be used). foreach (var v in DeclaredVariables.Where(d => d.RawValue == originalName)) { v.RenameRawValue(originalName, newName); } // Did that cause any duplicates? If so, remove them. if (DeclaredVariables.Where(d => d.RawValue == newName).Count() > 1) { _variables.Remove(_variables.Where(d => d.RawValue == newName).First()); } #endif foreach (var s in _statements) { s.RenameVariable(originalName, newName); } }
public void Clear() { _schema = null; Path.Clear(); Fragments.Clear(); UsedVariables.Clear(); UnusedVariables.Clear(); DeclaredVariables.Clear(); Errors.Clear(); }
public Function ToFunction() { return (new Function( _name, _lineNo, _parameterNames.ToList(), _directives, DeclaredVariables.ToList(), NestedFunctions.ToList(), FunctionBody, _isDeclaration)); }
protected override DeclaredVariables GetDeclaredVariables( string source, bool visibleScopesOnly, DeclarationContext declarationContext) { DeclaredVariables variables = new DeclaredVariables( source, fullNamespaceList, visibleScopesOnly, declarationContext); List <Variable> controls = GetServerControls(); variables.Items.AddRange(controls); return(variables); }
public void Free() { foreach (var scope in NestedScopes) { scope.Free(); } NestedScopes.Free(); foreach (var closure in Closures) { closure.Free(); } Closures.Free(); DeclaredVariables.Free(); }
public void Clear() { _schema = null; Path.Clear(); Variables.Clear(); Fragments.Clear(); UsedVariables.Clear(); UnusedVariables.Clear(); DeclaredVariables.Clear(); Names.Clear(); Types.Clear(); Directives.Clear(); OutputFields.Clear(); InputFields.Clear(); Errors.Clear(); IsInError = false; }
public void BlockEnd() { DeclaredVariables.Remove(Deepness); Deepness--; }
public void BlockStart() { Deepness++; DeclaredVariables.Add(Deepness, new Dictionary <string, Variable>()); }
public void Visit(Declaration instruction) { DeclaredVariables.Add(instruction.Name); }