@cparra/apex-reflection 0.1.0-alpha.0 → 0.1.1-alpha.10

package/antlr4-4.9.2/lib/src/lexer.dart

@@ -1,343 +0,0 @@
-/*
- * Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
- * Use of this file is governed by the BSD 3-clause license that
- * can be found in the LICENSE.txt file in the project root.
- */
-
-import 'dart:developer';
-
-import 'atn/atn.dart';
-import 'error/error.dart';
-import 'input_stream.dart';
-import 'interval_set.dart';
-import 'misc/pair.dart';
-import 'recognizer.dart';
-import 'token.dart';
-import 'token_factory.dart';
-import 'token_source.dart';
-import 'util/utils.dart';
-
-abstract class Lexer extends Recognizer<LexerATNSimulator>
-    implements TokenSource {
-  static final DEFAULT_MODE = 0;
-  static final MORE = -2;
-  static final SKIP = -3;
-
-  static final DEFAULT_TOKEN_CHANNEL = Token.DEFAULT_CHANNEL;
-  static final HIDDEN = Token.HIDDEN_CHANNEL;
-  static final MIN_CHAR_VALUE = 0x0000;
-  static final MAX_CHAR_VALUE = 0x10FFFF;
-
-  CharStream _input;
-
-  Pair<TokenSource, CharStream> _tokenFactorySourcePair;
-  @override
-  TokenFactory tokenFactory = CommonTokenFactory.DEFAULT;
-
-  /// The goal of all lexer rules/methods is to create a token object.
-  /// this is an instance variable as multiple rules may collaborate to
-  /// create a single token. nextToken will return this object after
-  /// matching lexer rule(s). If you subclass to allow multiple token
-  /// emissions, then set this to the last token to be matched or
-  /// something nonnull so that the auto token emit mechanism will not
-  /// emit another token.
-  Token _token;
-
-  /// What character index in the stream did the current token start at?
-  /// Needed, for example, to get the text for current token. Set at
-  /// the start of nextToken.
-  int tokenStartCharIndex = -1;
-
-  /// The line on which the first character of the token resides
-  int tokenStartLine = -1;
-
-  /// The character position of first character within the line
-  int tokenStartCharPositionInLine = -1;
-
-  /// Once we see EOF on char stream, next token will be EOF.
-  /// If you have DONE : EOF ; then you see DONE EOF.
-  bool _hitEOF = false;
-
-  /// The channel number for the current token
-  int channel = Token.DEFAULT_CHANNEL;
-
-  /// The token type for the current token
-  int type = Token.INVALID_TYPE;
-
-  final List<int> _modeStack = [];
-  int mode_ = Lexer.DEFAULT_MODE;
-
-  /// You can set the text for the current token to override what is in
-  /// the input char buffer. Use setText() or can set this instance var.
-  String _text;
-
-  Lexer(CharStream input) {
-    _input = input;
-    _tokenFactorySourcePair = Pair(this, input);
-  }
-
-  void reset() {
-    // wack Lexer state variables
-    if (_input != null) {
-      _input.seek(0); // rewind the input
-    }
-    _token = null;
-    type = Token.INVALID_TYPE;
-    channel = Token.DEFAULT_CHANNEL;
-    tokenStartCharIndex = -1;
-    tokenStartCharPositionInLine = -1;
-    tokenStartLine = -1;
-    _text = null;
-
-    _hitEOF = false;
-    mode_ = Lexer.DEFAULT_MODE;
-    _modeStack.clear();
-
-    interpreter.reset();
-  }
-
-  /// Return a token from this source; i.e., match a token on the char stream.
-  @override
-  Token nextToken() {
-    if (_input == null) {
-      throw StateError('nextToken requires a non-null input stream.');
-    }
-
-    // Mark start location in char stream so unbuffered streams are
-    // guaranteed at least have text of current token
-    final tokenStartMarker = _input.mark();
-    try {
-      outer:
-      while (true) {
-        if (_hitEOF) {
-          emitEOF();
-          return _token;
-        }
-
-        _token = null;
-        channel = Token.DEFAULT_CHANNEL;
-        tokenStartCharIndex = _input.index;
-        tokenStartCharPositionInLine = interpreter.charPositionInLine;
-        tokenStartLine = interpreter.line;
-        _text = null;
-        do {
-          type = Token.INVALID_TYPE;
-//				System.out.println("nextToken line "+tokenStartLine+" at "+((char)input.LA(1))+
-//								   " in mode "+mode+
-//								   " at index "+input.index());
-          int ttype;
-          try {
-            ttype = interpreter.match(_input, mode_);
-          } on LexerNoViableAltException catch (e) {
-            notifyListeners(e); // report error
-            recover(e);
-            ttype = SKIP;
-          }
-          if (_input.LA(1) == IntStream.EOF) {
-            _hitEOF = true;
-          }
-          if (type == Token.INVALID_TYPE) type = ttype;
-          if (type == SKIP) {
-            continue outer;
-          }
-        } while (type == MORE);
-        if (_token == null) emit();
-        return _token;
-      }
-    } finally {
-      // make sure we release marker after match or
-      // unbuffered char stream will keep buffering
-      _input.release(tokenStartMarker);
-    }
-  }
-
-  /// Instruct the lexer to skip creating a token for current lexer rule
-  /// and look for another token. nextToken() knows to keep looking when
-  /// a lexer rule finishes with token set to SKIP_TOKEN. Recall that
-  /// if token==null at end of any token rule, it creates one for you
-  /// and emits it.
-  void skip() {
-    type = Lexer.SKIP;
-  }
-
-  void more() {
-    type = Lexer.MORE;
-  }
-
-  void mode(int m) {
-    mode_ = m;
-  }
-
-  void pushMode(int m) {
-    if (LexerATNSimulator.debug) {
-      log('pushMode $m');
-    }
-    _modeStack.add(mode_);
-    mode(m);
-  }
-
-  int popMode() {
-    if (_modeStack.isEmpty) throw StateError('');
-    if (LexerATNSimulator.debug) log('popMode back to ${_modeStack.last}');
-    mode(_modeStack.removeLast());
-    return mode_;
-  }
-
-  /// Set the char stream and reset the lexer
-  @override
-  set inputStream(IntStream input) {
-    _input = null;
-    _tokenFactorySourcePair =
-        Pair<TokenSource, CharStream>(this, _input);
-    reset();
-    _input = input;
-    _tokenFactorySourcePair =
-        Pair<TokenSource, CharStream>(this, _input);
-  }
-
-  @override
-  String get sourceName {
-    return _input.sourceName;
-  }
-
-  @override
-  CharStream get inputStream {
-    return _input;
-  }
-
-  /// By default does not support multiple emits per nextToken invocation
-  ///  for efficiency reasons.  Subclass and override this method, nextToken,
-  ///  and getToken (to push tokens into a list and pull from that list
-  ///  rather than a single variable as this implementation does).
-  void emitToken(Token token) {
-    //System.err.println("emit "+token);
-    _token = token;
-  }
-
-  /// The standard method called to automatically emit a token at the
-  ///  outermost lexical rule.  The token object should point into the
-  ///  char buffer start..stop.  If there is a text override in 'text',
-  ///  use that to set the token's text.  Override this method to emit
-  ///  custom Token objects or provide a new factory.
-  Token emit() {
-    final t = tokenFactory.create(
-        type,
-        _text,
-        _tokenFactorySourcePair,
-        channel,
-        tokenStartCharIndex,
-        charIndex - 1,
-        tokenStartLine,
-        tokenStartCharPositionInLine);
-    emitToken(t);
-    return t;
-  }
-
-  Token emitEOF() {
-    final cpos = charPositionInLine;
-    final eof = tokenFactory.create(Token.EOF, null, _tokenFactorySourcePair,
-        Token.DEFAULT_CHANNEL, _input.index, _input.index - 1, line, cpos);
-    emitToken(eof);
-    return eof;
-  }
-
-  @override
-  int get charPositionInLine {
-    return interpreter.charPositionInLine;
-  }
-
-  @override
-  int get line {
-    return interpreter.line;
-  }
-
-  set line(int line) {
-    interpreter.line = line;
-  }
-
-  set charPositionInLine(int charPositionInLine) {
-    interpreter.charPositionInLine = charPositionInLine;
-  }
-
-  /// What is the index of the current character of lookahead?
-  int get charIndex {
-    return _input.index;
-  }
-
-  /// Return the text matched so far for the current token or any
-  ///  text override.
-  String get text {
-    if (_text != null) {
-      return _text;
-    }
-    return interpreter.getText(_input);
-  }
-
-  /// Set the complete text of this token; it wipes any previous
-  ///  changes to the text.
-  set text(String text) {
-    _text = text;
-  }
-
-  /// Override if emitting multiple tokens.
-  Token get token {
-    return _token;
-  }
-
-  void setToken(Token _token) {
-    this._token = _token;
-  }
-
-  List<String> get channelNames => null;
-
-  List<String> get modeNames => null;
-
-  /// Return a list of all Token objects in input char stream.
-  ///  Forces load of all tokens. Does not include EOF token.
-  List<Token> get allTokens {
-    final tokens = <Token>[];
-    var t = nextToken();
-    while (t.type != Token.EOF) {
-      tokens.add(t);
-      t = nextToken();
-    }
-    return tokens;
-  }
-
-  void notifyListeners(LexerNoViableAltException e) {
-    final text =
-        _input.getText(Interval.of(tokenStartCharIndex, _input.index));
-    final msg = "token recognition error at: '" + getErrorDisplay(text) + "'";
-
-    final listener = errorListenerDispatch;
-    listener.syntaxError(
-        this, null, tokenStartLine, tokenStartCharPositionInLine, msg, e);
-  }
-
-  String getErrorDisplay(String s) {
-    return escapeWhitespace(s);
-  }
-
-  String getCharErrorDisplay(int c) {
-    final s = getErrorDisplay(String.fromCharCode(c));
-    return "'$s'";
-  }
-
-  /// Lexers can normally match any char in it's vocabulary after matching
-  ///  a token, so do the easy thing and just kill a character and hope
-  ///  it all works out.  You can instead use the rule invocation stack
-  ///  to do sophisticated error recovery if you are in a fragment rule.
-  void recover(RecognitionException re) {
-    if (re is LexerNoViableAltException) {
-      if (_input.LA(1) != IntStream.EOF) {
-        // skip a char and try again
-        interpreter.consume(_input);
-      }
-    } else {
-      //System.out.println("consuming char "+(char)input.LA(1)+" during recovery");
-      //re.printStackTrace();
-      // TODO: Do we lose character or line position information?
-      _input.consume();
-    }
-  }
-}

