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

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

@@ -1,182 +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 'vocabulary.dart';
-import 'atn/atn.dart';
-import 'error/error.dart';
-import 'input_stream.dart';
-import 'rule_context.dart';
-import 'token.dart';
-import 'token_factory.dart';
-import 'util/utils.dart';
-
-abstract class Recognizer<ATNInterpreter extends ATNSimulator> {
-  static const EOF = -1;
-
-  static final Map<Vocabulary, Map<String, int>> tokenTypeMapCache = {};
-  static final Map<List<String>, Map<String, int>> ruleIndexMapCache = {};
-  final List<ErrorListener> _listeners = [ConsoleErrorListener.INSTANCE];
-
-  /// The ATN interpreter used by the recognizer for prediction.
-  ATNInterpreter interpreter;
-  int _stateNumber = -1;
-
-  List<String> get ruleNames;
-
-  /// Get the vocabulary used by the recognizer.
-  ///
-  /// @return A [Vocabulary] instance providing information about the
-  /// vocabulary used by the grammar.
-  Vocabulary get vocabulary;
-
-  /// Get a map from token names to token types.
-  ///
-  /// <p>Used for XPath and tree pattern compilation.</p>
-  Map<String, int> get tokenTypeMap {
-    final _vocabulary = vocabulary;
-
-    var result = tokenTypeMapCache[_vocabulary];
-    if (result == null) {
-      result = {};
-      for (var i = 0; i <= getATN().maxTokenType; i++) {
-        final literalName = _vocabulary.getLiteralName(i);
-        if (literalName != null) {
-          result[literalName] = i;
-        }
-
-        final symbolicName = _vocabulary.getSymbolicName(i);
-        if (symbolicName != null) {
-          result[symbolicName] = i;
-        }
-      }
-
-      result['EOF'] = Token.EOF;
-      result = Map.unmodifiable(result);
-      tokenTypeMapCache[_vocabulary] = result;
-    }
-
-    return result;
-  }
-
-  /// Get a map from rule names to rule indexes.
-  ///
-  /// <p>Used for XPath and tree pattern compilation.</p>
-  Map<String, int> get ruleIndexMap {
-    final _ruleNames = ruleNames;
-    if (_ruleNames == null) {
-      throw UnsupportedError(
-          'The current recognizer does not provide a list of rule names.');
-    }
-
-    var result = ruleIndexMapCache[_ruleNames];
-    if (result == null) {
-      result = Map.unmodifiable(toMap(_ruleNames));
-      ruleIndexMapCache[_ruleNames] = result;
-    }
-
-    return result;
-  }
-
-  int getTokenType(String tokenName) {
-    final ttype = tokenTypeMap[tokenName];
-    if (ttype != null) return ttype;
-    return Token.INVALID_TYPE;
-  }
-
-  /// If this recognizer was generated, it will have a serialized ATN
-  /// representation of the grammar.
-  ///
-  /// <p>For interpreters, we don't know their serialized ATN despite having
-  /// created the interpreter from it.</p>
-  String get serializedATN {
-    throw UnsupportedError('there is no serialized ATN');
-  }
-
-  /// For debugging and other purposes, might want the grammar name.
-  ///  Have ANTLR generate an implementation for this method.
-  String get grammarFileName;
-
-  /// Get the [ATN] used by the recognizer for prediction.
-  ///
-  /// @return The [ATN] used by the recognizer for prediction.
-  ATN getATN();
-
-  /// If profiling during the parse/lex, this will return DecisionInfo records
-  ///  for each decision in recognizer in a ParseInfo object.
-  ///
-  /// @since 4.3
-  ParseInfo get parseInfo {
-    return null;
-  }
-
-  /// What is the error header, normally line/character position information? */
-  String getErrorHeader(RecognitionException e) {
-    final line = e.offendingToken.line;
-    final charPositionInLine = e.offendingToken.charPositionInLine;
-    return 'line $line:$charPositionInLine';
-  }
-
-  /// @exception NullPointerException if [listener] is null.
-  void addErrorListener(ErrorListener listener) {
-    if (listener == null) {
-      throw ArgumentError.notNull('listener');
-    }
-
-    _listeners.add(listener);
-  }
-
-  void removeErrorListener(ErrorListener listener) {
-    _listeners.remove(listener);
-  }
-
-  void removeErrorListeners() {
-    _listeners.clear();
-  }
-
-  List<ErrorListener> get errorListeners {
-    return _listeners;
-  }
-
-  ErrorListener get errorListenerDispatch {
-    return ProxyErrorListener(errorListeners);
-  }
-
-  // subclass needs to override these if there are sempreds or actions
-  // that the ATN interp needs to execute
-  bool sempred(RuleContext _localctx, int ruleIndex, int actionIndex) {
-    return true;
-  }
-
-  bool precpred(RuleContext localctx, int precedence) {
-    return true;
-  }
-
-  void action(RuleContext _localctx, int ruleIndex, int actionIndex) {}
-
-  int get state {
-    return _stateNumber;
-  }
-
-  /// Indicate that the recognizer has changed internal state that is
-  ///  consistent with the ATN state passed in.  This way we always know
-  ///  where we are in the ATN as the parser goes along. The rule
-  ///  context objects form a stack that lets us see the stack of
-  ///  invoking rules. Combine this and we have complete ATN
-  ///  configuration information.
-  set state(int atnState) {
-//		System.err.println("setState "+atnState);
-    _stateNumber = atnState;
-//		if ( traceATNStates ) _ctx.trace(atnState);
-  }
-
-  IntStream get inputStream;
-
-  set inputStream(IntStream input);
-
-  TokenFactory get tokenFactory;
-
-  set tokenFactory(TokenFactory input);
-}

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

