public FromImportStatement(ModuleName root, NameExpression/*!*/[] names, NameExpression[] asNames, bool fromFuture, bool forceAbsolute) { _root = root; _names = names; _asNames = asNames; _fromFuture = fromFuture; _forceAbsolute = forceAbsolute; }
// relative_module: "."* module | "."+ private ModuleName ParseRelativeModuleName() { var start = GetStart(); int dotCount = 0; List<string> dotWhiteSpace = MakeWhiteSpaceList(); for (; ; ) { if (MaybeEat(TokenKind.Dot)) { if (dotWhiteSpace != null) { dotWhiteSpace.Add(_tokenWhiteSpace); } dotCount++; } else if (MaybeEat(TokenKind.Ellipsis)) { if (dotWhiteSpace != null) { dotWhiteSpace.Add(_tokenWhiteSpace); dotWhiteSpace.Add(""); dotWhiteSpace.Add(""); } dotCount += 3; } else { break; } } List<string> nameWhiteSpace = null; NameExpression[] names = EmptyNames; if (PeekToken() is NameToken) { names = ReadDottedName(out nameWhiteSpace); } ModuleName ret; if (dotCount > 0) { ret = new RelativeModuleName(names, dotCount); if (_verbatim) { if (nameWhiteSpace != null) { AddNamesWhiteSpace(ret, nameWhiteSpace.ToArray()); } AddListWhiteSpace(ret, dotWhiteSpace.ToArray()); } } else { if (names.Length == 0) { ReportSyntaxError(_lookahead.Span.Start, _lookahead.Span.End, "missing module name"); } ret = new ModuleName(names); if (nameWhiteSpace != null) { AddNamesWhiteSpace(ret, nameWhiteSpace.ToArray()); } } ret.SetLoc(start, GetEnd()); return ret; }
// module: (identifier '.')* identifier private ModuleName ParseModuleName() { var start = GetStart(); List<string> dotWhiteSpace; ModuleName ret = new ModuleName(ReadDottedName(out dotWhiteSpace)); if (_verbatim) { AddNamesWhiteSpace(ret, dotWhiteSpace.ToArray()); } ret.SetLoc(start, GetEnd()); return ret; }
// ModuleName public override bool Walk(ModuleName node) { return ShouldWalkWorker(node); }
public override void PostWalk(ModuleName node) { PostWalkWorker(node); }
/// <summary> /// Removes the import at the specified index (which must be in the range of /// the Names property) and returns a new ImportStatement which is the same /// as this one minus the imported name. Preserves all round-tripping metadata /// in the process. /// /// New in 1.1. /// </summary> public ImportStatement RemoveImport(JAst ast, int index) { if (index < 0 || index >= _names.Length) { throw new ArgumentOutOfRangeException("index"); } if (ast == null) { throw new ArgumentNullException("ast"); } ModuleName[] names = new ModuleName[_names.Length - 1]; NameExpression[] asNames = _asNames == null ? null : new NameExpression[_asNames.Length - 1]; var asNameWhiteSpace = this.GetNamesWhiteSpace(ast); var itemWhiteSpace = this.GetListWhiteSpace(ast); List<string> newAsNameWhiteSpace = new List<string>(); List<string> newListWhiteSpace = new List<string>(); int asIndex = 0; for (int i = 0, write = 0; i < _names.Length; i++) { bool includingCurrentName = i != index; // track the white space, this needs to be kept in sync w/ ToCodeString and how the // parser creates the white space. if (i > 0 && itemWhiteSpace != null) { if (includingCurrentName) { newListWhiteSpace.Add(itemWhiteSpace[i - 1]); } } if (includingCurrentName) { names[write] = _names[i]; if (_asNames != null) { asNames[write] = _asNames[i]; } write++; } if (AsNames[i] != null && includingCurrentName) { if (asNameWhiteSpace != null) { newAsNameWhiteSpace.Add(asNameWhiteSpace[asIndex++]); } if (_asNames[i].Name.Length != 0) { if (asNameWhiteSpace != null) { newAsNameWhiteSpace.Add(asNameWhiteSpace[asIndex++]); } } } } var res = new ImportStatement(names, asNames, _forceAbsolute); ast.CopyAttributes(this, res); ast.SetAttribute(res, NodeAttributes.NamesWhiteSpace, newAsNameWhiteSpace.ToArray()); ast.SetAttribute(res, NodeAttributes.ListWhiteSpace, newListWhiteSpace.ToArray()); return res; }
public ImportStatement(ModuleName[] names, NameExpression[] asNames, bool forceAbsolute) { _names = names; _asNames = asNames; _forceAbsolute = forceAbsolute; }