package/antlr4-4.9.2/lib/src/ll1_analyzer.dart

@@ -1,204 +0,0 @@
-/*
- * Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
- * Use of this file is governed by the BSD 3-clause license that
- * can be found in the LICENSE.txt file in the project root.
- */
-
-import './util/bit_set.dart';
-import 'atn/atn.dart';
-import 'interval_set.dart';
-import 'prediction_context.dart';
-import 'rule_context.dart';
-import 'token.dart';
-import 'util/bit_set.dart';
-
-class LL1Analyzer {
-  /// Special value added to the lookahead sets to indicate that we hit
-  ///  a predicate during analysis if {@code seeThruPreds==false}.
-  static final int HIT_PRED = Token.INVALID_TYPE;
-
-  final ATN atn;
-
-  LL1Analyzer(this.atn);
-
-  /// Calculates the SLL(1) expected lookahead set for each outgoing transition
-  /// of an [ATNState]. The returned array has one element for each
-  /// outgoing transition in [s]. If the closure from transition
-  /// <em>i</em> leads to a semantic predicate before matching a symbol, the
-  /// element at index <em>i</em> of the result will be null.
-  ///
-  /// @param s the ATN state
-  /// @return the expected symbols for each outgoing transition of [s].
-  List<IntervalSet> getDecisionLookahead(ATNState s) {
-//		System.out.println("LOOK("+s.stateNumber+")");
-    if (s == null) {
-      return null;
-    }
-
-    final look = List<IntervalSet>(s.numberOfTransitions);
-    for (var alt = 0; alt < s.numberOfTransitions; alt++) {
-      look[alt] = IntervalSet();
-      final lookBusy = <ATNConfig>{};
-      final seeThruPreds = false; // fail to get lookahead upon pred
-      _LOOK(s.transition(alt).target, null, PredictionContext.EMPTY, look[alt],
-          lookBusy, BitSet(), seeThruPreds, false);
-      // Wipe out lookahead for this alternative if we found nothing
-      // or we had a predicate when we !seeThruPreds
-      if (look[alt].length == 0 || look[alt].contains(HIT_PRED)) {
-        look[alt] = null;
-      }
-    }
-    return look;
-  }
-
-  /// Compute set of tokens that can follow [s] in the ATN in the
-  /// specified [ctx].
-  ///
-  /// <p>If [ctx] is null and the end of the rule containing
-  /// [s] is reached, {@link Token#EPSILON} is added to the result set.
-  /// If [ctx] is not null and the end of the outermost rule is
-  /// reached, {@link Token#EOF} is added to the result set.</p>
-  ///
-  /// @param s the ATN state
-  /// @param stopState the ATN state to stop at. This can be a
-  /// [BlockEndState] to detect epsilon paths through a closure.
-  /// @param ctx the complete parser context, or null if the context
-  /// should be ignored
-  ///
-  /// @return The set of tokens that can follow [s] in the ATN in the
-  /// specified [ctx].
-
-  IntervalSet LOOK(ATNState s, RuleContext ctx, [ATNState stopState]) {
-    final r = IntervalSet();
-    final seeThruPreds = true; // ignore preds; get all lookahead
-    final lookContext =
-        ctx != null ? PredictionContext.fromRuleContext(s.atn, ctx) : null;
-    _LOOK(
-        s, stopState, lookContext, r, <ATNConfig>{}, BitSet(), seeThruPreds, true);
-    return r;
-  }
-
-  /// Compute set of tokens that can follow [s] in the ATN in the
-  /// specified [ctx].
-  ///
-  /// <p>If [ctx] is null and [stopState] or the end of the
-  /// rule containing [s] is reached, {@link Token#EPSILON} is added to
-  /// the result set. If [ctx] is not null and [addEOF] is
-  /// [true] and [stopState] or the end of the outermost rule is
-  /// reached, {@link Token#EOF} is added to the result set.</p>
-  ///
-  /// @param s the ATN state.
-  /// @param stopState the ATN state to stop at. This can be a
-  /// [BlockEndState] to detect epsilon paths through a closure.
-  /// @param ctx The outer context, or null if the outer context should
-  /// not be used.
-  /// @param look The result lookahead set.
-  /// @param lookBusy A set used for preventing epsilon closures in the ATN
-  /// from causing a stack overflow. Outside code should pass
-  /// {@code new HashSet<ATNConfig>} for this argument.
-  /// @param calledRuleStack A set used for preventing left recursion in the
-  /// ATN from causing a stack overflow. Outside code should pass
-  /// {@code new BitSet()} for this argument.
-  /// @param seeThruPreds [true] to true semantic predicates as
-  /// implicitly [true] and "see through them", otherwise [false]
-  /// to treat semantic predicates as opaque and add {@link #HIT_PRED} to the
-  /// result if one is encountered.
-  /// @param addEOF Add {@link Token#EOF} to the result if the end of the
-  /// outermost context is reached. This parameter has no effect if [ctx]
-  /// is null.
-  void _LOOK(
-      ATNState s,
-      ATNState stopState,
-      PredictionContext ctx,
-      IntervalSet look,
-      Set<ATNConfig> lookBusy,
-      BitSet calledRuleStack,
-      bool seeThruPreds,
-      bool addEOF) {
-//		System.out.println("_LOOK("+s.stateNumber+", ctx="+ctx);
-    final c = ATNConfig(s, 0, ctx);
-    if (!lookBusy.add(c)) return;
-
-    if (s == stopState) {
-      if (ctx == null) {
-        look.addOne(Token.EPSILON);
-        return;
-      } else if (ctx.isEmpty && addEOF) {
-        look.addOne(Token.EOF);
-        return;
-      }
-    }
-
-    if (s is RuleStopState) {
-      if (ctx == null) {
-        look.addOne(Token.EPSILON);
-        return;
-      } else if (ctx.isEmpty && addEOF) {
-        look.addOne(Token.EOF);
-        return;
-      }
-
-      if (ctx != PredictionContext.EMPTY) {
-        // run thru all possible stack tops in ctx
-        final removed = calledRuleStack[s.ruleIndex];
-        try {
-          calledRuleStack.clear(s.ruleIndex);
-          for (var i = 0; i < ctx.length; i++) {
-            final returnState = atn.states[ctx.getReturnState(i)];
-//					    System.out.println("popping back to "+retState);
-            _LOOK(returnState, stopState, ctx.getParent(i), look, lookBusy,
-                calledRuleStack, seeThruPreds, addEOF);
-          }
-        } finally {
-          if (removed) {
-            calledRuleStack.set(s.ruleIndex);
-          }
-        }
-        return;
-      }
-    }
-
-    for (var i = 0; i < s.numberOfTransitions; i++) {
-      final t = s.transition(i);
-      if (t is RuleTransition) {
-        if (calledRuleStack[t.target.ruleIndex]) {
-          continue;
-        }
-
-        PredictionContext newContext =
-            SingletonPredictionContext.create(ctx, t.followState.stateNumber);
-
-        try {
-          calledRuleStack.set(t.target.ruleIndex);
-          _LOOK(t.target, stopState, newContext, look, lookBusy,
-              calledRuleStack, seeThruPreds, addEOF);
-        } finally {
-          calledRuleStack.clear(t.target.ruleIndex);
-        }
-      } else if (t is AbstractPredicateTransition) {
-        if (seeThruPreds) {
-          _LOOK(t.target, stopState, ctx, look, lookBusy, calledRuleStack,
-              seeThruPreds, addEOF);
-        } else {
-          look.addOne(HIT_PRED);
-        }
-      } else if (t.isEpsilon) {
-        _LOOK(t.target, stopState, ctx, look, lookBusy, calledRuleStack,
-            seeThruPreds, addEOF);
-      } else if (t is WildcardTransition) {
-        look.addAll(
-            IntervalSet.ofRange(Token.MIN_USER_TOKEN_TYPE, atn.maxTokenType));
-      } else {
-//				System.out.println("adding "+ t);
-        var set = t.label;
-        if (set != null) {
-          if (t is NotSetTransition) {
-            set = set.complement(IntervalSet.ofRange(
-                Token.MIN_USER_TOKEN_TYPE, atn.maxTokenType));
-          }
-          look.addAll(set);
-        }
-      }
-    }
-  }
-}

