public void Visit(PyAst.ImportStatement node) { if (node.AsNames.Count > 1 || node.Names.Count > 1) { throw CreateNotImplementedEx(); } var modName = FormatDottedName(node.Names.Single()); AppendLineWithIndentation($"import {modName} as {node.AsNames.Single()}"); }
public void PostWalk(ImportStatement node) { PostProcess(node); }
// ImportStmt public override bool Walk(ImportStatement node) { for (int i = 0; i < node.Names.Count; i++) { Define(node.AsNames[i] != null ? node.AsNames[i] : node.Names[i].Names[0]); } return true; }
private CodeGen CompileModuleInit(CompilerContext context, GlobalSuite gs, TypeGen tg, string moduleName) { CodeGen init; if (!AutoImportAll) { init = OutputGenerator.GenerateModuleInitialize(context, gs, tg); } else { // auto-import all compiled modules, useful for CodeDom scenarios. init = OutputGenerator.GenerateModuleInitialize(context, gs, tg, staticTypes, delegate(CodeGen cg) { Location dummyLocation = new Location(1, 1); for (int i = 0; i < sourceFiles.Count; i++) { string otherModName = GetModuleFromFilename(sourceFiles[i]); if (otherModName == moduleName) continue; FromImportStatement stmt = new FromImportStatement( new DottedName(new SymbolId[] { SymbolTable.StringToId(otherModName) }), FromImportStatement.Star, null); stmt.Start = dummyLocation; stmt.End = dummyLocation; stmt.Emit(cg); } // Import the first part of all namespaces in all referenced assemblies // First, determine the set of unique such prefixes Dictionary<string, object> nsPrefixes = new Dictionary<string, object>(); foreach (string name in ReferencedAssemblies) { Assembly a = LoadAssembly(name); foreach (Type t in a.GetTypes()) { // We only care about public types if (!t.IsPublic) continue; // Ignore types that don't have a namespace if (t.Namespace == null) continue; string nsPrefix = t.Namespace.Split('.')[0]; nsPrefixes[nsPrefix] = null; } } // Import all the uniquer prefixes we found foreach (string nsPrefix in nsPrefixes.Keys) { SymbolId symbolId = SymbolTable.StringToId(nsPrefix); cg.Names.CreateGlobalSlot(symbolId); DottedName dottedName = new DottedName(new SymbolId[] { symbolId }); ImportStatement importStmt = new ImportStatement( new DottedName[] { dottedName }, new SymbolId[] { SymbolTable.Empty }); importStmt.Start = dummyLocation; importStmt.End = dummyLocation; importStmt.Emit(cg); } }); } return init; }
public override void PostWalk(ImportStatement node) { CommonPostWalk(node); }
internal Import(ImportStatement stmt) : this() { _names = ConvertAliases(stmt.Names, stmt.AsNames); }
public override bool Walk(ImportStatement node) { var container = containers.Peek (); if (!container.SupportsImportStatements) return base.Walk (node); // import mod1, mod2, mod3,... for (int i = 0; i < node.Names.Count; i++) { var fullName = node.Names [i].MakeString (); var asname = node.AsNames [i]; var import = new PythonImport () { ModuleName = fullName, AsName = asname, Region = GetDomRegion (node) }; container.Imports.Add (import); } return base.Walk (node); }
// import_stmt: 'import' module ['as' name"] (',' module ['as' name])* // name: identifier private ImportStatement ParseImportStmt() { Eat(TokenKind.KeywordImport); SourceLocation start = GetStart(); List<ModuleName> l = new List<ModuleName>(); List<SymbolId> las = new List<SymbolId>(); l.Add(ParseModuleName()); las.Add(MaybeParseAsName()); while (MaybeEat(TokenKind.Comma)) { l.Add(ParseModuleName()); las.Add(MaybeParseAsName()); } ModuleName[] names = l.ToArray(); SymbolId[] asNames = las.ToArray(); ImportStatement ret = new ImportStatement(names, asNames, AbsoluteImports); ret.SetLoc(start, GetEnd()); return ret; }
public override bool Walk(ImportStatement node) { Emit(node); return false; }
public static string Format(ImportStatement node) { return("import " + string.Join(",", node.Names.Select(n => string.Join(".", n.Names)).ToArray()) + " as " + string.Join(", ", node.AsNames)); }
public virtual void PostWalk(ImportStatement node) { }
// ImportStatement public virtual bool Walk(ImportStatement node) { return true; }
//import_stmt: 'import' dotted_as_name (',' dotted_as_name)* private ImportStatement ParseImportStmt() { Eat(TokenKind.KeywordImport); Location start = GetStart(); List<DottedName> l = new List<DottedName>(); List<SymbolId> las = new List<SymbolId>(); l.Add(ParseDottedName()); las.Add(MaybeParseAsName()); while (MaybeEat(TokenKind.Comma)) { l.Add(ParseDottedName()); las.Add(MaybeParseAsName()); } DottedName[] names = l.ToArray(); SymbolId[] asNames = las.ToArray(); ImportStatement ret = new ImportStatement(names, asNames); ret.SetLoc(GetExternal(), start, GetEnd()); return ret; }
// ImportStatement public bool Walk(ImportStatement node) { return Process(node); }
// ImportStatement public override bool Walk(ImportStatement node) { PythonVariable[] variables = new PythonVariable[node.Names.Count]; for (int i = 0; i < node.Names.Count; i++) { SymbolId name = node.AsNames[i] != SymbolId.Empty ? node.AsNames[i] : node.Names[i].Names[0]; variables[i] = DefineName(name); } node.Variables = variables; return true; }
// ImportStatement public override bool Walk(ImportStatement node) { for (int i = 0; i < node.Names.Count; i++) { SymbolId name = node.AsNames[i] != SymbolTable.Empty ? node.AsNames[i] : node.Names[i].Names[0]; Define(name, new ImportDefinition(node.Names[i], node)); } return true; }
public ImportDefinition(DottedName name, ImportStatement import) { this.name = name; this.importStatement = import; }
public override bool Walk(ImportStatement node) { CommonWalk(node); return true; }
public PythonImport(IProjectContent projectContent, ImportStatement importStatement) : base(projectContent) { this.importStatement = importStatement; AddUsings(); }
// ImportStatement public override bool Walk(ImportStatement node) { node.Parent = _currentScope; PythonVariable[] variables = new PythonVariable[node.Names.Count]; for (int i = 0; i < node.Names.Count; i++) { string name = node.AsNames[i] != null ? node.AsNames[i] : node.Names[i].Names[0]; variables[i] = DefineName(name); node.Names[i].Parent = _currentScope; } node.Variables = variables; return true; }
/// <summary> /// Walks an import statement and adds it to the compilation unit's /// Usings. /// </summary> public override bool Walk(ImportStatement node) { PythonImport import = new PythonImport(compilationUnit.ProjectContent, node); compilationUnit.UsingScope.Usings.Add(import); return false; }
// import_stmt: 'import' module ['as' name"] (',' module ['as' name])* // name: identifier private ImportStatement ParseImportStmt() { Eat(TokenKind.KeywordImport); var start = GetStart(); List<ModuleName> l = new List<ModuleName>(); List<string> las = new List<string>(); l.Add(ParseModuleName()); las.Add(MaybeParseAsName()); while (MaybeEat(TokenKind.Comma)) { l.Add(ParseModuleName()); las.Add(MaybeParseAsName()); } ModuleName[] names = l.ToArray(); var asNames = las.ToArray(); ImportStatement ret = new ImportStatement(names, asNames, AbsoluteImports); ret.SetLoc(_globalParent, start, GetEnd()); return ret; }
public override bool Walk(ImportStatement node) { writer.WriteLine("Import: " + GetImports(node.Names)); return base.Walk(node); }