@@ -1,192 +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 'atn/atn.dart';
-import 'interval_set.dart';
-import 'parser.dart';
-import 'parser_rule_context.dart';
-import 'recognizer.dart';
-import 'tree/tree.dart';
-
-/// A rule context is a record of a single rule invocation.
-///
-///  We form a stack of these context objects using the parent
-///  pointer. A parent pointer of null indicates that the current
-///  context is the bottom of the stack. The ParserRuleContext subclass
-///  as a children list so that we can turn this data structure into a
-///  tree.
-///
-///  The root node always has a null pointer and invokingState of -1.
-///
-///  Upon entry to parsing, the first invoked rule function creates a
-///  context object (a subclass specialized for that rule such as
-///  SContext) and makes it the root of a parse tree, recorded by field
-///  Parser._ctx.
-///
-///  public final SContext s() throws RecognitionException {
-///      SContext _localctx = new SContext(_ctx, getState()); <-- create new node
-///      enterRule(_localctx, 0, RULE_s);                     <-- push it
-///      ...
-///      exitRule();                                          <-- pop back to _localctx
-///      return _localctx;
-///  }
-///
-///  A subsequent rule invocation of r from the start rule s pushes a
-///  new context object for r whose parent points at s and use invoking
-///  state is the state with r emanating as edge label.
-///
-///  The invokingState fields from a context object to the root
-///  together form a stack of rule indication states where the root
-///  (bottom of the stack) has a -1 sentinel value. If we invoke start
-///  symbol s then call r1, which calls r2, the  would look like
-///  this:
-///
-///     SContext[-1]   <- root node (bottom of the stack)
-///     R1Context[p]   <- p in rule s called r1
-///     R2Context[q]   <- q in rule r1 called r2
-///
-///  So the top of the stack, _ctx, represents a call to the current
-///  rule and it holds the return address from another rule that invoke
-///  to this rule. To invoke a rule, we must always have a current context.
-///
-///  The parent contexts are useful for computing lookahead sets and
-///  getting error information.
-///
-///  These objects are used during parsing and prediction.
-///  For the special case of parsers, we use the subclass
-///  ParserRuleContext.
-///
-///  @see ParserRuleContext
-abstract class RuleContext extends RuleNode {
-  /// What context invoked this rule?
-  @override
-  RuleContext parent;
-
-  /// What state invoked the rule associated with this context?
-  /// The "return address" is the followState of invokingState
-  /// If parent is null, this should be -1.
-  int invokingState;
-
-  RuleContext({this.parent, this.invokingState}) {
-    invokingState = invokingState ?? -1;
-  }
-
-  int depth() {
-    var n = 0;
-    var p = this;
-    while (p != null) {
-      p = p.parent;
-      n++;
-    }
-    return n;
-  }
-
-  /// A context is empty if there is no invoking state; meaning nobody call
-  /// current context.
-  bool get isEmpty => invokingState == -1;
-
-  /// satisfy the ParseTree / SyntaxTree interface
-  @override
-  Interval get sourceInterval => Interval.INVALID;
-
-  @override
-  RuleContext get ruleContext => this;
-
-  @override
-  RuleContext get payload => this;
-
-  /// Return the combined text of all child nodes. This method only considers
-  ///  tokens which have been added to the parse tree.
-  ///  <p>
-  ///  Since tokens on hidden channels (e.g. whitespace or comments) are not
-  ///  added to the parse trees, they will not appear in the output of this
-  ///  method.
-  @override
-  String get text {
-    if (childCount == 0) {
-      return '';
-    }
-
-    final builder = StringBuffer();
-    for (var i = 0; i < childCount; i++) {
-      builder.write(getChild(i).text);
-    }
-
-    return builder.toString();
-  }
-
-  int get ruleIndex => -1;
-
-  /// For rule associated with this parse tree internal node, return
-  /// the outer alternative number used to match the input. Default
-  /// implementation does not compute nor store this alt num. Create
-  /// a subclass of ParserRuleContext with backing field and set
-  /// option contextSuperClass.
-  /// to set it.
-  int get altNumber => ATN.INVALID_ALT_NUMBER;
-
-  /// Set the outer alternative number for this context node. Default
-  /// implementation does nothing to avoid backing field overhead for
-  /// trees that don't need it.  Create
-  /// a subclass of ParserRuleContext with backing field and set
-  /// option contextSuperClass.
-  set altNumber(int altNumber) {}
-
-  @override
-  ParseTree getChild<T>(int i) {
-    return null;
-  }
-
-  @override
-  int get childCount => 0;
-
-  @override
-  T accept<T>(ParseTreeVisitor<T> visitor) {
-    return visitor.visitChildren(this);
-  }
-
-  /// Print out a whole tree, not just a node, in LISP format
-  /// (root child1 .. childN). Print just a node if this is a leaf.
-  ///
-  @override
-  String toStringTree({List<String> ruleNames, Parser parser}) {
-    return Trees.toStringTree(this, ruleNames: ruleNames, recog: parser);
-  }
-
-  @override
-  String toString(
-      {List<String> ruleNames, Recognizer recog, RuleContext stop}) {
-    ruleNames = ruleNames ?? recog?.ruleNames;
-    final buf = StringBuffer();
-    var p = this;
-    buf.write('[');
-    while (p != null && p != stop) {
-      if (ruleNames == null) {
-        if (!p.isEmpty) {
-          buf.write(p.invokingState);
-        }
-      } else {
-        final ruleIndex = p.ruleIndex;
-        final ruleName = ruleIndex >= 0 && ruleIndex < ruleNames.length
-            ? ruleNames[ruleIndex]
-            : ruleIndex.toString();
-        buf.write(ruleName);
-      }
-
-      if (p.parent != null &&
-          (ruleNames != null || !p.parent.isEmpty)) {
-        buf.write(' ');
-      }
-
-      p = p.parent;
-    }
-
-    buf.write(']');
-    return buf.toString();
-  }
-
-  static final EMPTY = ParserRuleContext();
-}

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