package/antlr4-4.9.2/lib/src/misc/multi_map.dart

@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
- * Use of this file is governed by the BSD 3-clause license that
- * can be found in the LICENSE.txt file in the project root.
- */
-
-import 'package:collection/collection.dart';
-
-import 'pair.dart';
-
-class MultiMap<K, V> extends DelegatingMap<K, List<V>> {
-  MultiMap() : super({});
-
-  void put(K key, V value) {
-    var elementsForKey = this[key];
-    if (elementsForKey == null) {
-      elementsForKey = [];
-      this[key] = elementsForKey;
-    }
-    elementsForKey.add(value);
-  }
-
-  List<Pair<K, V>> get pairs {
-    final pairs = <Pair<K, V>>[];
-    for (var key in keys) {
-      for (var value in this[key]) {
-        pairs.add(Pair<K, V>(key, value));
-      }
-    }
-    return pairs;
-  }
-}

package/antlr4-4.9.2/lib/src/misc/pair.dart

@@ -1,34 +0,0 @@
-/*
- * Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
- * Use of this file is governed by the BSD 3-clause license that
- * can be found in the LICENSE.txt file in the project root.
- */
-
-import '../util/murmur_hash.dart';
-
-class Pair<A, B> {
-  final A a;
-  final B b;
-
-  const Pair(this.a, this.b);
-
-  @override
-  bool operator ==(other) {
-    return identical(this, other) || other is Pair && a == other.a && b == other.b;
-  }
-
-  @override
-  String toString() {
-    return '($a, $b)';
-  }
-
-  @override
-  int get hashCode {
-    MurmurHash.initialize();
-
-    var hash = MurmurHash.initialize();
-    hash = MurmurHash.update(hash, a);
-    hash = MurmurHash.update(hash, b);
-    return MurmurHash.finish(hash, 2);
-  }
-}