| /src/external/apache2/llvm/dist/clang/lib/Format/ |
| FormatTokenLexer.cpp | 62 assert(Tokens.empty());
65 Tokens.push_back(getNextToken());
74 // This needs to come after tokens have been merged so that C#
77 if (Tokens.back()->NewlinesBefore > 0 || Tokens.back()->IsMultiline)
78 FirstInLineIndex = Tokens.size() - 1;
79 } while (Tokens.back()->Tok.isNot(tok::eof));
80 return Tokens;
106 Tokens.back()->Tok.setKind(tok::pipepipe);
111 Tokens.back()->Tok.setKind(tok::period)
[all...] |
| UsingDeclarationsSorter.h | 30 FormatTokenLexer &Tokens) override;
|
| TokenAnnotator.h | 40 : First(Line.Tokens.front().Tok), Level(Line.Level),
48 assert(!Line.Tokens.empty());
50 // Calculate Next and Previous for all tokens. Note that we must overwrite
55 for (std::list<UnwrappedLineNode>::const_iterator I = ++Line.Tokens.begin(),
56 E = Line.Tokens.end();
84 /// \c true if this line starts with the given tokens in order, ignoring
86 template <typename... Ts> bool startsWith(Ts... Tokens) const {
87 return First && First->startsSequence(Tokens...);
90 /// \c true if this line ends with the given tokens in reversed order,
92 /// For example, given tokens [T1, T2, T3, ...], the function returns true i
[all...] |
| NamespaceEndCommentsFixer.h | 40 FormatTokenLexer &Tokens) override;
|
| MacroExpander.cpp | 51 DefinitionParser(ArrayRef<FormatToken *> Tokens) : Tokens(Tokens) {
52 assert(!Tokens.empty());
53 Current = Tokens[0];
110 if (Pos + 1 < Tokens.size())
112 Current = Tokens[Pos];
119 ArrayRef<FormatToken *> Tokens;
142 const auto Tokens = Lex.lex();
143 if (!Tokens.empty())
[all...] |
| UnwrappedLineParser.cpp | 11 /// which turns a stream of tokens into UnwrappedLines.
146 else if (!Parser.Line->Tokens.empty())
147 Parser.CurrentLines = &Parser.Line->Tokens.back().Children;
155 if (!Parser.Line->Tokens.empty()) {
158 assert(Parser.Line->Tokens.empty());
198 IndexedTokenSource(ArrayRef<FormatToken *> Tokens)
199 : Tokens(Tokens), Position(-1) {}
203 return Tokens[Position];
213 return Tokens[Position]
[all...] |
| UnwrappedLineParser.h | 11 /// which turns a stream of tokens into UnwrappedLines.
40 /// The \c Tokens comprising this \c UnwrappedLine.
41 std::list<UnwrappedLineNode> Tokens;
79 unsigned FirstStartColumn, ArrayRef<FormatToken *> Tokens,
159 // Decides which comment tokens should be added to the current line and which
162 // Comments specifies the sequence of comment tokens to analyze. They get
229 FormatTokenSource *Tokens;
233 // of the format tokens. The goal is to have the actual tokens created and
|
| FormatTokenLexer.h | 111 // Index (in 'Tokens') of the last token that starts a new line.
113 SmallVector<FormatToken *, 16> Tokens;
|
| TokenAnalyzer.h | 90 FormatTokenLexer &Tokens) = 0;
|
| BreakableToken.cpp | 221 "formatting regions are switched by comment tokens");
333 return Tokens[LineIndex] ? *Tokens[LineIndex] : Tok;
387 Tokens.resize(Lines.size());
660 assert(Tokens[LineIndex - 1] == Tokens[LineIndex] &&
775 Tokens.resize(Lines.size());
838 Tokens[i] = LineTok;
919 if (LineIndex > 0 && Tokens[LineIndex] != Tokens[LineIndex - 1])
[all...] |
| TokenAnalyzer.cpp | 74 SmallVector<FormatToken *, 10> Tokens(Toks.begin(), Toks.end());
76 Env.getFirstStartColumn(), Tokens, *this);
|
| FormatToken.h | 167 /// In this case, the tokens of the unexpanded macro call will have the
186 /// When formatting an expanded macro, all tokens that are part of macro
187 /// arguments will be MR_ExpandedArg, while all tokens that are not visible in
189 /// When formatting an unexpanded macro call, all tokens that are part of
193 /// The stack of macro call identifier tokens this token was expanded from.
342 /// line for multi-line tokens) in columns.
372 /// The length of following tokens until the next natural split point,
476 /// \c true if this token starts a sequence with the given tokens in order,
479 bool startsSequence(A K1, Ts... Tokens) const {
480 return startsSequenceInternal(K1, Tokens...)
[all...] |
| /src/external/apache2/llvm/lib/libclangToolingSyntax/ |
| Makefile | 14 Tokens.cpp \
|
| /src/external/apache2/llvm/dist/clang/lib/Tooling/Syntax/ |
| ComputeReplacements.cpp | 10 #include "clang/Tooling/Syntax/Tokens.h"
18 /// Enumerates spans of tokens from the tree consecutively laid out in memory.
70 // Check that \p Expanded actually points into expanded tokens.
75 // (!) empty tokens must always point before end().
80 assert(Spelled && "could not find spelled tokens for expanded");
104 &TU, [&](llvm::ArrayRef<syntax::Token> Tokens, bool IsOriginal) {
107 syntax::Token::range(SM, Tokens.front(), Tokens.back()).text(SM);
110 assert(NextOriginal <= Tokens.begin());
111 // We are looking at a span of original tokens
[all...] |
| Tokens.cpp | 1 //===- Tokens.cpp - collect tokens from preprocessing ---------------------===//
8 #include "clang/Tooling/Syntax/Tokens.h"
58 // Finds the smallest expansion range that contains expanded tokens First and
70 // Keep traversing up the spelling chain as longs as tokens are part of the
85 // Update the result afterwards, as we want the tokens that triggered the
90 // we've already found some tokens expanded from the same macro argument, and
91 // they should map to a consecutive subset of spelled tokens. Unfortunately
94 // referring to same tokens, SourceManager might tell us that one is before
132 assert(F.file() == L.file() && "tokens from different files")
[all...] |
| BuildTree.cpp | 30 #include "clang/Tooling/Syntax/Tokens.h"
356 /// Initially all tokens are added as pending nodes. When processing a clang AST
379 /// Populate children for \p New node, assuming it covers tokens from \p
401 /// Populate children for \p New list, assuming it covers tokens from a
438 auto Tokens = Arena.getTokenBuffer().expandedTokens();
439 assert(!Tokens.empty());
440 assert(Tokens.back().kind() == tok::eof);
443 Pending.foldChildren(Arena, Tokens.drop_back(),
454 /// Finds the syntax tokens corresponding to the \p SourceRange.
460 /// Finds the syntax tokens corresponding to the passed source locations
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/Support/ |
| GlobPattern.h | 48 std::vector<BitVector> Tokens;
|
| /src/external/apache2/llvm/dist/clang/lib/Lex/ |
| TokenLexer.cpp | 53 Tokens = &*Macro->tokens_begin();
64 assert(Tokens[0].getLocation().isValid());
65 assert((Tokens[0].getLocation().isFileID() || Tokens[0].is(tok::comment)) &&
70 // definition. Tokens that get lexed directly from the definition will
73 MacroDefStart = SM.getExpansionLoc(Tokens[0].getLocation());
82 // Tokens to point to the expanded tokens.
104 Tokens = TokArray;
126 // the expanded tokens
[all...] |
| DependencyDirectivesSourceMinimizer.cpp | 34 /// The known tokens encountered during the minimization.
35 SmallVectorImpl<Token> &Tokens;
37 Minimizer(SmallVectorImpl<char> &Out, SmallVectorImpl<Token> &Tokens,
40 : Out(Out), Tokens(Tokens), Input(Input), Diags(Diags),
70 Tokens.emplace_back(K, Out.size());
71 return Tokens.back();
74 Out.resize(Tokens.back().Offset);
75 Tokens.pop_back();
77 TokenKind top() const { return Tokens.empty() ? pp_none : Tokens.back().K;
[all...] |
| /src/external/apache2/llvm/dist/clang/include/clang/Lex/ |
| DependencyDirectivesSourceMinimizer.h | 104 &Tokens,
|
| TokenLexer.h | 27 /// TokenLexer - This implements a lexer that returns tokens from a macro body
43 /// This is the pointer to an array of tokens that the macro is
45 /// a token stream, these are the tokens we are returning. This points into
51 const Token *Tokens;
53 /// This is the length of the Tokens array.
89 /// This is true if this TokenLexer allocated the Tokens
95 /// This is true when tokens lexed from the TokenLexer
99 /// When true, the produced tokens have Token::IsReinjected flag set.
115 /// specified, this takes ownership of the tokens and delete[]'s them when
137 /// DisableExpansion is true when macro expansion of tokens lexed from thi
[all...] |
| /src/external/apache2/llvm/dist/clang/include/clang/Tooling/Syntax/ |
| Tokens.h | 1 //===- Tokens.h - collect tokens from preprocessing --------------*- C++-*-===//
8 // Record tokens that a preprocessor emits and define operations to map between
9 // the tokens written in a file and tokens produced by the preprocessor.
12 // - "spelled" tokens directly correspond to a substring written in some
14 // - "expanded" tokens represent the result of preprocessing, parses consumes
17 // Expanded tokens correspond directly to locations found in the AST, allowing
19 // tokens correspond directly to the source code written by the user.
22 // between expanded and spelled tokens that produced them (macro calls
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Support/ |
| GlobPattern.cpp | 138 Pat.Tokens.push_back(*BV);
150 return matchOne(Tokens, S);
|
| /src/external/gpl2/gettext/dist/gettext-tools/src/ |
| x-lisp.c | 65 - The syntax code assigned to each character, and how tokens are built
81 parts of symbol tokens. In Common Lisp: (readtable-case *readtable*). */
231 /* ========= Reading of tokens. See CLHS 2.2 "Reader Algorithm". ========= */
290 CLHS 2.3 "Interpretation of Tokens" for the possible interpretations,
486 See CLHS 2.3.1.1 "Potential Numbers as Tokens".
592 See CLHS 2.3.1 "Numbers as Tokens".
982 /* Tokens consisting entirely of dots are illegal, but be tolerant
998 /* We interpret all other tokens as symbols (including 'reserved
999 tokens', i.e. potential numbers which are not numbers). */
1405 /* Eat tokens until eof is seen. When read_object return
[all...] |
| /src/external/apache2/llvm/dist/clang/lib/Tooling/DependencyScanning/ |
| DependencyScanningFilesystem.cpp | 38 SmallVector<minimize_source_to_dependency_directives::Token, 64> Tokens;
40 Buffer->getBuffer(), MinimizedFileContents, Tokens)) {
77 minimize_source_to_dependency_directives::computeSkippedRanges(Tokens,
|