@@ -1,188 +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 'dart:math' as math;
-
-import 'package:logging/logging.dart';
-
-/// This class provides access to the current version of the ANTLR 4 runtime
-/// library as compile-time and runtime constants, along with methods for
-/// checking for matching version numbers and notifying listeners in the case
-/// where a version mismatch is detected.
-///
-/// <p>
-/// The runtime version information is provided by {@link #VERSION} and
-/// {@link #getRuntimeVersion()}. Detailed information about these values is
-/// provided in the documentation for each member.</p>
-///
-/// <p>
-/// The runtime version check is implemented by {@link #checkVersion}. Detailed
-/// information about incorporating this call into user code, as well as its use
-/// in generated code, is provided in the documentation for the method.</p>
-///
-/// <p>
-/// Version strings x.y and x.y.z are considered "compatible" and no error
-/// would be generated. Likewise, version strings x.y-SNAPSHOT and x.y.z are
-/// considered "compatible" because the major and minor components x.y
-/// are the same in each.</p>
-///
-/// <p>
-/// To trap any error messages issued by this code, use System.setErr()
-/// in your main() startup code.
-/// </p>
-///
-/// @since 4.3
-class RuntimeMetaData {
-  /// A compile-time constant containing the current version of the ANTLR 4
-  /// runtime library.
-  ///
-  /// <p>
-  /// This compile-time constant value allows generated parsers and other
-  /// libraries to include a literal reference to the version of the ANTLR 4
-  /// runtime library the code was compiled against. At each release, we
-  /// change this value.</p>
-  ///
-  /// <p>Version numbers are assumed to have the form
-  ///
-  /// <em>major</em>.<em>minor</em>.<em>patch</em>.<em>revision</em>-<em>suffix</em>,
-  ///
-  /// with the individual components defined as follows.</p>
-  ///
-  /// <ul>
-  /// <li><em>major</em> is a required non-negative integer, and is equal to
-  /// {@code 4} for ANTLR 4.</li>
-  /// <li><em>minor</em> is a required non-negative integer.</li>
-  /// <li><em>patch</em> is an optional non-negative integer. When
-  /// <em>patch</em> is omitted, the {@code .} (dot) appearing before it is
-  /// also omitted.</li>
-  /// <li><em>revision</em> is an optional non-negative integer, and may only
-  /// be included when <em>patch</em> is also included. When <em>revision</em>
-  /// is omitted, the {@code .} (dot) appearing before it is also omitted.</li>
-  /// <li><em>suffix</em> is an optional string. When <em>suffix</em> is
-  /// omitted, the {@code -} (hyphen-minus) appearing before it is also
-  /// omitted.</li>
-  /// </ul>
-  static final String VERSION = '4.9.2';
-
-  /// Gets the currently executing version of the ANTLR 4 runtime library.
-  ///
-  /// <p>
-  /// This method provides runtime access to the [VERSION] field, as
-  /// opposed to directly referencing the field as a compile-time constant.</p>
-  ///
-  /// @return The currently executing version of the ANTLR 4 library
-  static String get runtimeVersion {
-    return VERSION;
-  }
-
-  /// This method provides the ability to detect mismatches between the version
-  /// of ANTLR 4 used to generate a parser, the version of the ANTLR runtime a
-  /// parser was compiled against, and the version of the ANTLR runtime which
-  /// is currently executing.
-  ///
-  /// <p>
-  /// The version check is designed to detect the following two specific
-  /// scenarios.</p>
-  ///
-  /// <ul>
-  /// <li>The ANTLR Tool version used for code generation does not match the
-  /// currently executing runtime version.</li>
-  /// <li>The ANTLR Runtime version referenced at the time a parser was
-  /// compiled does not match the currently executing runtime version.</li>
-  /// </ul>
-  ///
-  /// <p>
-  /// Starting with ANTLR 4.3, the code generator emits a call to this method
-  /// using two constants in each generated lexer and parser: a hard-coded
-  /// constant indicating the version of the tool used to generate the parser
-  /// and a reference to the compile-time constant {@link #VERSION}. At
-  /// runtime, this method is called during the initialization of the generated
-  /// parser to detect mismatched versions, and notify the registered listeners
-  /// prior to creating instances of the parser.</p>
-  ///
-  /// <p>
-  /// This method does not perform any detection or filtering of semantic
-  /// changes between tool and runtime versions. It simply checks for a
-  /// version match and emits an error to stderr if a difference
-  /// is detected.</p>
-  ///
-  /// <p>
-  /// Note that some breaking changes between releases could result in other
-  /// types of runtime exceptions, such as a [LinkageError], prior to
-  /// calling this method. In these cases, the underlying version mismatch will
-  /// not be reported here. This method is primarily intended to
-  /// notify users of potential semantic changes between releases that do not
-  /// result in binary compatibility problems which would be detected by the
-  /// class loader. As with semantic changes, changes that break binary
-  /// compatibility between releases are mentioned in the release notes
-  /// accompanying the affected release.</p>
-  ///
-  /// <p>
-  /// <strong>Additional note for target developers:</strong> The version check
-  /// implemented by this class is designed to address specific compatibility
-  /// concerns that may arise during the execution of Java applications. Other
-  /// targets should consider the implementation of this method in the context
-  /// of that target's known execution environment, which may or may not
-  /// resemble the design provided for the Java target.</p>
-  ///
-  /// @param generatingToolVersion The version of the tool used to generate a parser.
-  /// This value may be null when called from user code that was not generated
-  /// by, and does not reference, the ANTLR 4 Tool itself.
-  /// @param compileTimeVersion The version of the runtime the parser was
-  /// compiled against. This should always be passed using a direct reference
-  /// to [VERSION].
-  static void checkVersion(
-      String generatingToolVersion, String compileTimeVersion) {
-    final runtimeVersion = VERSION;
-    var runtimeConflictsWithGeneratingTool = false;
-    var runtimeConflictsWithCompileTimeTool = false;
-
-    if (generatingToolVersion != null) {
-      runtimeConflictsWithGeneratingTool =
-          !(runtimeVersion == generatingToolVersion) &&
-              !(getMajorMinorVersion(runtimeVersion) ==
-                  getMajorMinorVersion(generatingToolVersion));
-    }
-
-    runtimeConflictsWithCompileTimeTool =
-        !(runtimeVersion == compileTimeVersion) &&
-            !(getMajorMinorVersion(runtimeVersion) ==
-                getMajorMinorVersion(compileTimeVersion));
-
-    if (runtimeConflictsWithGeneratingTool) {
-      log('ANTLR Tool version $generatingToolVersion used for code generation does not match the current runtime version $runtimeVersion',
-          level: Level.SEVERE.value);
-    }
-    if (runtimeConflictsWithCompileTimeTool) {
-      log('ANTLR Runtime version $compileTimeVersion used for parser compilation does not match the current runtime version $runtimeVersion',
-          level: Level.SEVERE.value);
-    }
-  }
-
-  /// Gets the major and minor version numbers from a version string. For
-  /// details about the syntax of the input [version].
-  /// E.g., from x.y.z return x.y.
-  ///
-  /// @param version The complete version string.
-  /// @return A string of the form <em>major</em>.<em>minor</em> containing
-  /// only the major and minor components of the version string.
-  static String getMajorMinorVersion(String version) {
-    final firstDot = version.indexOf('.');
-    final secondDot = firstDot >= 0 ? version.indexOf('.', firstDot + 1) : -1;
-    final firstDash = version.indexOf('-');
-    var referenceLength = version.length;
-    if (secondDot >= 0) {
-      referenceLength = math.min(referenceLength, secondDot);
-    }
-
-    if (firstDash >= 0) {
-      referenceLength = math.min(referenceLength, firstDash);
-    }
-
-    return version.substring(0, referenceLength);
-  }
-}