add the DA3 side measurer, packaged as the engine expects it

cameras/README-da3.md

@@ -0,0 +1,145 @@
+---
+license: apache-2.0
+pipeline_tag: image-to-3d
+tags:
+- depth-estimation
+- computer-vision
+- monocular-depth
+- multi-view-geometry
+- pose-estimation
+---
+
+# Depth Anything 3: DA3-BASE
+
+<div align="center">
+
+[![Project Page](https://img.shields.io/badge/Project_Page-Depth_Anything_3-green)](https://depth-anything-3.github.io)
+[![Paper](https://img.shields.io/badge/arXiv-Depth_Anything_3-red)](https://arxiv.org/abs/2511.10647)
+[![Demo](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Demo-blue)](https://huggingface.co/spaces/depth-anything/Depth-Anything-3)  # noqa: E501
+<!-- Benchmark badge removed as per request -->
+
+</div>
+
+## Abstract
+
+We present Depth Anything 3 (DA3), a model that predicts spatially consistent geometry from an arbitrary number of visual inputs, with or without known camera poses. In pursuit of minimal modeling, DA3 yields two key insights: a single plain transformer (e.g., vanilla DINO encoder) is sufficient as a backbone without architectural specialization, and a singular depth-ray prediction target obviates the need for complex multi-task learning. Through our teacher-student training paradigm, the model achieves a level of detail and generalization on par with Depth Anything 2 (DA2). We establish a new visual geometry benchmark covering camera pose estimation, any-view geometry and visual rendering. On this benchmark, DA3 sets a new state-of-the-art across all tasks, surpassing prior SOTA VGGT by an average of 44.3% in camera pose accuracy and 25.1% in geometric accuracy. Moreover, it outperforms DA2 in monocular depth estimation. All models are trained exclusively on public academic datasets.
+
+## Model Description
+
+DA3 Base model for multi-view depth estimation and camera pose estimation. Compact foundation model with unified depth-ray representation.
+
+| Property | Value |
+|----------|-------|
+| **Model Series** | Any-view Model |
+| **Parameters** | 0.12B |
+| **License** | Apache 2.0 |
+
+
+
+## Capabilities
+
+- ✅ Relative Depth
+- ✅ Pose Estimation
+- ✅ Pose Conditioning
+
+## Quick Start
+
+### Installation
+
+```bash
+git clone https://github.com/ByteDance-Seed/depth-anything-3
+cd depth-anything-3
+pip install -e .
+```
+
+### Basic Example
+
+```python
+import torch
+from depth_anything_3.api import DepthAnything3
+
+# Load model from Hugging Face Hub
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model = DepthAnything3.from_pretrained("depth-anything/da3-base")
+model = model.to(device=device)
+
+# Run inference on images
+images = ["image1.jpg", "image2.jpg"]  # List of image paths, PIL Images, or numpy arrays
+prediction = model.inference(
+    images,
+    export_dir="output",
+    export_format="glb"  # Options: glb, npz, ply, mini_npz, gs_ply, gs_video
+)
+
+# Access results
+print(prediction.depth.shape)        # Depth maps: [N, H, W] float32
+print(prediction.conf.shape)         # Confidence maps: [N, H, W] float32
+print(prediction.extrinsics.shape)   # Camera poses (w2c): [N, 3, 4] float32
+print(prediction.intrinsics.shape)   # Camera intrinsics: [N, 3, 3] float32
+```
+
+### Command Line Interface
+
+```bash
+# Process images with auto mode
+da3 auto path/to/images \
+    --export-format glb \
+    --export-dir output \
+    --model-dir depth-anything/da3-base
+
+# Use backend for faster repeated inference
+da3 backend --model-dir depth-anything/da3-base
+da3 auto path/to/images --export-format glb --use-backend
+```
+
+## Model Details
+
+- **Developed by:** ByteDance Seed Team
+- **Model Type:** Vision Transformer for Visual Geometry
+- **Architecture:** Plain transformer with unified depth-ray representation
+- **Training Data:** Public academic datasets only
+
+### Key Insights
+
+💎 A **single plain transformer** (e.g., vanilla DINO encoder) is sufficient as a backbone without architectural specialization.  # noqa: E501
+
+✨ A singular **depth-ray representation** obviates the need for complex multi-task learning.
+
+## Performance
+
+🏆 Depth Anything 3 significantly outperforms:
+- **Depth Anything 2** for monocular depth estimation
+- **VGGT** for multi-view depth estimation and pose estimation
+
+For detailed benchmarks, please refer to our [paper](https://arxiv.org/abs/2511.10647).  # noqa: E501
+
+## Limitations
+
+- The model is trained on academic datasets and may have limitations on certain domain-specific images  # noqa: E501
+- Performance may vary depending on image quality, lighting conditions, and scene complexity
+
+
+## Citation
+
+If you find Depth Anything 3 useful in your research or projects, please cite:
+
+```bibtex
+@article{depthanything3,
+  title={Depth Anything 3: Recovering the visual space from any views},
+  author={Haotong Lin and Sili Chen and Jun Hao Liew and Donny Y. Chen and Zhenyu Li and Guang Shi and Jiashi Feng and Bingyi Kang},  # noqa: E501
+  journal={arXiv preprint arXiv:2511.10647},
+  year={2025}
+}
+```
+
+## Links
+
+- 🏠 [Project Page](https://depth-anything-3.github.io)
+- 📄 [Paper](https://arxiv.org/abs/2511.10647)
+- 💻 [GitHub Repository](https://github.com/ByteDance-Seed/depth-anything-3)
+- 🤗 [Hugging Face Demo](https://huggingface.co/spaces/depth-anything/Depth-Anything-3)
+- 📚 [Documentation](https://github.com/ByteDance-Seed/depth-anything-3#-useful-documentation)
+
+## Authors
+
+[Haotong Lin](https://haotongl.github.io/) · [Sili Chen](https://github.com/SiliChen321) · [Junhao Liew](https://liewjunhao.github.io/) · [Donny Y. Chen](https://donydchen.github.io) · [Zhenyu Li](https://zhyever.github.io/) · [Guang Shi](https://scholar.google.com/citations?user=MjXxWbUAAAAJ&hl=en) · [Jiashi Feng](https://scholar.google.com.sg/citations?user=Q8iay0gAAAAJ&hl=en) · [Bingyi Kang](https://bingykang.github.io/)  # noqa: E501

cameras/config.json

@@ -0,0 +1,60 @@
+{
+  "model_name": "da3-base",
+  "config": {
+    "__object__": {
+      "path": "depth_anything_3.model.da3",
+      "name": "DepthAnything3Net",
+      "args": "as_params"
+    },
+    "net": {
+      "__object__": {
+        "path": "depth_anything_3.model.dinov2.dinov2",
+        "name": "DinoV2",
+        "args": "as_params"
+      },
+      "name": "vitb",
+      "out_layers": [
+        5,
+        7,
+        9,
+        11
+      ],
+      "alt_start": 4,
+      "qknorm_start": 4,
+      "rope_start": 4,
+      "cat_token": true
+    },
+    "head": {
+      "__object__": {
+        "path": "depth_anything_3.model.dualdpt",
+        "name": "DualDPT",
+        "args": "as_params"
+      },
+      "dim_in": 1536,
+      "output_dim": 2,
+      "features": 128,
+      "out_channels": [
+        96,
+        192,
+        384,
+        768
+      ]
+    },
+    "cam_enc": {
+      "__object__": {
+        "path": "depth_anything_3.model.cam_enc",
+        "name": "CameraEnc",
+        "args": "as_params"
+      },
+      "dim_out": 768
+    },
+    "cam_dec": {
+      "__object__": {
+        "path": "depth_anything_3.model.cam_dec",
+        "name": "CameraDec",
+        "args": "as_params"
+      },
+      "dim_in": 1536
+    }
+  }
+}

cameras/deps/addict-2.4.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

cameras/deps/addict-2.4.0.dist-info/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Mats Julian Olsen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

cameras/deps/addict-2.4.0.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.1
+Name: addict
+Version: 2.4.0
+Summary: Addict is a dictionary whose items can be set using both attribute and item syntax.
+Home-page: https://github.com/mewwts/addict
+Author: Mats Julian Olsen
+Author-email: mats@plysjbyen.net
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+
+Addict is a module that exposes a dictionary subclass that allows items to be set like attributes. Values are gettable and settable using both attribute and item syntax. For more info check out the README at 'github.com/mewwts/addict'.
+
+

cameras/deps/addict-2.4.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+addict-2.4.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+addict-2.4.0.dist-info/LICENSE,sha256=ykiNM8US0LImFCCQr5DomuJmqQGik_if1kLf7JMeIsE,1085
+addict-2.4.0.dist-info/METADATA,sha256=ZjIJZ5lvhfohHxIWp79fkh0TtBsN5duX84na3bxU6vQ,1028
+addict-2.4.0.dist-info/RECORD,,
+addict-2.4.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+addict-2.4.0.dist-info/WHEEL,sha256=EVRjI69F5qVjm_YgqcTXPnTAv3BfSUr0WVAHuSP3Xoo,92
+addict-2.4.0.dist-info/top_level.txt,sha256=GGfQKsz1N-bSRYzNpyp8GY8uAEqh3SWaXRbAnBUKjHA,7
+addict/__init__.py,sha256=xmlNiYYVoAD3_FfmgfOM2cc3wI17GSgsMBODbFRs_mY,233
+addict/addict.py,sha256=ScOfclaAM7ugyZoXOW2HHL9gCXt_XPe-i5bTLiY8ufU,4901

cameras/deps/addict-2.4.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.35.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cameras/deps/addict-2.4.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+addict

cameras/deps/addict/__init__.py

@@ -0,0 +1,10 @@
+from .addict import Dict
+from .addict import Dict as Addict
+
+
+__title__ = 'addict'
+__version__ = '2.4.0'
+__author__ = 'Mats Julian Olsen'
+__license__ = 'MIT'
+__copyright__ = 'Copyright 2014-2020 Mats Julian Olsen'
+__all__ = ['Dict']

cameras/deps/addict/addict.py

@@ -0,0 +1,159 @@
+import copy
+
+
+class Dict(dict):
+
+    def __init__(__self, *args, **kwargs):
+        object.__setattr__(__self, '__parent', kwargs.pop('__parent', None))
+        object.__setattr__(__self, '__key', kwargs.pop('__key', None))
+        object.__setattr__(__self, '__frozen', False)
+        for arg in args:
+            if not arg:
+                continue
+            elif isinstance(arg, dict):
+                for key, val in arg.items():
+                    __self[key] = __self._hook(val)
+            elif isinstance(arg, tuple) and (not isinstance(arg[0], tuple)):
+                __self[arg[0]] = __self._hook(arg[1])
+            else:
+                for key, val in iter(arg):
+                    __self[key] = __self._hook(val)
+
+        for key, val in kwargs.items():
+            __self[key] = __self._hook(val)
+
+    def __setattr__(self, name, value):
+        if hasattr(self.__class__, name):
+            raise AttributeError("'Dict' object attribute "
+                                 "'{0}' is read-only".format(name))
+        else:
+            self[name] = value
+
+    def __setitem__(self, name, value):
+        isFrozen = (hasattr(self, '__frozen') and
+                    object.__getattribute__(self, '__frozen'))
+        if isFrozen and name not in super(Dict, self).keys():
+                raise KeyError(name)
+        super(Dict, self).__setitem__(name, value)
+        try:
+            p = object.__getattribute__(self, '__parent')
+            key = object.__getattribute__(self, '__key')
+        except AttributeError:
+            p = None
+            key = None
+        if p is not None:
+            p[key] = self
+            object.__delattr__(self, '__parent')
+            object.__delattr__(self, '__key')
+
+    def __add__(self, other):
+        if not self.keys():
+            return other
+        else:
+            self_type = type(self).__name__
+            other_type = type(other).__name__
+            msg = "unsupported operand type(s) for +: '{}' and '{}'"
+            raise TypeError(msg.format(self_type, other_type))
+
+    @classmethod
+    def _hook(cls, item):
+        if isinstance(item, dict):
+            return cls(item)
+        elif isinstance(item, (list, tuple)):
+            return type(item)(cls._hook(elem) for elem in item)
+        return item
+
+    def __getattr__(self, item):
+        return self.__getitem__(item)
+
+    def __missing__(self, name):
+        if object.__getattribute__(self, '__frozen'):
+            raise KeyError(name)
+        return self.__class__(__parent=self, __key=name)
+
+    def __delattr__(self, name):
+        del self[name]
+
+    def to_dict(self):
+        base = {}
+        for key, value in self.items():
+            if isinstance(value, type(self)):
+                base[key] = value.to_dict()
+            elif isinstance(value, (list, tuple)):
+                base[key] = type(value)(
+                    item.to_dict() if isinstance(item, type(self)) else
+                    item for item in value)
+            else:
+                base[key] = value
+        return base
+
+    def copy(self):
+        return copy.copy(self)
+
+    def deepcopy(self):
+        return copy.deepcopy(self)
+
+    def __deepcopy__(self, memo):
+        other = self.__class__()
+        memo[id(self)] = other
+        for key, value in self.items():
+            other[copy.deepcopy(key, memo)] = copy.deepcopy(value, memo)
+        return other
+
+    def update(self, *args, **kwargs):
+        other = {}
+        if args:
+            if len(args) > 1:
+                raise TypeError()
+            other.update(args[0])
+        other.update(kwargs)
+        for k, v in other.items():
+            if ((k not in self) or
+                (not isinstance(self[k], dict)) or
+                (not isinstance(v, dict))):
+                self[k] = v
+            else:
+                self[k].update(v)
+
+    def __getnewargs__(self):
+        return tuple(self.items())
+
+    def __getstate__(self):
+        return self
+
+    def __setstate__(self, state):
+        self.update(state)
+
+    def __or__(self, other):
+        if not isinstance(other, (Dict, dict)):
+            return NotImplemented
+        new = Dict(self)
+        new.update(other)
+        return new
+
+    def __ror__(self, other):
+        if not isinstance(other, (Dict, dict)):
+            return NotImplemented
+        new = Dict(other)
+        new.update(self)
+        return new
+
+    def __ior__(self, other):
+        self.update(other)
+        return self
+
+    def setdefault(self, key, default=None):
+        if key in self:
+            return self[key]
+        else:
+            self[key] = default
+            return default
+
+    def freeze(self, shouldFreeze=True):
+        object.__setattr__(self, '__frozen', shouldFreeze)
+        for key, val in self.items():
+            if isinstance(val, Dict):
+                val.freeze(shouldFreeze)
+
+    def unfreeze(self):
+        self.freeze(False)

cameras/deps/antlr4/BufferedTokenStream.py

@@ -0,0 +1,302 @@
+#
+# 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.
+
+# This implementation of {@link TokenStream} loads tokens from a
+# {@link TokenSource} on-demand, and places the tokens in a buffer to provide
+# access to any previous token by index.
+#
+# <p>
+# This token stream ignores the value of {@link Token#getChannel}. If your
+# parser requires the token stream filter tokens to only those on a particular
+# channel, such as {@link Token#DEFAULT_CHANNEL} or
+# {@link Token#HIDDEN_CHANNEL}, use a filtering token stream such a
+# {@link CommonTokenStream}.</p>
+from io import StringIO
+from antlr4.Token import Token
+from antlr4.error.Errors import IllegalStateException
+
+# need forward declaration
+Lexer = None
+
+# this is just to keep meaningful parameter types to Parser
+class TokenStream(object):
+
+    pass
+
+
+class BufferedTokenStream(TokenStream):
+    __slots__ = ('tokenSource', 'tokens', 'index', 'fetchedEOF')
+
+    def __init__(self, tokenSource:Lexer):
+        # The {@link TokenSource} from which tokens for this stream are fetched.
+        self.tokenSource = tokenSource
+
+        # A collection of all tokens fetched from the token source. The list is
+        # considered a complete view of the input once {@link #fetchedEOF} is set
+        # to {@code true}.
+        self.tokens = []
+
+        # The index into {@link #tokens} of the current token (next token to
+        # {@link #consume}). {@link #tokens}{@code [}{@link #p}{@code ]} should be
+        # {@link #LT LT(1)}.
+        #
+        # <p>This field is set to -1 when the stream is first constructed or when
+        # {@link #setTokenSource} is called, indicating that the first token has
+        # not yet been fetched from the token source. For additional information,
+        # see the documentation of {@link IntStream} for a description of
+        # Initializing Methods.</p>
+        self.index = -1
+
+        # Indicates whether the {@link Token#EOF} token has been fetched from
+        # {@link #tokenSource} and added to {@link #tokens}. This field improves
+        # performance for the following cases:
+        #
+        # <ul>
+        # <li>{@link #consume}: The lookahead check in {@link #consume} to prevent
+        # consuming the EOF symbol is optimized by checking the values of
+        # {@link #fetchedEOF} and {@link #p} instead of calling {@link #LA}.</li>
+        # <li>{@link #fetch}: The check to prevent adding multiple EOF symbols into
+        # {@link #tokens} is trivial with this field.</li>
+        # <ul>
+        self.fetchedEOF = False
+
+    def mark(self):
+        return 0
+
+    def release(self, marker:int):
+        # no resources to release
+        pass
+
+    def reset(self):
+        self.seek(0)
+
+    def seek(self, index:int):
+        self.lazyInit()
+        self.index = self.adjustSeekIndex(index)
+
+    def get(self, index:int):
+        self.lazyInit()
+        return self.tokens[index]
+
+    def consume(self):
+        skipEofCheck = False
+        if self.index >= 0:
+            if self.fetchedEOF:
+                # the last token in tokens is EOF. skip check if p indexes any
+                # fetched token except the last.
+                skipEofCheck = self.index < len(self.tokens) - 1
+            else:
+               # no EOF token in tokens. skip check if p indexes a fetched token.
+                skipEofCheck = self.index < len(self.tokens)
+        else:
+            # not yet initialized
+            skipEofCheck = False
+
+        if not skipEofCheck and self.LA(1) == Token.EOF:
+            raise IllegalStateException("cannot consume EOF")
+
+        if self.sync(self.index + 1):
+            self.index = self.adjustSeekIndex(self.index + 1)
+
+    # Make sure index {@code i} in tokens has a token.
+    #
+    # @return {@code true} if a token is located at index {@code i}, otherwise
+    #    {@code false}.
+    # @see #get(int i)
+    #/
+    def sync(self, i:int):
+        n = i - len(self.tokens) + 1 # how many more elements we need?
+        if n > 0 :
+            fetched = self.fetch(n)
+            return fetched >= n
+        return True
+
+    # Add {@code n} elements to buffer.
+    #
+    # @return The actual number of elements added to the buffer.
+    #/
+    def fetch(self, n:int):
+        if self.fetchedEOF:
+            return 0
+        for i in range(0, n):
+            t = self.tokenSource.nextToken()
+            t.tokenIndex = len(self.tokens)
+            self.tokens.append(t)
+            if t.type==Token.EOF:
+                self.fetchedEOF = True
+                return i + 1
+        return n
+
+
+    # Get all tokens from start..stop inclusively#/
+    def getTokens(self, start:int, stop:int, types:set=None):
+        if start<0 or stop<0:
+            return None
+        self.lazyInit()
+        subset = []
+        if stop >= len(self.tokens):
+            stop = len(self.tokens)-1
+        for i in range(start, stop):
+            t = self.tokens[i]
+            if t.type==Token.EOF:
+                break
+            if types is None or t.type in types:
+                subset.append(t)
+        return subset
+
+    def LA(self, i:int):
+        return self.LT(i).type
+
+    def LB(self, k:int):
+        if (self.index-k) < 0:
+            return None
+        return self.tokens[self.index-k]
+
+    def LT(self, k:int):
+        self.lazyInit()
+        if k==0:
+            return None
+        if k < 0:
+            return self.LB(-k)
+        i = self.index + k - 1
+        self.sync(i)
+        if i >= len(self.tokens): # return EOF token
+            # EOF must be last token
+            return self.tokens[len(self.tokens)-1]
+        return self.tokens[i]
+
+    # Allowed derived classes to modify the behavior of operations which change
+    # the current stream position by adjusting the target token index of a seek
+    # operation. The default implementation simply returns {@code i}. If an
+    # exception is thrown in this method, the current stream index should not be
+    # changed.
+    #
+    # <p>For example, {@link CommonTokenStream} overrides this method to ensure that
+    # the seek target is always an on-channel token.</p>
+    #
+    # @param i The target token index.
+    # @return The adjusted target token index.
+
+    def adjustSeekIndex(self, i:int):
+        return i
+
+    def lazyInit(self):
+        if self.index == -1:
+            self.setup()
+
+    def setup(self):
+        self.sync(0)
+        self.index = self.adjustSeekIndex(0)
+
+    # Reset this token stream by setting its token source.#/
+    def setTokenSource(self, tokenSource:Lexer):
+        self.tokenSource = tokenSource
+        self.tokens = []
+        self.index = -1
+        self.fetchedEOF = False
+
+
+    # Given a starting index, return the index of the next token on channel.
+    #  Return i if tokens[i] is on channel.  Return the index of the EOF token
+    # if there are no tokens on channel between i and EOF.
+    #/
+    def nextTokenOnChannel(self, i:int, channel:int):
+        self.sync(i)
+        if i>=len(self.tokens):
+            return len(self.tokens) - 1
+        token = self.tokens[i]
+        while token.channel!=channel:
+            if token.type==Token.EOF:
+                return i
+            i += 1
+            self.sync(i)
+            token = self.tokens[i]
+        return i
+
+    # Given a starting index, return the index of the previous token on channel.
+    #  Return i if tokens[i] is on channel. Return -1 if there are no tokens
+    #  on channel between i and 0.
+    def previousTokenOnChannel(self, i:int, channel:int):
+        while i>=0 and self.tokens[i].channel!=channel:
+            i -= 1
+        return i
+
+    # Collect all tokens on specified channel to the right of
+    #  the current token up until we see a token on DEFAULT_TOKEN_CHANNEL or
+    #  EOF. If channel is -1, find any non default channel token.
+    def getHiddenTokensToRight(self, tokenIndex:int, channel:int=-1):
+        self.lazyInit()
+        if tokenIndex<0 or tokenIndex>=len(self.tokens):
+            raise Exception(str(tokenIndex) + " not in 0.." + str(len(self.tokens)-1))
+        from antlr4.Lexer import Lexer
+        nextOnChannel = self.nextTokenOnChannel(tokenIndex + 1, Lexer.DEFAULT_TOKEN_CHANNEL)
+        from_ = tokenIndex+1
+        # if none onchannel to right, nextOnChannel=-1 so set to = last token
+        to = (len(self.tokens)-1) if nextOnChannel==-1 else nextOnChannel
+        return self.filterForChannel(from_, to, channel)
+
+
+    # Collect all tokens on specified channel to the left of
+    #  the current token up until we see a token on DEFAULT_TOKEN_CHANNEL.
+    #  If channel is -1, find any non default channel token.
+    def getHiddenTokensToLeft(self, tokenIndex:int, channel:int=-1):
+        self.lazyInit()
+        if tokenIndex<0 or tokenIndex>=len(self.tokens):
+            raise Exception(str(tokenIndex) + " not in 0.." + str(len(self.tokens)-1))
+        from antlr4.Lexer import Lexer
+        prevOnChannel = self.previousTokenOnChannel(tokenIndex - 1, Lexer.DEFAULT_TOKEN_CHANNEL)
+        if prevOnChannel == tokenIndex - 1:
+            return None
+        # if none on channel to left, prevOnChannel=-1 then from=0
+        from_ = prevOnChannel+1
+        to = tokenIndex-1
+        return self.filterForChannel(from_, to, channel)
+
+
+    def filterForChannel(self, left:int, right:int, channel:int):
+        hidden = []
+        for i in range(left, right+1):
+            t = self.tokens[i]
+            if channel==-1:
+                from antlr4.Lexer import Lexer
+                if t.channel!= Lexer.DEFAULT_TOKEN_CHANNEL:
+                    hidden.append(t)
+            elif t.channel==channel:
+                    hidden.append(t)
+        if len(hidden)==0:
+            return None
+        return hidden
+
+    def getSourceName(self):
+        return self.tokenSource.getSourceName()
+
+    # Get the text of all tokens in this buffer.#/
+    def getText(self, start:int=None, stop:int=None):
+        self.lazyInit()
+        self.fill()
+        if isinstance(start, Token):
+            start = start.tokenIndex
+        elif start is None:
+            start = 0
+        if isinstance(stop, Token):
+            stop = stop.tokenIndex
+        elif stop is None or stop >= len(self.tokens):
+            stop = len(self.tokens) - 1
+        if start < 0 or stop < 0 or stop < start:
+            return ""
+        with StringIO() as buf:
+            for i in range(start, stop+1):
+                t = self.tokens[i]
+                if t.type==Token.EOF:
+                    break
+                buf.write(t.text)
+            return buf.getvalue()
+
+
+    # Get all tokens from lexer until EOF#/
+    def fill(self):
+        self.lazyInit()
+        while self.fetch(1000)==1000:
+            pass

cameras/deps/antlr4/CommonTokenFactory.py

@@ -0,0 +1,61 @@
+#
+# 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.
+#
+
+#
+# This default implementation of {@link TokenFactory} creates
+# {@link CommonToken} objects.
+#
+from antlr4.Token import CommonToken
+
+class TokenFactory(object):
+
+    pass
+
+class CommonTokenFactory(TokenFactory):
+    __slots__ = 'copyText'
+
+    #
+    # The default {@link CommonTokenFactory} instance.
+    #
+    # <p>
+    # This token factory does not explicitly copy token text when constructing
+    # tokens.</p>
+    #
+    DEFAULT = None
+
+    def __init__(self, copyText:bool=False):
+        # Indicates whether {@link CommonToken#setText} should be called after
+        # constructing tokens to explicitly set the text. This is useful for cases
+        # where the input stream might not be able to provide arbitrary substrings
+        # of text from the input after the lexer creates a token (e.g. the
+        # implementation of {@link CharStream#getText} in
+        # {@link UnbufferedCharStream} throws an
+        # {@link UnsupportedOperationException}). Explicitly setting the token text
+        # allows {@link Token#getText} to be called at any time regardless of the
+        # input stream implementation.
+        #
+        # <p>
+        # The default value is {@code false} to avoid the performance and memory
+        # overhead of copying text for every token unless explicitly requested.</p>
+        #
+        self.copyText = copyText
+
+    def create(self, source, type:int, text:str, channel:int, start:int, stop:int, line:int, column:int):
+        t = CommonToken(source, type, channel, start, stop)
+        t.line = line
+        t.column = column
+        if text is not None:
+            t.text = text
+        elif self.copyText and source[1] is not None:
+            t.text = source[1].getText(start,stop)
+        return t
+
+    def createThin(self, type:int, text:str):
+        t = CommonToken(type=type)
+        t.text = text
+        return t
+
+CommonTokenFactory.DEFAULT = CommonTokenFactory()

cameras/deps/antlr4/CommonTokenStream.py

@@ -0,0 +1,87 @@
+#
+# 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.
+#/
+
+#
+# This class extends {@link BufferedTokenStream} with functionality to filter
+# token streams to tokens on a particular channel (tokens where
+# {@link Token#getChannel} returns a particular value).
+#
+# <p>
+# This token stream provides access to all tokens by index or when calling
+# methods like {@link #getText}. The channel filtering is only used for code
+# accessing tokens via the lookahead methods {@link #LA}, {@link #LT}, and
+# {@link #LB}.</p>
+#
+# <p>
+# By default, tokens are placed on the default channel
+# ({@link Token#DEFAULT_CHANNEL}), but may be reassigned by using the
+# {@code ->channel(HIDDEN)} lexer command, or by using an embedded action to
+# call {@link Lexer#setChannel}.
+# </p>
+#
+# <p>
+# Note: lexer rules which use the {@code ->skip} lexer command or call
+# {@link Lexer#skip} do not produce tokens at all, so input text matched by
+# such a rule will not be available as part of the token stream, regardless of
+# channel.</p>
+#/
+
+from antlr4.BufferedTokenStream import BufferedTokenStream
+from antlr4.Lexer import Lexer
+from antlr4.Token import Token
+
+
+class CommonTokenStream(BufferedTokenStream):
+    __slots__ = 'channel'
+
+    def __init__(self, lexer:Lexer, channel:int=Token.DEFAULT_CHANNEL):
+        super().__init__(lexer)
+        self.channel = channel
+
+    def adjustSeekIndex(self, i:int):
+        return self.nextTokenOnChannel(i, self.channel)
+
+    def LB(self, k:int):
+        if k==0 or (self.index-k)<0:
+            return None
+        i = self.index
+        n = 1
+        # find k good tokens looking backwards
+        while n <= k:
+            # skip off-channel tokens
+            i = self.previousTokenOnChannel(i - 1, self.channel)
+            n += 1
+        if i < 0:
+            return None
+        return self.tokens[i]
+
+    def LT(self, k:int):
+        self.lazyInit()
+        if k == 0:
+            return None
+        if k < 0:
+            return self.LB(-k)
+        i = self.index
+        n = 1 # we know tokens[pos] is a good one
+        # find k good tokens
+        while n < k:
+            # skip off-channel tokens, but make sure to not look past EOF
+            if self.sync(i + 1):
+                i = self.nextTokenOnChannel(i + 1, self.channel)
+            n += 1
+        return self.tokens[i]
+
+    # Count EOF just once.#/
+    def getNumberOfOnChannelTokens(self):
+        n = 0
+        self.fill()
+        for i in range(0, len(self.tokens)):
+            t = self.tokens[i]
+            if t.channel==self.channel:
+                n += 1
+            if t.type==Token.EOF:
+                break
+        return n

cameras/deps/antlr4/FileStream.py

@@ -0,0 +1,27 @@
+#
+# 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.
+#
+
+#
+#  This is an InputStream that is loaded from a file all at once
+#  when you construct the object.
+#
+
+import codecs
+from antlr4.InputStream import InputStream
+
+
+class FileStream(InputStream):
+    __slots__ = 'fileName'
+
+    def __init__(self, fileName:str, encoding:str='ascii', errors:str='strict'):
+        super().__init__(self.readDataFrom(fileName, encoding, errors))
+        self.fileName = fileName
+
+    def readDataFrom(self, fileName:str, encoding:str, errors:str='strict'):
+        # read binary to avoid line ending conversion
+        with open(fileName, 'rb') as file:
+            bytes = file.read()
+            return codecs.decode(bytes, encoding, errors)

cameras/deps/antlr4/InputStream.py

@@ -0,0 +1,87 @@
+#
+# 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.
+#
+
+
+#
+#  Vacuum all input from a string and then treat it like a buffer.
+#
+from antlr4.Token import Token
+
+
+class InputStream (object):
+    __slots__ = ('name', 'strdata', '_index', 'data', '_size')
+
+    def __init__(self, data: str):
+        self.name = "<empty>"
+        self.strdata = data
+        self._loadString()
+
+    def _loadString(self):
+        self._index = 0
+        self.data = [ord(c) for c in self.strdata]
+        self._size = len(self.data)
+
+    @property
+    def index(self):
+        return self._index
+
+    @property
+    def size(self):
+        return self._size
+
+    # Reset the stream so that it's in the same state it was
+    #  when the object was created *except* the data array is not
+    #  touched.
+    #
+    def reset(self):
+        self._index = 0
+
+    def consume(self):
+        if self._index >= self._size:
+            assert self.LA(1) == Token.EOF
+            raise Exception("cannot consume EOF")
+        self._index += 1
+
+    def LA(self, offset: int):
+        if offset==0:
+            return 0 # undefined
+        if offset<0:
+            offset += 1 # e.g., translate LA(-1) to use offset=0
+        pos = self._index + offset - 1
+        if pos < 0 or pos >= self._size: # invalid
+            return Token.EOF
+        return self.data[pos]
+
+    def LT(self, offset: int):
+        return self.LA(offset)
+
+    # mark/release do nothing; we have entire buffer
+    def mark(self):
+        return -1
+
+    def release(self, marker: int):
+        pass
+
+    # consume() ahead until p==_index; can't just set p=_index as we must
+    # update line and column. If we seek backwards, just set p
+    #
+    def seek(self, _index: int):
+        if _index<=self._index:
+            self._index = _index # just jump; don't update stream state (line, ...)
+            return
+        # seek forward
+        self._index = min(_index, self._size)
+
+    def getText(self, start :int, stop: int):
+        if stop >= self._size:
+            stop = self._size-1
+        if start >= self._size:
+            return ""
+        else:
+            return self.strdata[start:stop+1]
+
+    def __str__(self):
+        return self.strdata

cameras/deps/antlr4/IntervalSet.py

@@ -0,0 +1,180 @@
+#
+# 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.
+#
+
+from io import StringIO
+from antlr4.Token import Token
+
+# need forward declarations
+IntervalSet = None
+
+class IntervalSet(object):
+    __slots__ = ('intervals', 'readonly')
+
+    def __init__(self):
+        self.intervals = None
+        self.readonly = False
+
+    def __iter__(self):
+        if self.intervals is not None:
+            for i in self.intervals:
+                for c in i:
+                    yield c
+
+    def __getitem__(self, item):
+        i = 0
+        for k in self:
+            if i==item:
+                return k
+            else:
+                i += 1
+        return Token.INVALID_TYPE
+
+    def addOne(self, v:int):
+        self.addRange(range(v, v+1))
+
+    def addRange(self, v:range):
+        if self.intervals is None:
+            self.intervals = list()
+            self.intervals.append(v)
+        else:
+            # find insert pos
+            k = 0
+            for i in self.intervals:
+                # distinct range -> insert
+                if v.stop<i.start:
+                    self.intervals.insert(k, v)
+                    return
+                # contiguous range -> adjust
+                elif v.stop==i.start:
+                    self.intervals[k] = range(v.start, i.stop)
+                    return
+                # overlapping range -> adjust and reduce
+                elif v.start<=i.stop:
+                    self.intervals[k] = range(min(i.start,v.start), max(i.stop,v.stop))
+                    self.reduce(k)
+                    return
+                k += 1
+            # greater than any existing
+            self.intervals.append(v)
+
+    def addSet(self, other:IntervalSet):
+        if other.intervals is not None:
+            for i in other.intervals:
+                self.addRange(i)
+        return self
+
+    def reduce(self, k:int):
+        # only need to reduce if k is not the last
+        if k<len(self.intervals)-1:
+            l = self.intervals[k]
+            r = self.intervals[k+1]
+            # if r contained in l
+            if l.stop >= r.stop:
+                self.intervals.pop(k+1)
+                self.reduce(k)
+            elif l.stop >= r.start:
+                self.intervals[k] = range(l.start, r.stop)
+                self.intervals.pop(k+1)
+
+    def complement(self, start, stop):
+        result = IntervalSet()
+        result.addRange(range(start,stop+1))
+        for i in self.intervals:
+            result.removeRange(i)
+        return result
+
+    def __contains__(self, item):
+        if self.intervals is None:
+            return False
+        else:
+            return any(item in i for i in self.intervals)
+
+    def __len__(self):
+        return sum(len(i) for i in self.intervals)
+
+    def removeRange(self, v):
+        if v.start==v.stop-1:
+            self.removeOne(v.start)
+        elif self.intervals is not None:
+            k = 0
+            for i in self.intervals:
+                # intervals are ordered
+                if v.stop<=i.start:
+                    return
+                # check for including range, split it
+                elif v.start>i.start and v.stop<i.stop:
+                    self.intervals[k] = range(i.start, v.start)
+                    x = range(v.stop, i.stop)
+                    self.intervals.insert(k, x)
+                    return
+                # check for included range, remove it
+                elif v.start<=i.start and v.stop>=i.stop:
+                    self.intervals.pop(k)
+                    k -= 1  # need another pass
+                # check for lower boundary
+                elif v.start<i.stop:
+                    self.intervals[k] = range(i.start, v.start)
+                # check for upper boundary
+                elif v.stop<i.stop:
+                    self.intervals[k] = range(v.stop, i.stop)
+                k += 1
+
+    def removeOne(self, v):
+        if self.intervals is not None:
+            k = 0
+            for i in self.intervals:
+                # intervals is ordered
+                if v<i.start:
+                    return
+                # check for single value range
+                elif v==i.start and v==i.stop-1:
+                    self.intervals.pop(k)
+                    return
+                # check for lower boundary
+                elif v==i.start:
+                    self.intervals[k] = range(i.start+1, i.stop)
+                    return
+                # check for upper boundary
+                elif v==i.stop-1:
+                    self.intervals[k] = range(i.start, i.stop-1)
+                    return
+                # split existing range
+                elif v<i.stop-1:
+                    x = range(i.start, v)
+                    self.intervals[k] = range(v + 1, i.stop)
+                    self.intervals.insert(k, x)
+                    return
+                k += 1
+
+
+    def toString(self, literalNames:list, symbolicNames:list):
+        if self.intervals is None:
+            return "{}"
+        with StringIO() as buf:
+            if len(self)>1:
+                buf.write("{")
+            first = True
+            for i in self.intervals:
+                for j in i:
+                    if not first:
+                        buf.write(", ")
+                    buf.write(self.elementName(literalNames, symbolicNames, j))
+                    first = False
+            if len(self)>1:
+                buf.write("}")
+            return buf.getvalue()
+
+    def elementName(self, literalNames:list, symbolicNames:list, a:int):
+        if a==Token.EOF:
+            return "<EOF>"
+        elif a==Token.EPSILON:
+            return "<EPSILON>"
+        else:
+            if a<len(literalNames) and literalNames[a] != "<INVALID>":
+                return literalNames[a]
+            if a<len(symbolicNames):
+                return symbolicNames[a]
+            return "<UNKNOWN>"

cameras/deps/antlr4/LL1Analyzer.py

@@ -0,0 +1,173 @@
+#
+# 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.
+#/
+from antlr4.IntervalSet import IntervalSet
+from antlr4.Token import Token
+from antlr4.PredictionContext import PredictionContext, SingletonPredictionContext, PredictionContextFromRuleContext
+from antlr4.RuleContext import RuleContext
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNConfig import ATNConfig
+from antlr4.atn.ATNState import ATNState, RuleStopState
+from antlr4.atn.Transition import WildcardTransition, NotSetTransition, AbstractPredicateTransition, RuleTransition
+
+
+class LL1Analyzer (object):
+    __slots__ = 'atn'
+
+    #* Special value added to the lookahead sets to indicate that we hit
+    #  a predicate during analysis if {@code seeThruPreds==false}.
+    #/
+    HIT_PRED = Token.INVALID_TYPE
+
+    def __init__(self, atn:ATN):
+        self.atn = atn
+
+    #*
+    # Calculates the SLL(1) expected lookahead set for each outgoing transition
+    # of an {@link ATNState}. The returned array has one element for each
+    # outgoing transition in {@code 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 {@code null}.
+    #
+    # @param s the ATN state
+    # @return the expected symbols for each outgoing transition of {@code s}.
+    #/
+    def getDecisionLookahead(self, s:ATNState):
+        if s is None:
+            return None
+
+        count = len(s.transitions)
+        look = [] * count
+        for alt in range(0, count):
+            look[alt] = set()
+            lookBusy = set()
+            seeThruPreds = False # fail to get lookahead upon pred
+            self._LOOK(s.transition(alt).target, None, PredictionContext.EMPTY,
+                  look[alt], lookBusy, set(), seeThruPreds, False)
+            # Wipe out lookahead for this alternative if we found nothing
+            # or we had a predicate when we !seeThruPreds
+            if len(look[alt])==0 or self.HIT_PRED in look[alt]:
+                look[alt] = None
+        return look
+
+    #*
+    # Compute set of tokens that can follow {@code s} in the ATN in the
+    # specified {@code ctx}.
+    #
+    # <p>If {@code ctx} is {@code null} and the end of the rule containing
+    # {@code s} is reached, {@link Token#EPSILON} is added to the result set.
+    # If {@code ctx} is not {@code 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
+    # {@link BlockEndState} to detect epsilon paths through a closure.
+    # @param ctx the complete parser context, or {@code null} if the context
+    # should be ignored
+    #
+    # @return The set of tokens that can follow {@code s} in the ATN in the
+    # specified {@code ctx}.
+    #/
+    def LOOK(self, s:ATNState, stopState:ATNState=None, ctx:RuleContext=None):
+        r = IntervalSet()
+        seeThruPreds = True # ignore preds; get all lookahead
+        lookContext = PredictionContextFromRuleContext(s.atn, ctx) if ctx is not None else None
+        self._LOOK(s, stopState, lookContext, r, set(), set(), seeThruPreds, True)
+        return r
+
+    #*
+    # Compute set of tokens that can follow {@code s} in the ATN in the
+    # specified {@code ctx}.
+    #
+    # <p>If {@code ctx} is {@code null} and {@code stopState} or the end of the
+    # rule containing {@code s} is reached, {@link Token#EPSILON} is added to
+    # the result set. If {@code ctx} is not {@code null} and {@code addEOF} is
+    # {@code true} and {@code 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
+    # {@link BlockEndState} to detect epsilon paths through a closure.
+    # @param ctx The outer context, or {@code 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 {@code true} to true semantic predicates as
+    # implicitly {@code true} and "see through them", otherwise {@code 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 {@code ctx}
+    # is {@code null}.
+    #/
+    def _LOOK(self, s:ATNState, stopState:ATNState , ctx:PredictionContext, look:IntervalSet, lookBusy:set,
+                     calledRuleStack:set, seeThruPreds:bool, addEOF:bool):
+        c = ATNConfig(s, 0, ctx)
+
+        if c in lookBusy:
+            return
+        lookBusy.add(c)
+
+        if s == stopState:
+            if ctx is None:
+                look.addOne(Token.EPSILON)
+                return
+            elif ctx.isEmpty() and addEOF:
+                look.addOne(Token.EOF)
+                return
+
+        if isinstance(s, RuleStopState ):
+            if ctx is None:
+                look.addOne(Token.EPSILON)
+                return
+            elif ctx.isEmpty() and addEOF:
+                look.addOne(Token.EOF)
+                return
+
+            if ctx != PredictionContext.EMPTY:
+                removed = s.ruleIndex in calledRuleStack
+                try:
+                    calledRuleStack.discard(s.ruleIndex)
+                    # run thru all possible stack tops in ctx
+                    for i in range(0, len(ctx)):
+                        returnState = self.atn.states[ctx.getReturnState(i)]
+                        self._LOOK(returnState, stopState, ctx.getParent(i), look, lookBusy, calledRuleStack, seeThruPreds, addEOF)
+                finally:
+                    if removed:
+                        calledRuleStack.add(s.ruleIndex)
+                return
+
+        for t in s.transitions:
+            if type(t) == RuleTransition:
+                if t.target.ruleIndex in calledRuleStack:
+                    continue
+
+                newContext = SingletonPredictionContext.create(ctx, t.followState.stateNumber)
+
+                try:
+                    calledRuleStack.add(t.target.ruleIndex)
+                    self._LOOK(t.target, stopState, newContext, look, lookBusy, calledRuleStack, seeThruPreds, addEOF)
+                finally:
+                    calledRuleStack.remove(t.target.ruleIndex)
+            elif isinstance(t, AbstractPredicateTransition ):
+                if seeThruPreds:
+                    self._LOOK(t.target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF)
+                else:
+                    look.addOne(self.HIT_PRED)
+            elif t.isEpsilon:
+                self._LOOK(t.target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF)
+            elif type(t) == WildcardTransition:
+                look.addRange( range(Token.MIN_USER_TOKEN_TYPE, self.atn.maxTokenType + 1) )
+            else:
+                set_ = t.label
+                if set_ is not None:
+                    if isinstance(t, NotSetTransition):
+                        set_ = set_.complement(Token.MIN_USER_TOKEN_TYPE, self.atn.maxTokenType)
+                    look.addSet(set_)

cameras/deps/antlr4/Lexer.py

@@ -0,0 +1,329 @@
+# 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.
+#/
+
+# A lexer is recognizer that draws input symbols from a character stream.
+#  lexer grammars result in a subclass of self object. A Lexer object
+#  uses simplified match() and error recovery mechanisms in the interest
+#  of speed.
+#/
+from io import StringIO
+
+import sys
+if sys.version_info[1] > 5:
+    from typing import TextIO
+else:
+    from typing.io import TextIO
+from antlr4.CommonTokenFactory import CommonTokenFactory
+from antlr4.atn.LexerATNSimulator import LexerATNSimulator
+from antlr4.InputStream import InputStream
+from antlr4.Recognizer import Recognizer
+from antlr4.Token import Token
+from antlr4.error.Errors import IllegalStateException, LexerNoViableAltException, RecognitionException
+
+class TokenSource(object):
+
+    pass
+
+
+class Lexer(Recognizer, TokenSource):
+    __slots__ = (
+        '_input', '_output', '_factory', '_tokenFactorySourcePair', '_token',
+        '_tokenStartCharIndex', '_tokenStartLine', '_tokenStartColumn',
+        '_hitEOF', '_channel', '_type', '_modeStack', '_mode', '_text'
+    )
+
+    DEFAULT_MODE = 0
+    MORE = -2
+    SKIP = -3
+
+    DEFAULT_TOKEN_CHANNEL = Token.DEFAULT_CHANNEL
+    HIDDEN = Token.HIDDEN_CHANNEL
+    MIN_CHAR_VALUE = 0x0000
+    MAX_CHAR_VALUE = 0x10FFFF
+
+    def __init__(self, input:InputStream, output:TextIO = sys.stdout):
+        super().__init__()
+        self._input = input
+        self._output = output
+        self._factory = CommonTokenFactory.DEFAULT
+        self._tokenFactorySourcePair = (self, input)
+
+        self._interp = None # child classes must populate this
+
+        # The goal of all lexer rules/methods is to create a token object.
+        #  self is an instance variable as multiple rules may collaborate to
+        #  create a single token.  nextToken will return self object after
+        #  matching lexer rule(s).  If you subclass to allow multiple token
+        #  emissions, then set self to the last token to be matched or
+        #  something nonnull so that the auto token emit mechanism will not
+        #  emit another token.
+        self._token = None
+
+        # 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.
+        self._tokenStartCharIndex = -1
+
+        # The line on which the first character of the token resides#/
+        self._tokenStartLine = -1
+
+        # The character position of first character within the line#/
+        self._tokenStartColumn = -1
+
+        # Once we see EOF on char stream, next token will be EOF.
+        #  If you have DONE : EOF ; then you see DONE EOF.
+        self._hitEOF = False
+
+        # The channel number for the current token#/
+        self._channel = Token.DEFAULT_CHANNEL
+
+        # The token type for the current token#/
+        self._type = Token.INVALID_TYPE
+
+        self._modeStack = []
+        self._mode = self.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 self instance var.
+        #/
+        self._text = None
+
+
+    def reset(self):
+        # wack Lexer state variables
+        if self._input is not None:
+            self._input.seek(0) # rewind the input
+        self._token = None
+        self._type = Token.INVALID_TYPE
+        self._channel = Token.DEFAULT_CHANNEL
+        self._tokenStartCharIndex = -1
+        self._tokenStartColumn = -1
+        self._tokenStartLine = -1
+        self._text = None
+
+        self._hitEOF = False
+        self._mode = Lexer.DEFAULT_MODE
+        self._modeStack = []
+
+        self._interp.reset()
+
+    # Return a token from self source; i.e., match a token on the char
+    #  stream.
+    def nextToken(self):
+        if self._input is None:
+            raise IllegalStateException("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
+        tokenStartMarker = self._input.mark()
+        try:
+            while True:
+                if self._hitEOF:
+                    self.emitEOF()
+                    return self._token
+                self._token = None
+                self._channel = Token.DEFAULT_CHANNEL
+                self._tokenStartCharIndex = self._input.index
+                self._tokenStartColumn = self._interp.column
+                self._tokenStartLine = self._interp.line
+                self._text = None
+                continueOuter = False
+                while True:
+                    self._type = Token.INVALID_TYPE
+                    ttype = self.SKIP
+                    try:
+                        ttype = self._interp.match(self._input, self._mode)
+                    except LexerNoViableAltException as e:
+                        self.notifyListeners(e)		# report error
+                        self.recover(e)
+                    if self._input.LA(1)==Token.EOF:
+                        self._hitEOF = True
+                    if self._type == Token.INVALID_TYPE:
+                        self._type = ttype
+                    if self._type == self.SKIP:
+                        continueOuter = True
+                        break
+                    if self._type!=self.MORE:
+                        break
+                if continueOuter:
+                    continue
+                if self._token is None:
+                    self.emit()
+                return self._token
+        finally:
+            # make sure we release marker after match or
+            # unbuffered char stream will keep buffering
+            self._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.
+    #/
+    def skip(self):
+        self._type = self.SKIP
+
+    def more(self):
+        self._type = self.MORE
+
+    def mode(self, m:int):
+        self._mode = m
+
+    def pushMode(self, m:int):
+        if self._interp.debug:
+            print("pushMode " + str(m), file=self._output)
+        self._modeStack.append(self._mode)
+        self.mode(m)
+
+    def popMode(self):
+        if len(self._modeStack)==0:
+            raise Exception("Empty Stack")
+        if self._interp.debug:
+            print("popMode back to "+ self._modeStack[:-1], file=self._output)
+        self.mode( self._modeStack.pop() )
+        return self._mode
+
+    # Set the char stream and reset the lexer#/
+    @property
+    def inputStream(self):
+        return self._input
+
+    @inputStream.setter
+    def inputStream(self, input:InputStream):
+        self._input = None
+        self._tokenFactorySourcePair = (self, self._input)
+        self.reset()
+        self._input = input
+        self._tokenFactorySourcePair = (self, self._input)
+
+    @property
+    def sourceName(self):
+        return self._input.sourceName
+
+    # By default does not support multiple emits per nextToken invocation
+    #  for efficiency reasons.  Subclass and override self method, nextToken,
+    #  and getToken (to push tokens into a list and pull from that list
+    #  rather than a single variable as self implementation does).
+    #/
+    def emitToken(self, token:Token):
+        self._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 self method to emit
+    #  custom Token objects or provide a new factory.
+    #/
+    def emit(self):
+        t = self._factory.create(self._tokenFactorySourcePair, self._type, self._text, self._channel, self._tokenStartCharIndex,
+                                 self.getCharIndex()-1, self._tokenStartLine, self._tokenStartColumn)
+        self.emitToken(t)
+        return t
+
+    def emitEOF(self):
+        cpos = self.column
+        lpos = self.line
+        eof = self._factory.create(self._tokenFactorySourcePair, Token.EOF, None, Token.DEFAULT_CHANNEL, self._input.index,
+                                   self._input.index-1, lpos, cpos)
+        self.emitToken(eof)
+        return eof
+
+    @property
+    def type(self):
+        return self._type
+
+    @type.setter
+    def type(self, type:int):
+        self._type = type
+
+    @property
+    def line(self):
+        return self._interp.line
+
+    @line.setter
+    def line(self, line:int):
+        self._interp.line = line
+
+    @property
+    def column(self):
+        return self._interp.column
+
+    @column.setter
+    def column(self, column:int):
+        self._interp.column = column
+
+    # What is the index of the current character of lookahead?#/
+    def getCharIndex(self):
+        return self._input.index
+
+    # Return the text matched so far for the current token or any
+    #  text override.
+    @property
+    def text(self):
+        if self._text is not None:
+            return self._text
+        else:
+            return self._interp.getText(self._input)
+
+    # Set the complete text of self token; it wipes any previous
+    #  changes to the text.
+    @text.setter
+    def text(self, txt:str):
+        self._text = txt
+
+    # Return a list of all Token objects in input char stream.
+    #  Forces load of all tokens. Does not include EOF token.
+    #/
+    def getAllTokens(self):
+        tokens = []
+        t = self.nextToken()
+        while t.type!=Token.EOF:
+            tokens.append(t)
+            t = self.nextToken()
+        return tokens
+
+    def notifyListeners(self, e:LexerNoViableAltException):
+        start = self._tokenStartCharIndex
+        stop = self._input.index
+        text = self._input.getText(start, stop)
+        msg = "token recognition error at: '" + self.getErrorDisplay(text) + "'"
+        listener = self.getErrorListenerDispatch()
+        listener.syntaxError(self, None, self._tokenStartLine, self._tokenStartColumn, msg, e)
+
+    def getErrorDisplay(self, s:str):
+        with StringIO() as buf:
+            for c in s:
+                buf.write(self.getErrorDisplayForChar(c))
+            return buf.getvalue()
+
+    def getErrorDisplayForChar(self, c:str):
+        if ord(c[0])==Token.EOF:
+            return "<EOF>"
+        elif c=='\n':
+            return "\\n"
+        elif c=='\t':
+            return "\\t"
+        elif c=='\r':
+            return "\\r"
+        else:
+            return c
+
+    def getCharErrorDisplay(self, c:str):
+        return "'" + self.getErrorDisplayForChar(c) + "'"
+
+    # 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.
+    #/
+    def recover(self, re:RecognitionException):
+        if self._input.LA(1) != Token.EOF:
+            if isinstance(re, LexerNoViableAltException):
+                    # skip a char and try again
+                    self._interp.consume(self._input)
+            else:
+                # TODO: Do we lose character or line position information?
+                self._input.consume()

cameras/deps/antlr4/ListTokenSource.py

@@ -0,0 +1,144 @@
+#
+# 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.
+#
+
+#
+# Provides an implementation of {@link TokenSource} as a wrapper around a list
+# of {@link Token} objects.
+#
+# <p>If the final token in the list is an {@link Token#EOF} token, it will be used
+# as the EOF token for every call to {@link #nextToken} after the end of the
+# list is reached. Otherwise, an EOF token will be created.</p>
+#
+from antlr4.CommonTokenFactory import CommonTokenFactory
+from antlr4.Lexer import TokenSource
+from antlr4.Token import Token
+
+
+class ListTokenSource(TokenSource):
+    __slots__ = ('tokens', 'sourceName', 'pos', 'eofToken', '_factory')
+
+    # Constructs a new {@link ListTokenSource} instance from the specified
+    # collection of {@link Token} objects and source name.
+    #
+    # @param tokens The collection of {@link Token} objects to provide as a
+    # {@link TokenSource}.
+    # @param sourceName The name of the {@link TokenSource}. If this value is
+    # {@code null}, {@link #getSourceName} will attempt to infer the name from
+    # the next {@link Token} (or the previous token if the end of the input has
+    # been reached).
+    #
+    # @exception NullPointerException if {@code tokens} is {@code null}
+    #
+    def __init__(self, tokens:list, sourceName:str=None):
+        if tokens is None:
+            raise ReferenceError("tokens cannot be null")
+        self.tokens = tokens
+        self.sourceName = sourceName
+        # The index into {@link #tokens} of token to return by the next call to
+        # {@link #nextToken}. The end of the input is indicated by this value
+        # being greater than or equal to the number of items in {@link #tokens}.
+        self.pos = 0
+        # This field caches the EOF token for the token source.
+        self.eofToken = None
+        # This is the backing field for {@link #getTokenFactory} and
+        self._factory = CommonTokenFactory.DEFAULT
+
+
+    #
+    # {@inheritDoc}
+    #
+    @property
+    def column(self):
+        if self.pos < len(self.tokens):
+            return self.tokens[self.pos].column
+        elif self.eofToken is not None:
+            return self.eofToken.column
+        elif len(self.tokens) > 0:
+            # have to calculate the result from the line/column of the previous
+            # token, along with the text of the token.
+            lastToken = self.tokens[len(self.tokens) - 1]
+            tokenText = lastToken.text
+            if tokenText is not None:
+                lastNewLine = tokenText.rfind('\n')
+                if lastNewLine >= 0:
+                    return len(tokenText) - lastNewLine - 1
+            return lastToken.column + lastToken.stop - lastToken.start + 1
+
+        # only reach this if tokens is empty, meaning EOF occurs at the first
+        # position in the input
+        return 0
+
+    #
+    # {@inheritDoc}
+    #
+    def nextToken(self):
+        if self.pos >= len(self.tokens):
+            if self.eofToken is None:
+                start = -1
+                if len(self.tokens) > 0:
+                    previousStop = self.tokens[len(self.tokens) - 1].stop
+                    if previousStop != -1:
+                        start = previousStop + 1
+                stop = max(-1, start - 1)
+                self.eofToken = self._factory.create((self, self.getInputStream()),
+                            Token.EOF, "EOF", Token.DEFAULT_CHANNEL, start, stop, self.line, self.column)
+            return self.eofToken
+        t = self.tokens[self.pos]
+        if self.pos == len(self.tokens) - 1 and t.type == Token.EOF:
+            self.eofToken = t
+        self.pos += 1
+        return t
+
+    #
+    # {@inheritDoc}
+    #
+    @property
+    def line(self):
+        if self.pos < len(self.tokens):
+            return self.tokens[self.pos].line
+        elif self.eofToken is not None:
+            return self.eofToken.line
+        elif len(self.tokens) > 0:
+            # have to calculate the result from the line/column of the previous
+            # token, along with the text of the token.
+            lastToken = self.tokens[len(self.tokens) - 1]
+            line = lastToken.line
+            tokenText = lastToken.text
+            if tokenText is not None:
+                line += tokenText.count('\n')
+
+            # if no text is available, assume the token did not contain any newline characters.
+            return line
+
+        # only reach this if tokens is empty, meaning EOF occurs at the first
+        # position in the input
+        return 1
+
+    #
+    # {@inheritDoc}
+    #
+    def getInputStream(self):
+        if self.pos < len(self.tokens):
+            return self.tokens[self.pos].getInputStream()
+        elif self.eofToken is not None:
+            return self.eofToken.getInputStream()
+        elif len(self.tokens) > 0:
+            return self.tokens[len(self.tokens) - 1].getInputStream()
+        else:
+            # no input stream information is available
+            return None
+
+    #
+    # {@inheritDoc}
+    #
+    def getSourceName(self):
+        if self.sourceName is not None:
+            return self.sourceName
+        inputStream = self.getInputStream()
+        if inputStream is not None:
+            return inputStream.getSourceName()
+        else:
+            return "List"

cameras/deps/antlr4/Parser.py

@@ -0,0 +1,580 @@
+#
+# 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 sys
+if sys.version_info[1] > 5:
+    from typing import TextIO
+else:
+    from typing.io import TextIO
+from antlr4.BufferedTokenStream import TokenStream
+from antlr4.CommonTokenFactory import TokenFactory
+from antlr4.error.ErrorStrategy import DefaultErrorStrategy
+from antlr4.InputStream import InputStream
+from antlr4.Recognizer import Recognizer
+from antlr4.RuleContext import RuleContext
+from antlr4.ParserRuleContext import ParserRuleContext
+from antlr4.Token import Token
+from antlr4.Lexer import Lexer
+from antlr4.atn.ATNDeserializer import ATNDeserializer
+from antlr4.atn.ATNDeserializationOptions import ATNDeserializationOptions
+from antlr4.error.Errors import UnsupportedOperationException, RecognitionException
+from antlr4.tree.ParseTreePatternMatcher import ParseTreePatternMatcher
+from antlr4.tree.Tree import ParseTreeListener, TerminalNode, ErrorNode
+
+class TraceListener(ParseTreeListener):
+    __slots__ = '_parser'
+
+    def __init__(self, parser):
+        self._parser = parser
+
+    def enterEveryRule(self, ctx):
+        print("enter   " + self._parser.ruleNames[ctx.getRuleIndex()] + ", LT(1)=" + self._parser._input.LT(1).text, file=self._parser._output)
+
+    def visitTerminal(self, node):
+
+        print("consume " + str(node.symbol) + " rule " + self._parser.ruleNames[self._parser._ctx.getRuleIndex()], file=self._parser._output)
+
+    def visitErrorNode(self, node):
+        pass
+
+
+    def exitEveryRule(self, ctx):
+        print("exit    " + self._parser.ruleNames[ctx.getRuleIndex()] + ", LT(1)=" + self._parser._input.LT(1).text, file=self._parser._output)
+
+
+# self is all the parsing support code essentially; most of it is error recovery stuff.#
+class Parser (Recognizer):
+    __slots__ = (
+        '_input', '_output', '_errHandler', '_precedenceStack', '_ctx',
+        'buildParseTrees', '_tracer', '_parseListeners', '_syntaxErrors'
+
+    )
+    # self field maps from the serialized ATN string to the deserialized {@link ATN} with
+    # bypass alternatives.
+    #
+    # @see ATNDeserializationOptions#isGenerateRuleBypassTransitions()
+    #
+    bypassAltsAtnCache = dict()
+
+    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
+        super().__init__()
+        # The input stream.
+        self._input = None
+        self._output = output
+        # The error handling strategy for the parser. The default value is a new
+        # instance of {@link DefaultErrorStrategy}.
+        self._errHandler = DefaultErrorStrategy()
+        self._precedenceStack = list()
+        self._precedenceStack.append(0)
+        # The {@link ParserRuleContext} object for the currently executing rule.
+        # self is always non-null during the parsing process.
+        self._ctx = None
+        # Specifies whether or not the parser should construct a parse tree during
+        # the parsing process. The default value is {@code true}.
+        self.buildParseTrees = True
+        # When {@link #setTrace}{@code (true)} is called, a reference to the
+        # {@link TraceListener} is stored here so it can be easily removed in a
+        # later call to {@link #setTrace}{@code (false)}. The listener itself is
+        # implemented as a parser listener so self field is not directly used by
+        # other parser methods.
+        self._tracer = None
+        # The list of {@link ParseTreeListener} listeners registered to receive
+        # events during the parse.
+        self._parseListeners = None
+        # The number of syntax errors reported during parsing. self value is
+        # incremented each time {@link #notifyErrorListeners} is called.
+        self._syntaxErrors = 0
+        self.setInputStream(input)
+
+    # reset the parser's state#
+    def reset(self):
+        if self._input is not None:
+            self._input.seek(0)
+        self._errHandler.reset(self)
+        self._ctx = None
+        self._syntaxErrors = 0
+        self.setTrace(False)
+        self._precedenceStack = list()
+        self._precedenceStack.append(0)
+        if self._interp is not None:
+            self._interp.reset()
+
+    # Match current input symbol against {@code ttype}. If the symbol type
+    # matches, {@link ANTLRErrorStrategy#reportMatch} and {@link #consume} are
+    # called to complete the match process.
+    #
+    # <p>If the symbol type does not match,
+    # {@link ANTLRErrorStrategy#recoverInline} is called on the current error
+    # strategy to attempt recovery. If {@link #getBuildParseTree} is
+    # {@code true} and the token index of the symbol returned by
+    # {@link ANTLRErrorStrategy#recoverInline} is -1, the symbol is added to
+    # the parse tree by calling {@link ParserRuleContext#addErrorNode}.</p>
+    #
+    # @param ttype the token type to match
+    # @return the matched symbol
+    # @throws RecognitionException if the current input symbol did not match
+    # {@code ttype} and the error strategy could not recover from the
+    # mismatched symbol
+
+    def match(self, ttype:int):
+        t = self.getCurrentToken()
+        if t.type==ttype:
+            self._errHandler.reportMatch(self)
+            self.consume()
+        else:
+            t = self._errHandler.recoverInline(self)
+            if self.buildParseTrees and t.tokenIndex==-1:
+                # we must have conjured up a new token during single token insertion
+                # if it's not the current symbol
+                self._ctx.addErrorNode(t)
+        return t
+
+    # Match current input symbol as a wildcard. If the symbol type matches
+    # (i.e. has a value greater than 0), {@link ANTLRErrorStrategy#reportMatch}
+    # and {@link #consume} are called to complete the match process.
+    #
+    # <p>If the symbol type does not match,
+    # {@link ANTLRErrorStrategy#recoverInline} is called on the current error
+    # strategy to attempt recovery. If {@link #getBuildParseTree} is
+    # {@code true} and the token index of the symbol returned by
+    # {@link ANTLRErrorStrategy#recoverInline} is -1, the symbol is added to
+    # the parse tree by calling {@link ParserRuleContext#addErrorNode}.</p>
+    #
+    # @return the matched symbol
+    # @throws RecognitionException if the current input symbol did not match
+    # a wildcard and the error strategy could not recover from the mismatched
+    # symbol
+
+    def matchWildcard(self):
+        t = self.getCurrentToken()
+        if t.type > 0:
+            self._errHandler.reportMatch(self)
+            self.consume()
+        else:
+            t = self._errHandler.recoverInline(self)
+            if self.buildParseTrees and t.tokenIndex == -1:
+                # we must have conjured up a new token during single token insertion
+                # if it's not the current symbol
+                self._ctx.addErrorNode(t)
+
+        return t
+
+    def getParseListeners(self):
+        return list() if self._parseListeners is None else self._parseListeners
+
+    # Registers {@code listener} to receive events during the parsing process.
+    #
+    # <p>To support output-preserving grammar transformations (including but not
+    # limited to left-recursion removal, automated left-factoring, and
+    # optimized code generation), calls to listener methods during the parse
+    # may differ substantially from calls made by
+    # {@link ParseTreeWalker#DEFAULT} used after the parse is complete. In
+    # particular, rule entry and exit events may occur in a different order
+    # during the parse than after the parser. In addition, calls to certain
+    # rule entry methods may be omitted.</p>
+    #
+    # <p>With the following specific exceptions, calls to listener events are
+    # <em>deterministic</em>, i.e. for identical input the calls to listener
+    # methods will be the same.</p>
+    #
+    # <ul>
+    # <li>Alterations to the grammar used to generate code may change the
+    # behavior of the listener calls.</li>
+    # <li>Alterations to the command line options passed to ANTLR 4 when
+    # generating the parser may change the behavior of the listener calls.</li>
+    # <li>Changing the version of the ANTLR Tool used to generate the parser
+    # may change the behavior of the listener calls.</li>
+    # </ul>
+    #
+    # @param listener the listener to add
+    #
+    # @throws NullPointerException if {@code} listener is {@code null}
+    #
+    def addParseListener(self, listener:ParseTreeListener):
+        if listener is None:
+            raise ReferenceError("listener")
+        if self._parseListeners is None:
+            self._parseListeners = []
+        self._parseListeners.append(listener)
+
+    #
+    # Remove {@code listener} from the list of parse listeners.
+    #
+    # <p>If {@code listener} is {@code null} or has not been added as a parse
+    # listener, self method does nothing.</p>
+    # @param listener the listener to remove
+    #
+    def removeParseListener(self, listener:ParseTreeListener):
+        if self._parseListeners is not None:
+            self._parseListeners.remove(listener)
+            if len(self._parseListeners)==0:
+                    self._parseListeners = None
+
+    # Remove all parse listeners.
+    def removeParseListeners(self):
+        self._parseListeners = None
+
+    # Notify any parse listeners of an enter rule event.
+    def triggerEnterRuleEvent(self):
+        if self._parseListeners is not None:
+            for listener in self._parseListeners:
+                listener.enterEveryRule(self._ctx)
+                self._ctx.enterRule(listener)
+
+    #
+    # Notify any parse listeners of an exit rule event.
+    #
+    # @see #addParseListener
+    #
+    def triggerExitRuleEvent(self):
+        if self._parseListeners is not None:
+            # reverse order walk of listeners
+            for listener in reversed(self._parseListeners):
+                self._ctx.exitRule(listener)
+                listener.exitEveryRule(self._ctx)
+
+
+    # Gets the number of syntax errors reported during parsing. This value is
+    # incremented each time {@link #notifyErrorListeners} is called.
+    #
+    # @see #notifyErrorListeners
+    #
+    def getNumberOfSyntaxErrors(self):
+        return self._syntaxErrors
+
+    def getTokenFactory(self):
+        return self._input.tokenSource._factory
+
+    # Tell our token source and error strategy about a new way to create tokens.#
+    def setTokenFactory(self, factory:TokenFactory):
+        self._input.tokenSource._factory = factory
+
+    # The ATN with bypass alternatives is expensive to create so we create it
+    # lazily.
+    #
+    # @throws UnsupportedOperationException if the current parser does not
+    # implement the {@link #getSerializedATN()} method.
+    #
+    def getATNWithBypassAlts(self):
+        serializedAtn = self.getSerializedATN()
+        if serializedAtn is None:
+            raise UnsupportedOperationException("The current parser does not support an ATN with bypass alternatives.")
+        result = self.bypassAltsAtnCache.get(serializedAtn, None)
+        if result is None:
+            deserializationOptions = ATNDeserializationOptions()
+            deserializationOptions.generateRuleBypassTransitions = True
+            result = ATNDeserializer(deserializationOptions).deserialize(serializedAtn)
+            self.bypassAltsAtnCache[serializedAtn] = result
+        return result
+
+    # The preferred method of getting a tree pattern. For example, here's a
+    # sample use:
+    #
+    # <pre>
+    # ParseTree t = parser.expr();
+    # ParseTreePattern p = parser.compileParseTreePattern("&lt;ID&gt;+0", MyParser.RULE_expr);
+    # ParseTreeMatch m = p.match(t);
+    # String id = m.get("ID");
+    # </pre>
+    #
+    def compileParseTreePattern(self, pattern:str, patternRuleIndex:int, lexer:Lexer = None):
+        if lexer is None:
+            if self.getTokenStream() is not None:
+                tokenSource = self.getTokenStream().tokenSource
+                if isinstance( tokenSource, Lexer ):
+                    lexer = tokenSource
+        if lexer is None:
+            raise UnsupportedOperationException("Parser can't discover a lexer to use")
+
+        m = ParseTreePatternMatcher(lexer, self)
+        return m.compile(pattern, patternRuleIndex)
+
+
+    def getInputStream(self):
+        return self.getTokenStream()
+
+    def setInputStream(self, input:InputStream):
+        self.setTokenStream(input)
+
+    def getTokenStream(self):
+        return self._input
+
+    # Set the token stream and reset the parser.#
+    def setTokenStream(self, input:TokenStream):
+        self._input = None
+        self.reset()
+        self._input = input
+
+    # Match needs to return the current input symbol, which gets put
+    #  into the label for the associated token ref; e.g., x=ID.
+    #
+    def getCurrentToken(self):
+        return self._input.LT(1)
+
+    def notifyErrorListeners(self, msg:str, offendingToken:Token = None, e:RecognitionException = None):
+        if offendingToken is None:
+            offendingToken = self.getCurrentToken()
+        self._syntaxErrors += 1
+        line = offendingToken.line
+        column = offendingToken.column
+        listener = self.getErrorListenerDispatch()
+        listener.syntaxError(self, offendingToken, line, column, msg, e)
+
+    #
+    # Consume and return the {@linkplain #getCurrentToken current symbol}.
+    #
+    # <p>E.g., given the following input with {@code A} being the current
+    # lookahead symbol, self function moves the cursor to {@code B} and returns
+    # {@code A}.</p>
+    #
+    # <pre>
+    #  A B
+    #  ^
+    # </pre>
+    #
+    # If the parser is not in error recovery mode, the consumed symbol is added
+    # to the parse tree using {@link ParserRuleContext#addChild(Token)}, and
+    # {@link ParseTreeListener#visitTerminal} is called on any parse listeners.
+    # If the parser <em>is</em> in error recovery mode, the consumed symbol is
+    # added to the parse tree using
+    # {@link ParserRuleContext#addErrorNode(Token)}, and
+    # {@link ParseTreeListener#visitErrorNode} is called on any parse
+    # listeners.
+    #
+    def consume(self):
+        o = self.getCurrentToken()
+        if o.type != Token.EOF:
+            self.getInputStream().consume()
+        hasListener = self._parseListeners is not None and len(self._parseListeners)>0
+        if self.buildParseTrees or hasListener:
+            if self._errHandler.inErrorRecoveryMode(self):
+                node = self._ctx.addErrorNode(o)
+            else:
+                node = self._ctx.addTokenNode(o)
+            if hasListener:
+                for listener in self._parseListeners:
+                    if isinstance(node, ErrorNode):
+                        listener.visitErrorNode(node)
+                    elif isinstance(node, TerminalNode):
+                        listener.visitTerminal(node)
+        return o
+
+    def addContextToParseTree(self):
+        # add current context to parent if we have a parent
+        if self._ctx.parentCtx is not None:
+            self._ctx.parentCtx.addChild(self._ctx)
+
+    # Always called by generated parsers upon entry to a rule. Access field
+    # {@link #_ctx} get the current context.
+    #
+    def enterRule(self, localctx:ParserRuleContext , state:int , ruleIndex:int):
+        self.state = state
+        self._ctx = localctx
+        self._ctx.start = self._input.LT(1)
+        if self.buildParseTrees:
+            self.addContextToParseTree()
+        if self._parseListeners  is not None:
+            self.triggerEnterRuleEvent()
+
+    def exitRule(self):
+        self._ctx.stop = self._input.LT(-1)
+        # trigger event on _ctx, before it reverts to parent
+        if self._parseListeners is not None:
+            self.triggerExitRuleEvent()
+        self.state = self._ctx.invokingState
+        self._ctx = self._ctx.parentCtx
+
+    def enterOuterAlt(self, localctx:ParserRuleContext, altNum:int):
+        localctx.setAltNumber(altNum)
+        # if we have new localctx, make sure we replace existing ctx
+        # that is previous child of parse tree
+        if self.buildParseTrees and self._ctx != localctx:
+            if self._ctx.parentCtx is not None:
+                self._ctx.parentCtx.removeLastChild()
+                self._ctx.parentCtx.addChild(localctx)
+        self._ctx = localctx
+
+    # Get the precedence level for the top-most precedence rule.
+    #
+    # @return The precedence level for the top-most precedence rule, or -1 if
+    # the parser context is not nested within a precedence rule.
+    #
+    def getPrecedence(self):
+        if len(self._precedenceStack)==0:
+            return -1
+        else:
+            return self._precedenceStack[-1]
+
+    def enterRecursionRule(self, localctx:ParserRuleContext, state:int, ruleIndex:int, precedence:int):
+        self.state = state
+        self._precedenceStack.append(precedence)
+        self._ctx = localctx
+        self._ctx.start = self._input.LT(1)
+        if self._parseListeners is not None:
+            self.triggerEnterRuleEvent() # simulates rule entry for left-recursive rules
+
+    #
+    # Like {@link #enterRule} but for recursive rules.
+    #
+    def pushNewRecursionContext(self, localctx:ParserRuleContext, state:int, ruleIndex:int):
+        previous = self._ctx
+        previous.parentCtx = localctx
+        previous.invokingState = state
+        previous.stop = self._input.LT(-1)
+
+        self._ctx = localctx
+        self._ctx.start = previous.start
+        if self.buildParseTrees:
+            self._ctx.addChild(previous)
+
+        if self._parseListeners is not None:
+            self.triggerEnterRuleEvent() # simulates rule entry for left-recursive rules
+
+    def unrollRecursionContexts(self, parentCtx:ParserRuleContext):
+        self._precedenceStack.pop()
+        self._ctx.stop = self._input.LT(-1)
+        retCtx = self._ctx # save current ctx (return value)
+        # unroll so _ctx is as it was before call to recursive method
+        if self._parseListeners is not None:
+            while self._ctx is not parentCtx:
+                self.triggerExitRuleEvent()
+                self._ctx = self._ctx.parentCtx
+        else:
+            self._ctx = parentCtx
+
+        # hook into tree
+        retCtx.parentCtx = parentCtx
+
+        if self.buildParseTrees and parentCtx is not None:
+            # add return ctx into invoking rule's tree
+            parentCtx.addChild(retCtx)
+
+    def getInvokingContext(self, ruleIndex:int):
+        ctx = self._ctx
+        while ctx is not None:
+            if ctx.getRuleIndex() == ruleIndex:
+                return ctx
+            ctx = ctx.parentCtx
+        return None
+
+
+    def precpred(self, localctx:RuleContext , precedence:int):
+        return precedence >= self._precedenceStack[-1]
+
+    def inContext(self, context:str):
+        # TODO: useful in parser?
+        return False
+
+    #
+    # Checks whether or not {@code symbol} can follow the current state in the
+    # ATN. The behavior of self method is equivalent to the following, but is
+    # implemented such that the complete context-sensitive follow set does not
+    # need to be explicitly constructed.
+    #
+    # <pre>
+    # return getExpectedTokens().contains(symbol);
+    # </pre>
+    #
+    # @param symbol the symbol type to check
+    # @return {@code true} if {@code symbol} can follow the current state in
+    # the ATN, otherwise {@code false}.
+    #
+    def isExpectedToken(self, symbol:int):
+        atn = self._interp.atn
+        ctx = self._ctx
+        s = atn.states[self.state]
+        following = atn.nextTokens(s)
+        if symbol in following:
+            return True
+        if not Token.EPSILON in following:
+            return False
+
+        while ctx is not None and ctx.invokingState>=0 and Token.EPSILON in following:
+            invokingState = atn.states[ctx.invokingState]
+            rt = invokingState.transitions[0]
+            following = atn.nextTokens(rt.followState)
+            if symbol in following:
+                return True
+            ctx = ctx.parentCtx
+
+        if Token.EPSILON in following and symbol == Token.EOF:
+            return True
+        else:
+            return False
+
+    # Computes the set of input symbols which could follow the current parser
+    # state and context, as given by {@link #getState} and {@link #getContext},
+    # respectively.
+    #
+    # @see ATN#getExpectedTokens(int, RuleContext)
+    #
+    def getExpectedTokens(self):
+        return self._interp.atn.getExpectedTokens(self.state, self._ctx)
+
+    def getExpectedTokensWithinCurrentRule(self):
+        atn = self._interp.atn
+        s = atn.states[self.state]
+        return atn.nextTokens(s)
+
+    # Get a rule's index (i.e., {@code RULE_ruleName} field) or -1 if not found.#
+    def getRuleIndex(self, ruleName:str):
+        ruleIndex = self.getRuleIndexMap().get(ruleName, None)
+        if ruleIndex is not None:
+            return ruleIndex
+        else:
+            return -1
+
+    # Return List&lt;String&gt; of the rule names in your parser instance
+    #  leading up to a call to the current rule.  You could override if
+    #  you want more details such as the file/line info of where
+    #  in the ATN a rule is invoked.
+    #
+    #  this is very useful for error messages.
+    #
+    def getRuleInvocationStack(self, p:RuleContext=None):
+        if p is None:
+            p = self._ctx
+        stack = list()
+        while p is not None:
+            # compute what follows who invoked us
+            ruleIndex = p.getRuleIndex()
+            if ruleIndex<0:
+                stack.append("n/a")
+            else:
+                stack.append(self.ruleNames[ruleIndex])
+            p = p.parentCtx
+        return stack
+
+    # For debugging and other purposes.#
+    def getDFAStrings(self):
+        return [ str(dfa) for dfa in self._interp.decisionToDFA]
+
+    # For debugging and other purposes.#
+    def dumpDFA(self):
+        seenOne = False
+        for i in range(0, len(self._interp.decisionToDFA)):
+            dfa = self._interp.decisionToDFA[i]
+            if len(dfa.states)>0:
+                if seenOne:
+                    print(file=self._output)
+                print("Decision " + str(dfa.decision) + ":", file=self._output)
+                print(dfa.toString(self.literalNames, self.symbolicNames), end='', file=self._output)
+                seenOne = True
+
+
+    def getSourceName(self):
+        return self._input.sourceName
+
+    # During a parse is sometimes useful to listen in on the rule entry and exit
+    #  events as well as token matches. self is for quick and dirty debugging.
+    #
+    def setTrace(self, trace:bool):
+        if not trace:
+            self.removeParseListener(self._tracer)
+            self._tracer = None
+        else:
+            if self._tracer is not None:
+                self.removeParseListener(self._tracer)
+            self._tracer = TraceListener(self)
+            self.addParseListener(self._tracer)

cameras/deps/antlr4/ParserInterpreter.py

@@ -0,0 +1,170 @@
+#
+# 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.
+#
+
+# A parser simulator that mimics what ANTLR's generated
+#  parser code does. A ParserATNSimulator is used to make
+#  predictions via adaptivePredict but this class moves a pointer through the
+#  ATN to simulate parsing. ParserATNSimulator just
+#  makes us efficient rather than having to backtrack, for example.
+#
+#  This properly creates parse trees even for left recursive rules.
+#
+#  We rely on the left recursive rule invocation and special predicate
+#  transitions to make left recursive rules work.
+#
+#  See TestParserInterpreter for examples.
+#
+from antlr4.dfa.DFA import DFA
+from antlr4.BufferedTokenStream import TokenStream
+from antlr4.Lexer import Lexer
+from antlr4.Parser import Parser
+from antlr4.ParserRuleContext import InterpreterRuleContext, ParserRuleContext
+from antlr4.Token import Token
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNState import StarLoopEntryState, ATNState, LoopEndState
+from antlr4.atn.ParserATNSimulator import ParserATNSimulator
+from antlr4.PredictionContext import PredictionContextCache
+from antlr4.atn.Transition import Transition
+from antlr4.error.Errors import RecognitionException, UnsupportedOperationException, FailedPredicateException
+
+
+class ParserInterpreter(Parser):
+    __slots__ = (
+        'grammarFileName', 'atn', 'tokenNames', 'ruleNames', 'decisionToDFA',
+        'sharedContextCache', '_parentContextStack',
+        'pushRecursionContextStates'
+    )
+
+    def __init__(self, grammarFileName:str, tokenNames:list, ruleNames:list, atn:ATN, input:TokenStream):
+        super().__init__(input)
+        self.grammarFileName = grammarFileName
+        self.atn = atn
+        self.tokenNames = tokenNames
+        self.ruleNames = ruleNames
+        self.decisionToDFA = [ DFA(state) for state in atn.decisionToState ]
+        self.sharedContextCache = PredictionContextCache()
+        self._parentContextStack = list()
+        # identify the ATN states where pushNewRecursionContext must be called
+        self.pushRecursionContextStates = set()
+        for state in atn.states:
+            if not isinstance(state, StarLoopEntryState):
+                continue
+            if state.isPrecedenceDecision:
+                self.pushRecursionContextStates.add(state.stateNumber)
+        # get atn simulator that knows how to do predictions
+        self._interp = ParserATNSimulator(self, atn, self.decisionToDFA, self.sharedContextCache)
+
+    # Begin parsing at startRuleIndex#
+    def parse(self, startRuleIndex:int):
+        startRuleStartState = self.atn.ruleToStartState[startRuleIndex]
+        rootContext = InterpreterRuleContext(None, ATNState.INVALID_STATE_NUMBER, startRuleIndex)
+        if startRuleStartState.isPrecedenceRule:
+            self.enterRecursionRule(rootContext, startRuleStartState.stateNumber, startRuleIndex, 0)
+        else:
+            self.enterRule(rootContext, startRuleStartState.stateNumber, startRuleIndex)
+        while True:
+            p = self.getATNState()
+            if p.stateType==ATNState.RULE_STOP :
+                # pop; return from rule
+                if len(self._ctx)==0:
+                    if startRuleStartState.isPrecedenceRule:
+                        result = self._ctx
+                        parentContext = self._parentContextStack.pop()
+                        self.unrollRecursionContexts(parentContext.a)
+                        return result
+                    else:
+                        self.exitRule()
+                        return rootContext
+                self.visitRuleStopState(p)
+
+            else:
+                try:
+                    self.visitState(p)
+                except RecognitionException as e:
+                    self.state = self.atn.ruleToStopState[p.ruleIndex].stateNumber
+                    self._ctx.exception = e
+                    self._errHandler.reportError(self, e)
+                    self._errHandler.recover(self, e)
+
+    def enterRecursionRule(self, localctx:ParserRuleContext, state:int, ruleIndex:int, precedence:int):
+        self._parentContextStack.append((self._ctx, localctx.invokingState))
+        super().enterRecursionRule(localctx, state, ruleIndex, precedence)
+
+    def getATNState(self):
+        return self.atn.states[self.state]
+
+    def visitState(self, p:ATNState):
+        edge = 0
+        if len(p.transitions) > 1:
+            self._errHandler.sync(self)
+            edge = self._interp.adaptivePredict(self._input, p.decision, self._ctx)
+        else:
+            edge = 1
+
+        transition = p.transitions[edge - 1]
+        tt = transition.serializationType
+        if tt==Transition.EPSILON:
+
+            if self.pushRecursionContextStates[p.stateNumber] and not isinstance(transition.target, LoopEndState):
+                t = self._parentContextStack[-1]
+                ctx = InterpreterRuleContext(t[0], t[1], self._ctx.ruleIndex)
+                self.pushNewRecursionContext(ctx, self.atn.ruleToStartState[p.ruleIndex].stateNumber, self._ctx.ruleIndex)
+
+        elif tt==Transition.ATOM:
+
+            self.match(transition.label)
+
+        elif tt in [ Transition.RANGE, Transition.SET, Transition.NOT_SET]:
+
+            if not transition.matches(self._input.LA(1), Token.MIN_USER_TOKEN_TYPE, Lexer.MAX_CHAR_VALUE):
+                self._errHandler.recoverInline(self)
+            self.matchWildcard()
+
+        elif tt==Transition.WILDCARD:
+
+            self.matchWildcard()
+
+        elif tt==Transition.RULE:
+
+            ruleStartState = transition.target
+            ruleIndex = ruleStartState.ruleIndex
+            ctx = InterpreterRuleContext(self._ctx, p.stateNumber, ruleIndex)
+            if ruleStartState.isPrecedenceRule:
+                self.enterRecursionRule(ctx, ruleStartState.stateNumber, ruleIndex, transition.precedence)
+            else:
+                self.enterRule(ctx, transition.target.stateNumber, ruleIndex)
+
+        elif tt==Transition.PREDICATE:
+
+            if not self.sempred(self._ctx, transition.ruleIndex, transition.predIndex):
+                raise FailedPredicateException(self)
+
+        elif tt==Transition.ACTION:
+
+            self.action(self._ctx, transition.ruleIndex, transition.actionIndex)
+
+        elif tt==Transition.PRECEDENCE:
+
+            if not self.precpred(self._ctx, transition.precedence):
+                msg = "precpred(_ctx, " + str(transition.precedence) + ")"
+                raise FailedPredicateException(self, msg)
+
+        else:
+            raise UnsupportedOperationException("Unrecognized ATN transition type.")
+
+        self.state = transition.target.stateNumber
+
+    def visitRuleStopState(self, p:ATNState):
+        ruleStartState = self.atn.ruleToStartState[p.ruleIndex]
+        if ruleStartState.isPrecedenceRule:
+            parentContext = self._parentContextStack.pop()
+            self.unrollRecursionContexts(parentContext.a)
+            self.state = parentContext[1]
+        else:
+            self.exitRule()
+
+        ruleTransition = self.atn.states[self.state].transitions[0]
+        self.state = ruleTransition.followState.stateNumber

cameras/deps/antlr4/ParserRuleContext.py

@@ -0,0 +1,186 @@
+# 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.
+
+#* A rule invocation record for parsing.
+#
+#  Contains all of the information about the current rule not stored in the
+#  RuleContext. It handles parse tree children list, Any ATN state
+#  tracing, and the default values available for rule indications:
+#  start, stop, rule index, current alt number, current
+#  ATN state.
+#
+#  Subclasses made for each rule and grammar track the parameters,
+#  return values, locals, and labels specific to that rule. These
+#  are the objects that are returned from rules.
+#
+#  Note text is not an actual field of a rule return value; it is computed
+#  from start and stop using the input stream's toString() method.  I
+#  could add a ctor to this so that we can pass in and store the input
+#  stream, but I'm not sure we want to do that.  It would seem to be undefined
+#  to get the .text property anyway if the rule matches tokens from multiple
+#  input streams.
+#
+#  I do not use getters for fields of objects that are used simply to
+#  group values such as this aggregate.  The getters/setters are there to
+#  satisfy the superclass interface.
+
+from antlr4.RuleContext import RuleContext
+from antlr4.Token import Token
+from antlr4.tree.Tree import ParseTreeListener, ParseTree, TerminalNodeImpl, ErrorNodeImpl, TerminalNode, \
+    INVALID_INTERVAL
+
+# need forward declaration
+ParserRuleContext = None
+
+class ParserRuleContext(RuleContext):
+    __slots__ = ('children', 'start', 'stop', 'exception')
+    def __init__(self, parent:ParserRuleContext = None, invokingStateNumber:int = None ):
+        super().__init__(parent, invokingStateNumber)
+        #* If we are debugging or building a parse tree for a visitor,
+        #  we need to track all of the tokens and rule invocations associated
+        #  with this rule's context. This is empty for parsing w/o tree constr.
+        #  operation because we don't the need to track the details about
+        #  how we parse this rule.
+        #/
+        self.children = None
+        self.start = None
+        self.stop = None
+        # The exception that forced this rule to return. If the rule successfully
+        # completed, this is {@code null}.
+        self.exception = None
+
+    #* COPY a ctx (I'm deliberately not using copy constructor)#/
+    #
+    # This is used in the generated parser code to flip a generic XContext
+    # node for rule X to a YContext for alt label Y. In that sense, it is
+    # not really a generic copy function.
+    #
+    # If we do an error sync() at start of a rule, we might add error nodes
+    # to the generic XContext so this function must copy those nodes to
+    # the YContext as well else they are lost!
+    #/
+    def copyFrom(self, ctx:ParserRuleContext):
+        # from RuleContext
+        self.parentCtx = ctx.parentCtx
+        self.invokingState = ctx.invokingState
+        self.children = None
+        self.start = ctx.start
+        self.stop = ctx.stop
+
+        # copy any error nodes to alt label node
+        if ctx.children is not None:
+            self.children = []
+            # reset parent pointer for any error nodes
+            for child in ctx.children:
+                if isinstance(child, ErrorNodeImpl):
+                    self.children.append(child)
+                    child.parentCtx = self
+
+    # Double dispatch methods for listeners
+    def enterRule(self, listener:ParseTreeListener):
+        pass
+
+    def exitRule(self, listener:ParseTreeListener):
+        pass
+
+    #* Does not set parent link; other add methods do that#/
+    def addChild(self, child:ParseTree):
+        if self.children is None:
+            self.children = []
+        self.children.append(child)
+        return child
+
+    #* Used by enterOuterAlt to toss out a RuleContext previously added as
+    #  we entered a rule. If we have # label, we will need to remove
+    #  generic ruleContext object.
+    #/
+    def removeLastChild(self):
+        if self.children is not None:
+            del self.children[len(self.children)-1]
+
+    def addTokenNode(self, token:Token):
+        node = TerminalNodeImpl(token)
+        self.addChild(node)
+        node.parentCtx = self
+        return node
+
+    def addErrorNode(self, badToken:Token):
+        node = ErrorNodeImpl(badToken)
+        self.addChild(node)
+        node.parentCtx = self
+        return node
+
+    def getChild(self, i:int, ttype:type = None):
+        if ttype is None:
+            return self.children[i] if len(self.children)>i else None
+        else:
+            for child in self.getChildren():
+                if not isinstance(child, ttype):
+                    continue
+                if i==0:
+                    return child
+                i -= 1
+            return None
+
+    def getChildren(self, predicate = None):
+        if self.children is not None:
+            for child in self.children:
+                if predicate is not None and not predicate(child):
+                    continue
+                yield child
+
+    def getToken(self, ttype:int, i:int):
+        for child in self.getChildren():
+            if not isinstance(child, TerminalNode):
+                continue
+            if child.symbol.type != ttype:
+                continue
+            if i==0:
+                return child
+            i -= 1
+        return None
+
+    def getTokens(self, ttype:int ):
+        if self.getChildren() is None:
+            return []
+        tokens = []
+        for child in self.getChildren():
+            if not isinstance(child, TerminalNode):
+                continue
+            if child.symbol.type != ttype:
+                continue
+            tokens.append(child)
+        return tokens
+
+    def getTypedRuleContext(self, ctxType:type, i:int):
+        return self.getChild(i, ctxType)
+
+    def getTypedRuleContexts(self, ctxType:type):
+        children = self.getChildren()
+        if children is None:
+            return []
+        contexts = []
+        for child in children:
+            if not isinstance(child, ctxType):
+                continue
+            contexts.append(child)
+        return contexts
+
+    def getChildCount(self):
+        return len(self.children) if self.children else 0
+
+    def getSourceInterval(self):
+        if self.start is None or self.stop is None:
+            return INVALID_INTERVAL
+        else:
+            return (self.start.tokenIndex, self.stop.tokenIndex)
+
+
+RuleContext.EMPTY = ParserRuleContext()
+
+class InterpreterRuleContext(ParserRuleContext):
+
+    def __init__(self, parent:ParserRuleContext, invokingStateNumber:int, ruleIndex:int):
+        super().__init__(parent, invokingStateNumber)
+        self.ruleIndex = ruleIndex

cameras/deps/antlr4/PredictionContext.py

@@ -0,0 +1,623 @@
+#
+# 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.
+#/
+from io import StringIO
+
+from antlr4.error.Errors import IllegalStateException
+
+from antlr4.RuleContext import RuleContext
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNState import ATNState
+
+
+class PredictionContext(object):
+
+    # Represents {@code $} in local context prediction, which means wildcard.
+    # {@code#+x =#}.
+    #/
+    EMPTY = None
+
+    # Represents {@code $} in an array in full context mode, when {@code $}
+    # doesn't mean wildcard: {@code $ + x = [$,x]}. Here,
+    # {@code $} = {@link #EMPTY_RETURN_STATE}.
+    #/
+    EMPTY_RETURN_STATE = 0x7FFFFFFF
+
+    globalNodeCount = 1
+    id = globalNodeCount
+
+    # Stores the computed hash code of this {@link PredictionContext}. The hash
+    # code is computed in parts to match the following reference algorithm.
+    #
+    # <pre>
+    #  private int referenceHashCode() {
+    #      int hash = {@link MurmurHash#initialize MurmurHash.initialize}({@link #INITIAL_HASH});
+    #
+    #      for (int i = 0; i &lt; {@link #size()}; i++) {
+    #          hash = {@link MurmurHash#update MurmurHash.update}(hash, {@link #getParent getParent}(i));
+    #      }
+    #
+    #      for (int i = 0; i &lt; {@link #size()}; i++) {
+    #          hash = {@link MurmurHash#update MurmurHash.update}(hash, {@link #getReturnState getReturnState}(i));
+    #      }
+    #
+    #      hash = {@link MurmurHash#finish MurmurHash.finish}(hash, 2# {@link #size()});
+    #      return hash;
+    #  }
+    # </pre>
+    #/
+
+    def __init__(self, cachedHashCode:int):
+        self.cachedHashCode = cachedHashCode
+
+    def __len__(self):
+        return 0
+
+    # This means only the {@link #EMPTY} context is in set.
+    def isEmpty(self):
+        return self is self.EMPTY
+
+    def hasEmptyPath(self):
+        return self.getReturnState(len(self) - 1) == self.EMPTY_RETURN_STATE
+
+    def getReturnState(self, index:int):
+        raise IllegalStateException("illegal!")
+
+    def __hash__(self):
+        return self.cachedHashCode
+
+def calculateHashCode(parent:PredictionContext, returnState:int):
+    return hash("") if parent is None else hash((hash(parent), returnState))
+
+def calculateListsHashCode(parents:[], returnStates:[] ):
+    h = 0
+    for parent, returnState in zip(parents, returnStates):
+        h = hash((h, calculateHashCode(parent, returnState)))
+    return h
+
+#  Used to cache {@link PredictionContext} objects. Its used for the shared
+#  context cash associated with contexts in DFA states. This cache
+#  can be used for both lexers and parsers.
+
+class PredictionContextCache(object):
+
+    def __init__(self):
+        self.cache = dict()
+
+    #  Add a context to the cache and return it. If the context already exists,
+    #  return that one instead and do not add a new context to the cache.
+    #  Protect shared cache from unsafe thread access.
+    #
+    def add(self, ctx:PredictionContext):
+        if ctx==PredictionContext.EMPTY:
+            return PredictionContext.EMPTY
+        existing = self.cache.get(ctx, None)
+        if existing is not None:
+            return existing
+        self.cache[ctx] = ctx
+        return ctx
+
+    def get(self, ctx:PredictionContext):
+        return self.cache.get(ctx, None)
+
+    def __len__(self):
+        return len(self.cache)
+
+
+class SingletonPredictionContext(PredictionContext):
+
+    @staticmethod
+    def create(parent:PredictionContext , returnState:int ):
+        if returnState == PredictionContext.EMPTY_RETURN_STATE and parent is None:
+            # someone can pass in the bits of an array ctx that mean $
+            return SingletonPredictionContext.EMPTY
+        else:
+            return SingletonPredictionContext(parent, returnState)
+
+    def __init__(self, parent:PredictionContext, returnState:int):
+        hashCode = calculateHashCode(parent, returnState)
+        super().__init__(hashCode)
+        self.parentCtx = parent
+        self.returnState = returnState
+
+    def __len__(self):
+        return 1
+
+    def getParent(self, index:int):
+        return self.parentCtx
+
+    def getReturnState(self, index:int):
+        return self.returnState
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif other is None:
+            return False
+        elif not isinstance(other, SingletonPredictionContext):
+            return False
+        else:
+            return self.returnState == other.returnState and self.parentCtx == other.parentCtx
+
+    def __hash__(self):
+        return self.cachedHashCode
+
+    def __str__(self):
+        up = "" if self.parentCtx is None else str(self.parentCtx)
+        if len(up)==0:
+            if self.returnState == self.EMPTY_RETURN_STATE:
+                return "$"
+            else:
+                return str(self.returnState)
+        else:
+            return str(self.returnState) + " " + up
+
+
+class EmptyPredictionContext(SingletonPredictionContext):
+
+    def __init__(self):
+        super().__init__(None, PredictionContext.EMPTY_RETURN_STATE)
+
+    def isEmpty(self):
+        return True
+
+    def __eq__(self, other):
+        return self is other
+
+    def __hash__(self):
+        return self.cachedHashCode
+
+    def __str__(self):
+        return "$"
+
+
+PredictionContext.EMPTY = EmptyPredictionContext()
+
+class ArrayPredictionContext(PredictionContext):
+    # Parent can be null only if full ctx mode and we make an array
+    #  from {@link #EMPTY} and non-empty. We merge {@link #EMPTY} by using null parent and
+    #  returnState == {@link #EMPTY_RETURN_STATE}.
+
+    def __init__(self, parents:list, returnStates:list):
+        super().__init__(calculateListsHashCode(parents, returnStates))
+        self.parents = parents
+        self.returnStates = returnStates
+
+    def isEmpty(self):
+        # since EMPTY_RETURN_STATE can only appear in the last position, we
+        # don't need to verify that size==1
+        return self.returnStates[0]==PredictionContext.EMPTY_RETURN_STATE
+
+    def __len__(self):
+        return len(self.returnStates)
+
+    def getParent(self, index:int):
+        return self.parents[index]
+
+    def getReturnState(self, index:int):
+        return self.returnStates[index]
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, ArrayPredictionContext):
+            return False
+        elif hash(self) != hash(other):
+            return False # can't be same if hash is different
+        else:
+            return self.returnStates==other.returnStates and self.parents==other.parents
+
+    def __str__(self):
+        if self.isEmpty():
+            return "[]"
+        with StringIO() as buf:
+            buf.write("[")
+            for i in range(0,len(self.returnStates)):
+                if i>0:
+                    buf.write(", ")
+                if self.returnStates[i]==PredictionContext.EMPTY_RETURN_STATE:
+                    buf.write("$")
+                    continue
+                buf.write(str(self.returnStates[i]))
+                if self.parents[i] is not None:
+                    buf.write(' ')
+                    buf.write(str(self.parents[i]))
+                else:
+                    buf.write("null")
+            buf.write("]")
+            return buf.getvalue()
+
+    def __hash__(self):
+        return self.cachedHashCode
+
+
+
+#  Convert a {@link RuleContext} tree to a {@link PredictionContext} graph.
+#  Return {@link #EMPTY} if {@code outerContext} is empty or null.
+#/
+def PredictionContextFromRuleContext(atn:ATN, outerContext:RuleContext=None):
+    if outerContext is None:
+        outerContext = RuleContext.EMPTY
+
+    # if we are in RuleContext of start rule, s, then PredictionContext
+    # is EMPTY. Nobody called us. (if we are empty, return empty)
+    if outerContext.parentCtx is None or outerContext is RuleContext.EMPTY:
+        return PredictionContext.EMPTY
+
+    # If we have a parent, convert it to a PredictionContext graph
+    parent = PredictionContextFromRuleContext(atn, outerContext.parentCtx)
+    state = atn.states[outerContext.invokingState]
+    transition = state.transitions[0]
+    return SingletonPredictionContext.create(parent, transition.followState.stateNumber)
+
+
+def merge(a:PredictionContext, b:PredictionContext, rootIsWildcard:bool, mergeCache:dict):
+
+    # share same graph if both same
+    if a==b:
+        return a
+
+    if isinstance(a, SingletonPredictionContext) and isinstance(b, SingletonPredictionContext):
+        return mergeSingletons(a, b, rootIsWildcard, mergeCache)
+
+    # At least one of a or b is array
+    # If one is $ and rootIsWildcard, return $ as# wildcard
+    if rootIsWildcard:
+        if isinstance( a, EmptyPredictionContext ):
+            return a
+        if isinstance( b, EmptyPredictionContext ):
+            return b
+
+    # convert singleton so both are arrays to normalize
+    if isinstance( a, SingletonPredictionContext ):
+        a = ArrayPredictionContext([a.parentCtx], [a.returnState])
+    if isinstance( b, SingletonPredictionContext):
+        b = ArrayPredictionContext([b.parentCtx], [b.returnState])
+    return mergeArrays(a, b, rootIsWildcard, mergeCache)
+
+
+#
+# Merge two {@link SingletonPredictionContext} instances.
+#
+# <p>Stack tops equal, parents merge is same; return left graph.<br>
+# <embed src="images/SingletonMerge_SameRootSamePar.svg" type="image/svg+xml"/></p>
+#
+# <p>Same stack top, parents differ; merge parents giving array node, then
+# remainders of those graphs. A new root node is created to point to the
+# merged parents.<br>
+# <embed src="images/SingletonMerge_SameRootDiffPar.svg" type="image/svg+xml"/></p>
+#
+# <p>Different stack tops pointing to same parent. Make array node for the
+# root where both element in the root point to the same (original)
+# parent.<br>
+# <embed src="images/SingletonMerge_DiffRootSamePar.svg" type="image/svg+xml"/></p>
+#
+# <p>Different stack tops pointing to different parents. Make array node for
+# the root where each element points to the corresponding original
+# parent.<br>
+# <embed src="images/SingletonMerge_DiffRootDiffPar.svg" type="image/svg+xml"/></p>
+#
+# @param a the first {@link SingletonPredictionContext}
+# @param b the second {@link SingletonPredictionContext}
+# @param rootIsWildcard {@code true} if this is a local-context merge,
+# otherwise false to indicate a full-context merge
+# @param mergeCache
+#/
+def mergeSingletons(a:SingletonPredictionContext, b:SingletonPredictionContext, rootIsWildcard:bool, mergeCache:dict):
+    if mergeCache is not None:
+        previous = mergeCache.get((a,b), None)
+        if previous is not None:
+            return previous
+        previous = mergeCache.get((b,a), None)
+        if previous is not None:
+            return previous
+
+    merged = mergeRoot(a, b, rootIsWildcard)
+    if merged is not None:
+        if mergeCache is not None:
+            mergeCache[(a, b)] = merged
+        return merged
+
+    if a.returnState==b.returnState:
+        parent = merge(a.parentCtx, b.parentCtx, rootIsWildcard, mergeCache)
+        # if parent is same as existing a or b parent or reduced to a parent, return it
+        if parent == a.parentCtx:
+            return a # ax + bx = ax, if a=b
+        if parent == b.parentCtx:
+            return b # ax + bx = bx, if a=b
+        # else: ax + ay = a'[x,y]
+        # merge parents x and y, giving array node with x,y then remainders
+        # of those graphs.  dup a, a' points at merged array
+        # new joined parent so create new singleton pointing to it, a'
+        merged = SingletonPredictionContext.create(parent, a.returnState)
+        if mergeCache is not None:
+            mergeCache[(a, b)] = merged
+        return merged
+    else: # a != b payloads differ
+        # see if we can collapse parents due to $+x parents if local ctx
+        singleParent = None
+        if a is b or (a.parentCtx is not None and a.parentCtx==b.parentCtx): # ax + bx = [a,b]x
+            singleParent = a.parentCtx
+        if singleParent is not None:	# parents are same
+            # sort payloads and use same parent
+            payloads = [ a.returnState, b.returnState ]
+            if a.returnState > b.returnState:
+                payloads = [ b.returnState, a.returnState ]
+            parents = [singleParent, singleParent]
+            merged = ArrayPredictionContext(parents, payloads)
+            if mergeCache is not None:
+                mergeCache[(a, b)] = merged
+            return merged
+        # parents differ and can't merge them. Just pack together
+        # into array; can't merge.
+        # ax + by = [ax,by]
+        payloads = [ a.returnState, b.returnState ]
+        parents = [ a.parentCtx, b.parentCtx ]
+        if a.returnState > b.returnState: # sort by payload
+            payloads = [ b.returnState, a.returnState ]
+            parents = [ b.parentCtx, a.parentCtx ]
+        merged = ArrayPredictionContext(parents, payloads)
+        if mergeCache is not None:
+            mergeCache[(a, b)] = merged
+        return merged
+
+
+#
+# Handle case where at least one of {@code a} or {@code b} is
+# {@link #EMPTY}. In the following diagrams, the symbol {@code $} is used
+# to represent {@link #EMPTY}.
+#
+# <h2>Local-Context Merges</h2>
+#
+# <p>These local-context merge operations are used when {@code rootIsWildcard}
+# is true.</p>
+#
+# <p>{@link #EMPTY} is superset of any graph; return {@link #EMPTY}.<br>
+# <embed src="images/LocalMerge_EmptyRoot.svg" type="image/svg+xml"/></p>
+#
+# <p>{@link #EMPTY} and anything is {@code #EMPTY}, so merged parent is
+# {@code #EMPTY}; return left graph.<br>
+# <embed src="images/LocalMerge_EmptyParent.svg" type="image/svg+xml"/></p>
+#
+# <p>Special case of last merge if local context.<br>
+# <embed src="images/LocalMerge_DiffRoots.svg" type="image/svg+xml"/></p>
+#
+# <h2>Full-Context Merges</h2>
+#
+# <p>These full-context merge operations are used when {@code rootIsWildcard}
+# is false.</p>
+#
+# <p><embed src="images/FullMerge_EmptyRoots.svg" type="image/svg+xml"/></p>
+#
+# <p>Must keep all contexts; {@link #EMPTY} in array is a special value (and
+# null parent).<br>
+# <embed src="images/FullMerge_EmptyRoot.svg" type="image/svg+xml"/></p>
+#
+# <p><embed src="images/FullMerge_SameRoot.svg" type="image/svg+xml"/></p>
+#
+# @param a the first {@link SingletonPredictionContext}
+# @param b the second {@link SingletonPredictionContext}
+# @param rootIsWildcard {@code true} if this is a local-context merge,
+# otherwise false to indicate a full-context merge
+#/
+def mergeRoot(a:SingletonPredictionContext, b:SingletonPredictionContext, rootIsWildcard:bool):
+    if rootIsWildcard:
+        if a == PredictionContext.EMPTY:
+            return PredictionContext.EMPTY  ## + b =#
+        if b == PredictionContext.EMPTY:
+            return PredictionContext.EMPTY  # a +# =#
+    else:
+        if a == PredictionContext.EMPTY and b == PredictionContext.EMPTY:
+            return PredictionContext.EMPTY # $ + $ = $
+        elif a == PredictionContext.EMPTY: # $ + x = [$,x]
+            payloads = [ b.returnState, PredictionContext.EMPTY_RETURN_STATE ]
+            parents = [ b.parentCtx, None ]
+            return ArrayPredictionContext(parents, payloads)
+        elif b == PredictionContext.EMPTY: # x + $ = [$,x] ($ is always first if present)
+            payloads = [ a.returnState, PredictionContext.EMPTY_RETURN_STATE ]
+            parents = [ a.parentCtx, None ]
+            return ArrayPredictionContext(parents, payloads)
+    return None
+
+
+#
+# Merge two {@link ArrayPredictionContext} instances.
+#
+# <p>Different tops, different parents.<br>
+# <embed src="images/ArrayMerge_DiffTopDiffPar.svg" type="image/svg+xml"/></p>
+#
+# <p>Shared top, same parents.<br>
+# <embed src="images/ArrayMerge_ShareTopSamePar.svg" type="image/svg+xml"/></p>
+#
+# <p>Shared top, different parents.<br>
+# <embed src="images/ArrayMerge_ShareTopDiffPar.svg" type="image/svg+xml"/></p>
+#
+# <p>Shared top, all shared parents.<br>
+# <embed src="images/ArrayMerge_ShareTopSharePar.svg" type="image/svg+xml"/></p>
+#
+# <p>Equal tops, merge parents and reduce top to
+# {@link SingletonPredictionContext}.<br>
+# <embed src="images/ArrayMerge_EqualTop.svg" type="image/svg+xml"/></p>
+#/
+def mergeArrays(a:ArrayPredictionContext, b:ArrayPredictionContext, rootIsWildcard:bool, mergeCache:dict):
+    if mergeCache is not None:
+        previous = mergeCache.get((a,b), None)
+        if previous is not None:
+            return previous
+        previous = mergeCache.get((b,a), None)
+        if previous is not None:
+            return previous
+
+    # merge sorted payloads a + b => M
+    i = 0 # walks a
+    j = 0 # walks b
+    k = 0 # walks target M array
+
+    mergedReturnStates = [None] * (len(a.returnStates) + len( b.returnStates))
+    mergedParents = [None] * len(mergedReturnStates)
+    # walk and merge to yield mergedParents, mergedReturnStates
+    while i<len(a.returnStates) and j<len(b.returnStates):
+        a_parent = a.parents[i]
+        b_parent = b.parents[j]
+        if a.returnStates[i]==b.returnStates[j]:
+            # same payload (stack tops are equal), must yield merged singleton
+            payload = a.returnStates[i]
+            # $+$ = $
+            bothDollars = payload == PredictionContext.EMPTY_RETURN_STATE and \
+                            a_parent is None and b_parent is None
+            ax_ax = (a_parent is not None and b_parent is not None) and a_parent==b_parent # ax+ax -> ax
+            if bothDollars or ax_ax:
+                mergedParents[k] = a_parent # choose left
+                mergedReturnStates[k] = payload
+            else: # ax+ay -> a'[x,y]
+                mergedParent = merge(a_parent, b_parent, rootIsWildcard, mergeCache)
+                mergedParents[k] = mergedParent
+                mergedReturnStates[k] = payload
+            i += 1 # hop over left one as usual
+            j += 1 # but also skip one in right side since we merge
+        elif a.returnStates[i]<b.returnStates[j]: # copy a[i] to M
+            mergedParents[k] = a_parent
+            mergedReturnStates[k] = a.returnStates[i]
+            i += 1
+        else: # b > a, copy b[j] to M
+            mergedParents[k] = b_parent
+            mergedReturnStates[k] = b.returnStates[j]
+            j += 1
+        k += 1
+
+    # copy over any payloads remaining in either array
+    if i < len(a.returnStates):
+        for p in range(i, len(a.returnStates)):
+            mergedParents[k] = a.parents[p]
+            mergedReturnStates[k] = a.returnStates[p]
+            k += 1
+    else:
+        for p in range(j, len(b.returnStates)):
+            mergedParents[k] = b.parents[p]
+            mergedReturnStates[k] = b.returnStates[p]
+            k += 1
+
+    # trim merged if we combined a few that had same stack tops
+    if k < len(mergedParents): # write index < last position; trim
+        if k == 1: # for just one merged element, return singleton top
+            merged = SingletonPredictionContext.create(mergedParents[0], mergedReturnStates[0])
+            if mergeCache is not None:
+                mergeCache[(a,b)] = merged
+            return merged
+        mergedParents = mergedParents[0:k]
+        mergedReturnStates = mergedReturnStates[0:k]
+
+    merged = ArrayPredictionContext(mergedParents, mergedReturnStates)
+
+    # if we created same array as a or b, return that instead
+    # TODO: track whether this is possible above during merge sort for speed
+    if merged==a:
+        if mergeCache is not None:
+            mergeCache[(a,b)] = a
+        return a
+    if merged==b:
+        if mergeCache is not None:
+            mergeCache[(a,b)] = b
+        return b
+    combineCommonParents(mergedParents)
+
+    if mergeCache is not None:
+        mergeCache[(a,b)] = merged
+    return merged
+
+
+#
+# Make pass over all <em>M</em> {@code parents}; merge any {@code equals()}
+# ones.
+#/
+def combineCommonParents(parents:list):
+    uniqueParents = dict()
+
+    for p in range(0, len(parents)):
+        parent = parents[p]
+        if uniqueParents.get(parent, None) is None:
+            uniqueParents[parent] = parent
+
+    for p in range(0, len(parents)):
+        parents[p] = uniqueParents[parents[p]]
+
+def getCachedPredictionContext(context:PredictionContext, contextCache:PredictionContextCache, visited:dict):
+    if context.isEmpty():
+        return context
+    existing = visited.get(context)
+    if existing is not None:
+        return existing
+    existing = contextCache.get(context)
+    if existing is not None:
+        visited[context] = existing
+        return existing
+    changed = False
+    parents = [None] * len(context)
+    for i in range(0, len(parents)):
+        parent = getCachedPredictionContext(context.getParent(i), contextCache, visited)
+        if changed or parent is not context.getParent(i):
+            if not changed:
+                parents = [context.getParent(j) for j in range(len(context))]
+                changed = True
+            parents[i] = parent
+    if not changed:
+        contextCache.add(context)
+        visited[context] = context
+        return context
+
+    updated = None
+    if len(parents) == 0:
+        updated = PredictionContext.EMPTY
+    elif len(parents) == 1:
+        updated = SingletonPredictionContext.create(parents[0], context.getReturnState(0))
+    else:
+        updated = ArrayPredictionContext(parents, context.returnStates)
+
+    contextCache.add(updated)
+    visited[updated] = updated
+    visited[context] = updated
+
+    return updated
+
+
+#	# extra structures, but cut/paste/morphed works, so leave it.
+#	# seems to do a breadth-first walk
+#	public static List<PredictionContext> getAllNodes(PredictionContext context) {
+#		Map<PredictionContext, PredictionContext> visited =
+#			new IdentityHashMap<PredictionContext, PredictionContext>();
+#		Deque<PredictionContext> workList = new ArrayDeque<PredictionContext>();
+#		workList.add(context);
+#		visited.put(context, context);
+#		List<PredictionContext> nodes = new ArrayList<PredictionContext>();
+#		while (!workList.isEmpty()) {
+#			PredictionContext current = workList.pop();
+#			nodes.add(current);
+#			for (int i = 0; i < current.size(); i++) {
+#				PredictionContext parent = current.getParent(i);
+#				if ( parent!=null && visited.put(parent, parent) == null) {
+#					workList.push(parent);
+#				}
+#			}
+#		}
+#		return nodes;
+#	}
+
+# ter's recursive version of Sam's getAllNodes()
+def getAllContextNodes(context:PredictionContext, nodes:list=None, visited:dict=None):
+    if nodes is None:
+        nodes = list()
+        return getAllContextNodes(context, nodes, visited)
+    elif visited is None:
+        visited = dict()
+        return getAllContextNodes(context, nodes, visited)
+    else:
+        if context is None or visited.get(context, None) is not None:
+            return nodes
+        visited.put(context, context)
+        nodes.add(context)
+        for i in range(0, len(context)):
+            getAllContextNodes(context.getParent(i), nodes, visited)
+        return nodes
+

cameras/deps/antlr4/Recognizer.py

@@ -0,0 +1,147 @@
+#
+# 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.
+#
+from antlr4.RuleContext import RuleContext
+from antlr4.Token import Token
+from antlr4.error.ErrorListener import ProxyErrorListener, ConsoleErrorListener
+
+# need forward delcaration
+RecognitionException = None
+
+class Recognizer(object):
+    __slots__ = ('_listeners', '_interp', '_stateNumber')
+
+    tokenTypeMapCache = dict()
+    ruleIndexMapCache = dict()
+
+    def __init__(self):
+        self._listeners = [ ConsoleErrorListener.INSTANCE ]
+        self._interp = None
+        self._stateNumber = -1
+
+    def extractVersion(self, version):
+        pos = version.find(".")
+        major = version[0:pos]
+        version = version[pos+1:]
+        pos = version.find(".")
+        if pos==-1:
+            pos = version.find("-")
+        if pos==-1:
+            pos = len(version)
+        minor = version[0:pos]
+        return major, minor
+
+    def checkVersion(self, toolVersion):
+        runtimeVersion = "4.9.3"
+        rvmajor, rvminor = self.extractVersion(runtimeVersion)
+        tvmajor, tvminor = self.extractVersion(toolVersion)
+        if rvmajor!=tvmajor or rvminor!=tvminor:
+            print("ANTLR runtime and generated code versions disagree: "+runtimeVersion+"!="+toolVersion)
+
+    def addErrorListener(self, listener):
+        self._listeners.append(listener)
+
+    def removeErrorListener(self, listener):
+        self._listeners.remove(listener)
+
+    def removeErrorListeners(self):
+        self._listeners = []
+
+    def getTokenTypeMap(self):
+        tokenNames = self.getTokenNames()
+        if tokenNames is None:
+            from antlr4.error.Errors import UnsupportedOperationException
+            raise UnsupportedOperationException("The current recognizer does not provide a list of token names.")
+        result = self.tokenTypeMapCache.get(tokenNames, None)
+        if result is None:
+            result = zip( tokenNames, range(0, len(tokenNames)))
+            result["EOF"] = Token.EOF
+            self.tokenTypeMapCache[tokenNames] = result
+        return result
+
+    # Get a map from rule names to rule indexes.
+    #
+    # <p>Used for XPath and tree pattern compilation.</p>
+    #
+    def getRuleIndexMap(self):
+        ruleNames = self.getRuleNames()
+        if ruleNames is None:
+            from antlr4.error.Errors import UnsupportedOperationException
+            raise UnsupportedOperationException("The current recognizer does not provide a list of rule names.")
+        result = self.ruleIndexMapCache.get(ruleNames, None)
+        if result is None:
+            result = zip( ruleNames, range(0, len(ruleNames)))
+            self.ruleIndexMapCache[ruleNames] = result
+        return result
+
+    def getTokenType(self, tokenName:str):
+        ttype = self.getTokenTypeMap().get(tokenName, None)
+        if ttype is not None:
+            return ttype
+        else:
+            return Token.INVALID_TYPE
+
+
+    # What is the error header, normally line/character position information?#
+    def getErrorHeader(self, e:RecognitionException):
+        line = e.getOffendingToken().line
+        column = e.getOffendingToken().column
+        return "line "+line+":"+column
+
+
+    # How should a token be displayed in an error message? The default
+    #  is to display just the text, but during development you might
+    #  want to have a lot of information spit out.  Override in that case
+    #  to use t.toString() (which, for CommonToken, dumps everything about
+    #  the token). This is better than forcing you to override a method in
+    #  your token objects because you don't have to go modify your lexer
+    #  so that it creates a new Java type.
+    #
+    # @deprecated This method is not called by the ANTLR 4 Runtime. Specific
+    # implementations of {@link ANTLRErrorStrategy} may provide a similar
+    # feature when necessary. For example, see
+    # {@link DefaultErrorStrategy#getTokenErrorDisplay}.
+    #
+    def getTokenErrorDisplay(self, t:Token):
+        if t is None:
+            return "<no token>"
+        s = t.text
+        if s is None:
+            if t.type==Token.EOF:
+                s = "<EOF>"
+            else:
+                s = "<" + str(t.type) + ">"
+        s = s.replace("\n","\\n")
+        s = s.replace("\r","\\r")
+        s = s.replace("\t","\\t")
+        return "'" + s + "'"
+
+    def getErrorListenerDispatch(self):
+        return ProxyErrorListener(self._listeners)
+
+    # subclass needs to override these if there are sempreds or actions
+    # that the ATN interp needs to execute
+    def sempred(self, localctx:RuleContext, ruleIndex:int, actionIndex:int):
+        return True
+
+    def precpred(self, localctx:RuleContext , precedence:int):
+        return True
+
+    @property
+    def state(self):
+        return self._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.
+
+    @state.setter
+    def state(self, atnState:int):
+        self._stateNumber = atnState
+
+del RecognitionException

cameras/deps/antlr4/RuleContext.py

@@ -0,0 +1,227 @@
+# 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.
+#/
+
+
+#  A rule context is a record of a single rule invocation. It knows
+#  which context invoked it, if any. If there is no parent context, then
+#  naturally the invoking state is not valid.  The parent link
+#  provides a chain upwards from the current rule invocation to the root
+#  of the invocation tree, forming a stack. We actually carry no
+#  information about the rule associated with this context (except
+#  when parsing). We keep only the state number of the invoking state from
+#  the ATN submachine that invoked this. Contrast this with the s
+#  pointer inside ParserRuleContext that tracks the current state
+#  being "executed" for the current rule.
+#
+#  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
+#/
+from io import StringIO
+from antlr4.tree.Tree import RuleNode, INVALID_INTERVAL, ParseTreeVisitor
+from antlr4.tree.Trees import Trees
+
+# need forward declarations
+RuleContext = None
+Parser = None
+
+class RuleContext(RuleNode):
+    __slots__ = ('parentCtx', 'invokingState')
+    EMPTY = None
+
+    def __init__(self, parent:RuleContext=None, invokingState:int=-1):
+        super().__init__()
+        # What context invoked this rule?
+        self.parentCtx = 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.
+        self.invokingState = invokingState
+
+
+    def depth(self):
+        n = 0
+        p = self
+        while p is not None:
+            p = p.parentCtx
+            n += 1
+        return n
+
+    # A context is empty if there is no invoking state; meaning nobody call
+    #  current context.
+    def isEmpty(self):
+        return self.invokingState == -1
+
+    # satisfy the ParseTree / SyntaxTree interface
+
+    def getSourceInterval(self):
+        return INVALID_INTERVAL
+
+    def getRuleContext(self):
+        return self
+
+    def getPayload(self):
+        return self
+
+   # 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.
+    #/
+    def getText(self):
+        if self.getChildCount() == 0:
+            return ""
+        with StringIO() as builder:
+            for child in self.getChildren():
+                builder.write(child.getText())
+            return builder.getvalue()
+
+    def getRuleIndex(self):
+        return -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.
+    def getAltNumber(self):
+        return 0 # should use ATN.INVALID_ALT_NUMBER but won't compile
+
+    # 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.
+    def setAltNumber(self, altNumber:int):
+        pass
+
+    def getChild(self, i:int):
+        return None
+
+    def getChildCount(self):
+        return 0
+
+    def getChildren(self):
+        for c in []:
+            yield c
+
+    def accept(self, visitor:ParseTreeVisitor):
+        return visitor.visitChildren(self)
+
+   # # Call this method to view a parse tree in a dialog box visually.#/
+   #  public Future<JDialog> inspect(@Nullable Parser parser) {
+   #      List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
+   #      return inspect(ruleNames);
+   #  }
+   #
+   #  public Future<JDialog> inspect(@Nullable List<String> ruleNames) {
+   #      TreeViewer viewer = new TreeViewer(ruleNames, this);
+   #      return viewer.open();
+   #  }
+   #
+   # # Save this tree in a postscript file#/
+   #  public void save(@Nullable Parser parser, String fileName)
+   #      throws IOException, PrintException
+   #  {
+   #      List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
+   #      save(ruleNames, fileName);
+   #  }
+   #
+   # # Save this tree in a postscript file using a particular font name and size#/
+   #  public void save(@Nullable Parser parser, String fileName,
+   #                   String fontName, int fontSize)
+   #      throws IOException
+   #  {
+   #      List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
+   #      save(ruleNames, fileName, fontName, fontSize);
+   #  }
+   #
+   # # Save this tree in a postscript file#/
+   #  public void save(@Nullable List<String> ruleNames, String fileName)
+   #      throws IOException, PrintException
+   #  {
+   #      Trees.writePS(this, ruleNames, fileName);
+   #  }
+   #
+   # # Save this tree in a postscript file using a particular font name and size#/
+   #  public void save(@Nullable List<String> ruleNames, String fileName,
+   #                   String fontName, int fontSize)
+   #      throws IOException
+   #  {
+   #      Trees.writePS(this, ruleNames, fileName, fontName, fontSize);
+   #  }
+   #
+   # # Print out a whole tree, not just a node, in LISP format
+   #  #  (root child1 .. childN). Print just a node if this is a leaf.
+   #  #  We have to know the recognizer so we can get rule names.
+   #  #/
+   #  @Override
+   #  public String toStringTree(@Nullable Parser recog) {
+   #      return Trees.toStringTree(this, recog);
+   #  }
+   #
+   # Print out a whole tree, not just a node, in LISP format
+   #  (root child1 .. childN). Print just a node if this is a leaf.
+   #
+    def toStringTree(self, ruleNames:list=None, recog:Parser=None):
+        return Trees.toStringTree(self, ruleNames=ruleNames, recog=recog)
+   #  }
+   #
+   #  @Override
+   #  public String toStringTree() {
+   #      return toStringTree((List<String>)null);
+   #  }
+   #
+    def __str__(self):
+        return self.toString(None, None)
+
+   #  @Override
+   #  public String toString() {
+   #      return toString((List<String>)null, (RuleContext)null);
+   #  }
+   #
+   #  public final String toString(@Nullable Recognizer<?,?> recog) {
+   #      return toString(recog, ParserRuleContext.EMPTY);
+   #  }
+   #
+   #  public final String toString(@Nullable List<String> ruleNames) {
+   #      return toString(ruleNames, null);
+   #  }
+   #
+   #  // recog null unless ParserRuleContext, in which case we use subclass toString(...)
+   #  public String toString(@Nullable Recognizer<?,?> recog, @Nullable RuleContext stop) {
+   #      String[] ruleNames = recog != null ? recog.getRuleNames() : null;
+   #      List<String> ruleNamesList = ruleNames != null ? Arrays.asList(ruleNames) : null;
+   #      return toString(ruleNamesList, stop);
+   #  }
+
+    def toString(self, ruleNames:list, stop:RuleContext)->str:
+        with StringIO() as buf:
+            p = self
+            buf.write("[")
+            while p is not None and p is not stop:
+                if ruleNames is None:
+                    if not p.isEmpty():
+                        buf.write(str(p.invokingState))
+                else:
+                    ri = p.getRuleIndex()
+                    ruleName = ruleNames[ri] if ri >= 0 and ri < len(ruleNames) else str(ri)
+                    buf.write(ruleName)
+
+                if p.parentCtx is not None and (ruleNames is not None or not p.parentCtx.isEmpty()):
+                    buf.write(" ")
+
+                p = p.parentCtx
+
+            buf.write("]")
+            return buf.getvalue()

cameras/deps/antlr4/StdinStream.py

@@ -0,0 +1,11 @@
+import codecs
+import sys
+
+from antlr4.InputStream import InputStream
+
+
+class StdinStream(InputStream):
+    def __init__(self, encoding:str='ascii', errors:str='strict') -> None:
+        bytes = sys.stdin.buffer.read()
+        data = codecs.decode(bytes, encoding, errors)
+        super().__init__(data)

cameras/deps/antlr4/Token.py

@@ -0,0 +1,155 @@
+# 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.
+#
+
+# A token has properties: text, type, line, character position in the line
+# (so we can ignore tabs), token channel, index, and source from which
+# we obtained this token.
+from io import StringIO
+
+
+class Token (object):
+    __slots__ = ('source', 'type', 'channel', 'start', 'stop', 'tokenIndex', 'line', 'column', '_text')
+
+    INVALID_TYPE = 0
+
+    # During lookahead operations, this "token" signifies we hit rule end ATN state
+    # and did not follow it despite needing to.
+    EPSILON = -2
+
+    MIN_USER_TOKEN_TYPE = 1
+
+    EOF = -1
+
+    # All tokens go to the parser (unless skip() is called in that rule)
+    # on a particular "channel".  The parser tunes to a particular channel
+    # so that whitespace etc... can go to the parser on a "hidden" channel.
+
+    DEFAULT_CHANNEL = 0
+
+    # Anything on different channel than DEFAULT_CHANNEL is not parsed
+    # by parser.
+
+    HIDDEN_CHANNEL = 1
+
+    def __init__(self):
+        self.source = None
+        self.type = None # token type of the token
+        self.channel = None # The parser ignores everything not on DEFAULT_CHANNEL
+        self.start = None # optional; return -1 if not implemented.
+        self.stop = None  # optional; return -1 if not implemented.
+        self.tokenIndex = None # from 0..n-1 of the token object in the input stream
+        self.line = None # line=1..n of the 1st character
+        self.column = None # beginning of the line at which it occurs, 0..n-1
+        self._text = None # text of the token.
+
+    @property
+    def text(self):
+        return self._text
+
+    # Explicitly set the text for this token. If {code text} is not
+    # {@code null}, then {@link #getText} will return this value rather than
+    # extracting the text from the input.
+    #
+    # @param text The explicit text of the token, or {@code null} if the text
+    # should be obtained from the input along with the start and stop indexes
+    # of the token.
+
+    @text.setter
+    def text(self, text:str):
+        self._text = text
+
+
+    def getTokenSource(self):
+        return self.source[0]
+
+    def getInputStream(self):
+        return self.source[1]
+
+class CommonToken(Token):
+
+    # An empty {@link Pair} which is used as the default value of
+    # {@link #source} for tokens that do not have a source.
+    EMPTY_SOURCE = (None, None)
+
+    def __init__(self, source:tuple = EMPTY_SOURCE, type:int = None, channel:int=Token.DEFAULT_CHANNEL, start:int=-1, stop:int=-1):
+        super().__init__()
+        self.source = source
+        self.type = type
+        self.channel = channel
+        self.start = start
+        self.stop = stop
+        self.tokenIndex = -1
+        if source[0] is not None:
+            self.line = source[0].line
+            self.column = source[0].column
+        else:
+            self.column = -1
+
+    # Constructs a new {@link CommonToken} as a copy of another {@link Token}.
+    #
+    # <p>
+    # If {@code oldToken} is also a {@link CommonToken} instance, the newly
+    # constructed token will share a reference to the {@link #text} field and
+    # the {@link Pair} stored in {@link #source}. Otherwise, {@link #text} will
+    # be assigned the result of calling {@link #getText}, and {@link #source}
+    # will be constructed from the result of {@link Token#getTokenSource} and
+    # {@link Token#getInputStream}.</p>
+    #
+    # @param oldToken The token to copy.
+     #
+    def clone(self):
+        t = CommonToken(self.source, self.type, self.channel, self.start, self.stop)
+        t.tokenIndex = self.tokenIndex
+        t.line = self.line
+        t.column = self.column
+        t.text = self.text
+        return t
+
+    @property
+    def text(self):
+        if self._text is not None:
+            return self._text
+        input = self.getInputStream()
+        if input is None:
+            return None
+        n = input.size
+        if self.start < n and self.stop < n:
+            return input.getText(self.start, self.stop)
+        else:
+            return "<EOF>"
+
+    @text.setter
+    def text(self, text:str):
+        self._text = text
+
+    def __str__(self):
+        with StringIO() as buf:
+            buf.write("[@")
+            buf.write(str(self.tokenIndex))
+            buf.write(",")
+            buf.write(str(self.start))
+            buf.write(":")
+            buf.write(str(self.stop))
+            buf.write("='")
+            txt = self.text
+            if txt is not None:
+                txt = txt.replace("\n","\\n")
+                txt = txt.replace("\r","\\r")
+                txt = txt.replace("\t","\\t")
+            else:
+                txt = "<no text>"
+            buf.write(txt)
+            buf.write("',<")
+            buf.write(str(self.type))
+            buf.write(">")
+            if self.channel > 0:
+                buf.write(",channel=")
+                buf.write(str(self.channel))
+            buf.write(",")
+            buf.write(str(self.line))
+            buf.write(":")
+            buf.write(str(self.column))
+            buf.write("]")
+            return buf.getvalue()

cameras/deps/antlr4/TokenStreamRewriter.py

@@ -0,0 +1,255 @@
+#
+# 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.
+#
+
+from io import StringIO
+from antlr4.Token import Token
+
+from antlr4.CommonTokenStream import CommonTokenStream
+
+
+class TokenStreamRewriter(object):
+    __slots__ = ('tokens', 'programs', 'lastRewriteTokenIndexes')
+
+    DEFAULT_PROGRAM_NAME = "default"
+    PROGRAM_INIT_SIZE = 100
+    MIN_TOKEN_INDEX = 0
+
+    def __init__(self, tokens):
+        """
+        :type  tokens: antlr4.BufferedTokenStream.BufferedTokenStream
+        :param tokens:
+        :return:
+        """
+        super(TokenStreamRewriter, self).__init__()
+        self.tokens = tokens
+        self.programs = {self.DEFAULT_PROGRAM_NAME: []}
+        self.lastRewriteTokenIndexes = {}
+
+    def getTokenStream(self):
+        return self.tokens
+
+    def rollback(self, instruction_index, program_name):
+        ins = self.programs.get(program_name, None)
+        if ins:
+            self.programs[program_name] = ins[self.MIN_TOKEN_INDEX: instruction_index]
+
+    def deleteProgram(self, program_name=DEFAULT_PROGRAM_NAME):
+        self.rollback(self.MIN_TOKEN_INDEX, program_name)
+
+    def insertAfterToken(self, token, text, program_name=DEFAULT_PROGRAM_NAME):
+        self.insertAfter(token.tokenIndex, text, program_name)
+
+    def insertAfter(self, index, text, program_name=DEFAULT_PROGRAM_NAME):
+        op = self.InsertAfterOp(self.tokens, index + 1, text)
+        rewrites = self.getProgram(program_name)
+        op.instructionIndex = len(rewrites)
+        rewrites.append(op)
+
+    def insertBeforeIndex(self, index, text):
+        self.insertBefore(self.DEFAULT_PROGRAM_NAME, index, text)
+
+    def insertBeforeToken(self, token, text, program_name=DEFAULT_PROGRAM_NAME):
+        self.insertBefore(program_name, token.tokenIndex, text)
+
+    def insertBefore(self, program_name, index, text):
+        op = self.InsertBeforeOp(self.tokens, index, text)
+        rewrites = self.getProgram(program_name)
+        op.instructionIndex = len(rewrites)
+        rewrites.append(op)
+
+    def replaceIndex(self, index, text):
+        self.replace(self.DEFAULT_PROGRAM_NAME, index, index, text)
+
+    def replaceRange(self, from_idx, to_idx, text):
+        self.replace(self.DEFAULT_PROGRAM_NAME, from_idx, to_idx, text)
+
+    def replaceSingleToken(self, token, text):
+        self.replace(self.DEFAULT_PROGRAM_NAME, token.tokenIndex, token.tokenIndex, text)
+
+    def replaceRangeTokens(self, from_token, to_token, text, program_name=DEFAULT_PROGRAM_NAME):
+        self.replace(program_name, from_token.tokenIndex, to_token.tokenIndex, text)
+
+    def replace(self, program_name, from_idx, to_idx, text):
+        if any((from_idx > to_idx, from_idx < 0, to_idx < 0, to_idx >= len(self.tokens.tokens))):
+            raise ValueError(
+                'replace: range invalid: {}..{}(size={})'.format(from_idx, to_idx, len(self.tokens.tokens)))
+        op = self.ReplaceOp(from_idx, to_idx, self.tokens, text)
+        rewrites = self.getProgram(program_name)
+        op.instructionIndex = len(rewrites)
+        rewrites.append(op)
+
+    def deleteToken(self, token):
+        self.delete(self.DEFAULT_PROGRAM_NAME, token, token)
+
+    def deleteIndex(self, index):
+        self.delete(self.DEFAULT_PROGRAM_NAME, index, index)
+
+    def delete(self, program_name, from_idx, to_idx):
+        if isinstance(from_idx, Token):
+            self.replace(program_name, from_idx.tokenIndex, to_idx.tokenIndex, "")
+        else:
+            self.replace(program_name, from_idx, to_idx, "")
+
+    def lastRewriteTokenIndex(self, program_name=DEFAULT_PROGRAM_NAME):
+        return self.lastRewriteTokenIndexes.get(program_name, -1)
+
+    def setLastRewriteTokenIndex(self, program_name, i):
+        self.lastRewriteTokenIndexes[program_name] = i
+
+    def getProgram(self, program_name):
+        return self.programs.setdefault(program_name, [])
+
+    def getDefaultText(self):
+        return self.getText(self.DEFAULT_PROGRAM_NAME, 0, len(self.tokens.tokens) - 1)
+
+    def getText(self, program_name, start:int, stop:int):
+        """
+        :return: the text in tokens[start, stop](closed interval)
+        """
+        rewrites = self.programs.get(program_name)
+
+        # ensure start/end are in range
+        if stop > len(self.tokens.tokens) - 1:
+            stop = len(self.tokens.tokens) - 1
+        if start < 0:
+            start = 0
+
+        # if no instructions to execute
+        if not rewrites: return self.tokens.getText(start, stop)
+        buf = StringIO()
+        indexToOp = self._reduceToSingleOperationPerIndex(rewrites)
+        i = start
+        while all((i <= stop, i < len(self.tokens.tokens))):
+            op = indexToOp.pop(i, None)
+            token = self.tokens.get(i)
+            if op is None:
+                if token.type != Token.EOF: buf.write(token.text)
+                i += 1
+            else:
+                i = op.execute(buf)
+
+        if stop == len(self.tokens.tokens)-1:
+            for op in indexToOp.values():
+                if op.index >= len(self.tokens.tokens)-1: buf.write(op.text)
+
+        return buf.getvalue()
+
+    def _reduceToSingleOperationPerIndex(self, rewrites):
+        # Walk replaces
+        for i, rop in enumerate(rewrites):
+            if any((rop is None, not isinstance(rop, TokenStreamRewriter.ReplaceOp))):
+                continue
+            # Wipe prior inserts within range
+            inserts = [op for op in rewrites[:i] if isinstance(op, TokenStreamRewriter.InsertBeforeOp)]
+            for iop in inserts:
+                if iop.index == rop.index:
+                    rewrites[iop.instructionIndex] = None
+                    rop.text = '{}{}'.format(iop.text, rop.text)
+                elif all((iop.index > rop.index, iop.index <= rop.last_index)):
+                    rewrites[iop.instructionIndex] = None
+
+            # Drop any prior replaces contained within
+            prevReplaces = [op for op in rewrites[:i] if isinstance(op, TokenStreamRewriter.ReplaceOp)]
+            for prevRop in prevReplaces:
+                if all((prevRop.index >= rop.index, prevRop.last_index <= rop.last_index)):
+                    rewrites[prevRop.instructionIndex] = None
+                    continue
+                isDisjoint = any((prevRop.last_index<rop.index, prevRop.index>rop.last_index))
+                if all((prevRop.text is None, rop.text is None, not isDisjoint)):
+                    rewrites[prevRop.instructionIndex] = None
+                    rop.index = min(prevRop.index, rop.index)
+                    rop.last_index = min(prevRop.last_index, rop.last_index)
+                    print('New rop {}'.format(rop))
+                elif (not(isDisjoint)):
+                    raise ValueError("replace op boundaries of {} overlap with previous {}".format(rop, prevRop))
+
+        # Walk inserts
+        for i, iop in enumerate(rewrites):
+            if any((iop is None, not isinstance(iop, TokenStreamRewriter.InsertBeforeOp))):
+                continue
+            prevInserts = [op for op in rewrites[:i] if isinstance(op, TokenStreamRewriter.InsertBeforeOp)]
+            for prev_index, prevIop in enumerate(prevInserts):
+                if prevIop.index == iop.index and type(prevIop) is TokenStreamRewriter.InsertBeforeOp:
+                    iop.text += prevIop.text
+                    rewrites[prev_index] = None
+                elif prevIop.index == iop.index and type(prevIop) is TokenStreamRewriter.InsertAfterOp:
+                    iop.text = prevIop.text + iop.text
+                    rewrites[prev_index] = None
+            # look for replaces where iop.index is in range; error
+            prevReplaces = [op for op in rewrites[:i] if isinstance(op, TokenStreamRewriter.ReplaceOp)]
+            for rop in prevReplaces:
+                if iop.index == rop.index:
+                    rop.text = iop.text + rop.text
+                    rewrites[i] = None
+                    continue
+                if all((iop.index >= rop.index, iop.index <= rop.last_index)):
+                    raise ValueError("insert op {} within boundaries of previous {}".format(iop, rop))
+
+        reduced = {}
+        for i, op in enumerate(rewrites):
+            if op is None: continue
+            if reduced.get(op.index): raise ValueError('should be only one op per index')
+            reduced[op.index] = op
+
+        return reduced
+
+    class RewriteOperation(object):
+        __slots__ = ('tokens', 'index', 'text', 'instructionIndex')
+
+        def __init__(self, tokens, index, text=""):
+            """
+            :type tokens: CommonTokenStream
+            :param tokens:
+            :param index:
+            :param text:
+            :return:
+            """
+            self.tokens = tokens
+            self.index = index
+            self.text = text
+            self.instructionIndex = 0
+
+        def execute(self, buf):
+            """
+            :type buf: StringIO.StringIO
+            :param buf:
+            :return:
+            """
+            return self.index
+
+        def __str__(self):
+            return '<{}@{}:"{}">'.format(self.__class__.__name__, self.tokens.get(self.index), self.text)
+
+    class InsertBeforeOp(RewriteOperation):
+
+        def __init__(self, tokens, index, text=""):
+            super(TokenStreamRewriter.InsertBeforeOp, self).__init__(tokens, index, text)
+
+        def execute(self, buf):
+            buf.write(self.text)
+            if self.tokens.get(self.index).type != Token.EOF:
+                buf.write(self.tokens.get(self.index).text)
+            return self.index + 1
+
+    class InsertAfterOp(InsertBeforeOp):
+        pass
+
+    class ReplaceOp(RewriteOperation):
+        __slots__ = 'last_index'
+
+        def __init__(self, from_idx, to_idx, tokens, text):
+            super(TokenStreamRewriter.ReplaceOp, self).__init__(tokens, from_idx, text)
+            self.last_index = to_idx
+
+        def execute(self, buf):
+            if self.text:
+                buf.write(self.text)
+            return self.last_index + 1
+
+        def __str__(self):
+            if self.text:
+                return '<ReplaceOp@{}..{}:"{}">'.format(self.tokens.get(self.index), self.tokens.get(self.last_index),
+                                                        self.text)

cameras/deps/antlr4/Utils.py

@@ -0,0 +1,33 @@
+# 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.
+#
+
+from io import StringIO
+
+def str_list(val):
+    with StringIO() as buf:
+        buf.write('[')
+        first = True
+        for item in val:
+            if not first:
+                buf.write(', ')
+            buf.write(str(item))
+            first = False
+        buf.write(']')
+        return buf.getvalue()
+
+def escapeWhitespace(s:str, escapeSpaces:bool):
+    with StringIO() as buf:
+        for c in s:
+            if c==' ' and escapeSpaces:
+                buf.write('\u00B7')
+            elif c=='\t':
+                buf.write("\\t")
+            elif c=='\n':
+                buf.write("\\n")
+            elif c=='\r':
+                buf.write("\\r")
+            else:
+                buf.write(c)
+        return buf.getvalue()

cameras/deps/antlr4/__init__.py

@@ -0,0 +1,21 @@
+from antlr4.Token import Token
+from antlr4.InputStream import InputStream
+from antlr4.FileStream import FileStream
+from antlr4.StdinStream import StdinStream
+from antlr4.BufferedTokenStream import TokenStream
+from antlr4.CommonTokenStream import CommonTokenStream
+from antlr4.Lexer import Lexer
+from antlr4.Parser import Parser
+from antlr4.dfa.DFA import DFA
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNDeserializer import ATNDeserializer
+from antlr4.atn.LexerATNSimulator import LexerATNSimulator
+from antlr4.atn.ParserATNSimulator import ParserATNSimulator
+from antlr4.atn.PredictionMode import PredictionMode
+from antlr4.PredictionContext import PredictionContextCache
+from antlr4.ParserRuleContext import RuleContext, ParserRuleContext
+from antlr4.tree.Tree import ParseTreeListener, ParseTreeVisitor, ParseTreeWalker, TerminalNode, ErrorNode, RuleNode
+from antlr4.error.Errors import RecognitionException, IllegalStateException, NoViableAltException
+from antlr4.error.ErrorStrategy import BailErrorStrategy
+from antlr4.error.DiagnosticErrorListener import DiagnosticErrorListener
+from antlr4.Utils import str_list

cameras/deps/antlr4/atn/ATN.py

@@ -0,0 +1,132 @@
+# 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.
+#/
+from antlr4.IntervalSet import IntervalSet
+
+from antlr4.RuleContext import RuleContext
+
+from antlr4.Token import Token
+from antlr4.atn.ATNType import ATNType
+from antlr4.atn.ATNState import ATNState, DecisionState
+
+
+class ATN(object):
+    __slots__ = (
+        'grammarType', 'maxTokenType', 'states', 'decisionToState',
+        'ruleToStartState', 'ruleToStopState', 'modeNameToStartState',
+        'ruleToTokenType', 'lexerActions', 'modeToStartState'
+    )
+
+    INVALID_ALT_NUMBER = 0
+
+    # Used for runtime deserialization of ATNs from strings#/
+    def __init__(self, grammarType:ATNType , maxTokenType:int ):
+        # The type of the ATN.
+        self.grammarType = grammarType
+        # The maximum value for any symbol recognized by a transition in the ATN.
+        self.maxTokenType = maxTokenType
+        self.states = []
+        # Each subrule/rule is a decision point and we must track them so we
+        #  can go back later and build DFA predictors for them.  This includes
+        #  all the rules, subrules, optional blocks, ()+, ()* etc...
+        self.decisionToState = []
+        # Maps from rule index to starting state number.
+        self.ruleToStartState = []
+        # Maps from rule index to stop state number.
+        self.ruleToStopState = None
+        self.modeNameToStartState = dict()
+        # For lexer ATNs, this maps the rule index to the resulting token type.
+        # For parser ATNs, this maps the rule index to the generated bypass token
+        # type if the
+        # {@link ATNDeserializationOptions#isGenerateRuleBypassTransitions}
+        # deserialization option was specified; otherwise, this is {@code null}.
+        self.ruleToTokenType = None
+        # For lexer ATNs, this is an array of {@link LexerAction} objects which may
+        # be referenced by action transitions in the ATN.
+        self.lexerActions = None
+        self.modeToStartState = []
+
+    # Compute the set of valid tokens that can occur starting in state {@code s}.
+    #  If {@code ctx} is null, the set of tokens will not include what can follow
+    #  the rule surrounding {@code s}. In other words, the set will be
+    #  restricted to tokens reachable staying within {@code s}'s rule.
+    def nextTokensInContext(self, s:ATNState, ctx:RuleContext):
+        from antlr4.LL1Analyzer import LL1Analyzer
+        anal = LL1Analyzer(self)
+        return anal.LOOK(s, ctx=ctx)
+
+    # Compute the set of valid tokens that can occur starting in {@code s} and
+    # staying in same rule. {@link Token#EPSILON} is in set if we reach end of
+    # rule.
+    def nextTokensNoContext(self, s:ATNState):
+        if s.nextTokenWithinRule is not None:
+            return s.nextTokenWithinRule
+        s.nextTokenWithinRule = self.nextTokensInContext(s, None)
+        s.nextTokenWithinRule.readonly = True
+        return s.nextTokenWithinRule
+
+    def nextTokens(self, s:ATNState, ctx:RuleContext = None):
+        if ctx==None:
+            return self.nextTokensNoContext(s)
+        else:
+            return self.nextTokensInContext(s, ctx)
+
+    def addState(self, state:ATNState):
+        if state is not None:
+            state.atn = self
+            state.stateNumber = len(self.states)
+        self.states.append(state)
+
+    def removeState(self, state:ATNState):
+        self.states[state.stateNumber] = None # just free mem, don't shift states in list
+
+    def defineDecisionState(self, s:DecisionState):
+        self.decisionToState.append(s)
+        s.decision = len(self.decisionToState)-1
+        return s.decision
+
+    def getDecisionState(self, decision:int):
+        if len(self.decisionToState)==0:
+            return None
+        else:
+            return self.decisionToState[decision]
+
+    # Computes the set of input symbols which could follow ATN state number
+    # {@code stateNumber} in the specified full {@code context}. This method
+    # considers the complete parser context, but does not evaluate semantic
+    # predicates (i.e. all predicates encountered during the calculation are
+    # assumed true). If a path in the ATN exists from the starting state to the
+    # {@link RuleStopState} of the outermost context without matching any
+    # symbols, {@link Token#EOF} is added to the returned set.
+    #
+    # <p>If {@code context} is {@code null}, it is treated as
+    # {@link ParserRuleContext#EMPTY}.</p>
+    #
+    # @param stateNumber the ATN state number
+    # @param context the full parse context
+    # @return The set of potentially valid input symbols which could follow the
+    # specified state in the specified context.
+    # @throws IllegalArgumentException if the ATN does not contain a state with
+    # number {@code stateNumber}
+    #/
+    def getExpectedTokens(self, stateNumber:int, ctx:RuleContext ):
+        if stateNumber < 0 or stateNumber >= len(self.states):
+            raise Exception("Invalid state number.")
+        s = self.states[stateNumber]
+        following = self.nextTokens(s)
+        if Token.EPSILON not in following:
+            return following
+        expected = IntervalSet()
+        expected.addSet(following)
+        expected.removeOne(Token.EPSILON)
+        while (ctx != None and ctx.invokingState >= 0 and Token.EPSILON in following):
+            invokingState = self.states[ctx.invokingState]
+            rt = invokingState.transitions[0]
+            following = self.nextTokens(rt.followState)
+            expected.addSet(following)
+            expected.removeOne(Token.EPSILON)
+            ctx = ctx.parentCtx
+        if Token.EPSILON in following:
+            expected.addOne(Token.EOF)
+        return expected

cameras/deps/antlr4/atn/ATNConfig.py

@@ -0,0 +1,159 @@
+#
+# 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.
+#/
+
+# A tuple: (ATN state, predicted alt, syntactic, semantic context).
+#  The syntactic context is a graph-structured stack node whose
+#  path(s) to the root is the rule invocation(s)
+#  chain used to arrive at the state.  The semantic context is
+#  the tree of semantic predicates encountered before reaching
+#  an ATN state.
+#/
+from io import StringIO
+from antlr4.PredictionContext import PredictionContext
+from antlr4.atn.ATNState import ATNState, DecisionState
+from antlr4.atn.LexerActionExecutor import LexerActionExecutor
+from antlr4.atn.SemanticContext import SemanticContext
+
+# need a forward declaration
+ATNConfig = None
+
+class ATNConfig(object):
+    __slots__ = (
+        'state', 'alt', 'context', 'semanticContext', 'reachesIntoOuterContext',
+        'precedenceFilterSuppressed'
+    )
+
+    def __init__(self, state:ATNState=None, alt:int=None, context:PredictionContext=None, semantic:SemanticContext=None, config:ATNConfig=None):
+        if config is not None:
+            if state is None:
+                state = config.state
+            if alt is None:
+                alt = config.alt
+            if context is None:
+                context = config.context
+            if semantic is None:
+                semantic = config.semanticContext
+        if semantic is None:
+            semantic = SemanticContext.NONE
+        # The ATN state associated with this configuration#/
+        self.state = state
+        # What alt (or lexer rule) is predicted by this configuration#/
+        self.alt = alt
+        # The stack of invoking states leading to the rule/states associated
+        #  with this config.  We track only those contexts pushed during
+        #  execution of the ATN simulator.
+        self.context = context
+        self.semanticContext = semantic
+        # We cannot execute predicates dependent upon local context unless
+        # we know for sure we are in the correct context. Because there is
+        # no way to do this efficiently, we simply cannot evaluate
+        # dependent predicates unless we are in the rule that initially
+        # invokes the ATN simulator.
+        #
+        # closure() tracks the depth of how far we dip into the
+        # outer context: depth > 0.  Note that it may not be totally
+        # accurate depth since I don't ever decrement. TODO: make it a boolean then
+        self.reachesIntoOuterContext = 0 if config is None else config.reachesIntoOuterContext
+        self.precedenceFilterSuppressed = False if config is None else config.precedenceFilterSuppressed
+
+    # An ATN configuration is equal to another if both have
+    #  the same state, they predict the same alternative, and
+    #  syntactic/semantic contexts are the same.
+    #/
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, ATNConfig):
+            return False
+        else:
+            return self.state.stateNumber==other.state.stateNumber \
+                and self.alt==other.alt \
+                and ((self.context is other.context) or (self.context==other.context)) \
+                and self.semanticContext==other.semanticContext \
+                and self.precedenceFilterSuppressed==other.precedenceFilterSuppressed
+
+    def __hash__(self):
+        return hash((self.state.stateNumber, self.alt, self.context, self.semanticContext))
+
+    def hashCodeForConfigSet(self):
+        return hash((self.state.stateNumber, self.alt, hash(self.semanticContext)))
+
+    def equalsForConfigSet(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, ATNConfig):
+            return False
+        else:
+            return self.state.stateNumber==other.state.stateNumber \
+                and self.alt==other.alt \
+                and self.semanticContext==other.semanticContext
+
+    def __str__(self):
+        with StringIO() as buf:
+            buf.write('(')
+            buf.write(str(self.state))
+            buf.write(",")
+            buf.write(str(self.alt))
+            if self.context is not None:
+                buf.write(",[")
+                buf.write(str(self.context))
+                buf.write("]")
+            if self.semanticContext is not None and self.semanticContext is not SemanticContext.NONE:
+                buf.write(",")
+                buf.write(str(self.semanticContext))
+            if self.reachesIntoOuterContext>0:
+                buf.write(",up=")
+                buf.write(str(self.reachesIntoOuterContext))
+            buf.write(')')
+            return buf.getvalue()
+
+# need a forward declaration
+LexerATNConfig = None
+
+class LexerATNConfig(ATNConfig):
+    __slots__ = ('lexerActionExecutor', 'passedThroughNonGreedyDecision')
+
+    def __init__(self, state:ATNState, alt:int=None, context:PredictionContext=None, semantic:SemanticContext=SemanticContext.NONE,
+                 lexerActionExecutor:LexerActionExecutor=None, config:LexerATNConfig=None):
+        super().__init__(state=state, alt=alt, context=context, semantic=semantic, config=config)
+        if config is not None:
+            if lexerActionExecutor is None:
+                lexerActionExecutor = config.lexerActionExecutor
+        # This is the backing field for {@link #getLexerActionExecutor}.
+        self.lexerActionExecutor = lexerActionExecutor
+        self.passedThroughNonGreedyDecision = False if config is None else self.checkNonGreedyDecision(config, state)
+
+    def __hash__(self):
+        return hash((self.state.stateNumber, self.alt, self.context,
+                self.semanticContext, self.passedThroughNonGreedyDecision,
+                self.lexerActionExecutor))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerATNConfig):
+            return False
+        if self.passedThroughNonGreedyDecision != other.passedThroughNonGreedyDecision:
+            return False
+        if not(self.lexerActionExecutor == other.lexerActionExecutor):
+            return False
+        return super().__eq__(other)
+
+
+
+    def hashCodeForConfigSet(self):
+        return hash(self)
+
+
+
+    def equalsForConfigSet(self, other):
+        return self==other
+
+
+
+    def checkNonGreedyDecision(self, source:LexerATNConfig, target:ATNState):
+        return source.passedThroughNonGreedyDecision \
+            or isinstance(target, DecisionState) and target.nonGreedy

cameras/deps/antlr4/atn/ATNConfigSet.py

@@ -0,0 +1,212 @@
+#
+# 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.
+
+#
+# Specialized {@link Set}{@code <}{@link ATNConfig}{@code >} that can track
+# info about the set, with support for combining similar configurations using a
+# graph-structured stack.
+#/
+from io import StringIO
+from functools import reduce
+from antlr4.PredictionContext import PredictionContext, merge
+from antlr4.Utils import str_list
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNConfig import ATNConfig
+from antlr4.atn.SemanticContext import SemanticContext
+from antlr4.error.Errors import UnsupportedOperationException, IllegalStateException
+
+ATNSimulator = None
+
+class ATNConfigSet(object):
+    __slots__ = (
+        'configLookup', 'fullCtx', 'readonly', 'configs', 'uniqueAlt',
+        'conflictingAlts', 'hasSemanticContext', 'dipsIntoOuterContext',
+        'cachedHashCode'
+    )
+
+    #
+    # The reason that we need this is because we don't want the hash map to use
+    # the standard hash code and equals. We need all configurations with the same
+    # {@code (s,i,_,semctx)} to be equal. Unfortunately, this key effectively doubles
+    # the number of objects associated with ATNConfigs. The other solution is to
+    # use a hash table that lets us specify the equals/hashcode operation.
+
+    def __init__(self, fullCtx:bool=True):
+        # All configs but hashed by (s, i, _, pi) not including context. Wiped out
+        # when we go readonly as this set becomes a DFA state.
+        self.configLookup = dict()
+        # Indicates that this configuration set is part of a full context
+        #  LL prediction. It will be used to determine how to merge $. With SLL
+        #  it's a wildcard whereas it is not for LL context merge.
+        self.fullCtx = fullCtx
+        # Indicates that the set of configurations is read-only. Do not
+        #  allow any code to manipulate the set; DFA states will point at
+        #  the sets and they must not change. This does not protect the other
+        #  fields; in particular, conflictingAlts is set after
+        #  we've made this readonly.
+        self.readonly = False
+        # Track the elements as they are added to the set; supports get(i)#/
+        self.configs = []
+
+        # TODO: these fields make me pretty uncomfortable but nice to pack up info together, saves recomputation
+        # TODO: can we track conflicts as they are added to save scanning configs later?
+        self.uniqueAlt = 0
+        self.conflictingAlts = None
+
+        # Used in parser and lexer. In lexer, it indicates we hit a pred
+        # while computing a closure operation.  Don't make a DFA state from this.
+        self.hasSemanticContext = False
+        self.dipsIntoOuterContext = False
+
+        self.cachedHashCode = -1
+
+    def __iter__(self):
+        return self.configs.__iter__()
+
+    # Adding a new config means merging contexts with existing configs for
+    # {@code (s, i, pi, _)}, where {@code s} is the
+    # {@link ATNConfig#state}, {@code i} is the {@link ATNConfig#alt}, and
+    # {@code pi} is the {@link ATNConfig#semanticContext}. We use
+    # {@code (s,i,pi)} as key.
+    #
+    # <p>This method updates {@link #dipsIntoOuterContext} and
+    # {@link #hasSemanticContext} when necessary.</p>
+    #/
+    def add(self, config:ATNConfig, mergeCache=None):
+        if self.readonly:
+            raise Exception("This set is readonly")
+        if config.semanticContext is not SemanticContext.NONE:
+            self.hasSemanticContext = True
+        if config.reachesIntoOuterContext > 0:
+            self.dipsIntoOuterContext = True
+        existing = self.getOrAdd(config)
+        if existing is config:
+            self.cachedHashCode = -1
+            self.configs.append(config)  # track order here
+            return True
+        # a previous (s,i,pi,_), merge with it and save result
+        rootIsWildcard = not self.fullCtx
+        merged = merge(existing.context, config.context, rootIsWildcard, mergeCache)
+        # no need to check for existing.context, config.context in cache
+        # since only way to create new graphs is "call rule" and here.
+        # We cache at both places.
+        existing.reachesIntoOuterContext = max(existing.reachesIntoOuterContext, config.reachesIntoOuterContext)
+        # make sure to preserve the precedence filter suppression during the merge
+        if config.precedenceFilterSuppressed:
+            existing.precedenceFilterSuppressed = True
+        existing.context = merged # replace context; no need to alt mapping
+        return True
+
+    def getOrAdd(self, config:ATNConfig):
+        h = config.hashCodeForConfigSet()
+        l = self.configLookup.get(h, None)
+        if l is not None:
+            r = next((cfg for cfg in l if config.equalsForConfigSet(cfg)), None)
+            if r is not None:
+                return r
+        if l is None:
+            l = [config]
+            self.configLookup[h] = l
+        else:
+            l.append(config)
+        return config
+
+    def getStates(self):
+        return set(c.state for c in self.configs)
+
+    def getPredicates(self):
+        return list(cfg.semanticContext for cfg in self.configs if cfg.semanticContext!=SemanticContext.NONE)
+
+    def get(self, i:int):
+        return self.configs[i]
+
+    def optimizeConfigs(self, interpreter:ATNSimulator):
+        if self.readonly:
+            raise IllegalStateException("This set is readonly")
+        if len(self.configs)==0:
+            return
+        for config in self.configs:
+            config.context = interpreter.getCachedContext(config.context)
+
+    def addAll(self, coll:list):
+        for c in coll:
+            self.add(c)
+        return False
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, ATNConfigSet):
+            return False
+
+        same = self.configs is not None and \
+            self.configs==other.configs and \
+            self.fullCtx == other.fullCtx and \
+            self.uniqueAlt == other.uniqueAlt and \
+            self.conflictingAlts == other.conflictingAlts and \
+            self.hasSemanticContext == other.hasSemanticContext and \
+            self.dipsIntoOuterContext == other.dipsIntoOuterContext
+
+        return same
+
+    def __hash__(self):
+        if self.readonly:
+            if self.cachedHashCode == -1:
+                self.cachedHashCode = self.hashConfigs()
+            return self.cachedHashCode
+        return self.hashConfigs()
+
+    def hashConfigs(self):
+        return reduce(lambda h, cfg: hash((h, cfg)), self.configs, 0)
+
+    def __len__(self):
+        return len(self.configs)
+
+    def isEmpty(self):
+        return len(self.configs)==0
+
+    def __contains__(self, config):
+        if self.configLookup is None:
+            raise UnsupportedOperationException("This method is not implemented for readonly sets.")
+        h = config.hashCodeForConfigSet()
+        l = self.configLookup.get(h, None)
+        if l is not None:
+            for c in l:
+                if config.equalsForConfigSet(c):
+                    return True
+        return False
+
+    def clear(self):
+        if self.readonly:
+            raise IllegalStateException("This set is readonly")
+        self.configs.clear()
+        self.cachedHashCode = -1
+        self.configLookup.clear()
+
+    def setReadonly(self, readonly:bool):
+        self.readonly = readonly
+        self.configLookup = None # can't mod, no need for lookup cache
+
+    def __str__(self):
+        with StringIO() as buf:
+            buf.write(str_list(self.configs))
+            if self.hasSemanticContext:
+                buf.write(",hasSemanticContext=")
+                buf.write(str(self.hasSemanticContext))
+            if self.uniqueAlt!=ATN.INVALID_ALT_NUMBER:
+                buf.write(",uniqueAlt=")
+                buf.write(str(self.uniqueAlt))
+            if self.conflictingAlts is not None:
+                buf.write(",conflictingAlts=")
+                buf.write(str(self.conflictingAlts))
+            if self.dipsIntoOuterContext:
+                buf.write(",dipsIntoOuterContext")
+            return buf.getvalue()
+
+
+class OrderedATNConfigSet(ATNConfigSet):
+
+    def __init__(self):
+        super().__init__()

cameras/deps/antlr4/atn/ATNDeserializationOptions.py

@@ -0,0 +1,24 @@
+# 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.
+
+# need a forward declaration
+ATNDeserializationOptions = None
+
+class ATNDeserializationOptions(object):
+    __slots__ = ('readonly', 'verifyATN', 'generateRuleBypassTransitions')
+
+    defaultOptions = None
+
+    def __init__(self, copyFrom:ATNDeserializationOptions = None):
+        self.readonly = False
+        self.verifyATN = True if copyFrom is None else copyFrom.verifyATN
+        self.generateRuleBypassTransitions = False if copyFrom is None else copyFrom.generateRuleBypassTransitions
+
+    def __setattr__(self, key, value):
+        if key!="readonly" and self.readonly:
+            raise Exception("The object is read only.")
+        super(type(self), self).__setattr__(key,value)
+
+ATNDeserializationOptions.defaultOptions = ATNDeserializationOptions()
+ATNDeserializationOptions.defaultOptions.readonly = True

cameras/deps/antlr4/atn/ATNDeserializer.py

@@ -0,0 +1,529 @@
+# 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.
+#/
+from uuid import UUID
+from io import StringIO
+from typing import Callable
+from antlr4.Token import Token
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNType import ATNType
+from antlr4.atn.ATNState import *
+from antlr4.atn.Transition import *
+from antlr4.atn.LexerAction import *
+from antlr4.atn.ATNDeserializationOptions import ATNDeserializationOptions
+
+# This is the earliest supported serialized UUID.
+BASE_SERIALIZED_UUID = UUID("AADB8D7E-AEEF-4415-AD2B-8204D6CF042E")
+
+# This UUID indicates the serialized ATN contains two sets of
+# IntervalSets, where the second set's values are encoded as
+# 32-bit integers to support the full Unicode SMP range up to U+10FFFF.
+ADDED_UNICODE_SMP = UUID("59627784-3BE5-417A-B9EB-8131A7286089")
+
+# This list contains all of the currently supported UUIDs, ordered by when
+# the feature first appeared in this branch.
+SUPPORTED_UUIDS = [ BASE_SERIALIZED_UUID, ADDED_UNICODE_SMP ]
+
+SERIALIZED_VERSION = 3
+
+# This is the current serialized UUID.
+SERIALIZED_UUID = ADDED_UNICODE_SMP
+
+class ATNDeserializer (object):
+    __slots__ = ('deserializationOptions', 'data', 'pos', 'uuid')
+
+    def __init__(self, options : ATNDeserializationOptions = None):
+        if options is None:
+            options = ATNDeserializationOptions.defaultOptions
+        self.deserializationOptions = options
+
+    # Determines if a particular serialized representation of an ATN supports
+    # a particular feature, identified by the {@link UUID} used for serializing
+    # the ATN at the time the feature was first introduced.
+    #
+    # @param feature The {@link UUID} marking the first time the feature was
+    # supported in the serialized ATN.
+    # @param actualUuid The {@link UUID} of the actual serialized ATN which is
+    # currently being deserialized.
+    # @return {@code true} if the {@code actualUuid} value represents a
+    # serialized ATN at or after the feature identified by {@code feature} was
+    # introduced; otherwise, {@code false}.
+
+    def isFeatureSupported(self, feature : UUID , actualUuid : UUID ):
+        idx1 = SUPPORTED_UUIDS.index(feature)
+        if idx1<0:
+            return False
+        idx2 = SUPPORTED_UUIDS.index(actualUuid)
+        return idx2 >= idx1
+
+    def deserialize(self, data : str):
+        self.reset(data)
+        self.checkVersion()
+        self.checkUUID()
+        atn = self.readATN()
+        self.readStates(atn)
+        self.readRules(atn)
+        self.readModes(atn)
+        sets = []
+        # First, read all sets with 16-bit Unicode code points <= U+FFFF.
+        self.readSets(atn, sets, self.readInt)
+        # Next, if the ATN was serialized with the Unicode SMP feature,
+        # deserialize sets with 32-bit arguments <= U+10FFFF.
+        if self.isFeatureSupported(ADDED_UNICODE_SMP, self.uuid):
+            self.readSets(atn, sets, self.readInt32)
+        self.readEdges(atn, sets)
+        self.readDecisions(atn)
+        self.readLexerActions(atn)
+        self.markPrecedenceDecisions(atn)
+        self.verifyATN(atn)
+        if self.deserializationOptions.generateRuleBypassTransitions \
+                and atn.grammarType == ATNType.PARSER:
+            self.generateRuleBypassTransitions(atn)
+            # re-verify after modification
+            self.verifyATN(atn)
+        return atn
+
+    def reset(self, data:str):
+        def adjust(c):
+            v = ord(c)
+            return v-2 if v>1 else v + 65533
+        temp = [ adjust(c) for c in data ]
+        # don't adjust the first value since that's the version number
+        temp[0] = ord(data[0])
+        self.data = temp
+        self.pos = 0
+
+    def checkVersion(self):
+        version = self.readInt()
+        if version != SERIALIZED_VERSION:
+            raise Exception("Could not deserialize ATN with version " + str(version) + " (expected " + str(SERIALIZED_VERSION) + ").")
+
+    def checkUUID(self):
+        uuid = self.readUUID()
+        if not uuid in SUPPORTED_UUIDS:
+            raise Exception("Could not deserialize ATN with UUID: " + str(uuid) + \
+                            " (expected " + str(SERIALIZED_UUID) + " or a legacy UUID).", uuid, SERIALIZED_UUID)
+        self.uuid = uuid
+
+    def readATN(self):
+        idx = self.readInt()
+        grammarType = ATNType.fromOrdinal(idx)
+        maxTokenType = self.readInt()
+        return ATN(grammarType, maxTokenType)
+
+    def readStates(self, atn:ATN):
+        loopBackStateNumbers = []
+        endStateNumbers = []
+        nstates = self.readInt()
+        for i in range(0, nstates):
+            stype = self.readInt()
+            # ignore bad type of states
+            if stype==ATNState.INVALID_TYPE:
+                atn.addState(None)
+                continue
+            ruleIndex = self.readInt()
+            if ruleIndex == 0xFFFF:
+                ruleIndex = -1
+
+            s = self.stateFactory(stype, ruleIndex)
+            if stype == ATNState.LOOP_END: # special case
+                loopBackStateNumber = self.readInt()
+                loopBackStateNumbers.append((s, loopBackStateNumber))
+            elif isinstance(s, BlockStartState):
+                endStateNumber = self.readInt()
+                endStateNumbers.append((s, endStateNumber))
+
+            atn.addState(s)
+
+        # delay the assignment of loop back and end states until we know all the state instances have been initialized
+        for pair in loopBackStateNumbers:
+            pair[0].loopBackState = atn.states[pair[1]]
+
+        for pair in endStateNumbers:
+            pair[0].endState = atn.states[pair[1]]
+
+        numNonGreedyStates = self.readInt()
+        for i in range(0, numNonGreedyStates):
+            stateNumber = self.readInt()
+            atn.states[stateNumber].nonGreedy = True
+
+        numPrecedenceStates = self.readInt()
+        for i in range(0, numPrecedenceStates):
+            stateNumber = self.readInt()
+            atn.states[stateNumber].isPrecedenceRule = True
+
+    def readRules(self, atn:ATN):
+        nrules = self.readInt()
+        if atn.grammarType == ATNType.LEXER:
+            atn.ruleToTokenType = [0] * nrules
+
+        atn.ruleToStartState = [0] * nrules
+        for i in range(0, nrules):
+            s = self.readInt()
+            startState = atn.states[s]
+            atn.ruleToStartState[i] = startState
+            if atn.grammarType == ATNType.LEXER:
+                tokenType = self.readInt()
+                if tokenType == 0xFFFF:
+                    tokenType = Token.EOF
+
+                atn.ruleToTokenType[i] = tokenType
+
+        atn.ruleToStopState = [0] * nrules
+        for state in atn.states:
+            if not isinstance(state, RuleStopState):
+                continue
+            atn.ruleToStopState[state.ruleIndex] = state
+            atn.ruleToStartState[state.ruleIndex].stopState = state
+
+    def readModes(self, atn:ATN):
+        nmodes = self.readInt()
+        for i in range(0, nmodes):
+            s = self.readInt()
+            atn.modeToStartState.append(atn.states[s])
+
+    def readSets(self, atn:ATN, sets:list, readUnicode:Callable[[], int]):
+        m = self.readInt()
+        for i in range(0, m):
+            iset = IntervalSet()
+            sets.append(iset)
+            n = self.readInt()
+            containsEof = self.readInt()
+            if containsEof!=0:
+                iset.addOne(-1)
+            for j in range(0, n):
+                i1 = readUnicode()
+                i2 = readUnicode()
+                iset.addRange(range(i1, i2 + 1)) # range upper limit is exclusive
+
+    def readEdges(self, atn:ATN, sets:list):
+        nedges = self.readInt()
+        for i in range(0, nedges):
+            src = self.readInt()
+            trg = self.readInt()
+            ttype = self.readInt()
+            arg1 = self.readInt()
+            arg2 = self.readInt()
+            arg3 = self.readInt()
+            trans = self.edgeFactory(atn, ttype, src, trg, arg1, arg2, arg3, sets)
+            srcState = atn.states[src]
+            srcState.addTransition(trans)
+
+        # edges for rule stop states can be derived, so they aren't serialized
+        for state in atn.states:
+            for i in range(0, len(state.transitions)):
+                t = state.transitions[i]
+                if not isinstance(t, RuleTransition):
+                    continue
+                outermostPrecedenceReturn = -1
+                if atn.ruleToStartState[t.target.ruleIndex].isPrecedenceRule:
+                    if t.precedence == 0:
+                        outermostPrecedenceReturn = t.target.ruleIndex
+                trans = EpsilonTransition(t.followState, outermostPrecedenceReturn)
+                atn.ruleToStopState[t.target.ruleIndex].addTransition(trans)
+
+        for state in atn.states:
+            if isinstance(state, BlockStartState):
+                # we need to know the end state to set its start state
+                if state.endState is None:
+                    raise Exception("IllegalState")
+                # block end states can only be associated to a single block start state
+                if state.endState.startState is not None:
+                    raise Exception("IllegalState")
+                state.endState.startState = state
+
+            if isinstance(state, PlusLoopbackState):
+                for i in range(0, len(state.transitions)):
+                    target = state.transitions[i].target
+                    if isinstance(target, PlusBlockStartState):
+                        target.loopBackState = state
+            elif isinstance(state, StarLoopbackState):
+                for i in range(0, len(state.transitions)):
+                    target = state.transitions[i].target
+                    if isinstance(target, StarLoopEntryState):
+                        target.loopBackState = state
+
+    def readDecisions(self, atn:ATN):
+        ndecisions = self.readInt()
+        for i in range(0, ndecisions):
+            s = self.readInt()
+            decState = atn.states[s]
+            atn.decisionToState.append(decState)
+            decState.decision = i
+
+    def readLexerActions(self, atn:ATN):
+        if atn.grammarType == ATNType.LEXER:
+            count = self.readInt()
+            atn.lexerActions = [ None ] * count
+            for i in range(0, count):
+                actionType = self.readInt()
+                data1 = self.readInt()
+                if data1 == 0xFFFF:
+                    data1 = -1
+                data2 = self.readInt()
+                if data2 == 0xFFFF:
+                    data2 = -1
+                lexerAction = self.lexerActionFactory(actionType, data1, data2)
+                atn.lexerActions[i] = lexerAction
+
+    def generateRuleBypassTransitions(self, atn:ATN):
+
+        count = len(atn.ruleToStartState)
+        atn.ruleToTokenType = [ 0 ] * count
+        for i in range(0, count):
+            atn.ruleToTokenType[i] = atn.maxTokenType + i + 1
+
+        for i in range(0, count):
+            self.generateRuleBypassTransition(atn, i)
+
+    def generateRuleBypassTransition(self, atn:ATN, idx:int):
+
+        bypassStart = BasicBlockStartState()
+        bypassStart.ruleIndex = idx
+        atn.addState(bypassStart)
+
+        bypassStop = BlockEndState()
+        bypassStop.ruleIndex = idx
+        atn.addState(bypassStop)
+
+        bypassStart.endState = bypassStop
+        atn.defineDecisionState(bypassStart)
+
+        bypassStop.startState = bypassStart
+
+        excludeTransition = None
+
+        if atn.ruleToStartState[idx].isPrecedenceRule:
+            # wrap from the beginning of the rule to the StarLoopEntryState
+            endState = None
+            for state in atn.states:
+                if self.stateIsEndStateFor(state, idx):
+                    endState = state
+                    excludeTransition = state.loopBackState.transitions[0]
+                    break
+
+            if excludeTransition is None:
+                raise Exception("Couldn't identify final state of the precedence rule prefix section.")
+
+        else:
+
+            endState = atn.ruleToStopState[idx]
+
+        # all non-excluded transitions that currently target end state need to target blockEnd instead
+        for state in atn.states:
+            for transition in state.transitions:
+                if transition == excludeTransition:
+                    continue
+                if transition.target == endState:
+                    transition.target = bypassStop
+
+        # all transitions leaving the rule start state need to leave blockStart instead
+        ruleToStartState = atn.ruleToStartState[idx]
+        count = len(ruleToStartState.transitions)
+        while count > 0:
+            bypassStart.addTransition(ruleToStartState.transitions[count-1])
+            del ruleToStartState.transitions[-1]
+
+        # link the new states
+        atn.ruleToStartState[idx].addTransition(EpsilonTransition(bypassStart))
+        bypassStop.addTransition(EpsilonTransition(endState))
+
+        matchState = BasicState()
+        atn.addState(matchState)
+        matchState.addTransition(AtomTransition(bypassStop, atn.ruleToTokenType[idx]))
+        bypassStart.addTransition(EpsilonTransition(matchState))
+
+
+    def stateIsEndStateFor(self, state:ATNState, idx:int):
+        if state.ruleIndex != idx:
+            return None
+        if not isinstance(state, StarLoopEntryState):
+            return None
+
+        maybeLoopEndState = state.transitions[len(state.transitions) - 1].target
+        if not isinstance(maybeLoopEndState, LoopEndState):
+            return None
+
+        if maybeLoopEndState.epsilonOnlyTransitions and \
+                isinstance(maybeLoopEndState.transitions[0].target, RuleStopState):
+            return state
+        else:
+            return None
+
+
+    #
+    # Analyze the {@link StarLoopEntryState} states in the specified ATN to set
+    # the {@link StarLoopEntryState#isPrecedenceDecision} field to the
+    # correct value.
+    #
+    # @param atn The ATN.
+    #
+    def markPrecedenceDecisions(self, atn:ATN):
+        for state in atn.states:
+            if not isinstance(state, StarLoopEntryState):
+                continue
+
+            # We analyze the ATN to determine if this ATN decision state is the
+            # decision for the closure block that determines whether a
+            # precedence rule should continue or complete.
+            #
+            if atn.ruleToStartState[state.ruleIndex].isPrecedenceRule:
+                maybeLoopEndState = state.transitions[len(state.transitions) - 1].target
+                if isinstance(maybeLoopEndState, LoopEndState):
+                    if maybeLoopEndState.epsilonOnlyTransitions and \
+                            isinstance(maybeLoopEndState.transitions[0].target, RuleStopState):
+                        state.isPrecedenceDecision = True
+
+    def verifyATN(self, atn:ATN):
+        if not self.deserializationOptions.verifyATN:
+            return
+        # verify assumptions
+        for state in atn.states:
+            if state is None:
+                continue
+
+            self.checkCondition(state.epsilonOnlyTransitions or len(state.transitions) <= 1)
+
+            if isinstance(state, PlusBlockStartState):
+                self.checkCondition(state.loopBackState is not None)
+
+            if isinstance(state, StarLoopEntryState):
+                self.checkCondition(state.loopBackState is not None)
+                self.checkCondition(len(state.transitions) == 2)
+
+                if isinstance(state.transitions[0].target, StarBlockStartState):
+                    self.checkCondition(isinstance(state.transitions[1].target, LoopEndState))
+                    self.checkCondition(not state.nonGreedy)
+                elif isinstance(state.transitions[0].target, LoopEndState):
+                    self.checkCondition(isinstance(state.transitions[1].target, StarBlockStartState))
+                    self.checkCondition(state.nonGreedy)
+                else:
+                    raise Exception("IllegalState")
+
+            if isinstance(state, StarLoopbackState):
+                self.checkCondition(len(state.transitions) == 1)
+                self.checkCondition(isinstance(state.transitions[0].target, StarLoopEntryState))
+
+            if isinstance(state, LoopEndState):
+                self.checkCondition(state.loopBackState is not None)
+
+            if isinstance(state, RuleStartState):
+                self.checkCondition(state.stopState is not None)
+
+            if isinstance(state, BlockStartState):
+                self.checkCondition(state.endState is not None)
+
+            if isinstance(state, BlockEndState):
+                self.checkCondition(state.startState is not None)
+
+            if isinstance(state, DecisionState):
+                self.checkCondition(len(state.transitions) <= 1 or state.decision >= 0)
+            else:
+                self.checkCondition(len(state.transitions) <= 1 or isinstance(state, RuleStopState))
+
+    def checkCondition(self, condition:bool, message=None):
+        if not condition:
+            if message is None:
+                message = "IllegalState"
+            raise Exception(message)
+
+    def readInt(self):
+        i = self.data[self.pos]
+        self.pos += 1
+        return i
+
+    def readInt32(self):
+        low = self.readInt()
+        high = self.readInt()
+        return low | (high << 16)
+
+    def readLong(self):
+        low = self.readInt32()
+        high = self.readInt32()
+        return (low & 0x00000000FFFFFFFF) | (high << 32)
+
+    def readUUID(self):
+        low = self.readLong()
+        high = self.readLong()
+        allBits = (low & 0xFFFFFFFFFFFFFFFF) | (high << 64)
+        return UUID(int=allBits)
+
+    edgeFactories = [ lambda args : None,
+                      lambda atn, src, trg, arg1, arg2, arg3, sets, target : EpsilonTransition(target),
+                      lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                        RangeTransition(target, Token.EOF, arg2) if arg3 != 0 else RangeTransition(target, arg1, arg2),
+                      lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                        RuleTransition(atn.states[arg1], arg2, arg3, target),
+                      lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                        PredicateTransition(target, arg1, arg2, arg3 != 0),
+                      lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                        AtomTransition(target, Token.EOF) if arg3 != 0 else AtomTransition(target, arg1),
+                      lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                        ActionTransition(target, arg1, arg2, arg3 != 0),
+                      lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                        SetTransition(target, sets[arg1]),
+                      lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                        NotSetTransition(target, sets[arg1]),
+                      lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                        WildcardTransition(target),
+                      lambda atn, src, trg, arg1, arg2, arg3, sets, target : \
+                        PrecedencePredicateTransition(target, arg1)
+                      ]
+
+    def edgeFactory(self, atn:ATN, type:int, src:int, trg:int, arg1:int, arg2:int, arg3:int, sets:list):
+        target = atn.states[trg]
+        if type > len(self.edgeFactories) or self.edgeFactories[type] is None:
+            raise Exception("The specified transition type: " + str(type) + " is not valid.")
+        else:
+            return self.edgeFactories[type](atn, src, trg, arg1, arg2, arg3, sets, target)
+
+    stateFactories = [  lambda : None,
+                        lambda : BasicState(),
+                        lambda : RuleStartState(),
+                        lambda : BasicBlockStartState(),
+                        lambda : PlusBlockStartState(),
+                        lambda : StarBlockStartState(),
+                        lambda : TokensStartState(),
+                        lambda : RuleStopState(),
+                        lambda : BlockEndState(),
+                        lambda : StarLoopbackState(),
+                        lambda : StarLoopEntryState(),
+                        lambda : PlusLoopbackState(),
+                        lambda : LoopEndState()
+                    ]
+
+    def stateFactory(self, type:int, ruleIndex:int):
+        if type> len(self.stateFactories) or self.stateFactories[type] is None:
+            raise Exception("The specified state type " + str(type) + " is not valid.")
+        else:
+            s = self.stateFactories[type]()
+            if s is not None:
+                s.ruleIndex = ruleIndex
+        return s
+
+    CHANNEL = 0     #The type of a {@link LexerChannelAction} action.
+    CUSTOM = 1      #The type of a {@link LexerCustomAction} action.
+    MODE = 2        #The type of a {@link LexerModeAction} action.
+    MORE = 3        #The type of a {@link LexerMoreAction} action.
+    POP_MODE = 4    #The type of a {@link LexerPopModeAction} action.
+    PUSH_MODE = 5   #The type of a {@link LexerPushModeAction} action.
+    SKIP = 6        #The type of a {@link LexerSkipAction} action.
+    TYPE = 7        #The type of a {@link LexerTypeAction} action.
+
+    actionFactories = [ lambda data1, data2: LexerChannelAction(data1),
+                        lambda data1, data2: LexerCustomAction(data1, data2),
+                        lambda data1, data2: LexerModeAction(data1),
+                        lambda data1, data2: LexerMoreAction.INSTANCE,
+                        lambda data1, data2: LexerPopModeAction.INSTANCE,
+                        lambda data1, data2: LexerPushModeAction(data1),
+                        lambda data1, data2: LexerSkipAction.INSTANCE,
+                        lambda data1, data2: LexerTypeAction(data1)
+                      ]
+
+    def lexerActionFactory(self, type:int, data1:int, data2:int):
+
+        if type > len(self.actionFactories) or self.actionFactories[type] is None:
+            raise Exception("The specified lexer action type " + str(type) + " is not valid.")
+        else:
+            return self.actionFactories[type](data1, data2)

cameras/deps/antlr4/atn/ATNSimulator.py

@@ -0,0 +1,47 @@
+#
+# 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.
+#/
+from antlr4.PredictionContext import PredictionContextCache, PredictionContext, getCachedPredictionContext
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNConfigSet import ATNConfigSet
+from antlr4.dfa.DFAState import DFAState
+
+
+class ATNSimulator(object):
+    __slots__ = ('atn', 'sharedContextCache', '__dict__')
+
+    # Must distinguish between missing edge and edge we know leads nowhere#/
+    ERROR = DFAState(configs=ATNConfigSet())
+    ERROR.stateNumber = 0x7FFFFFFF
+
+    # The context cache maps all PredictionContext objects that are ==
+    #  to a single cached copy. This cache is shared across all contexts
+    #  in all ATNConfigs in all DFA states.  We rebuild each ATNConfigSet
+    #  to use only cached nodes/graphs in addDFAState(). We don't want to
+    #  fill this during closure() since there are lots of contexts that
+    #  pop up but are not used ever again. It also greatly slows down closure().
+    #
+    #  <p>This cache makes a huge difference in memory and a little bit in speed.
+    #  For the Java grammar on java.*, it dropped the memory requirements
+    #  at the end from 25M to 16M. We don't store any of the full context
+    #  graphs in the DFA because they are limited to local context only,
+    #  but apparently there's a lot of repetition there as well. We optimize
+    #  the config contexts before storing the config set in the DFA states
+    #  by literally rebuilding them with cached subgraphs only.</p>
+    #
+    #  <p>I tried a cache for use during closure operations, that was
+    #  whacked after each adaptivePredict(). It cost a little bit
+    #  more time I think and doesn't save on the overall footprint
+    #  so it's not worth the complexity.</p>
+    #/
+    def __init__(self, atn:ATN, sharedContextCache:PredictionContextCache):
+        self.atn = atn
+        self.sharedContextCache = sharedContextCache
+
+    def getCachedContext(self, context:PredictionContext):
+        if self.sharedContextCache is None:
+            return context
+        visited = dict()
+        return getCachedPredictionContext(context, self.sharedContextCache, visited)

cameras/deps/antlr4/atn/ATNState.py

@@ -0,0 +1,264 @@
+#
+# 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.
+#
+
+# The following images show the relation of states and
+# {@link ATNState#transitions} for various grammar constructs.
+#
+# <ul>
+#
+# <li>Solid edges marked with an &#0949; indicate a required
+# {@link EpsilonTransition}.</li>
+#
+# <li>Dashed edges indicate locations where any transition derived from
+# {@link Transition} might appear.</li>
+#
+# <li>Dashed nodes are place holders for either a sequence of linked
+# {@link BasicState} states or the inclusion of a block representing a nested
+# construct in one of the forms below.</li>
+#
+# <li>Nodes showing multiple outgoing alternatives with a {@code ...} support
+# any number of alternatives (one or more). Nodes without the {@code ...} only
+# support the exact number of alternatives shown in the diagram.</li>
+#
+# </ul>
+#
+# <h2>Basic Blocks</h2>
+#
+# <h3>Rule</h3>
+#
+# <embed src="images/Rule.svg" type="image/svg+xml"/>
+#
+# <h3>Block of 1 or more alternatives</h3>
+#
+# <embed src="images/Block.svg" type="image/svg+xml"/>
+#
+# <h2>Greedy Loops</h2>
+#
+# <h3>Greedy Closure: {@code (...)*}</h3>
+#
+# <embed src="images/ClosureGreedy.svg" type="image/svg+xml"/>
+#
+# <h3>Greedy Positive Closure: {@code (...)+}</h3>
+#
+# <embed src="images/PositiveClosureGreedy.svg" type="image/svg+xml"/>
+#
+# <h3>Greedy Optional: {@code (...)?}</h3>
+#
+# <embed src="images/OptionalGreedy.svg" type="image/svg+xml"/>
+#
+# <h2>Non-Greedy Loops</h2>
+#
+# <h3>Non-Greedy Closure: {@code (...)*?}</h3>
+#
+# <embed src="images/ClosureNonGreedy.svg" type="image/svg+xml"/>
+#
+# <h3>Non-Greedy Positive Closure: {@code (...)+?}</h3>
+#
+# <embed src="images/PositiveClosureNonGreedy.svg" type="image/svg+xml"/>
+#
+# <h3>Non-Greedy Optional: {@code (...)??}</h3>
+#
+# <embed src="images/OptionalNonGreedy.svg" type="image/svg+xml"/>
+#
+
+from antlr4.atn.Transition import Transition
+
+INITIAL_NUM_TRANSITIONS = 4
+
+class ATNState(object):
+    __slots__ = (
+        'atn', 'stateNumber', 'stateType', 'ruleIndex', 'epsilonOnlyTransitions',
+        'transitions', 'nextTokenWithinRule',
+    )
+
+    # constants for serialization
+    INVALID_TYPE = 0
+    BASIC = 1
+    RULE_START = 2
+    BLOCK_START = 3
+    PLUS_BLOCK_START = 4
+    STAR_BLOCK_START = 5
+    TOKEN_START = 6
+    RULE_STOP = 7
+    BLOCK_END = 8
+    STAR_LOOP_BACK = 9
+    STAR_LOOP_ENTRY = 10
+    PLUS_LOOP_BACK = 11
+    LOOP_END = 12
+
+    serializationNames = [
+            "INVALID",
+            "BASIC",
+            "RULE_START",
+            "BLOCK_START",
+            "PLUS_BLOCK_START",
+            "STAR_BLOCK_START",
+            "TOKEN_START",
+            "RULE_STOP",
+            "BLOCK_END",
+            "STAR_LOOP_BACK",
+            "STAR_LOOP_ENTRY",
+            "PLUS_LOOP_BACK",
+            "LOOP_END" ]
+
+    INVALID_STATE_NUMBER = -1
+
+    def __init__(self):
+        # Which ATN are we in?
+        self.atn = None
+        self.stateNumber = ATNState.INVALID_STATE_NUMBER
+        self.stateType = None
+        self.ruleIndex = 0 # at runtime, we don't have Rule objects
+        self.epsilonOnlyTransitions = False
+        # Track the transitions emanating from this ATN state.
+        self.transitions = []
+        # Used to cache lookahead during parsing, not used during construction
+        self.nextTokenWithinRule = None
+
+    def __hash__(self):
+        return self.stateNumber
+
+    def __eq__(self, other):
+        return isinstance(other, ATNState) and self.stateNumber==other.stateNumber
+
+    def onlyHasEpsilonTransitions(self):
+        return self.epsilonOnlyTransitions
+
+    def isNonGreedyExitState(self):
+        return False
+
+    def __str__(self):
+        return str(self.stateNumber)
+
+    def addTransition(self, trans:Transition, index:int=-1):
+        if len(self.transitions)==0:
+            self.epsilonOnlyTransitions = trans.isEpsilon
+        elif self.epsilonOnlyTransitions != trans.isEpsilon:
+            self.epsilonOnlyTransitions = False
+            # TODO System.err.format(Locale.getDefault(), "ATN state %d has both epsilon and non-epsilon transitions.\n", stateNumber);
+        if index==-1:
+            self.transitions.append(trans)
+        else:
+            self.transitions.insert(index, trans)
+
+class BasicState(ATNState):
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.BASIC
+
+
+class DecisionState(ATNState):
+    __slots__ = ('decision', 'nonGreedy')
+    def __init__(self):
+        super().__init__()
+        self.decision = -1
+        self.nonGreedy = False
+
+#  The start of a regular {@code (...)} block.
+class BlockStartState(DecisionState):
+    __slots__ = 'endState'
+
+    def __init__(self):
+        super().__init__()
+        self.endState = None
+
+class BasicBlockStartState(BlockStartState):
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.BLOCK_START
+
+# Terminal node of a simple {@code (a|b|c)} block.
+class BlockEndState(ATNState):
+    __slots__ = 'startState'
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.BLOCK_END
+        self.startState = None
+
+# The last node in the ATN for a rule, unless that rule is the start symbol.
+#  In that case, there is one transition to EOF. Later, we might encode
+#  references to all calls to this rule to compute FOLLOW sets for
+#  error handling.
+#
+class RuleStopState(ATNState):
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.RULE_STOP
+
+class RuleStartState(ATNState):
+    __slots__ = ('stopState', 'isPrecedenceRule')
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.RULE_START
+        self.stopState = None
+        self.isPrecedenceRule = False
+
+# Decision state for {@code A+} and {@code (A|B)+}.  It has two transitions:
+#  one to the loop back to start of the block and one to exit.
+#
+class PlusLoopbackState(DecisionState):
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.PLUS_LOOP_BACK
+
+# Start of {@code (A|B|...)+} loop. Technically a decision state, but
+#  we don't use for code generation; somebody might need it, so I'm defining
+#  it for completeness. In reality, the {@link PlusLoopbackState} node is the
+#  real decision-making note for {@code A+}.
+#
+class PlusBlockStartState(BlockStartState):
+    __slots__ = 'loopBackState'
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.PLUS_BLOCK_START
+        self.loopBackState = None
+
+# The block that begins a closure loop.
+class StarBlockStartState(BlockStartState):
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.STAR_BLOCK_START
+
+class StarLoopbackState(ATNState):
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.STAR_LOOP_BACK
+
+
+class StarLoopEntryState(DecisionState):
+    __slots__ = ('loopBackState', 'isPrecedenceDecision')
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.STAR_LOOP_ENTRY
+        self.loopBackState = None
+        # Indicates whether this state can benefit from a precedence DFA during SLL decision making.
+        self.isPrecedenceDecision = None
+
+# Mark the end of a * or + loop.
+class LoopEndState(ATNState):
+    __slots__ = 'loopBackState'
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.LOOP_END
+        self.loopBackState = None
+
+# The Tokens rule start state linking to each lexer rule start state */
+class TokensStartState(DecisionState):
+
+    def __init__(self):
+        super().__init__()
+        self.stateType = self.TOKEN_START

cameras/deps/antlr4/atn/ATNType.py

@@ -0,0 +1,17 @@
+# 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.
+#/
+
+from enum import IntEnum
+
+# Represents the type of recognizer an ATN applies to.
+
+class ATNType(IntEnum):
+
+    LEXER = 0
+    PARSER = 1
+
+    @classmethod
+    def fromOrdinal(cls, i:int):
+        return cls._value2member_map_[i]

cameras/deps/antlr4/atn/LexerATNSimulator.py

@@ -0,0 +1,570 @@
+#
+# 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.
+#/
+
+# When we hit an accept state in either the DFA or the ATN, we
+#  have to notify the character stream to start buffering characters
+#  via {@link IntStream#mark} and record the current state. The current sim state
+#  includes the current index into the input, the current line,
+#  and current character position in that line. Note that the Lexer is
+#  tracking the starting line and characterization of the token. These
+#  variables track the "state" of the simulator when it hits an accept state.
+#
+#  <p>We track these variables separately for the DFA and ATN simulation
+#  because the DFA simulation often has to fail over to the ATN
+#  simulation. If the ATN simulation fails, we need the DFA to fall
+#  back to its previously accepted state, if any. If the ATN succeeds,
+#  then the ATN does the accept and the DFA simulator that invoked it
+#  can simply return the predicted token type.</p>
+#/
+
+from antlr4.PredictionContext import PredictionContextCache, SingletonPredictionContext, PredictionContext
+from antlr4.InputStream import InputStream
+from antlr4.Token import Token
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNConfig import LexerATNConfig
+from antlr4.atn.ATNSimulator import ATNSimulator
+from antlr4.atn.ATNConfigSet import ATNConfigSet, OrderedATNConfigSet
+from antlr4.atn.ATNState import RuleStopState, ATNState
+from antlr4.atn.LexerActionExecutor import LexerActionExecutor
+from antlr4.atn.Transition import Transition
+from antlr4.dfa.DFAState import DFAState
+from antlr4.error.Errors import LexerNoViableAltException, UnsupportedOperationException
+
+class SimState(object):
+    __slots__ = ('index', 'line', 'column', 'dfaState')
+
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
+        self.index = -1
+        self.line = 0
+        self.column = -1
+        self.dfaState = None
+
+# need forward declaration
+Lexer = None
+LexerATNSimulator = None
+
+class LexerATNSimulator(ATNSimulator):
+    __slots__ = (
+        'decisionToDFA', 'recog', 'startIndex', 'line', 'column', 'mode',
+        'DEFAULT_MODE', 'MAX_CHAR_VALUE', 'prevAccept'
+    )
+
+    debug = False
+    dfa_debug = False
+
+    MIN_DFA_EDGE = 0
+    MAX_DFA_EDGE = 127 # forces unicode to stay in ATN
+
+    ERROR = None
+
+    def __init__(self, recog:Lexer, atn:ATN, decisionToDFA:list, sharedContextCache:PredictionContextCache):
+        super().__init__(atn, sharedContextCache)
+        self.decisionToDFA = decisionToDFA
+        self.recog = recog
+        # The current token's starting index into the character stream.
+        #  Shared across DFA to ATN simulation in case the ATN fails and the
+        #  DFA did not have a previous accept state. In this case, we use the
+        #  ATN-generated exception object.
+        self.startIndex = -1
+        # line number 1..n within the input#/
+        self.line = 1
+        # The index of the character relative to the beginning of the line 0..n-1#/
+        self.column = 0
+        from antlr4.Lexer import Lexer
+        self.mode = Lexer.DEFAULT_MODE
+        # Cache Lexer properties to avoid further imports
+        self.DEFAULT_MODE = Lexer.DEFAULT_MODE
+        self.MAX_CHAR_VALUE = Lexer.MAX_CHAR_VALUE
+        # Used during DFA/ATN exec to record the most recent accept configuration info
+        self.prevAccept = SimState()
+
+
+    def copyState(self, simulator:LexerATNSimulator ):
+        self.column = simulator.column
+        self.line = simulator.line
+        self.mode = simulator.mode
+        self.startIndex = simulator.startIndex
+
+    def match(self, input:InputStream , mode:int):
+        self.mode = mode
+        mark = input.mark()
+        try:
+            self.startIndex = input.index
+            self.prevAccept.reset()
+            dfa = self.decisionToDFA[mode]
+            if dfa.s0 is None:
+                return self.matchATN(input)
+            else:
+                return self.execATN(input, dfa.s0)
+        finally:
+            input.release(mark)
+
+    def reset(self):
+        self.prevAccept.reset()
+        self.startIndex = -1
+        self.line = 1
+        self.column = 0
+        self.mode = self.DEFAULT_MODE
+
+    def matchATN(self, input:InputStream):
+        startState = self.atn.modeToStartState[self.mode]
+
+        if LexerATNSimulator.debug:
+            print("matchATN mode " + str(self.mode) + " start: " + str(startState))
+
+        old_mode = self.mode
+        s0_closure = self.computeStartState(input, startState)
+        suppressEdge = s0_closure.hasSemanticContext
+        s0_closure.hasSemanticContext = False
+
+        next = self.addDFAState(s0_closure)
+        if not suppressEdge:
+            self.decisionToDFA[self.mode].s0 = next
+
+        predict = self.execATN(input, next)
+
+        if LexerATNSimulator.debug:
+            print("DFA after matchATN: " + str(self.decisionToDFA[old_mode].toLexerString()))
+
+        return predict
+
+    def execATN(self, input:InputStream, ds0:DFAState):
+        if LexerATNSimulator.debug:
+            print("start state closure=" + str(ds0.configs))
+
+        if ds0.isAcceptState:
+            # allow zero-length tokens
+            self.captureSimState(self.prevAccept, input, ds0)
+
+        t = input.LA(1)
+        s = ds0 # s is current/from DFA state
+
+        while True: # while more work
+            if LexerATNSimulator.debug:
+                print("execATN loop starting closure:", str(s.configs))
+
+            # As we move src->trg, src->trg, we keep track of the previous trg to
+            # avoid looking up the DFA state again, which is expensive.
+            # If the previous target was already part of the DFA, we might
+            # be able to avoid doing a reach operation upon t. If s!=null,
+            # it means that semantic predicates didn't prevent us from
+            # creating a DFA state. Once we know s!=null, we check to see if
+            # the DFA state has an edge already for t. If so, we can just reuse
+            # it's configuration set; there's no point in re-computing it.
+            # This is kind of like doing DFA simulation within the ATN
+            # simulation because DFA simulation is really just a way to avoid
+            # computing reach/closure sets. Technically, once we know that
+            # we have a previously added DFA state, we could jump over to
+            # the DFA simulator. But, that would mean popping back and forth
+            # a lot and making things more complicated algorithmically.
+            # This optimization makes a lot of sense for loops within DFA.
+            # A character will take us back to an existing DFA state
+            # that already has lots of edges out of it. e.g., .* in comments.
+            # print("Target for:" + str(s) + " and:" + str(t))
+            target = self.getExistingTargetState(s, t)
+            # print("Existing:" + str(target))
+            if target is None:
+                target = self.computeTargetState(input, s, t)
+                # print("Computed:" + str(target))
+
+            if target == self.ERROR:
+                break
+
+            # If this is a consumable input element, make sure to consume before
+            # capturing the accept state so the input index, line, and char
+            # position accurately reflect the state of the interpreter at the
+            # end of the token.
+            if t != Token.EOF:
+                self.consume(input)
+
+            if target.isAcceptState:
+                self.captureSimState(self.prevAccept, input, target)
+                if t == Token.EOF:
+                    break
+
+            t = input.LA(1)
+
+            s = target # flip; current DFA target becomes new src/from state
+
+        return self.failOrAccept(self.prevAccept, input, s.configs, t)
+
+    # Get an existing target state for an edge in the DFA. If the target state
+    # for the edge has not yet been computed or is otherwise not available,
+    # this method returns {@code null}.
+    #
+    # @param s The current DFA state
+    # @param t The next input symbol
+    # @return The existing target DFA state for the given input symbol
+    # {@code t}, or {@code null} if the target state for this edge is not
+    # already cached
+    def getExistingTargetState(self, s:DFAState, t:int):
+        if s.edges is None or t < self.MIN_DFA_EDGE or t > self.MAX_DFA_EDGE:
+            return None
+
+        target = s.edges[t - self.MIN_DFA_EDGE]
+        if LexerATNSimulator.debug and target is not None:
+            print("reuse state", str(s.stateNumber), "edge to", str(target.stateNumber))
+
+        return target
+
+    # Compute a target state for an edge in the DFA, and attempt to add the
+    # computed state and corresponding edge to the DFA.
+    #
+    # @param input The input stream
+    # @param s The current DFA state
+    # @param t The next input symbol
+    #
+    # @return The computed target DFA state for the given input symbol
+    # {@code t}. If {@code t} does not lead to a valid DFA state, this method
+    # returns {@link #ERROR}.
+    def computeTargetState(self, input:InputStream, s:DFAState, t:int):
+        reach = OrderedATNConfigSet()
+
+        # if we don't find an existing DFA state
+        # Fill reach starting from closure, following t transitions
+        self.getReachableConfigSet(input, s.configs, reach, t)
+
+        if len(reach)==0: # we got nowhere on t from s
+            if not reach.hasSemanticContext:
+                # we got nowhere on t, don't throw out this knowledge; it'd
+                # cause a failover from DFA later.
+               self. addDFAEdge(s, t, self.ERROR)
+
+            # stop when we can't match any more char
+            return self.ERROR
+
+        # Add an edge from s to target DFA found/created for reach
+        return self.addDFAEdge(s, t, cfgs=reach)
+
+    def failOrAccept(self, prevAccept:SimState , input:InputStream, reach:ATNConfigSet, t:int):
+        if self.prevAccept.dfaState is not None:
+            lexerActionExecutor = prevAccept.dfaState.lexerActionExecutor
+            self.accept(input, lexerActionExecutor, self.startIndex, prevAccept.index, prevAccept.line, prevAccept.column)
+            return prevAccept.dfaState.prediction
+        else:
+            # if no accept and EOF is first char, return EOF
+            if t==Token.EOF and input.index==self.startIndex:
+                return Token.EOF
+            raise LexerNoViableAltException(self.recog, input, self.startIndex, reach)
+
+    # Given a starting configuration set, figure out all ATN configurations
+    #  we can reach upon input {@code t}. Parameter {@code reach} is a return
+    #  parameter.
+    def getReachableConfigSet(self, input:InputStream, closure:ATNConfigSet, reach:ATNConfigSet, t:int):
+        # this is used to skip processing for configs which have a lower priority
+        # than a config that already reached an accept state for the same rule
+        skipAlt = ATN.INVALID_ALT_NUMBER
+        for cfg in closure:
+            currentAltReachedAcceptState = ( cfg.alt == skipAlt )
+            if currentAltReachedAcceptState and cfg.passedThroughNonGreedyDecision:
+                continue
+
+            if LexerATNSimulator.debug:
+                print("testing", self.getTokenName(t), "at",  str(cfg))
+
+            for trans in cfg.state.transitions:          # for each transition
+                target = self.getReachableTarget(trans, t)
+                if target is not None:
+                    lexerActionExecutor = cfg.lexerActionExecutor
+                    if lexerActionExecutor is not None:
+                        lexerActionExecutor = lexerActionExecutor.fixOffsetBeforeMatch(input.index - self.startIndex)
+
+                    treatEofAsEpsilon = (t == Token.EOF)
+                    config = LexerATNConfig(state=target, lexerActionExecutor=lexerActionExecutor, config=cfg)
+                    if self.closure(input, config, reach, currentAltReachedAcceptState, True, treatEofAsEpsilon):
+                        # any remaining configs for this alt have a lower priority than
+                        # the one that just reached an accept state.
+                        skipAlt = cfg.alt
+
+    def accept(self, input:InputStream, lexerActionExecutor:LexerActionExecutor, startIndex:int, index:int, line:int, charPos:int):
+        if LexerATNSimulator.debug:
+            print("ACTION", lexerActionExecutor)
+
+        # seek to after last char in token
+        input.seek(index)
+        self.line = line
+        self.column = charPos
+
+        if lexerActionExecutor is not None and self.recog is not None:
+            lexerActionExecutor.execute(self.recog, input, startIndex)
+
+    def getReachableTarget(self, trans:Transition, t:int):
+        if trans.matches(t, 0, self.MAX_CHAR_VALUE):
+            return trans.target
+        else:
+            return None
+
+    def computeStartState(self, input:InputStream, p:ATNState):
+        initialContext = PredictionContext.EMPTY
+        configs = OrderedATNConfigSet()
+        for i in range(0,len(p.transitions)):
+            target = p.transitions[i].target
+            c = LexerATNConfig(state=target, alt=i+1, context=initialContext)
+            self.closure(input, c, configs, False, False, False)
+        return configs
+
+    # Since the alternatives within any lexer decision are ordered by
+    # preference, this method stops pursuing the closure as soon as an accept
+    # state is reached. After the first accept state is reached by depth-first
+    # search from {@code config}, all other (potentially reachable) states for
+    # this rule would have a lower priority.
+    #
+    # @return {@code true} if an accept state is reached, otherwise
+    # {@code false}.
+    def closure(self, input:InputStream, config:LexerATNConfig, configs:ATNConfigSet, currentAltReachedAcceptState:bool,
+                speculative:bool, treatEofAsEpsilon:bool):
+        if LexerATNSimulator.debug:
+            print("closure(" + str(config) + ")")
+
+        if isinstance( config.state, RuleStopState ):
+            if LexerATNSimulator.debug:
+                if self.recog is not None:
+                    print("closure at", self.recog.symbolicNames[config.state.ruleIndex],  "rule stop", str(config))
+                else:
+                    print("closure at rule stop", str(config))
+
+            if config.context is None or config.context.hasEmptyPath():
+                if config.context is None or config.context.isEmpty():
+                    configs.add(config)
+                    return True
+                else:
+                    configs.add(LexerATNConfig(state=config.state, config=config, context=PredictionContext.EMPTY))
+                    currentAltReachedAcceptState = True
+
+            if config.context is not None and not config.context.isEmpty():
+                for i in range(0,len(config.context)):
+                    if config.context.getReturnState(i) != PredictionContext.EMPTY_RETURN_STATE:
+                        newContext = config.context.getParent(i) # "pop" return state
+                        returnState = self.atn.states[config.context.getReturnState(i)]
+                        c = LexerATNConfig(state=returnState, config=config, context=newContext)
+                        currentAltReachedAcceptState = self.closure(input, c, configs,
+                                    currentAltReachedAcceptState, speculative, treatEofAsEpsilon)
+
+            return currentAltReachedAcceptState
+
+        # optimization
+        if not config.state.epsilonOnlyTransitions:
+            if not currentAltReachedAcceptState or not config.passedThroughNonGreedyDecision:
+                configs.add(config)
+
+        for t in config.state.transitions:
+            c = self.getEpsilonTarget(input, config, t, configs, speculative, treatEofAsEpsilon)
+            if c is not None:
+                currentAltReachedAcceptState = self.closure(input, c, configs, currentAltReachedAcceptState, speculative, treatEofAsEpsilon)
+
+        return currentAltReachedAcceptState
+
+    # side-effect: can alter configs.hasSemanticContext
+    def getEpsilonTarget(self, input:InputStream, config:LexerATNConfig, t:Transition, configs:ATNConfigSet,
+                                           speculative:bool, treatEofAsEpsilon:bool):
+        c = None
+        if t.serializationType==Transition.RULE:
+                newContext = SingletonPredictionContext.create(config.context, t.followState.stateNumber)
+                c = LexerATNConfig(state=t.target, config=config, context=newContext)
+
+        elif t.serializationType==Transition.PRECEDENCE:
+                raise UnsupportedOperationException("Precedence predicates are not supported in lexers.")
+
+        elif t.serializationType==Transition.PREDICATE:
+                #  Track traversing semantic predicates. If we traverse,
+                # we cannot add a DFA state for this "reach" computation
+                # because the DFA would not test the predicate again in the
+                # future. Rather than creating collections of semantic predicates
+                # like v3 and testing them on prediction, v4 will test them on the
+                # fly all the time using the ATN not the DFA. This is slower but
+                # semantically it's not used that often. One of the key elements to
+                # this predicate mechanism is not adding DFA states that see
+                # predicates immediately afterwards in the ATN. For example,
+
+                # a : ID {p1}? | ID {p2}? ;
+
+                # should create the start state for rule 'a' (to save start state
+                # competition), but should not create target of ID state. The
+                # collection of ATN states the following ID references includes
+                # states reached by traversing predicates. Since this is when we
+                # test them, we cannot cash the DFA state target of ID.
+
+                if LexerATNSimulator.debug:
+                    print("EVAL rule "+ str(t.ruleIndex) + ":" + str(t.predIndex))
+                configs.hasSemanticContext = True
+                if self.evaluatePredicate(input, t.ruleIndex, t.predIndex, speculative):
+                    c = LexerATNConfig(state=t.target, config=config)
+
+        elif t.serializationType==Transition.ACTION:
+                if config.context is None or config.context.hasEmptyPath():
+                    # execute actions anywhere in the start rule for a token.
+                    #
+                    # TODO: if the entry rule is invoked recursively, some
+                    # actions may be executed during the recursive call. The
+                    # problem can appear when hasEmptyPath() is true but
+                    # isEmpty() is false. In this case, the config needs to be
+                    # split into two contexts - one with just the empty path
+                    # and another with everything but the empty path.
+                    # Unfortunately, the current algorithm does not allow
+                    # getEpsilonTarget to return two configurations, so
+                    # additional modifications are needed before we can support
+                    # the split operation.
+                    lexerActionExecutor = LexerActionExecutor.append(config.lexerActionExecutor,
+                                    self.atn.lexerActions[t.actionIndex])
+                    c = LexerATNConfig(state=t.target, config=config, lexerActionExecutor=lexerActionExecutor)
+
+                else:
+                    # ignore actions in referenced rules
+                    c = LexerATNConfig(state=t.target, config=config)
+
+        elif t.serializationType==Transition.EPSILON:
+            c = LexerATNConfig(state=t.target, config=config)
+
+        elif t.serializationType in [ Transition.ATOM, Transition.RANGE, Transition.SET ]:
+            if treatEofAsEpsilon:
+                if t.matches(Token.EOF, 0, self.MAX_CHAR_VALUE):
+                    c = LexerATNConfig(state=t.target, config=config)
+
+        return c
+
+    # Evaluate a predicate specified in the lexer.
+    #
+    # <p>If {@code speculative} is {@code true}, this method was called before
+    # {@link #consume} for the matched character. This method should call
+    # {@link #consume} before evaluating the predicate to ensure position
+    # sensitive values, including {@link Lexer#getText}, {@link Lexer#getLine},
+    # and {@link Lexer#getcolumn}, properly reflect the current
+    # lexer state. This method should restore {@code input} and the simulator
+    # to the original state before returning (i.e. undo the actions made by the
+    # call to {@link #consume}.</p>
+    #
+    # @param input The input stream.
+    # @param ruleIndex The rule containing the predicate.
+    # @param predIndex The index of the predicate within the rule.
+    # @param speculative {@code true} if the current index in {@code input} is
+    # one character before the predicate's location.
+    #
+    # @return {@code true} if the specified predicate evaluates to
+    # {@code true}.
+    #/
+    def evaluatePredicate(self, input:InputStream, ruleIndex:int, predIndex:int, speculative:bool):
+        # assume true if no recognizer was provided
+        if self.recog is None:
+            return True
+
+        if not speculative:
+            return self.recog.sempred(None, ruleIndex, predIndex)
+
+        savedcolumn = self.column
+        savedLine = self.line
+        index = input.index
+        marker = input.mark()
+        try:
+            self.consume(input)
+            return self.recog.sempred(None, ruleIndex, predIndex)
+        finally:
+            self.column = savedcolumn
+            self.line = savedLine
+            input.seek(index)
+            input.release(marker)
+
+    def captureSimState(self, settings:SimState, input:InputStream, dfaState:DFAState):
+        settings.index = input.index
+        settings.line = self.line
+        settings.column = self.column
+        settings.dfaState = dfaState
+
+    def addDFAEdge(self, from_:DFAState, tk:int, to:DFAState=None, cfgs:ATNConfigSet=None) -> DFAState:
+
+        if to is None and cfgs is not None:
+            # leading to this call, ATNConfigSet.hasSemanticContext is used as a
+            # marker indicating dynamic predicate evaluation makes this edge
+            # dependent on the specific input sequence, so the static edge in the
+            # DFA should be omitted. The target DFAState is still created since
+            # execATN has the ability to resynchronize with the DFA state cache
+            # following the predicate evaluation step.
+            #
+            # TJP notes: next time through the DFA, we see a pred again and eval.
+            # If that gets us to a previously created (but dangling) DFA
+            # state, we can continue in pure DFA mode from there.
+            #/
+            suppressEdge = cfgs.hasSemanticContext
+            cfgs.hasSemanticContext = False
+
+            to = self.addDFAState(cfgs)
+
+            if suppressEdge:
+                return to
+
+        # add the edge
+        if tk < self.MIN_DFA_EDGE or tk > self.MAX_DFA_EDGE:
+            # Only track edges within the DFA bounds
+            return to
+
+        if LexerATNSimulator.debug:
+            print("EDGE " + str(from_) + " -> " + str(to) + " upon "+ chr(tk))
+
+        if from_.edges is None:
+            #  make room for tokens 1..n and -1 masquerading as index 0
+            from_.edges = [ None ] * (self.MAX_DFA_EDGE - self.MIN_DFA_EDGE + 1)
+
+        from_.edges[tk - self.MIN_DFA_EDGE] = to # connect
+
+        return to
+
+
+    # Add a new DFA state if there isn't one with this set of
+    # configurations already. This method also detects the first
+    # configuration containing an ATN rule stop state. Later, when
+    # traversing the DFA, we will know which rule to accept.
+    def addDFAState(self, configs:ATNConfigSet) -> DFAState:
+
+        proposed = DFAState(configs=configs)
+        firstConfigWithRuleStopState = next((cfg for cfg in configs if isinstance(cfg.state, RuleStopState)), None)
+
+        if firstConfigWithRuleStopState is not None:
+            proposed.isAcceptState = True
+            proposed.lexerActionExecutor = firstConfigWithRuleStopState.lexerActionExecutor
+            proposed.prediction = self.atn.ruleToTokenType[firstConfigWithRuleStopState.state.ruleIndex]
+
+        dfa = self.decisionToDFA[self.mode]
+        existing = dfa.states.get(proposed, None)
+        if existing is not None:
+            return existing
+
+        newState = proposed
+
+        newState.stateNumber = len(dfa.states)
+        configs.setReadonly(True)
+        newState.configs = configs
+        dfa.states[newState] = newState
+        return newState
+
+    def getDFA(self, mode:int):
+        return self.decisionToDFA[mode]
+
+    # Get the text matched so far for the current token.
+    def getText(self, input:InputStream):
+        # index is first lookahead char, don't include.
+        return input.getText(self.startIndex, input.index-1)
+
+    def consume(self, input:InputStream):
+        curChar = input.LA(1)
+        if curChar==ord('\n'):
+            self.line += 1
+            self.column = 0
+        else:
+            self.column += 1
+        input.consume()
+
+    def getTokenName(self, t:int):
+        if t==-1:
+            return "EOF"
+        else:
+            return "'" + chr(t) + "'"
+
+
+LexerATNSimulator.ERROR = DFAState(0x7FFFFFFF, ATNConfigSet())
+
+del Lexer

cameras/deps/antlr4/atn/LexerAction.py

@@ -0,0 +1,298 @@
+#
+# 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.
+ #
+
+from enum import IntEnum
+
+# need forward declaration
+Lexer = None
+
+
+class LexerActionType(IntEnum):
+
+    CHANNEL = 0     #The type of a {@link LexerChannelAction} action.
+    CUSTOM = 1      #The type of a {@link LexerCustomAction} action.
+    MODE = 2        #The type of a {@link LexerModeAction} action.
+    MORE = 3        #The type of a {@link LexerMoreAction} action.
+    POP_MODE = 4    #The type of a {@link LexerPopModeAction} action.
+    PUSH_MODE = 5   #The type of a {@link LexerPushModeAction} action.
+    SKIP = 6        #The type of a {@link LexerSkipAction} action.
+    TYPE = 7        #The type of a {@link LexerTypeAction} action.
+
+class LexerAction(object):
+    __slots__ = ('actionType', 'isPositionDependent')
+
+    def __init__(self, action:LexerActionType):
+        self.actionType = action
+        self.isPositionDependent = False
+
+    def __hash__(self):
+        return hash(self.actionType)
+
+    def __eq__(self, other):
+        return self is other
+
+
+#
+# Implements the {@code skip} lexer action by calling {@link Lexer#skip}.
+#
+# <p>The {@code skip} command does not have any parameters, so this action is
+# implemented as a singleton instance exposed by {@link #INSTANCE}.</p>
+class LexerSkipAction(LexerAction):
+
+    # Provides a singleton instance of this parameterless lexer action.
+    INSTANCE = None
+
+    def __init__(self):
+        super().__init__(LexerActionType.SKIP)
+
+    def execute(self, lexer:Lexer):
+        lexer.skip()
+
+    def __str__(self):
+        return "skip"
+
+LexerSkipAction.INSTANCE = LexerSkipAction()
+
+#  Implements the {@code type} lexer action by calling {@link Lexer#setType}
+# with the assigned type.
+class LexerTypeAction(LexerAction):
+    __slots__ = 'type'
+
+    def __init__(self, type:int):
+        super().__init__(LexerActionType.TYPE)
+        self.type = type
+
+    def execute(self, lexer:Lexer):
+        lexer.type = self.type
+
+    def __hash__(self):
+        return hash((self.actionType, self.type))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerTypeAction):
+            return False
+        else:
+            return self.type == other.type
+
+    def __str__(self):
+        return "type(" + str(self.type) + ")"
+
+
+# Implements the {@code pushMode} lexer action by calling
+# {@link Lexer#pushMode} with the assigned mode.
+class LexerPushModeAction(LexerAction):
+    __slots__ = 'mode'
+
+    def __init__(self, mode:int):
+        super().__init__(LexerActionType.PUSH_MODE)
+        self.mode = mode
+
+    # <p>This action is implemented by calling {@link Lexer#pushMode} with the
+    # value provided by {@link #getMode}.</p>
+    def execute(self, lexer:Lexer):
+        lexer.pushMode(self.mode)
+
+    def __hash__(self):
+        return hash((self.actionType, self.mode))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerPushModeAction):
+            return False
+        else:
+            return self.mode == other.mode
+
+    def __str__(self):
+        return "pushMode(" + str(self.mode) + ")"
+
+
+# Implements the {@code popMode} lexer action by calling {@link Lexer#popMode}.
+#
+# <p>The {@code popMode} command does not have any parameters, so this action is
+# implemented as a singleton instance exposed by {@link #INSTANCE}.</p>
+class LexerPopModeAction(LexerAction):
+
+    INSTANCE = None
+
+    def __init__(self):
+        super().__init__(LexerActionType.POP_MODE)
+
+    # <p>This action is implemented by calling {@link Lexer#popMode}.</p>
+    def execute(self, lexer:Lexer):
+        lexer.popMode()
+
+    def __str__(self):
+        return "popMode"
+
+LexerPopModeAction.INSTANCE = LexerPopModeAction()
+
+# Implements the {@code more} lexer action by calling {@link Lexer#more}.
+#
+# <p>The {@code more} command does not have any parameters, so this action is
+# implemented as a singleton instance exposed by {@link #INSTANCE}.</p>
+class LexerMoreAction(LexerAction):
+
+    INSTANCE = None
+
+    def __init__(self):
+        super().__init__(LexerActionType.MORE)
+
+    # <p>This action is implemented by calling {@link Lexer#popMode}.</p>
+    def execute(self, lexer:Lexer):
+        lexer.more()
+
+    def __str__(self):
+        return "more"
+
+LexerMoreAction.INSTANCE = LexerMoreAction()
+
+# Implements the {@code mode} lexer action by calling {@link Lexer#mode} with
+# the assigned mode.
+class LexerModeAction(LexerAction):
+    __slots__ = 'mode'
+
+    def __init__(self, mode:int):
+        super().__init__(LexerActionType.MODE)
+        self.mode = mode
+
+    # <p>This action is implemented by calling {@link Lexer#mode} with the
+    # value provided by {@link #getMode}.</p>
+    def execute(self, lexer:Lexer):
+        lexer.mode(self.mode)
+
+    def __hash__(self):
+        return hash((self.actionType, self.mode))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerModeAction):
+            return False
+        else:
+            return self.mode == other.mode
+
+    def __str__(self):
+        return "mode(" + str(self.mode) + ")"
+
+# Executes a custom lexer action by calling {@link Recognizer#action} with the
+# rule and action indexes assigned to the custom action. The implementation of
+# a custom action is added to the generated code for the lexer in an override
+# of {@link Recognizer#action} when the grammar is compiled.
+#
+# <p>This class may represent embedded actions created with the <code>{...}</code>
+# syntax in ANTLR 4, as well as actions created for lexer commands where the
+# command argument could not be evaluated when the grammar was compiled.</p>
+
+class LexerCustomAction(LexerAction):
+    __slots__ = ('ruleIndex', 'actionIndex')
+
+    # Constructs a custom lexer action with the specified rule and action
+    # indexes.
+    #
+    # @param ruleIndex The rule index to use for calls to
+    # {@link Recognizer#action}.
+    # @param actionIndex The action index to use for calls to
+    # {@link Recognizer#action}.
+    #/
+    def __init__(self, ruleIndex:int, actionIndex:int):
+        super().__init__(LexerActionType.CUSTOM)
+        self.ruleIndex = ruleIndex
+        self.actionIndex = actionIndex
+        self.isPositionDependent = True
+
+    # <p>Custom actions are implemented by calling {@link Lexer#action} with the
+    # appropriate rule and action indexes.</p>
+    def execute(self, lexer:Lexer):
+        lexer.action(None, self.ruleIndex, self.actionIndex)
+
+    def __hash__(self):
+        return hash((self.actionType, self.ruleIndex, self.actionIndex))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerCustomAction):
+            return False
+        else:
+            return self.ruleIndex == other.ruleIndex and self.actionIndex == other.actionIndex
+
+# Implements the {@code channel} lexer action by calling
+# {@link Lexer#setChannel} with the assigned channel.
+class LexerChannelAction(LexerAction):
+    __slots__ = 'channel'
+
+    # Constructs a new {@code channel} action with the specified channel value.
+    # @param channel The channel value to pass to {@link Lexer#setChannel}.
+    def __init__(self, channel:int):
+        super().__init__(LexerActionType.CHANNEL)
+        self.channel = channel
+
+    # <p>This action is implemented by calling {@link Lexer#setChannel} with the
+    # value provided by {@link #getChannel}.</p>
+    def execute(self, lexer:Lexer):
+        lexer._channel = self.channel
+
+    def __hash__(self):
+        return hash((self.actionType, self.channel))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerChannelAction):
+            return False
+        else:
+            return self.channel == other.channel
+
+    def __str__(self):
+        return "channel(" + str(self.channel) + ")"
+
+# This implementation of {@link LexerAction} is used for tracking input offsets
+# for position-dependent actions within a {@link LexerActionExecutor}.
+#
+# <p>This action is not serialized as part of the ATN, and is only required for
+# position-dependent lexer actions which appear at a location other than the
+# end of a rule. For more information about DFA optimizations employed for
+# lexer actions, see {@link LexerActionExecutor#append} and
+# {@link LexerActionExecutor#fixOffsetBeforeMatch}.</p>
+class LexerIndexedCustomAction(LexerAction):
+    __slots__ = ('offset', 'action')
+
+    # Constructs a new indexed custom action by associating a character offset
+    # with a {@link LexerAction}.
+    #
+    # <p>Note: This class is only required for lexer actions for which
+    # {@link LexerAction#isPositionDependent} returns {@code true}.</p>
+    #
+    # @param offset The offset into the input {@link CharStream}, relative to
+    # the token start index, at which the specified lexer action should be
+    # executed.
+    # @param action The lexer action to execute at a particular offset in the
+    # input {@link CharStream}.
+    def __init__(self, offset:int, action:LexerAction):
+        super().__init__(action.actionType)
+        self.offset = offset
+        self.action = action
+        self.isPositionDependent = True
+
+    # <p>This method calls {@link #execute} on the result of {@link #getAction}
+    # using the provided {@code lexer}.</p>
+    def execute(self, lexer:Lexer):
+        # assume the input stream position was properly set by the calling code
+        self.action.execute(lexer)
+
+    def __hash__(self):
+        return hash((self.actionType, self.offset, self.action))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerIndexedCustomAction):
+            return False
+        else:
+            return self.offset == other.offset and self.action == other.action

cameras/deps/antlr4/atn/LexerActionExecutor.py

@@ -0,0 +1,143 @@
+#
+# 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.
+#/
+
+# Represents an executor for a sequence of lexer actions which traversed during
+# the matching operation of a lexer rule (token).
+#
+# <p>The executor tracks position information for position-dependent lexer actions
+# efficiently, ensuring that actions appearing only at the end of the rule do
+# not cause bloating of the {@link DFA} created for the lexer.</p>
+
+
+from antlr4.InputStream import InputStream
+from antlr4.atn.LexerAction import LexerAction, LexerIndexedCustomAction
+
+# need a forward declaration
+Lexer = None
+LexerActionExecutor = None
+
+class LexerActionExecutor(object):
+    __slots__ = ('lexerActions', 'hashCode')
+
+    def __init__(self, lexerActions:list=list()):
+        self.lexerActions = lexerActions
+        # Caches the result of {@link #hashCode} since the hash code is an element
+        # of the performance-critical {@link LexerATNConfig#hashCode} operation.
+        self.hashCode = hash("".join([str(la) for la in lexerActions]))
+
+
+    # Creates a {@link LexerActionExecutor} which executes the actions for
+    # the input {@code lexerActionExecutor} followed by a specified
+    # {@code lexerAction}.
+    #
+    # @param lexerActionExecutor The executor for actions already traversed by
+    # the lexer while matching a token within a particular
+    # {@link LexerATNConfig}. If this is {@code null}, the method behaves as
+    # though it were an empty executor.
+    # @param lexerAction The lexer action to execute after the actions
+    # specified in {@code lexerActionExecutor}.
+    #
+    # @return A {@link LexerActionExecutor} for executing the combine actions
+    # of {@code lexerActionExecutor} and {@code lexerAction}.
+    @staticmethod
+    def append(lexerActionExecutor:LexerActionExecutor , lexerAction:LexerAction ):
+        if lexerActionExecutor is None:
+            return LexerActionExecutor([ lexerAction ])
+
+        lexerActions = lexerActionExecutor.lexerActions + [ lexerAction ]
+        return LexerActionExecutor(lexerActions)
+
+    # Creates a {@link LexerActionExecutor} which encodes the current offset
+    # for position-dependent lexer actions.
+    #
+    # <p>Normally, when the executor encounters lexer actions where
+    # {@link LexerAction#isPositionDependent} returns {@code true}, it calls
+    # {@link IntStream#seek} on the input {@link CharStream} to set the input
+    # position to the <em>end</em> of the current token. This behavior provides
+    # for efficient DFA representation of lexer actions which appear at the end
+    # of a lexer rule, even when the lexer rule matches a variable number of
+    # characters.</p>
+    #
+    # <p>Prior to traversing a match transition in the ATN, the current offset
+    # from the token start index is assigned to all position-dependent lexer
+    # actions which have not already been assigned a fixed offset. By storing
+    # the offsets relative to the token start index, the DFA representation of
+    # lexer actions which appear in the middle of tokens remains efficient due
+    # to sharing among tokens of the same length, regardless of their absolute
+    # position in the input stream.</p>
+    #
+    # <p>If the current executor already has offsets assigned to all
+    # position-dependent lexer actions, the method returns {@code this}.</p>
+    #
+    # @param offset The current offset to assign to all position-dependent
+    # lexer actions which do not already have offsets assigned.
+    #
+    # @return A {@link LexerActionExecutor} which stores input stream offsets
+    # for all position-dependent lexer actions.
+    #/
+    def fixOffsetBeforeMatch(self, offset:int):
+        updatedLexerActions = None
+        for i in range(0, len(self.lexerActions)):
+            if self.lexerActions[i].isPositionDependent and not isinstance(self.lexerActions[i], LexerIndexedCustomAction):
+                if updatedLexerActions is None:
+                    updatedLexerActions = [ la for la in self.lexerActions ]
+                updatedLexerActions[i] = LexerIndexedCustomAction(offset, self.lexerActions[i])
+
+        if updatedLexerActions is None:
+            return self
+        else:
+            return LexerActionExecutor(updatedLexerActions)
+
+
+    # Execute the actions encapsulated by this executor within the context of a
+    # particular {@link Lexer}.
+    #
+    # <p>This method calls {@link IntStream#seek} to set the position of the
+    # {@code input} {@link CharStream} prior to calling
+    # {@link LexerAction#execute} on a position-dependent action. Before the
+    # method returns, the input position will be restored to the same position
+    # it was in when the method was invoked.</p>
+    #
+    # @param lexer The lexer instance.
+    # @param input The input stream which is the source for the current token.
+    # When this method is called, the current {@link IntStream#index} for
+    # {@code input} should be the start of the following token, i.e. 1
+    # character past the end of the current token.
+    # @param startIndex The token start index. This value may be passed to
+    # {@link IntStream#seek} to set the {@code input} position to the beginning
+    # of the token.
+    #/
+    def execute(self, lexer:Lexer, input:InputStream, startIndex:int):
+        requiresSeek = False
+        stopIndex = input.index
+        try:
+            for lexerAction in self.lexerActions:
+                if isinstance(lexerAction, LexerIndexedCustomAction):
+                    offset = lexerAction.offset
+                    input.seek(startIndex + offset)
+                    lexerAction = lexerAction.action
+                    requiresSeek = (startIndex + offset) != stopIndex
+                elif lexerAction.isPositionDependent:
+                    input.seek(stopIndex)
+                    requiresSeek = False
+                lexerAction.execute(lexer)
+        finally:
+            if requiresSeek:
+                input.seek(stopIndex)
+
+    def __hash__(self):
+        return self.hashCode
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerActionExecutor):
+            return False
+        else:
+            return self.hashCode == other.hashCode \
+                and self.lexerActions == other.lexerActions
+
+del Lexer

cameras/deps/antlr4/atn/ParserATNSimulator.py

@@ -0,0 +1,1649 @@
+#
+# 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.
+#
+
+#
+# The embodiment of the adaptive LL(*), ALL(*), parsing strategy.
+#
+# <p>
+# The basic complexity of the adaptive strategy makes it harder to understand.
+# We begin with ATN simulation to build paths in a DFA. Subsequent prediction
+# requests go through the DFA first. If they reach a state without an edge for
+# the current symbol, the algorithm fails over to the ATN simulation to
+# complete the DFA path for the current input (until it finds a conflict state
+# or uniquely predicting state).</p>
+#
+# <p>
+# All of that is done without using the outer context because we want to create
+# a DFA that is not dependent upon the rule invocation stack when we do a
+# prediction. One DFA works in all contexts. We avoid using context not
+# necessarily because it's slower, although it can be, but because of the DFA
+# caching problem. The closure routine only considers the rule invocation stack
+# created during prediction beginning in the decision rule. For example, if
+# prediction occurs without invoking another rule's ATN, there are no context
+# stacks in the configurations. When lack of context leads to a conflict, we
+# don't know if it's an ambiguity or a weakness in the strong LL(*) parsing
+# strategy (versus full LL(*)).</p>
+#
+# <p>
+# When SLL yields a configuration set with conflict, we rewind the input and
+# retry the ATN simulation, this time using full outer context without adding
+# to the DFA. Configuration context stacks will be the full invocation stacks
+# from the start rule. If we get a conflict using full context, then we can
+# definitively say we have a true ambiguity for that input sequence. If we
+# don't get a conflict, it implies that the decision is sensitive to the outer
+# context. (It is not context-sensitive in the sense of context-sensitive
+# grammars.)</p>
+#
+# <p>
+# The next time we reach this DFA state with an SLL conflict, through DFA
+# simulation, we will again retry the ATN simulation using full context mode.
+# This is slow because we can't save the results and have to "interpret" the
+# ATN each time we get that input.</p>
+#
+# <p>
+# <strong>CACHING FULL CONTEXT PREDICTIONS</strong></p>
+#
+# <p>
+# We could cache results from full context to predicted alternative easily and
+# that saves a lot of time but doesn't work in presence of predicates. The set
+# of visible predicates from the ATN start state changes depending on the
+# context, because closure can fall off the end of a rule. I tried to cache
+# tuples (stack context, semantic context, predicted alt) but it was slower
+# than interpreting and much more complicated. Also required a huge amount of
+# memory. The goal is not to create the world's fastest parser anyway. I'd like
+# to keep this algorithm simple. By launching multiple threads, we can improve
+# the speed of parsing across a large number of files.</p>
+#
+# <p>
+# There is no strict ordering between the amount of input used by SLL vs LL,
+# which makes it really hard to build a cache for full context. Let's say that
+# we have input A B C that leads to an SLL conflict with full context X. That
+# implies that using X we might only use A B but we could also use A B C D to
+# resolve conflict. Input A B C D could predict alternative 1 in one position
+# in the input and A B C E could predict alternative 2 in another position in
+# input. The conflicting SLL configurations could still be non-unique in the
+# full context prediction, which would lead us to requiring more input than the
+# original A B C.	To make a	prediction cache work, we have to track	the exact
+# input	used during the previous prediction. That amounts to a cache that maps
+# X to a specific DFA for that context.</p>
+#
+# <p>
+# Something should be done for left-recursive expression predictions. They are
+# likely LL(1) + pred eval. Easier to do the whole SLL unless error and retry
+# with full LL thing Sam does.</p>
+#
+# <p>
+# <strong>AVOIDING FULL CONTEXT PREDICTION</strong></p>
+#
+# <p>
+# We avoid doing full context retry when the outer context is empty, we did not
+# dip into the outer context by falling off the end of the decision state rule,
+# or when we force SLL mode.</p>
+#
+# <p>
+# As an example of the not dip into outer context case, consider as super
+# constructor calls versus function calls. One grammar might look like
+# this:</p>
+#
+# <pre>
+# ctorBody
+#   : '{' superCall? stat* '}'
+#   ;
+# </pre>
+#
+# <p>
+# Or, you might see something like</p>
+#
+# <pre>
+# stat
+#   : superCall ';'
+#   | expression ';'
+#   | ...
+#   ;
+# </pre>
+#
+# <p>
+# In both cases I believe that no closure operations will dip into the outer
+# context. In the first case ctorBody in the worst case will stop at the '}'.
+# In the 2nd case it should stop at the ';'. Both cases should stay within the
+# entry rule and not dip into the outer context.</p>
+#
+# <p>
+# <strong>PREDICATES</strong></p>
+#
+# <p>
+# Predicates are always evaluated if present in either SLL or LL both. SLL and
+# LL simulation deals with predicates differently. SLL collects predicates as
+# it performs closure operations like ANTLR v3 did. It delays predicate
+# evaluation until it reaches and accept state. This allows us to cache the SLL
+# ATN simulation whereas, if we had evaluated predicates on-the-fly during
+# closure, the DFA state configuration sets would be different and we couldn't
+# build up a suitable DFA.</p>
+#
+# <p>
+# When building a DFA accept state during ATN simulation, we evaluate any
+# predicates and return the sole semantically valid alternative. If there is
+# more than 1 alternative, we report an ambiguity. If there are 0 alternatives,
+# we throw an exception. Alternatives without predicates act like they have
+# true predicates. The simple way to think about it is to strip away all
+# alternatives with false predicates and choose the minimum alternative that
+# remains.</p>
+#
+# <p>
+# When we start in the DFA and reach an accept state that's predicated, we test
+# those and return the minimum semantically viable alternative. If no
+# alternatives are viable, we throw an exception.</p>
+#
+# <p>
+# During full LL ATN simulation, closure always evaluates predicates and
+# on-the-fly. This is crucial to reducing the configuration set size during
+# closure. It hits a landmine when parsing with the Java grammar, for example,
+# without this on-the-fly evaluation.</p>
+#
+# <p>
+# <strong>SHARING DFA</strong></p>
+#
+# <p>
+# All instances of the same parser share the same decision DFAs through a
+# static field. Each instance gets its own ATN simulator but they share the
+# same {@link #decisionToDFA} field. They also share a
+# {@link PredictionContextCache} object that makes sure that all
+# {@link PredictionContext} objects are shared among the DFA states. This makes
+# a big size difference.</p>
+#
+# <p>
+# <strong>THREAD SAFETY</strong></p>
+#
+# <p>
+# The {@link ParserATNSimulator} locks on the {@link #decisionToDFA} field when
+# it adds a new DFA object to that array. {@link #addDFAEdge}
+# locks on the DFA for the current decision when setting the
+# {@link DFAState#edges} field. {@link #addDFAState} locks on
+# the DFA for the current decision when looking up a DFA state to see if it
+# already exists. We must make sure that all requests to add DFA states that
+# are equivalent result in the same shared DFA object. This is because lots of
+# threads will be trying to update the DFA at once. The
+# {@link #addDFAState} method also locks inside the DFA lock
+# but this time on the shared context cache when it rebuilds the
+# configurations' {@link PredictionContext} objects using cached
+# subgraphs/nodes. No other locking occurs, even during DFA simulation. This is
+# safe as long as we can guarantee that all threads referencing
+# {@code s.edge[t]} get the same physical target {@link DFAState}, or
+# {@code null}. Once into the DFA, the DFA simulation does not reference the
+# {@link DFA#states} map. It follows the {@link DFAState#edges} field to new
+# targets. The DFA simulator will either find {@link DFAState#edges} to be
+# {@code null}, to be non-{@code null} and {@code dfa.edges[t]} null, or
+# {@code dfa.edges[t]} to be non-null. The
+# {@link #addDFAEdge} method could be racing to set the field
+# but in either case the DFA simulator works; if {@code null}, and requests ATN
+# simulation. It could also race trying to get {@code dfa.edges[t]}, but either
+# way it will work because it's not doing a test and set operation.</p>
+#
+# <p>
+# <strong>Starting with SLL then failing to combined SLL/LL (Two-Stage
+# Parsing)</strong></p>
+#
+# <p>
+# Sam pointed out that if SLL does not give a syntax error, then there is no
+# point in doing full LL, which is slower. We only have to try LL if we get a
+# syntax error. For maximum speed, Sam starts the parser set to pure SLL
+# mode with the {@link BailErrorStrategy}:</p>
+#
+# <pre>
+# parser.{@link Parser#getInterpreter() getInterpreter()}.{@link #setPredictionMode setPredictionMode}{@code (}{@link PredictionMode#SLL}{@code )};
+# parser.{@link Parser#setErrorHandler setErrorHandler}(new {@link BailErrorStrategy}());
+# </pre>
+#
+# <p>
+# If it does not get a syntax error, then we're done. If it does get a syntax
+# error, we need to retry with the combined SLL/LL strategy.</p>
+#
+# <p>
+# The reason this works is as follows. If there are no SLL conflicts, then the
+# grammar is SLL (at least for that input set). If there is an SLL conflict,
+# the full LL analysis must yield a set of viable alternatives which is a
+# subset of the alternatives reported by SLL. If the LL set is a singleton,
+# then the grammar is LL but not SLL. If the LL set is the same size as the SLL
+# set, the decision is SLL. If the LL set has size &gt; 1, then that decision
+# is truly ambiguous on the current input. If the LL set is smaller, then the
+# SLL conflict resolution might choose an alternative that the full LL would
+# rule out as a possibility based upon better context information. If that's
+# the case, then the SLL parse will definitely get an error because the full LL
+# analysis says it's not viable. If SLL conflict resolution chooses an
+# alternative within the LL set, them both SLL and LL would choose the same
+# alternative because they both choose the minimum of multiple conflicting
+# alternatives.</p>
+#
+# <p>
+# Let's say we have a set of SLL conflicting alternatives {@code {1, 2, 3}} and
+# a smaller LL set called <em>s</em>. If <em>s</em> is {@code {2, 3}}, then SLL
+# parsing will get an error because SLL will pursue alternative 1. If
+# <em>s</em> is {@code {1, 2}} or {@code {1, 3}} then both SLL and LL will
+# choose the same alternative because alternative one is the minimum of either
+# set. If <em>s</em> is {@code {2}} or {@code {3}} then SLL will get a syntax
+# error. If <em>s</em> is {@code {1}} then SLL will succeed.</p>
+#
+# <p>
+# Of course, if the input is invalid, then we will get an error for sure in
+# both SLL and LL parsing. Erroneous input will therefore require 2 passes over
+# the input.</p>
+#
+import sys
+from antlr4 import DFA
+from antlr4.PredictionContext import PredictionContextCache, PredictionContext, SingletonPredictionContext, \
+    PredictionContextFromRuleContext
+from antlr4.BufferedTokenStream import TokenStream
+from antlr4.Parser import Parser
+from antlr4.ParserRuleContext import ParserRuleContext
+from antlr4.RuleContext import RuleContext
+from antlr4.Token import Token
+from antlr4.Utils import str_list
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNConfig import ATNConfig
+from antlr4.atn.ATNConfigSet import ATNConfigSet
+from antlr4.atn.ATNSimulator import ATNSimulator
+from antlr4.atn.ATNState import StarLoopEntryState, DecisionState, RuleStopState, ATNState
+from antlr4.atn.PredictionMode import PredictionMode
+from antlr4.atn.SemanticContext import SemanticContext, AND, andContext, orContext
+from antlr4.atn.Transition import Transition, RuleTransition, ActionTransition, PrecedencePredicateTransition, \
+    PredicateTransition, AtomTransition, SetTransition, NotSetTransition
+from antlr4.dfa.DFAState import DFAState, PredPrediction
+from antlr4.error.Errors import NoViableAltException
+
+
+class ParserATNSimulator(ATNSimulator):
+    __slots__ = (
+        'parser', 'decisionToDFA', 'predictionMode', '_input', '_startIndex',
+        '_outerContext', '_dfa', 'mergeCache'
+    )
+
+    debug = False
+    debug_list_atn_decisions = False
+    dfa_debug = False
+    retry_debug = False
+
+
+    def __init__(self, parser:Parser, atn:ATN, decisionToDFA:list, sharedContextCache:PredictionContextCache):
+        super().__init__(atn, sharedContextCache)
+        self.parser = parser
+        self.decisionToDFA = decisionToDFA
+        # SLL, LL, or LL + exact ambig detection?#
+        self.predictionMode = PredictionMode.LL
+        # LAME globals to avoid parameters!!!!! I need these down deep in predTransition
+        self._input = None
+        self._startIndex = 0
+        self._outerContext = None
+        self._dfa = None
+        # Each prediction operation uses a cache for merge of prediction contexts.
+        #  Don't keep around as it wastes huge amounts of memory. DoubleKeyMap
+        #  isn't synchronized but we're ok since two threads shouldn't reuse same
+        #  parser/atnsim object because it can only handle one input at a time.
+        #  This maps graphs a and b to merged result c. (a,b)&rarr;c. We can avoid
+        #  the merge if we ever see a and b again.  Note that (b,a)&rarr;c should
+        #  also be examined during cache lookup.
+        #
+        self.mergeCache = None
+
+
+    def reset(self):
+        pass
+
+    def adaptivePredict(self, input:TokenStream, decision:int, outerContext:ParserRuleContext):
+        if ParserATNSimulator.debug or ParserATNSimulator.debug_list_atn_decisions:
+            print("adaptivePredict decision " + str(decision) +
+                                   " exec LA(1)==" + self.getLookaheadName(input) +
+                                   " line " + str(input.LT(1).line) + ":" +
+                                   str(input.LT(1).column))
+        self._input = input
+        self._startIndex = input.index
+        self._outerContext = outerContext
+
+        dfa = self.decisionToDFA[decision]
+        self._dfa = dfa
+        m = input.mark()
+        index = input.index
+
+        # Now we are certain to have a specific decision's DFA
+        # But, do we still need an initial state?
+        try:
+            if dfa.precedenceDfa:
+                # the start state for a precedence DFA depends on the current
+                # parser precedence, and is provided by a DFA method.
+                s0 = dfa.getPrecedenceStartState(self.parser.getPrecedence())
+            else:
+                # the start state for a "regular" DFA is just s0
+                s0 = dfa.s0
+
+            if s0 is None:
+                if outerContext is None:
+                    outerContext = ParserRuleContext.EMPTY
+                if ParserATNSimulator.debug or ParserATNSimulator.debug_list_atn_decisions:
+                    print("predictATN decision " + str(dfa.decision) +
+                                       " exec LA(1)==" + self.getLookaheadName(input) +
+                                       ", outerContext=" + outerContext.toString(self.parser.literalNames, None))
+
+                fullCtx = False
+                s0_closure = self.computeStartState(dfa.atnStartState, ParserRuleContext.EMPTY, fullCtx)
+
+                if dfa.precedenceDfa:
+                    # If this is a precedence DFA, we use applyPrecedenceFilter
+                    # to convert the computed start state to a precedence start
+                    # state. We then use DFA.setPrecedenceStartState to set the
+                    # appropriate start state for the precedence level rather
+                    # than simply setting DFA.s0.
+                    #
+                    dfa.s0.configs = s0_closure # not used for prediction but useful to know start configs anyway
+                    s0_closure = self.applyPrecedenceFilter(s0_closure)
+                    s0 = self.addDFAState(dfa, DFAState(configs=s0_closure))
+                    dfa.setPrecedenceStartState(self.parser.getPrecedence(), s0)
+                else:
+                    s0 = self.addDFAState(dfa, DFAState(configs=s0_closure))
+                    dfa.s0 = s0
+
+            alt = self.execATN(dfa, s0, input, index, outerContext)
+            if ParserATNSimulator.debug:
+                print("DFA after predictATN: " + dfa.toString(self.parser.literalNames))
+            return alt
+        finally:
+            self._dfa = None
+            self.mergeCache = None # wack cache after each prediction
+            input.seek(index)
+            input.release(m)
+
+    # Performs ATN simulation to compute a predicted alternative based
+    #  upon the remaining input, but also updates the DFA cache to avoid
+    #  having to traverse the ATN again for the same input sequence.
+
+    # There are some key conditions we're looking for after computing a new
+    # set of ATN configs (proposed DFA state):
+          # if the set is empty, there is no viable alternative for current symbol
+          # does the state uniquely predict an alternative?
+          # does the state have a conflict that would prevent us from
+          #   putting it on the work list?
+
+    # We also have some key operations to do:
+          # add an edge from previous DFA state to potentially new DFA state, D,
+          #   upon current symbol but only if adding to work list, which means in all
+          #   cases except no viable alternative (and possibly non-greedy decisions?)
+          # collecting predicates and adding semantic context to DFA accept states
+          # adding rule context to context-sensitive DFA accept states
+          # consuming an input symbol
+          # reporting a conflict
+          # reporting an ambiguity
+          # reporting a context sensitivity
+          # reporting insufficient predicates
+
+    # cover these cases:
+    #    dead end
+    #    single alt
+    #    single alt + preds
+    #    conflict
+    #    conflict + preds
+    #
+    def execATN(self, dfa:DFA, s0:DFAState, input:TokenStream, startIndex:int, outerContext:ParserRuleContext ):
+        if ParserATNSimulator.debug or ParserATNSimulator.debug_list_atn_decisions:
+            print("execATN decision " + str(dfa.decision) +
+                    " exec LA(1)==" + self.getLookaheadName(input) +
+                    " line " + str(input.LT(1).line) + ":" + str(input.LT(1).column))
+
+        previousD = s0
+
+        if ParserATNSimulator.debug:
+            print("s0 = " + str(s0))
+
+        t = input.LA(1)
+
+        while True: # while more work
+            D = self.getExistingTargetState(previousD, t)
+            if D is None:
+                D = self.computeTargetState(dfa, previousD, t)
+            if D is self.ERROR:
+                # if any configs in previous dipped into outer context, that
+                # means that input up to t actually finished entry rule
+                # at least for SLL decision. Full LL doesn't dip into outer
+                # so don't need special case.
+                # We will get an error no matter what so delay until after
+                # decision; better error message. Also, no reachable target
+                # ATN states in SLL implies LL will also get nowhere.
+                # If conflict in states that dip out, choose min since we
+                # will get error no matter what.
+                e = self.noViableAlt(input, outerContext, previousD.configs, startIndex)
+                input.seek(startIndex)
+                alt = self.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(previousD.configs, outerContext)
+                if alt!=ATN.INVALID_ALT_NUMBER:
+                    return alt
+                raise e
+
+            if D.requiresFullContext and self.predictionMode != PredictionMode.SLL:
+                # IF PREDS, MIGHT RESOLVE TO SINGLE ALT => SLL (or syntax error)
+                conflictingAlts = D.configs.conflictingAlts
+                if D.predicates is not None:
+                    if ParserATNSimulator.debug:
+                        print("DFA state has preds in DFA sim LL failover")
+                    conflictIndex = input.index
+                    if conflictIndex != startIndex:
+                        input.seek(startIndex)
+
+                    conflictingAlts = self.evalSemanticContext(D.predicates, outerContext, True)
+                    if len(conflictingAlts)==1:
+                        if ParserATNSimulator.debug:
+                            print("Full LL avoided")
+                        return min(conflictingAlts)
+
+                    if conflictIndex != startIndex:
+                        # restore the index so reporting the fallback to full
+                        # context occurs with the index at the correct spot
+                        input.seek(conflictIndex)
+
+                if ParserATNSimulator.dfa_debug:
+                    print("ctx sensitive state " + str(outerContext) +" in " + str(D))
+                fullCtx = True
+                s0_closure = self.computeStartState(dfa.atnStartState, outerContext, fullCtx)
+                self.reportAttemptingFullContext(dfa, conflictingAlts, D.configs, startIndex, input.index)
+                alt = self.execATNWithFullContext(dfa, D, s0_closure, input, startIndex, outerContext)
+                return alt
+
+            if D.isAcceptState:
+                if D.predicates is None:
+                    return D.prediction
+
+                stopIndex = input.index
+                input.seek(startIndex)
+                alts = self.evalSemanticContext(D.predicates, outerContext, True)
+                if len(alts)==0:
+                    raise self.noViableAlt(input, outerContext, D.configs, startIndex)
+                elif len(alts)==1:
+                    return min(alts)
+                else:
+                    # report ambiguity after predicate evaluation to make sure the correct
+                    # set of ambig alts is reported.
+                    self.reportAmbiguity(dfa, D, startIndex, stopIndex, False, alts, D.configs)
+                    return min(alts)
+
+            previousD = D
+
+            if t != Token.EOF:
+                input.consume()
+                t = input.LA(1)
+
+    #
+    # Get an existing target state for an edge in the DFA. If the target state
+    # for the edge has not yet been computed or is otherwise not available,
+    # this method returns {@code null}.
+    #
+    # @param previousD The current DFA state
+    # @param t The next input symbol
+    # @return The existing target DFA state for the given input symbol
+    # {@code t}, or {@code null} if the target state for this edge is not
+    # already cached
+    #
+    def getExistingTargetState(self, previousD:DFAState, t:int):
+        edges = previousD.edges
+        if edges is None or t + 1 < 0 or t + 1 >= len(edges):
+            return None
+        else:
+            return edges[t + 1]
+
+    #
+    # Compute a target state for an edge in the DFA, and attempt to add the
+    # computed state and corresponding edge to the DFA.
+    #
+    # @param dfa The DFA
+    # @param previousD The current DFA state
+    # @param t The next input symbol
+    #
+    # @return The computed target DFA state for the given input symbol
+    # {@code t}. If {@code t} does not lead to a valid DFA state, this method
+    # returns {@link #ERROR}.
+    #
+    def computeTargetState(self, dfa:DFA, previousD:DFAState, t:int):
+        reach = self.computeReachSet(previousD.configs, t, False)
+        if reach is None:
+            self.addDFAEdge(dfa, previousD, t, self.ERROR)
+            return self.ERROR
+
+        # create new target state; we'll add to DFA after it's complete
+        D = DFAState(configs=reach)
+
+        predictedAlt = self.getUniqueAlt(reach)
+
+        if ParserATNSimulator.debug:
+            altSubSets = PredictionMode.getConflictingAltSubsets(reach)
+            print("SLL altSubSets=" + str(altSubSets) + ", configs=" + str(reach) +
+                        ", predict=" + str(predictedAlt) + ", allSubsetsConflict=" +
+                        str(PredictionMode.allSubsetsConflict(altSubSets)) + ", conflictingAlts=" +
+                        str(self.getConflictingAlts(reach)))
+
+        if predictedAlt!=ATN.INVALID_ALT_NUMBER:
+            # NO CONFLICT, UNIQUELY PREDICTED ALT
+            D.isAcceptState = True
+            D.configs.uniqueAlt = predictedAlt
+            D.prediction = predictedAlt
+        elif PredictionMode.hasSLLConflictTerminatingPrediction(self.predictionMode, reach):
+            # MORE THAN ONE VIABLE ALTERNATIVE
+            D.configs.conflictingAlts = self.getConflictingAlts(reach)
+            D.requiresFullContext = True
+            # in SLL-only mode, we will stop at this state and return the minimum alt
+            D.isAcceptState = True
+            D.prediction = min(D.configs.conflictingAlts)
+
+        if D.isAcceptState and D.configs.hasSemanticContext:
+            self.predicateDFAState(D, self.atn.getDecisionState(dfa.decision))
+            if D.predicates is not None:
+                D.prediction = ATN.INVALID_ALT_NUMBER
+
+        # all adds to dfa are done after we've created full D state
+        D = self.addDFAEdge(dfa, previousD, t, D)
+        return D
+
+    def predicateDFAState(self, dfaState:DFAState, decisionState:DecisionState):
+        # We need to test all predicates, even in DFA states that
+        # uniquely predict alternative.
+        nalts = len(decisionState.transitions)
+        # Update DFA so reach becomes accept state with (predicate,alt)
+        # pairs if preds found for conflicting alts
+        altsToCollectPredsFrom = self.getConflictingAltsOrUniqueAlt(dfaState.configs)
+        altToPred = self.getPredsForAmbigAlts(altsToCollectPredsFrom, dfaState.configs, nalts)
+        if altToPred is not None:
+            dfaState.predicates = self.getPredicatePredictions(altsToCollectPredsFrom, altToPred)
+            dfaState.prediction = ATN.INVALID_ALT_NUMBER # make sure we use preds
+        else:
+            # There are preds in configs but they might go away
+            # when OR'd together like {p}? || NONE == NONE. If neither
+            # alt has preds, resolve to min alt
+            dfaState.prediction = min(altsToCollectPredsFrom)
+
+    # comes back with reach.uniqueAlt set to a valid alt
+    def execATNWithFullContext(self, dfa:DFA, D:DFAState, # how far we got before failing over
+                                         s0:ATNConfigSet,
+                                         input:TokenStream,
+                                         startIndex:int,
+                                         outerContext:ParserRuleContext):
+        if ParserATNSimulator.debug or ParserATNSimulator.debug_list_atn_decisions:
+            print("execATNWithFullContext", str(s0))
+        fullCtx = True
+        foundExactAmbig = False
+        reach = None
+        previous = s0
+        input.seek(startIndex)
+        t = input.LA(1)
+        predictedAlt = -1
+        while (True): # while more work
+            reach = self.computeReachSet(previous, t, fullCtx)
+            if reach is None:
+                # if any configs in previous dipped into outer context, that
+                # means that input up to t actually finished entry rule
+                # at least for LL decision. Full LL doesn't dip into outer
+                # so don't need special case.
+                # We will get an error no matter what so delay until after
+                # decision; better error message. Also, no reachable target
+                # ATN states in SLL implies LL will also get nowhere.
+                # If conflict in states that dip out, choose min since we
+                # will get error no matter what.
+                e = self.noViableAlt(input, outerContext, previous, startIndex)
+                input.seek(startIndex)
+                alt = self.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(previous, outerContext)
+                if alt!=ATN.INVALID_ALT_NUMBER:
+                    return alt
+                else:
+                    raise e
+
+            altSubSets = PredictionMode.getConflictingAltSubsets(reach)
+            if ParserATNSimulator.debug:
+                print("LL altSubSets=" + str(altSubSets) + ", predict=" +
+                      str(PredictionMode.getUniqueAlt(altSubSets)) + ", resolvesToJustOneViableAlt=" +
+                      str(PredictionMode.resolvesToJustOneViableAlt(altSubSets)))
+
+            reach.uniqueAlt = self.getUniqueAlt(reach)
+            # unique prediction?
+            if reach.uniqueAlt!=ATN.INVALID_ALT_NUMBER:
+                predictedAlt = reach.uniqueAlt
+                break
+            elif self.predictionMode is not PredictionMode.LL_EXACT_AMBIG_DETECTION:
+                predictedAlt = PredictionMode.resolvesToJustOneViableAlt(altSubSets)
+                if predictedAlt != ATN.INVALID_ALT_NUMBER:
+                    break
+            else:
+                # In exact ambiguity mode, we never try to terminate early.
+                # Just keeps scarfing until we know what the conflict is
+                if PredictionMode.allSubsetsConflict(altSubSets) and PredictionMode.allSubsetsEqual(altSubSets):
+                    foundExactAmbig = True
+                    predictedAlt = PredictionMode.getSingleViableAlt(altSubSets)
+                    break
+                # else there are multiple non-conflicting subsets or
+                # we're not sure what the ambiguity is yet.
+                # So, keep going.
+
+            previous = reach
+            if t != Token.EOF:
+                input.consume()
+                t = input.LA(1)
+
+        # If the configuration set uniquely predicts an alternative,
+        # without conflict, then we know that it's a full LL decision
+        # not SLL.
+        if reach.uniqueAlt != ATN.INVALID_ALT_NUMBER :
+            self.reportContextSensitivity(dfa, predictedAlt, reach, startIndex, input.index)
+            return predictedAlt
+
+        # We do not check predicates here because we have checked them
+        # on-the-fly when doing full context prediction.
+
+        #
+        # In non-exact ambiguity detection mode, we might	actually be able to
+        # detect an exact ambiguity, but I'm not going to spend the cycles
+        # needed to check. We only emit ambiguity warnings in exact ambiguity
+        # mode.
+        #
+        # For example, we might know that we have conflicting configurations.
+        # But, that does not mean that there is no way forward without a
+        # conflict. It's possible to have nonconflicting alt subsets as in:
+
+        # altSubSets=[{1, 2}, {1, 2}, {1}, {1, 2}]
+
+        # from
+        #
+        #    [(17,1,[5 $]), (13,1,[5 10 $]), (21,1,[5 10 $]), (11,1,[$]),
+        #     (13,2,[5 10 $]), (21,2,[5 10 $]), (11,2,[$])]
+        #
+        # In this case, (17,1,[5 $]) indicates there is some next sequence that
+        # would resolve this without conflict to alternative 1. Any other viable
+        # next sequence, however, is associated with a conflict.  We stop
+        # looking for input because no amount of further lookahead will alter
+        # the fact that we should predict alternative 1.  We just can't say for
+        # sure that there is an ambiguity without looking further.
+
+        self.reportAmbiguity(dfa, D, startIndex, input.index, foundExactAmbig, None, reach)
+
+        return predictedAlt
+
+    def computeReachSet(self, closure:ATNConfigSet, t:int, fullCtx:bool):
+        if ParserATNSimulator.debug:
+            print("in computeReachSet, starting closure: " + str(closure))
+
+        if self.mergeCache is None:
+            self.mergeCache = dict()
+
+        intermediate = ATNConfigSet(fullCtx)
+
+        # Configurations already in a rule stop state indicate reaching the end
+        # of the decision rule (local context) or end of the start rule (full
+        # context). Once reached, these configurations are never updated by a
+        # closure operation, so they are handled separately for the performance
+        # advantage of having a smaller intermediate set when calling closure.
+        #
+        # For full-context reach operations, separate handling is required to
+        # ensure that the alternative matching the longest overall sequence is
+        # chosen when multiple such configurations can match the input.
+
+        skippedStopStates = None
+
+        # First figure out where we can reach on input t
+        for c in closure:
+            if ParserATNSimulator.debug:
+                print("testing " + self.getTokenName(t) + " at " + str(c))
+
+            if isinstance(c.state, RuleStopState):
+                if fullCtx or t == Token.EOF:
+                    if skippedStopStates is None:
+                        skippedStopStates = list()
+                    skippedStopStates.append(c)
+                continue
+
+            for trans in c.state.transitions:
+                target = self.getReachableTarget(trans, t)
+                if target is not None:
+                    intermediate.add(ATNConfig(state=target, config=c), self.mergeCache)
+
+        # Now figure out where the reach operation can take us...
+
+        reach = None
+
+        # This block optimizes the reach operation for intermediate sets which
+        # trivially indicate a termination state for the overall
+        # adaptivePredict operation.
+        #
+        # The conditions assume that intermediate
+        # contains all configurations relevant to the reach set, but this
+        # condition is not true when one or more configurations have been
+        # withheld in skippedStopStates, or when the current symbol is EOF.
+        #
+        if skippedStopStates is None and t!=Token.EOF:
+            if len(intermediate)==1:
+                # Don't pursue the closure if there is just one state.
+                # It can only have one alternative; just add to result
+                # Also don't pursue the closure if there is unique alternative
+                # among the configurations.
+                reach = intermediate
+            elif self.getUniqueAlt(intermediate)!=ATN.INVALID_ALT_NUMBER:
+                # Also don't pursue the closure if there is unique alternative
+                # among the configurations.
+                reach = intermediate
+
+        # If the reach set could not be trivially determined, perform a closure
+        # operation on the intermediate set to compute its initial value.
+        #
+        if reach is None:
+            reach = ATNConfigSet(fullCtx)
+            closureBusy = set()
+            treatEofAsEpsilon = t == Token.EOF
+            for c in intermediate:
+                self.closure(c, reach, closureBusy, False, fullCtx, treatEofAsEpsilon)
+
+        if t == Token.EOF:
+            # After consuming EOF no additional input is possible, so we are
+            # only interested in configurations which reached the end of the
+            # decision rule (local context) or end of the start rule (full
+            # context). Update reach to contain only these configurations. This
+            # handles both explicit EOF transitions in the grammar and implicit
+            # EOF transitions following the end of the decision or start rule.
+            #
+            # When reach==intermediate, no closure operation was performed. In
+            # this case, removeAllConfigsNotInRuleStopState needs to check for
+            # reachable rule stop states as well as configurations already in
+            # a rule stop state.
+            #
+            # This is handled before the configurations in skippedStopStates,
+            # because any configurations potentially added from that list are
+            # already guaranteed to meet this condition whether or not it's
+            # required.
+            #
+            reach = self.removeAllConfigsNotInRuleStopState(reach, reach is intermediate)
+
+        # If skippedStopStates is not null, then it contains at least one
+        # configuration. For full-context reach operations, these
+        # configurations reached the end of the start rule, in which case we
+        # only add them back to reach if no configuration during the current
+        # closure operation reached such a state. This ensures adaptivePredict
+        # chooses an alternative matching the longest overall sequence when
+        # multiple alternatives are viable.
+        #
+        if skippedStopStates is not None and ( (not fullCtx) or (not PredictionMode.hasConfigInRuleStopState(reach))):
+            for c in skippedStopStates:
+                reach.add(c, self.mergeCache)
+        if len(reach)==0:
+            return None
+        else:
+            return reach
+
+    #
+    # Return a configuration set containing only the configurations from
+    # {@code configs} which are in a {@link RuleStopState}. If all
+    # configurations in {@code configs} are already in a rule stop state, this
+    # method simply returns {@code configs}.
+    #
+    # <p>When {@code lookToEndOfRule} is true, this method uses
+    # {@link ATN#nextTokens} for each configuration in {@code configs} which is
+    # not already in a rule stop state to see if a rule stop state is reachable
+    # from the configuration via epsilon-only transitions.</p>
+    #
+    # @param configs the configuration set to update
+    # @param lookToEndOfRule when true, this method checks for rule stop states
+    # reachable by epsilon-only transitions from each configuration in
+    # {@code configs}.
+    #
+    # @return {@code configs} if all configurations in {@code configs} are in a
+    # rule stop state, otherwise return a new configuration set containing only
+    # the configurations from {@code configs} which are in a rule stop state
+    #
+    def removeAllConfigsNotInRuleStopState(self, configs:ATNConfigSet, lookToEndOfRule:bool):
+        if PredictionMode.allConfigsInRuleStopStates(configs):
+            return configs
+        result = ATNConfigSet(configs.fullCtx)
+        for config in configs:
+            if isinstance(config.state, RuleStopState):
+                result.add(config, self.mergeCache)
+                continue
+            if lookToEndOfRule and config.state.epsilonOnlyTransitions:
+                nextTokens = self.atn.nextTokens(config.state)
+                if Token.EPSILON in nextTokens:
+                    endOfRuleState = self.atn.ruleToStopState[config.state.ruleIndex]
+                    result.add(ATNConfig(state=endOfRuleState, config=config), self.mergeCache)
+        return result
+
+    def computeStartState(self, p:ATNState, ctx:RuleContext, fullCtx:bool):
+        # always at least the implicit call to start rule
+        initialContext = PredictionContextFromRuleContext(self.atn, ctx)
+        configs = ATNConfigSet(fullCtx)
+
+        for i in range(0, len(p.transitions)):
+            target = p.transitions[i].target
+            c = ATNConfig(target, i+1, initialContext)
+            closureBusy = set()
+            self.closure(c, configs, closureBusy, True, fullCtx, False)
+        return configs
+
+    #
+    # This method transforms the start state computed by
+    # {@link #computeStartState} to the special start state used by a
+    # precedence DFA for a particular precedence value. The transformation
+    # process applies the following changes to the start state's configuration
+    # set.
+    #
+    # <ol>
+    # <li>Evaluate the precedence predicates for each configuration using
+    # {@link SemanticContext#evalPrecedence}.</li>
+    # <li>Remove all configurations which predict an alternative greater than
+    # 1, for which another configuration that predicts alternative 1 is in the
+    # same ATN state with the same prediction context. This transformation is
+    # valid for the following reasons:
+    # <ul>
+    # <li>The closure block cannot contain any epsilon transitions which bypass
+    # the body of the closure, so all states reachable via alternative 1 are
+    # part of the precedence alternatives of the transformed left-recursive
+    # rule.</li>
+    # <li>The "primary" portion of a left recursive rule cannot contain an
+    # epsilon transition, so the only way an alternative other than 1 can exist
+    # in a state that is also reachable via alternative 1 is by nesting calls
+    # to the left-recursive rule, with the outer calls not being at the
+    # preferred precedence level.</li>
+    # </ul>
+    # </li>
+    # </ol>
+    #
+    # <p>
+    # The prediction context must be considered by this filter to address
+    # situations like the following.
+    # </p>
+    # <code>
+    # <pre>
+    # grammar TA;
+    # prog: statement* EOF;
+    # statement: letterA | statement letterA 'b' ;
+    # letterA: 'a';
+    # </pre>
+    # </code>
+    # <p>
+    # If the above grammar, the ATN state immediately before the token
+    # reference {@code 'a'} in {@code letterA} is reachable from the left edge
+    # of both the primary and closure blocks of the left-recursive rule
+    # {@code statement}. The prediction context associated with each of these
+    # configurations distinguishes between them, and prevents the alternative
+    # which stepped out to {@code prog} (and then back in to {@code statement}
+    # from being eliminated by the filter.
+    # </p>
+    #
+    # @param configs The configuration set computed by
+    # {@link #computeStartState} as the start state for the DFA.
+    # @return The transformed configuration set representing the start state
+    # for a precedence DFA at a particular precedence level (determined by
+    # calling {@link Parser#getPrecedence}).
+    #
+    def applyPrecedenceFilter(self, configs:ATNConfigSet):
+        statesFromAlt1 = dict()
+        configSet = ATNConfigSet(configs.fullCtx)
+        for config in configs:
+            # handle alt 1 first
+            if config.alt != 1:
+                continue
+            updatedContext = config.semanticContext.evalPrecedence(self.parser, self._outerContext)
+            if updatedContext is None:
+                # the configuration was eliminated
+                continue
+
+            statesFromAlt1[config.state.stateNumber] = config.context
+            if updatedContext is not config.semanticContext:
+                configSet.add(ATNConfig(config=config, semantic=updatedContext), self.mergeCache)
+            else:
+                configSet.add(config, self.mergeCache)
+
+        for config in configs:
+            if config.alt == 1:
+                # already handled
+                continue
+
+            # In the future, this elimination step could be updated to also
+            # filter the prediction context for alternatives predicting alt>1
+            # (basically a graph subtraction algorithm).
+            #
+            if not config.precedenceFilterSuppressed:
+                context = statesFromAlt1.get(config.state.stateNumber, None)
+                if context==config.context:
+                    # eliminated
+                    continue
+
+            configSet.add(config, self.mergeCache)
+
+        return configSet
+
+    def getReachableTarget(self, trans:Transition, ttype:int):
+        if trans.matches(ttype, 0, self.atn.maxTokenType):
+            return trans.target
+        else:
+            return None
+
+    def getPredsForAmbigAlts(self, ambigAlts:set, configs:ATNConfigSet, nalts:int):
+        # REACH=[1|1|[]|0:0, 1|2|[]|0:1]
+        # altToPred starts as an array of all null contexts. The entry at index i
+        # corresponds to alternative i. altToPred[i] may have one of three values:
+        #   1. null: no ATNConfig c is found such that c.alt==i
+        #   2. SemanticContext.NONE: At least one ATNConfig c exists such that
+        #      c.alt==i and c.semanticContext==SemanticContext.NONE. In other words,
+        #      alt i has at least one unpredicated config.
+        #   3. Non-NONE Semantic Context: There exists at least one, and for all
+        #      ATNConfig c such that c.alt==i, c.semanticContext!=SemanticContext.NONE.
+        #
+        # From this, it is clear that NONE||anything==NONE.
+        #
+        altToPred = [None] * (nalts + 1)
+        for c in configs:
+            if c.alt in ambigAlts:
+                altToPred[c.alt] = orContext(altToPred[c.alt], c.semanticContext)
+
+        nPredAlts = 0
+        for i in range(1, nalts+1):
+            if altToPred[i] is None:
+                altToPred[i] = SemanticContext.NONE
+            elif altToPred[i] is not SemanticContext.NONE:
+                nPredAlts += 1
+
+        # nonambig alts are null in altToPred
+        if nPredAlts==0:
+            altToPred = None
+        if ParserATNSimulator.debug:
+            print("getPredsForAmbigAlts result " + str_list(altToPred))
+        return altToPred
+
+    def getPredicatePredictions(self, ambigAlts:set, altToPred:list):
+        pairs = []
+        containsPredicate = False
+        for i in range(1, len(altToPred)):
+            pred = altToPred[i]
+            # unpredicated is indicated by SemanticContext.NONE
+            if ambigAlts is not None and i in ambigAlts:
+                pairs.append(PredPrediction(pred, i))
+            if pred is not SemanticContext.NONE:
+                containsPredicate = True
+
+        if not containsPredicate:
+            return None
+
+        return pairs
+
+    #
+    # This method is used to improve the localization of error messages by
+    # choosing an alternative rather than throwing a
+    # {@link NoViableAltException} in particular prediction scenarios where the
+    # {@link #ERROR} state was reached during ATN simulation.
+    #
+    # <p>
+    # The default implementation of this method uses the following
+    # algorithm to identify an ATN configuration which successfully parsed the
+    # decision entry rule. Choosing such an alternative ensures that the
+    # {@link ParserRuleContext} returned by the calling rule will be complete
+    # and valid, and the syntax error will be reported later at a more
+    # localized location.</p>
+    #
+    # <ul>
+    # <li>If a syntactically valid path or paths reach the end of the decision rule and
+    # they are semantically valid if predicated, return the min associated alt.</li>
+    # <li>Else, if a semantically invalid but syntactically valid path exist
+    # or paths exist, return the minimum associated alt.
+    # </li>
+    # <li>Otherwise, return {@link ATN#INVALID_ALT_NUMBER}.</li>
+    # </ul>
+    #
+    # <p>
+    # In some scenarios, the algorithm described above could predict an
+    # alternative which will result in a {@link FailedPredicateException} in
+    # the parser. Specifically, this could occur if the <em>only</em> configuration
+    # capable of successfully parsing to the end of the decision rule is
+    # blocked by a semantic predicate. By choosing this alternative within
+    # {@link #adaptivePredict} instead of throwing a
+    # {@link NoViableAltException}, the resulting
+    # {@link FailedPredicateException} in the parser will identify the specific
+    # predicate which is preventing the parser from successfully parsing the
+    # decision rule, which helps developers identify and correct logic errors
+    # in semantic predicates.
+    # </p>
+    #
+    # @param configs The ATN configurations which were valid immediately before
+    # the {@link #ERROR} state was reached
+    # @param outerContext The is the \gamma_0 initial parser context from the paper
+    # or the parser stack at the instant before prediction commences.
+    #
+    # @return The value to return from {@link #adaptivePredict}, or
+    # {@link ATN#INVALID_ALT_NUMBER} if a suitable alternative was not
+    # identified and {@link #adaptivePredict} should report an error instead.
+    #
+    def getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(self, configs:ATNConfigSet, outerContext:ParserRuleContext):
+        semValidConfigs, semInvalidConfigs = self.splitAccordingToSemanticValidity(configs, outerContext)
+        alt = self.getAltThatFinishedDecisionEntryRule(semValidConfigs)
+        if alt!=ATN.INVALID_ALT_NUMBER: # semantically/syntactically viable path exists
+            return alt
+        # Is there a syntactically valid path with a failed pred?
+        if len(semInvalidConfigs)>0:
+            alt = self.getAltThatFinishedDecisionEntryRule(semInvalidConfigs)
+            if alt!=ATN.INVALID_ALT_NUMBER: # syntactically viable path exists
+                return alt
+        return ATN.INVALID_ALT_NUMBER
+
+    def getAltThatFinishedDecisionEntryRule(self, configs:ATNConfigSet):
+        alts = set()
+        for c in configs:
+            if c.reachesIntoOuterContext>0 or (isinstance(c.state, RuleStopState) and c.context.hasEmptyPath() ):
+                alts.add(c.alt)
+        if len(alts)==0:
+            return ATN.INVALID_ALT_NUMBER
+        else:
+            return min(alts)
+
+    # Walk the list of configurations and split them according to
+    #  those that have preds evaluating to true/false.  If no pred, assume
+    #  true pred and include in succeeded set.  Returns Pair of sets.
+    #
+    #  Create a new set so as not to alter the incoming parameter.
+    #
+    #  Assumption: the input stream has been restored to the starting point
+    #  prediction, which is where predicates need to evaluate.
+    #
+    def splitAccordingToSemanticValidity(self, configs:ATNConfigSet, outerContext:ParserRuleContext):
+        succeeded = ATNConfigSet(configs.fullCtx)
+        failed = ATNConfigSet(configs.fullCtx)
+        for c in configs:
+            if c.semanticContext is not SemanticContext.NONE:
+                predicateEvaluationResult = c.semanticContext.eval(self.parser, outerContext)
+                if predicateEvaluationResult:
+                    succeeded.add(c)
+                else:
+                    failed.add(c)
+            else:
+                succeeded.add(c)
+        return (succeeded,failed)
+
+    # Look through a list of predicate/alt pairs, returning alts for the
+    #  pairs that win. A {@code NONE} predicate indicates an alt containing an
+    #  unpredicated config which behaves as "always true." If !complete
+    #  then we stop at the first predicate that evaluates to true. This
+    #  includes pairs with null predicates.
+    #
+    def evalSemanticContext(self, predPredictions:list, outerContext:ParserRuleContext, complete:bool):
+        predictions = set()
+        for pair in predPredictions:
+            if pair.pred is SemanticContext.NONE:
+                predictions.add(pair.alt)
+                if not complete:
+                    break
+                continue
+            predicateEvaluationResult = pair.pred.eval(self.parser, outerContext)
+            if ParserATNSimulator.debug or ParserATNSimulator.dfa_debug:
+                print("eval pred " + str(pair) + "=" + str(predicateEvaluationResult))
+
+            if predicateEvaluationResult:
+                if ParserATNSimulator.debug or ParserATNSimulator.dfa_debug:
+                    print("PREDICT " + str(pair.alt))
+                predictions.add(pair.alt)
+                if not complete:
+                    break
+        return predictions
+
+
+    # TODO: If we are doing predicates, there is no point in pursuing
+    #     closure operations if we reach a DFA state that uniquely predicts
+    #     alternative. We will not be caching that DFA state and it is a
+    #     waste to pursue the closure. Might have to advance when we do
+    #     ambig detection thought :(
+    #
+
+    def closure(self, config:ATNConfig, configs:ATNConfigSet, closureBusy:set, collectPredicates:bool, fullCtx:bool, treatEofAsEpsilon:bool):
+        initialDepth = 0
+        self.closureCheckingStopState(config, configs, closureBusy, collectPredicates,
+                                 fullCtx, initialDepth, treatEofAsEpsilon)
+
+
+    def closureCheckingStopState(self, config:ATNConfig, configs:ATNConfigSet, closureBusy:set, collectPredicates:bool, fullCtx:bool, depth:int, treatEofAsEpsilon:bool):
+        if ParserATNSimulator.debug:
+            print("closure(" + str(config) + ")")
+
+        if isinstance(config.state, RuleStopState):
+            # We hit rule end. If we have context info, use it
+            # run thru all possible stack tops in ctx
+            if not config.context.isEmpty():
+                for i in range(0, len(config.context)):
+                    state = config.context.getReturnState(i)
+                    if state is PredictionContext.EMPTY_RETURN_STATE:
+                        if fullCtx:
+                            configs.add(ATNConfig(state=config.state, context=PredictionContext.EMPTY, config=config), self.mergeCache)
+                            continue
+                        else:
+                            # we have no context info, just chase follow links (if greedy)
+                            if ParserATNSimulator.debug:
+                                print("FALLING off rule " + self.getRuleName(config.state.ruleIndex))
+                            self.closure_(config, configs, closureBusy, collectPredicates,
+                                     fullCtx, depth, treatEofAsEpsilon)
+                        continue
+                    returnState = self.atn.states[state]
+                    newContext = config.context.getParent(i) # "pop" return state
+                    c = ATNConfig(state=returnState, alt=config.alt, context=newContext, semantic=config.semanticContext)
+                    # While we have context to pop back from, we may have
+                    # gotten that context AFTER having falling off a rule.
+                    # Make sure we track that we are now out of context.
+                    c.reachesIntoOuterContext = config.reachesIntoOuterContext
+                    self.closureCheckingStopState(c, configs, closureBusy, collectPredicates, fullCtx, depth - 1, treatEofAsEpsilon)
+                return
+            elif fullCtx:
+                # reached end of start rule
+                configs.add(config, self.mergeCache)
+                return
+            else:
+                # else if we have no context info, just chase follow links (if greedy)
+                if ParserATNSimulator.debug:
+                    print("FALLING off rule " + self.getRuleName(config.state.ruleIndex))
+
+        self.closure_(config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEofAsEpsilon)
+
+    # Do the actual work of walking epsilon edges#
+    def closure_(self, config:ATNConfig, configs:ATNConfigSet, closureBusy:set, collectPredicates:bool, fullCtx:bool, depth:int, treatEofAsEpsilon:bool):
+        p = config.state
+        # optimization
+        if not p.epsilonOnlyTransitions:
+            configs.add(config, self.mergeCache)
+            # make sure to not return here, because EOF transitions can act as
+            # both epsilon transitions and non-epsilon transitions.
+
+        first = True
+        for t in p.transitions:
+            if first:
+                first = False
+                if self.canDropLoopEntryEdgeInLeftRecursiveRule(config):
+                    continue
+
+            continueCollecting = collectPredicates and not isinstance(t, ActionTransition)
+            c = self.getEpsilonTarget(config, t, continueCollecting, depth == 0, fullCtx, treatEofAsEpsilon)
+            if c is not None:
+                newDepth = depth
+                if isinstance( config.state, RuleStopState):
+                    # target fell off end of rule; mark resulting c as having dipped into outer context
+                    # We can't get here if incoming config was rule stop and we had context
+                    # track how far we dip into outer context.  Might
+                    # come in handy and we avoid evaluating context dependent
+                    # preds if this is > 0.
+                    if self._dfa is not None and self._dfa.precedenceDfa:
+                        if t.outermostPrecedenceReturn == self._dfa.atnStartState.ruleIndex:
+                            c.precedenceFilterSuppressed = True
+                    c.reachesIntoOuterContext += 1
+                    if c in closureBusy:
+                        # avoid infinite recursion for right-recursive rules
+                        continue
+                    closureBusy.add(c)
+                    configs.dipsIntoOuterContext = True # TODO: can remove? only care when we add to set per middle of this method
+                    newDepth -= 1
+                    if ParserATNSimulator.debug:
+                        print("dips into outer ctx: " + str(c))
+                else:
+                    if not t.isEpsilon:
+                        if c in closureBusy:
+                            # avoid infinite recursion for EOF* and EOF+
+                            continue
+                        closureBusy.add(c)
+                    if isinstance(t, RuleTransition):
+                        # latch when newDepth goes negative - once we step out of the entry context we can't return
+                        if newDepth >= 0:
+                            newDepth += 1
+
+                self.closureCheckingStopState(c, configs, closureBusy, continueCollecting, fullCtx, newDepth, treatEofAsEpsilon)
+
+
+
+    # Implements first-edge (loop entry) elimination as an optimization
+    #  during closure operations.  See antlr/antlr4#1398.
+    #
+    # The optimization is to avoid adding the loop entry config when
+    # the exit path can only lead back to the same
+    # StarLoopEntryState after popping context at the rule end state
+    # (traversing only epsilon edges, so we're still in closure, in
+    # this same rule).
+    #
+    # We need to detect any state that can reach loop entry on
+    # epsilon w/o exiting rule. We don't have to look at FOLLOW
+    # links, just ensure that all stack tops for config refer to key
+    # states in LR rule.
+    #
+    # To verify we are in the right situation we must first check
+    # closure is at a StarLoopEntryState generated during LR removal.
+    # Then we check that each stack top of context is a return state
+    # from one of these cases:
+    #
+    #   1. 'not' expr, '(' type ')' expr. The return state points at loop entry state
+    #   2. expr op expr. The return state is the block end of internal block of (...)*
+    #   3. 'between' expr 'and' expr. The return state of 2nd expr reference.
+    #      That state points at block end of internal block of (...)*.
+    #   4. expr '?' expr ':' expr. The return state points at block end,
+    #      which points at loop entry state.
+    #
+    # If any is true for each stack top, then closure does not add a
+    # config to the current config set for edge[0], the loop entry branch.
+    #
+    #  Conditions fail if any context for the current config is:
+    #
+    #   a. empty (we'd fall out of expr to do a global FOLLOW which could
+    #      even be to some weird spot in expr) or,
+    #   b. lies outside of expr or,
+    #   c. lies within expr but at a state not the BlockEndState
+    #   generated during LR removal
+    #
+    # Do we need to evaluate predicates ever in closure for this case?
+    #
+    # No. Predicates, including precedence predicates, are only
+    # evaluated when computing a DFA start state. I.e., only before
+    # the lookahead (but not parser) consumes a token.
+    #
+    # There are no epsilon edges allowed in LR rule alt blocks or in
+    # the "primary" part (ID here). If closure is in
+    # StarLoopEntryState any lookahead operation will have consumed a
+    # token as there are no epsilon-paths that lead to
+    # StarLoopEntryState. We do not have to evaluate predicates
+    # therefore if we are in the generated StarLoopEntryState of a LR
+    # rule. Note that when making a prediction starting at that
+    # decision point, decision d=2, compute-start-state performs
+    # closure starting at edges[0], edges[1] emanating from
+    # StarLoopEntryState. That means it is not performing closure on
+    # StarLoopEntryState during compute-start-state.
+    #
+    # How do we know this always gives same prediction answer?
+    #
+    # Without predicates, loop entry and exit paths are ambiguous
+    # upon remaining input +b (in, say, a+b). Either paths lead to
+    # valid parses. Closure can lead to consuming + immediately or by
+    # falling out of this call to expr back into expr and loop back
+    # again to StarLoopEntryState to match +b. In this special case,
+    # we choose the more efficient path, which is to take the bypass
+    # path.
+    #
+    # The lookahead language has not changed because closure chooses
+    # one path over the other. Both paths lead to consuming the same
+    # remaining input during a lookahead operation. If the next token
+    # is an operator, lookahead will enter the choice block with
+    # operators. If it is not, lookahead will exit expr. Same as if
+    # closure had chosen to enter the choice block immediately.
+    #
+    # Closure is examining one config (some loopentrystate, some alt,
+    # context) which means it is considering exactly one alt. Closure
+    # always copies the same alt to any derived configs.
+    #
+    # How do we know this optimization doesn't mess up precedence in
+    # our parse trees?
+    #
+    # Looking through expr from left edge of stat only has to confirm
+    # that an input, say, a+b+c; begins with any valid interpretation
+    # of an expression. The precedence actually doesn't matter when
+    # making a decision in stat seeing through expr. It is only when
+    # parsing rule expr that we must use the precedence to get the
+    # right interpretation and, hence, parse tree.
+    #
+    # @since 4.6
+    #
+    def canDropLoopEntryEdgeInLeftRecursiveRule(self, config):
+        # return False
+        p = config.state
+        # First check to see if we are in StarLoopEntryState generated during
+        # left-recursion elimination. For efficiency, also check if
+        # the context has an empty stack case. If so, it would mean
+        # global FOLLOW so we can't perform optimization
+        # Are we the special loop entry/exit state? or SLL wildcard
+        if p.stateType != ATNState.STAR_LOOP_ENTRY  \
+                or not p.isPrecedenceDecision       \
+                or config.context.isEmpty()         \
+                or config.context.hasEmptyPath():
+            return False
+
+        # Require all return states to return back to the same rule
+        # that p is in.
+        numCtxs = len(config.context)
+        for i in range(0, numCtxs):  # for each stack context
+            returnState = self.atn.states[config.context.getReturnState(i)]
+            if returnState.ruleIndex != p.ruleIndex:
+                return False
+
+        decisionStartState = p.transitions[0].target
+        blockEndStateNum = decisionStartState.endState.stateNumber
+        blockEndState = self.atn.states[blockEndStateNum]
+
+        # Verify that the top of each stack context leads to loop entry/exit
+        # state through epsilon edges and w/o leaving rule.
+        for i in range(0, numCtxs):  # for each stack context
+            returnStateNumber = config.context.getReturnState(i)
+            returnState = self.atn.states[returnStateNumber]
+            # all states must have single outgoing epsilon edge
+            if len(returnState.transitions) != 1 or not returnState.transitions[0].isEpsilon:
+                return False
+
+            # Look for prefix op case like 'not expr', (' type ')' expr
+            returnStateTarget = returnState.transitions[0].target
+            if returnState.stateType == ATNState.BLOCK_END and returnStateTarget is p:
+                continue
+
+            # Look for 'expr op expr' or case where expr's return state is block end
+            # of (...)* internal block; the block end points to loop back
+            # which points to p but we don't need to check that
+            if returnState is blockEndState:
+                continue
+
+            # Look for ternary expr ? expr : expr. The return state points at block end,
+            # which points at loop entry state
+            if returnStateTarget is blockEndState:
+                continue
+
+            # Look for complex prefix 'between expr and expr' case where 2nd expr's
+            # return state points at block end state of (...)* internal block
+            if returnStateTarget.stateType == ATNState.BLOCK_END \
+                and len(returnStateTarget.transitions) == 1 \
+                and returnStateTarget.transitions[0].isEpsilon \
+                and returnStateTarget.transitions[0].target is p:
+                    continue
+
+            # anything else ain't conforming
+            return False
+
+        return True
+
+
+    def getRuleName(self, index:int):
+        if self.parser is not None and index>=0:
+            return self.parser.ruleNames[index]
+        else:
+            return "<rule " + str(index) + ">"
+
+    epsilonTargetMethods = dict()
+    epsilonTargetMethods[Transition.RULE] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        sim.ruleTransition(config, t)
+    epsilonTargetMethods[Transition.PRECEDENCE] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        sim.precedenceTransition(config, t, collectPredicates, inContext, fullCtx)
+    epsilonTargetMethods[Transition.PREDICATE] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        sim.predTransition(config, t, collectPredicates, inContext, fullCtx)
+    epsilonTargetMethods[Transition.ACTION] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        sim.actionTransition(config, t)
+    epsilonTargetMethods[Transition.EPSILON] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        ATNConfig(state=t.target, config=config)
+    epsilonTargetMethods[Transition.ATOM] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        ATNConfig(state=t.target, config=config) if treatEofAsEpsilon and t.matches(Token.EOF, 0, 1) else None
+    epsilonTargetMethods[Transition.RANGE] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        ATNConfig(state=t.target, config=config) if treatEofAsEpsilon and t.matches(Token.EOF, 0, 1) else None
+    epsilonTargetMethods[Transition.SET] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        ATNConfig(state=t.target, config=config) if treatEofAsEpsilon and t.matches(Token.EOF, 0, 1) else None
+
+    def getEpsilonTarget(self, config:ATNConfig, t:Transition, collectPredicates:bool, inContext:bool, fullCtx:bool, treatEofAsEpsilon:bool):
+        m = self.epsilonTargetMethods.get(t.serializationType, None)
+        if m is None:
+            return None
+        else:
+            return m(self, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon)
+
+    def actionTransition(self, config:ATNConfig, t:ActionTransition):
+        if ParserATNSimulator.debug:
+            print("ACTION edge " + str(t.ruleIndex) + ":" + str(t.actionIndex))
+        return ATNConfig(state=t.target, config=config)
+
+    def precedenceTransition(self, config:ATNConfig, pt:PrecedencePredicateTransition,  collectPredicates:bool, inContext:bool, fullCtx:bool):
+        if ParserATNSimulator.debug:
+            print("PRED (collectPredicates=" + str(collectPredicates) + ") " +
+                    str(pt.precedence) + ">=_p, ctx dependent=true")
+            if self.parser is not None:
+                print("context surrounding pred is " + str(self.parser.getRuleInvocationStack()))
+
+        c = None
+        if collectPredicates and inContext:
+            if fullCtx:
+                # In full context mode, we can evaluate predicates on-the-fly
+                # during closure, which dramatically reduces the size of
+                # the config sets. It also obviates the need to test predicates
+                # later during conflict resolution.
+                currentPosition = self._input.index
+                self._input.seek(self._startIndex)
+                predSucceeds = pt.getPredicate().eval(self.parser, self._outerContext)
+                self._input.seek(currentPosition)
+                if predSucceeds:
+                    c = ATNConfig(state=pt.target, config=config) # no pred context
+            else:
+                newSemCtx = andContext(config.semanticContext, pt.getPredicate())
+                c = ATNConfig(state=pt.target, semantic=newSemCtx, config=config)
+        else:
+            c = ATNConfig(state=pt.target, config=config)
+
+        if ParserATNSimulator.debug:
+            print("config from pred transition=" + str(c))
+        return c
+
+    def predTransition(self, config:ATNConfig, pt:PredicateTransition, collectPredicates:bool, inContext:bool, fullCtx:bool):
+        if ParserATNSimulator.debug:
+            print("PRED (collectPredicates=" + str(collectPredicates) + ") " + str(pt.ruleIndex) +
+                    ":" + str(pt.predIndex) + ", ctx dependent=" + str(pt.isCtxDependent))
+            if self.parser is not None:
+                print("context surrounding pred is " + str(self.parser.getRuleInvocationStack()))
+
+        c = None
+        if collectPredicates and (not pt.isCtxDependent or (pt.isCtxDependent and inContext)):
+            if fullCtx:
+                # In full context mode, we can evaluate predicates on-the-fly
+                # during closure, which dramatically reduces the size of
+                # the config sets. It also obviates the need to test predicates
+                # later during conflict resolution.
+                currentPosition = self._input.index
+                self._input.seek(self._startIndex)
+                predSucceeds = pt.getPredicate().eval(self.parser, self._outerContext)
+                self._input.seek(currentPosition)
+                if predSucceeds:
+                    c = ATNConfig(state=pt.target, config=config) # no pred context
+            else:
+                newSemCtx = andContext(config.semanticContext, pt.getPredicate())
+                c = ATNConfig(state=pt.target, semantic=newSemCtx, config=config)
+        else:
+            c = ATNConfig(state=pt.target, config=config)
+
+        if ParserATNSimulator.debug:
+            print("config from pred transition=" + str(c))
+        return c
+
+    def ruleTransition(self, config:ATNConfig, t:RuleTransition):
+        if ParserATNSimulator.debug:
+            print("CALL rule " + self.getRuleName(t.target.ruleIndex) + ", ctx=" + str(config.context))
+        returnState = t.followState
+        newContext = SingletonPredictionContext.create(config.context, returnState.stateNumber)
+        return ATNConfig(state=t.target, context=newContext, config=config )
+
+    def getConflictingAlts(self, configs:ATNConfigSet):
+        altsets = PredictionMode.getConflictingAltSubsets(configs)
+        return PredictionMode.getAlts(altsets)
+
+     # Sam pointed out a problem with the previous definition, v3, of
+     # ambiguous states. If we have another state associated with conflicting
+     # alternatives, we should keep going. For example, the following grammar
+     #
+     # s : (ID | ID ID?) ';' ;
+     #
+     # When the ATN simulation reaches the state before ';', it has a DFA
+     # state that looks like: [12|1|[], 6|2|[], 12|2|[]]. Naturally
+     # 12|1|[] and 12|2|[] conflict, but we cannot stop processing this node
+     # because alternative to has another way to continue, via [6|2|[]].
+     # The key is that we have a single state that has config's only associated
+     # with a single alternative, 2, and crucially the state transitions
+     # among the configurations are all non-epsilon transitions. That means
+     # we don't consider any conflicts that include alternative 2. So, we
+     # ignore the conflict between alts 1 and 2. We ignore a set of
+     # conflicting alts when there is an intersection with an alternative
+     # associated with a single alt state in the state&rarr;config-list map.
+     #
+     # It's also the case that we might have two conflicting configurations but
+     # also a 3rd nonconflicting configuration for a different alternative:
+     # [1|1|[], 1|2|[], 8|3|[]]. This can come about from grammar:
+     #
+     # a : A | A | A B ;
+     #
+     # After matching input A, we reach the stop state for rule A, state 1.
+     # State 8 is the state right before B. Clearly alternatives 1 and 2
+     # conflict and no amount of further lookahead will separate the two.
+     # However, alternative 3 will be able to continue and so we do not
+     # stop working on this state. In the previous example, we're concerned
+     # with states associated with the conflicting alternatives. Here alt
+     # 3 is not associated with the conflicting configs, but since we can continue
+     # looking for input reasonably, I don't declare the state done. We
+     # ignore a set of conflicting alts when we have an alternative
+     # that we still need to pursue.
+    #
+
+    def getConflictingAltsOrUniqueAlt(self, configs:ATNConfigSet):
+        conflictingAlts = None
+        if configs.uniqueAlt!= ATN.INVALID_ALT_NUMBER:
+            conflictingAlts = set()
+            conflictingAlts.add(configs.uniqueAlt)
+        else:
+            conflictingAlts = configs.conflictingAlts
+        return conflictingAlts
+
+    def getTokenName(self, t:int):
+        if t==Token.EOF:
+            return "EOF"
+        if self.parser is not None and \
+            self.parser.literalNames is not None and \
+            t < len(self.parser.literalNames):
+                 return self.parser.literalNames[t] + "<" + str(t) + ">"
+        else:
+            return str(t)
+
+    def getLookaheadName(self, input:TokenStream):
+        return self.getTokenName(input.LA(1))
+
+    # Used for debugging in adaptivePredict around execATN but I cut
+    #  it out for clarity now that alg. works well. We can leave this
+    #  "dead" code for a bit.
+    #
+    def dumpDeadEndConfigs(self, nvae:NoViableAltException):
+        print("dead end configs: ")
+        for c in nvae.getDeadEndConfigs():
+            trans = "no edges"
+            if len(c.state.transitions)>0:
+                t = c.state.transitions[0]
+                if isinstance(t, AtomTransition):
+                    trans = "Atom "+ self.getTokenName(t.label)
+                elif isinstance(t, SetTransition):
+                    neg = isinstance(t, NotSetTransition)
+                    trans = ("~" if neg else "")+"Set "+ str(t.set)
+            print(c.toString(self.parser, True) + ":" + trans, file=sys.stderr)
+
+    def noViableAlt(self, input:TokenStream, outerContext:ParserRuleContext, configs:ATNConfigSet, startIndex:int):
+        return NoViableAltException(self.parser, input, input.get(startIndex), input.LT(1), configs, outerContext)
+
+    def getUniqueAlt(self, configs:ATNConfigSet):
+        alt = ATN.INVALID_ALT_NUMBER
+        for c in configs:
+            if alt == ATN.INVALID_ALT_NUMBER:
+                alt = c.alt # found first alt
+            elif c.alt!=alt:
+                return ATN.INVALID_ALT_NUMBER
+        return alt
+
+    #
+    # Add an edge to the DFA, if possible. This method calls
+    # {@link #addDFAState} to ensure the {@code to} state is present in the
+    # DFA. If {@code from} is {@code null}, or if {@code t} is outside the
+    # range of edges that can be represented in the DFA tables, this method
+    # returns without adding the edge to the DFA.
+    #
+    # <p>If {@code to} is {@code null}, this method returns {@code null}.
+    # Otherwise, this method returns the {@link DFAState} returned by calling
+    # {@link #addDFAState} for the {@code to} state.</p>
+    #
+    # @param dfa The DFA
+    # @param from The source state for the edge
+    # @param t The input symbol
+    # @param to The target state for the edge
+    #
+    # @return If {@code to} is {@code null}, this method returns {@code null};
+    # otherwise this method returns the result of calling {@link #addDFAState}
+    # on {@code to}
+    #
+    def addDFAEdge(self, dfa:DFA, from_:DFAState, t:int, to:DFAState):
+        if ParserATNSimulator.debug:
+            print("EDGE " + str(from_) + " -> " + str(to) + " upon " + self.getTokenName(t))
+
+        if to is None:
+            return None
+
+        to = self.addDFAState(dfa, to) # used existing if possible not incoming
+        if from_ is None or t < -1 or t > self.atn.maxTokenType:
+            return to
+
+        if from_.edges is None:
+            from_.edges = [None] * (self.atn.maxTokenType + 2)
+        from_.edges[t+1] = to # connect
+
+        if ParserATNSimulator.debug:
+            names = None if self.parser is None else self.parser.literalNames
+            print("DFA=\n" + dfa.toString(names))
+
+        return to
+
+    #
+    # Add state {@code D} to the DFA if it is not already present, and return
+    # the actual instance stored in the DFA. If a state equivalent to {@code D}
+    # is already in the DFA, the existing state is returned. Otherwise this
+    # method returns {@code D} after adding it to the DFA.
+    #
+    # <p>If {@code D} is {@link #ERROR}, this method returns {@link #ERROR} and
+    # does not change the DFA.</p>
+    #
+    # @param dfa The dfa
+    # @param D The DFA state to add
+    # @return The state stored in the DFA. This will be either the existing
+    # state if {@code D} is already in the DFA, or {@code D} itself if the
+    # state was not already present.
+    #
+    def addDFAState(self, dfa:DFA, D:DFAState):
+        if D is self.ERROR:
+            return D
+
+
+        existing = dfa.states.get(D, None)
+        if existing is not None:
+            return existing
+
+        D.stateNumber = len(dfa.states)
+        if not D.configs.readonly:
+            D.configs.optimizeConfigs(self)
+            D.configs.setReadonly(True)
+        dfa.states[D] = D
+        if ParserATNSimulator.debug:
+            print("adding new DFA state: " + str(D))
+        return D
+
+    def reportAttemptingFullContext(self, dfa:DFA, conflictingAlts:set, configs:ATNConfigSet, startIndex:int, stopIndex:int):
+        if ParserATNSimulator.debug or ParserATNSimulator.retry_debug:
+            print("reportAttemptingFullContext decision=" + str(dfa.decision) + ":" + str(configs) +
+                               ", input=" + self.parser.getTokenStream().getText(startIndex, stopIndex))
+        if self.parser is not None:
+            self.parser.getErrorListenerDispatch().reportAttemptingFullContext(self.parser, dfa, startIndex, stopIndex, conflictingAlts, configs)
+
+    def reportContextSensitivity(self, dfa:DFA, prediction:int, configs:ATNConfigSet, startIndex:int, stopIndex:int):
+        if ParserATNSimulator.debug or ParserATNSimulator.retry_debug:
+            print("reportContextSensitivity decision=" + str(dfa.decision) + ":" + str(configs) +
+                               ", input=" + self.parser.getTokenStream().getText(startIndex, stopIndex))
+        if self.parser is not None:
+            self.parser.getErrorListenerDispatch().reportContextSensitivity(self.parser, dfa, startIndex, stopIndex, prediction, configs)
+
+    # If context sensitive parsing, we know it's ambiguity not conflict#
+    def reportAmbiguity(self, dfa:DFA, D:DFAState, startIndex:int, stopIndex:int,
+                                   exact:bool, ambigAlts:set, configs:ATNConfigSet ):
+        if ParserATNSimulator.debug or ParserATNSimulator.retry_debug:
+#			ParserATNPathFinder finder = new ParserATNPathFinder(parser, atn);
+#			int i = 1;
+#			for (Transition t : dfa.atnStartState.transitions) {
+#				print("ALT "+i+"=");
+#				print(startIndex+".."+stopIndex+", len(input)="+parser.getInputStream().size());
+#				TraceTree path = finder.trace(t.target, parser.getContext(), (TokenStream)parser.getInputStream(),
+#											  startIndex, stopIndex);
+#				if ( path!=null ) {
+#					print("path = "+path.toStringTree());
+#					for (TraceTree leaf : path.leaves) {
+#						List<ATNState> states = path.getPathToNode(leaf);
+#						print("states="+states);
+#					}
+#				}
+#				i++;
+#			}
+            print("reportAmbiguity " + str(ambigAlts) + ":" + str(configs) +
+                               ", input=" + self.parser.getTokenStream().getText(startIndex, stopIndex))
+        if self.parser is not None:
+            self.parser.getErrorListenerDispatch().reportAmbiguity(self.parser, dfa, startIndex, stopIndex, exact, ambigAlts, configs)

cameras/deps/antlr4/atn/PredictionMode.py

@@ -0,0 +1,499 @@
+#
+# 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.
+#
+#
+# This enumeration defines the prediction modes available in ANTLR 4 along with
+# utility methods for analyzing configuration sets for conflicts and/or
+# ambiguities.
+
+
+from enum import Enum
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNConfig import ATNConfig
+from antlr4.atn.ATNConfigSet import ATNConfigSet
+from antlr4.atn.ATNState import RuleStopState
+from antlr4.atn.SemanticContext import SemanticContext
+
+PredictionMode = None
+
+class PredictionMode(Enum):
+    #
+    # The SLL(*) prediction mode. This prediction mode ignores the current
+    # parser context when making predictions. This is the fastest prediction
+    # mode, and provides correct results for many grammars. This prediction
+    # mode is more powerful than the prediction mode provided by ANTLR 3, but
+    # may result in syntax errors for grammar and input combinations which are
+    # not SLL.
+    #
+    # <p>
+    # When using this prediction mode, the parser will either return a correct
+    # parse tree (i.e. the same parse tree that would be returned with the
+    # {@link #LL} prediction mode), or it will report a syntax error. If a
+    # syntax error is encountered when using the {@link #SLL} prediction mode,
+    # it may be due to either an actual syntax error in the input or indicate
+    # that the particular combination of grammar and input requires the more
+    # powerful {@link #LL} prediction abilities to complete successfully.</p>
+    #
+    # <p>
+    # This prediction mode does not provide any guarantees for prediction
+    # behavior for syntactically-incorrect inputs.</p>
+    #
+    SLL = 0
+    #
+    # The LL(*) prediction mode. This prediction mode allows the current parser
+    # context to be used for resolving SLL conflicts that occur during
+    # prediction. This is the fastest prediction mode that guarantees correct
+    # parse results for all combinations of grammars with syntactically correct
+    # inputs.
+    #
+    # <p>
+    # When using this prediction mode, the parser will make correct decisions
+    # for all syntactically-correct grammar and input combinations. However, in
+    # cases where the grammar is truly ambiguous this prediction mode might not
+    # report a precise answer for <em>exactly which</em> alternatives are
+    # ambiguous.</p>
+    #
+    # <p>
+    # This prediction mode does not provide any guarantees for prediction
+    # behavior for syntactically-incorrect inputs.</p>
+    #
+    LL = 1
+    #
+    # The LL(*) prediction mode with exact ambiguity detection. In addition to
+    # the correctness guarantees provided by the {@link #LL} prediction mode,
+    # this prediction mode instructs the prediction algorithm to determine the
+    # complete and exact set of ambiguous alternatives for every ambiguous
+    # decision encountered while parsing.
+    #
+    # <p>
+    # This prediction mode may be used for diagnosing ambiguities during
+    # grammar development. Due to the performance overhead of calculating sets
+    # of ambiguous alternatives, this prediction mode should be avoided when
+    # the exact results are not necessary.</p>
+    #
+    # <p>
+    # This prediction mode does not provide any guarantees for prediction
+    # behavior for syntactically-incorrect inputs.</p>
+    #
+    LL_EXACT_AMBIG_DETECTION = 2
+
+
+    #
+    # Computes the SLL prediction termination condition.
+    #
+    # <p>
+    # This method computes the SLL prediction termination condition for both of
+    # the following cases.</p>
+    #
+    # <ul>
+    # <li>The usual SLL+LL fallback upon SLL conflict</li>
+    # <li>Pure SLL without LL fallback</li>
+    # </ul>
+    #
+    # <p><strong>COMBINED SLL+LL PARSING</strong></p>
+    #
+    # <p>When LL-fallback is enabled upon SLL conflict, correct predictions are
+    # ensured regardless of how the termination condition is computed by this
+    # method. Due to the substantially higher cost of LL prediction, the
+    # prediction should only fall back to LL when the additional lookahead
+    # cannot lead to a unique SLL prediction.</p>
+    #
+    # <p>Assuming combined SLL+LL parsing, an SLL configuration set with only
+    # conflicting subsets should fall back to full LL, even if the
+    # configuration sets don't resolve to the same alternative (e.g.
+    # {@code {1,2}} and {@code {3,4}}. If there is at least one non-conflicting
+    # configuration, SLL could continue with the hopes that more lookahead will
+    # resolve via one of those non-conflicting configurations.</p>
+    #
+    # <p>Here's the prediction termination rule them: SLL (for SLL+LL parsing)
+    # stops when it sees only conflicting configuration subsets. In contrast,
+    # full LL keeps going when there is uncertainty.</p>
+    #
+    # <p><strong>HEURISTIC</strong></p>
+    #
+    # <p>As a heuristic, we stop prediction when we see any conflicting subset
+    # unless we see a state that only has one alternative associated with it.
+    # The single-alt-state thing lets prediction continue upon rules like
+    # (otherwise, it would admit defeat too soon):</p>
+    #
+    # <p>{@code [12|1|[], 6|2|[], 12|2|[]]. s : (ID | ID ID?) ';' ;}</p>
+    #
+    # <p>When the ATN simulation reaches the state before {@code ';'}, it has a
+    # DFA state that looks like: {@code [12|1|[], 6|2|[], 12|2|[]]}. Naturally
+    # {@code 12|1|[]} and {@code 12|2|[]} conflict, but we cannot stop
+    # processing this node because alternative to has another way to continue,
+    # via {@code [6|2|[]]}.</p>
+    #
+    # <p>It also let's us continue for this rule:</p>
+    #
+    # <p>{@code [1|1|[], 1|2|[], 8|3|[]] a : A | A | A B ;}</p>
+    #
+    # <p>After matching input A, we reach the stop state for rule A, state 1.
+    # State 8 is the state right before B. Clearly alternatives 1 and 2
+    # conflict and no amount of further lookahead will separate the two.
+    # However, alternative 3 will be able to continue and so we do not stop
+    # working on this state. In the previous example, we're concerned with
+    # states associated with the conflicting alternatives. Here alt 3 is not
+    # associated with the conflicting configs, but since we can continue
+    # looking for input reasonably, don't declare the state done.</p>
+    #
+    # <p><strong>PURE SLL PARSING</strong></p>
+    #
+    # <p>To handle pure SLL parsing, all we have to do is make sure that we
+    # combine stack contexts for configurations that differ only by semantic
+    # predicate. From there, we can do the usual SLL termination heuristic.</p>
+    #
+    # <p><strong>PREDICATES IN SLL+LL PARSING</strong></p>
+    #
+    # <p>SLL decisions don't evaluate predicates until after they reach DFA stop
+    # states because they need to create the DFA cache that works in all
+    # semantic situations. In contrast, full LL evaluates predicates collected
+    # during start state computation so it can ignore predicates thereafter.
+    # This means that SLL termination detection can totally ignore semantic
+    # predicates.</p>
+    #
+    # <p>Implementation-wise, {@link ATNConfigSet} combines stack contexts but not
+    # semantic predicate contexts so we might see two configurations like the
+    # following.</p>
+    #
+    # <p>{@code (s, 1, x, {}), (s, 1, x', {p})}</p>
+    #
+    # <p>Before testing these configurations against others, we have to merge
+    # {@code x} and {@code x'} (without modifying the existing configurations).
+    # For example, we test {@code (x+x')==x''} when looking for conflicts in
+    # the following configurations.</p>
+    #
+    # <p>{@code (s, 1, x, {}), (s, 1, x', {p}), (s, 2, x'', {})}</p>
+    #
+    # <p>If the configuration set has predicates (as indicated by
+    # {@link ATNConfigSet#hasSemanticContext}), this algorithm makes a copy of
+    # the configurations to strip out all of the predicates so that a standard
+    # {@link ATNConfigSet} will merge everything ignoring predicates.</p>
+    #
+    @classmethod
+    def hasSLLConflictTerminatingPrediction(cls, mode:PredictionMode, configs:ATNConfigSet):
+        # Configs in rule stop states indicate reaching the end of the decision
+        # rule (local context) or end of start rule (full context). If all
+        # configs meet this condition, then none of the configurations is able
+        # to match additional input so we terminate prediction.
+        #
+        if cls.allConfigsInRuleStopStates(configs):
+            return True
+
+        # pure SLL mode parsing
+        if mode == PredictionMode.SLL:
+            # Don't bother with combining configs from different semantic
+            # contexts if we can fail over to full LL; costs more time
+            # since we'll often fail over anyway.
+            if configs.hasSemanticContext:
+                # dup configs, tossing out semantic predicates
+                dup = ATNConfigSet()
+                for c in configs:
+                    c = ATNConfig(config=c, semantic=SemanticContext.NONE)
+                    dup.add(c)
+                configs = dup
+            # now we have combined contexts for configs with dissimilar preds
+
+        # pure SLL or combined SLL+LL mode parsing
+        altsets = cls.getConflictingAltSubsets(configs)
+        return cls.hasConflictingAltSet(altsets) and not cls.hasStateAssociatedWithOneAlt(configs)
+
+    # Checks if any configuration in {@code configs} is in a
+    # {@link RuleStopState}. Configurations meeting this condition have reached
+    # the end of the decision rule (local context) or end of start rule (full
+    # context).
+    #
+    # @param configs the configuration set to test
+    # @return {@code true} if any configuration in {@code configs} is in a
+    # {@link RuleStopState}, otherwise {@code false}
+    @classmethod
+    def hasConfigInRuleStopState(cls, configs:ATNConfigSet):
+        return any(isinstance(cfg.state, RuleStopState) for cfg in configs)
+
+    # Checks if all configurations in {@code configs} are in a
+    # {@link RuleStopState}. Configurations meeting this condition have reached
+    # the end of the decision rule (local context) or end of start rule (full
+    # context).
+    #
+    # @param configs the configuration set to test
+    # @return {@code true} if all configurations in {@code configs} are in a
+    # {@link RuleStopState}, otherwise {@code false}
+    @classmethod
+    def allConfigsInRuleStopStates(cls, configs:ATNConfigSet):
+        return all(isinstance(cfg.state, RuleStopState) for cfg in configs)
+
+    #
+    # Full LL prediction termination.
+    #
+    # <p>Can we stop looking ahead during ATN simulation or is there some
+    # uncertainty as to which alternative we will ultimately pick, after
+    # consuming more input? Even if there are partial conflicts, we might know
+    # that everything is going to resolve to the same minimum alternative. That
+    # means we can stop since no more lookahead will change that fact. On the
+    # other hand, there might be multiple conflicts that resolve to different
+    # minimums. That means we need more look ahead to decide which of those
+    # alternatives we should predict.</p>
+    #
+    # <p>The basic idea is to split the set of configurations {@code C}, into
+    # conflicting subsets {@code (s, _, ctx, _)} and singleton subsets with
+    # non-conflicting configurations. Two configurations conflict if they have
+    # identical {@link ATNConfig#state} and {@link ATNConfig#context} values
+    # but different {@link ATNConfig#alt} value, e.g. {@code (s, i, ctx, _)}
+    # and {@code (s, j, ctx, _)} for {@code i!=j}.</p>
+    #
+    # <p>Reduce these configuration subsets to the set of possible alternatives.
+    # You can compute the alternative subsets in one pass as follows:</p>
+    #
+    # <p>{@code A_s,ctx = {i | (s, i, ctx, _)}} for each configuration in
+    # {@code C} holding {@code s} and {@code ctx} fixed.</p>
+    #
+    # <p>Or in pseudo-code, for each configuration {@code c} in {@code C}:</p>
+    #
+    # <pre>
+    # map[c] U= c.{@link ATNConfig#alt alt} # map hash/equals uses s and x, not
+    # alt and not pred
+    # </pre>
+    #
+    # <p>The values in {@code map} are the set of {@code A_s,ctx} sets.</p>
+    #
+    # <p>If {@code |A_s,ctx|=1} then there is no conflict associated with
+    # {@code s} and {@code ctx}.</p>
+    #
+    # <p>Reduce the subsets to singletons by choosing a minimum of each subset. If
+    # the union of these alternative subsets is a singleton, then no amount of
+    # more lookahead will help us. We will always pick that alternative. If,
+    # however, there is more than one alternative, then we are uncertain which
+    # alternative to predict and must continue looking for resolution. We may
+    # or may not discover an ambiguity in the future, even if there are no
+    # conflicting subsets this round.</p>
+    #
+    # <p>The biggest sin is to terminate early because it means we've made a
+    # decision but were uncertain as to the eventual outcome. We haven't used
+    # enough lookahead. On the other hand, announcing a conflict too late is no
+    # big deal; you will still have the conflict. It's just inefficient. It
+    # might even look until the end of file.</p>
+    #
+    # <p>No special consideration for semantic predicates is required because
+    # predicates are evaluated on-the-fly for full LL prediction, ensuring that
+    # no configuration contains a semantic context during the termination
+    # check.</p>
+    #
+    # <p><strong>CONFLICTING CONFIGS</strong></p>
+    #
+    # <p>Two configurations {@code (s, i, x)} and {@code (s, j, x')}, conflict
+    # when {@code i!=j} but {@code x=x'}. Because we merge all
+    # {@code (s, i, _)} configurations together, that means that there are at
+    # most {@code n} configurations associated with state {@code s} for
+    # {@code n} possible alternatives in the decision. The merged stacks
+    # complicate the comparison of configuration contexts {@code x} and
+    # {@code x'}. Sam checks to see if one is a subset of the other by calling
+    # merge and checking to see if the merged result is either {@code x} or
+    # {@code x'}. If the {@code x} associated with lowest alternative {@code i}
+    # is the superset, then {@code i} is the only possible prediction since the
+    # others resolve to {@code min(i)} as well. However, if {@code x} is
+    # associated with {@code j>i} then at least one stack configuration for
+    # {@code j} is not in conflict with alternative {@code i}. The algorithm
+    # should keep going, looking for more lookahead due to the uncertainty.</p>
+    #
+    # <p>For simplicity, I'm doing a equality check between {@code x} and
+    # {@code x'} that lets the algorithm continue to consume lookahead longer
+    # than necessary. The reason I like the equality is of course the
+    # simplicity but also because that is the test you need to detect the
+    # alternatives that are actually in conflict.</p>
+    #
+    # <p><strong>CONTINUE/STOP RULE</strong></p>
+    #
+    # <p>Continue if union of resolved alternative sets from non-conflicting and
+    # conflicting alternative subsets has more than one alternative. We are
+    # uncertain about which alternative to predict.</p>
+    #
+    # <p>The complete set of alternatives, {@code [i for (_,i,_)]}, tells us which
+    # alternatives are still in the running for the amount of input we've
+    # consumed at this point. The conflicting sets let us to strip away
+    # configurations that won't lead to more states because we resolve
+    # conflicts to the configuration with a minimum alternate for the
+    # conflicting set.</p>
+    #
+    # <p><strong>CASES</strong></p>
+    #
+    # <ul>
+    #
+    # <li>no conflicts and more than 1 alternative in set =&gt; continue</li>
+    #
+    # <li> {@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s, 3, z)},
+    # {@code (s', 1, y)}, {@code (s', 2, y)} yields non-conflicting set
+    # {@code {3}} U conflicting sets {@code min({1,2})} U {@code min({1,2})} =
+    # {@code {1,3}} =&gt; continue
+    # </li>
+    #
+    # <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 1, y)},
+    # {@code (s', 2, y)}, {@code (s'', 1, z)} yields non-conflicting set
+    # {@code {1}} U conflicting sets {@code min({1,2})} U {@code min({1,2})} =
+    # {@code {1}} =&gt; stop and predict 1</li>
+    #
+    # <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 1, y)},
+    # {@code (s', 2, y)} yields conflicting, reduced sets {@code {1}} U
+    # {@code {1}} = {@code {1}} =&gt; stop and predict 1, can announce
+    # ambiguity {@code {1,2}}</li>
+    #
+    # <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 2, y)},
+    # {@code (s', 3, y)} yields conflicting, reduced sets {@code {1}} U
+    # {@code {2}} = {@code {1,2}} =&gt; continue</li>
+    #
+    # <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 3, y)},
+    # {@code (s', 4, y)} yields conflicting, reduced sets {@code {1}} U
+    # {@code {3}} = {@code {1,3}} =&gt; continue</li>
+    #
+    # </ul>
+    #
+    # <p><strong>EXACT AMBIGUITY DETECTION</strong></p>
+    #
+    # <p>If all states report the same conflicting set of alternatives, then we
+    # know we have the exact ambiguity set.</p>
+    #
+    # <p><code>|A_<em>i</em>|&gt;1</code> and
+    # <code>A_<em>i</em> = A_<em>j</em></code> for all <em>i</em>, <em>j</em>.</p>
+    #
+    # <p>In other words, we continue examining lookahead until all {@code A_i}
+    # have more than one alternative and all {@code A_i} are the same. If
+    # {@code A={{1,2}, {1,3}}}, then regular LL prediction would terminate
+    # because the resolved set is {@code {1}}. To determine what the real
+    # ambiguity is, we have to know whether the ambiguity is between one and
+    # two or one and three so we keep going. We can only stop prediction when
+    # we need exact ambiguity detection when the sets look like
+    # {@code A={{1,2}}} or {@code {{1,2},{1,2}}}, etc...</p>
+    #
+    @classmethod
+    def resolvesToJustOneViableAlt(cls, altsets:list):
+        return cls.getSingleViableAlt(altsets)
+
+    #
+    # Determines if every alternative subset in {@code altsets} contains more
+    # than one alternative.
+    #
+    # @param altsets a collection of alternative subsets
+    # @return {@code true} if every {@link BitSet} in {@code altsets} has
+    # {@link BitSet#cardinality cardinality} &gt; 1, otherwise {@code false}
+    #
+    @classmethod
+    def allSubsetsConflict(cls, altsets:list):
+        return not cls.hasNonConflictingAltSet(altsets)
+
+    #
+    # Determines if any single alternative subset in {@code altsets} contains
+    # exactly one alternative.
+    #
+    # @param altsets a collection of alternative subsets
+    # @return {@code true} if {@code altsets} contains a {@link BitSet} with
+    # {@link BitSet#cardinality cardinality} 1, otherwise {@code false}
+    #
+    @classmethod
+    def hasNonConflictingAltSet(cls, altsets:list):
+        return any(len(alts) == 1 for alts in altsets)
+
+    #
+    # Determines if any single alternative subset in {@code altsets} contains
+    # more than one alternative.
+    #
+    # @param altsets a collection of alternative subsets
+    # @return {@code true} if {@code altsets} contains a {@link BitSet} with
+    # {@link BitSet#cardinality cardinality} &gt; 1, otherwise {@code false}
+    #
+    @classmethod
+    def hasConflictingAltSet(cls, altsets:list):
+        return any(len(alts) > 1 for alts in altsets)
+
+    #
+    # Determines if every alternative subset in {@code altsets} is equivalent.
+    #
+    # @param altsets a collection of alternative subsets
+    # @return {@code true} if every member of {@code altsets} is equal to the
+    # others, otherwise {@code false}
+    #
+    @classmethod
+    def allSubsetsEqual(cls, altsets:list):
+        if not altsets:
+            return True
+        first = next(iter(altsets))
+        return all(alts == first for alts in iter(altsets))
+
+    #
+    # Returns the unique alternative predicted by all alternative subsets in
+    # {@code altsets}. If no such alternative exists, this method returns
+    # {@link ATN#INVALID_ALT_NUMBER}.
+    #
+    # @param altsets a collection of alternative subsets
+    #
+    @classmethod
+    def getUniqueAlt(cls, altsets:list):
+        all = cls.getAlts(altsets)
+        if len(all)==1:
+            return next(iter(all))
+        return ATN.INVALID_ALT_NUMBER
+
+    # Gets the complete set of represented alternatives for a collection of
+    # alternative subsets. This method returns the union of each {@link BitSet}
+    # in {@code altsets}.
+    #
+    # @param altsets a collection of alternative subsets
+    # @return the set of represented alternatives in {@code altsets}
+    #
+    @classmethod
+    def getAlts(cls, altsets:list):
+        return set.union(*altsets)
+
+    #
+    # This function gets the conflicting alt subsets from a configuration set.
+    # For each configuration {@code c} in {@code configs}:
+    #
+    # <pre>
+    # map[c] U= c.{@link ATNConfig#alt alt} # map hash/equals uses s and x, not
+    # alt and not pred
+    # </pre>
+    #
+    @classmethod
+    def getConflictingAltSubsets(cls, configs:ATNConfigSet):
+        configToAlts = dict()
+        for c in configs:
+            h = hash((c.state.stateNumber, c.context))
+            alts = configToAlts.get(h, None)
+            if alts is None:
+                alts = set()
+                configToAlts[h] = alts
+            alts.add(c.alt)
+        return configToAlts.values()
+
+    #
+    # Get a map from state to alt subset from a configuration set. For each
+    # configuration {@code c} in {@code configs}:
+    #
+    # <pre>
+    # map[c.{@link ATNConfig#state state}] U= c.{@link ATNConfig#alt alt}
+    # </pre>
+    #
+    @classmethod
+    def getStateToAltMap(cls, configs:ATNConfigSet):
+        m = dict()
+        for c in configs:
+            alts = m.get(c.state, None)
+            if alts is None:
+                alts = set()
+                m[c.state] = alts
+            alts.add(c.alt)
+        return m
+
+    @classmethod
+    def hasStateAssociatedWithOneAlt(cls, configs:ATNConfigSet):
+        return any(len(alts) == 1 for alts in cls.getStateToAltMap(configs).values())
+
+    @classmethod
+    def getSingleViableAlt(cls, altsets:list):
+        viableAlts = set()
+        for alts in altsets:
+            minAlt = min(alts)
+            viableAlts.add(minAlt)
+            if len(viableAlts)>1 : # more than 1 viable alt
+                return ATN.INVALID_ALT_NUMBER
+        return min(viableAlts)

cameras/deps/antlr4/atn/SemanticContext.py

@@ -0,0 +1,323 @@
+#
+# 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.
+#
+
+# A tree structure used to record the semantic context in which
+#  an ATN configuration is valid.  It's either a single predicate,
+#  a conjunction {@code p1&&p2}, or a sum of products {@code p1||p2}.
+#
+#  <p>I have scoped the {@link AND}, {@link OR}, and {@link Predicate} subclasses of
+#  {@link SemanticContext} within the scope of this outer class.</p>
+#
+from antlr4.Recognizer import Recognizer
+from antlr4.RuleContext import RuleContext
+from io import StringIO
+
+
+class SemanticContext(object):
+    #
+    # The default {@link SemanticContext}, which is semantically equivalent to
+    # a predicate of the form {@code {true}?}.
+    #
+    NONE = None
+
+    #
+    # For context independent predicates, we evaluate them without a local
+    # context (i.e., null context). That way, we can evaluate them without
+    # having to create proper rule-specific context during prediction (as
+    # opposed to the parser, which creates them naturally). In a practical
+    # sense, this avoids a cast exception from RuleContext to myruleContext.
+    #
+    # <p>For context dependent predicates, we must pass in a local context so that
+    # references such as $arg evaluate properly as _localctx.arg. We only
+    # capture context dependent predicates in the context in which we begin
+    # prediction, so we passed in the outer context here in case of context
+    # dependent predicate evaluation.</p>
+    #
+    def eval(self, parser:Recognizer , outerContext:RuleContext ):
+        pass
+
+    #
+    # Evaluate the precedence predicates for the context and reduce the result.
+    #
+    # @param parser The parser instance.
+    # @param outerContext The current parser context object.
+    # @return The simplified semantic context after precedence predicates are
+    # evaluated, which will be one of the following values.
+    # <ul>
+    # <li>{@link #NONE}: if the predicate simplifies to {@code true} after
+    # precedence predicates are evaluated.</li>
+    # <li>{@code null}: if the predicate simplifies to {@code false} after
+    # precedence predicates are evaluated.</li>
+    # <li>{@code this}: if the semantic context is not changed as a result of
+    # precedence predicate evaluation.</li>
+    # <li>A non-{@code null} {@link SemanticContext}: the new simplified
+    # semantic context after precedence predicates are evaluated.</li>
+    # </ul>
+    #
+    def evalPrecedence(self, parser:Recognizer, outerContext:RuleContext):
+        return self
+
+# need forward declaration
+AND = None
+
+def andContext(a:SemanticContext, b:SemanticContext):
+    if a is None or a is SemanticContext.NONE:
+        return b
+    if b is None or b is SemanticContext.NONE:
+        return a
+    result = AND(a, b)
+    if len(result.opnds) == 1:
+        return result.opnds[0]
+    else:
+        return result
+
+# need forward declaration
+OR = None
+
+def orContext(a:SemanticContext, b:SemanticContext):
+    if a is None:
+        return b
+    if b is None:
+        return a
+    if a is SemanticContext.NONE or b is SemanticContext.NONE:
+        return SemanticContext.NONE
+    result = OR(a, b)
+    if len(result.opnds) == 1:
+        return result.opnds[0]
+    else:
+        return result
+
+def filterPrecedencePredicates(collection:set):
+    return [context for context in collection if isinstance(context, PrecedencePredicate)]
+
+
+class Predicate(SemanticContext):
+    __slots__ = ('ruleIndex', 'predIndex', 'isCtxDependent')
+
+    def __init__(self, ruleIndex:int=-1, predIndex:int=-1, isCtxDependent:bool=False):
+        self.ruleIndex = ruleIndex
+        self.predIndex = predIndex
+        self.isCtxDependent = isCtxDependent # e.g., $i ref in pred
+
+    def eval(self, parser:Recognizer , outerContext:RuleContext ):
+        localctx = outerContext if self.isCtxDependent else None
+        return parser.sempred(localctx, self.ruleIndex, self.predIndex)
+
+    def __hash__(self):
+        return hash((self.ruleIndex, self.predIndex, self.isCtxDependent))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, Predicate):
+            return False
+        return self.ruleIndex == other.ruleIndex and \
+               self.predIndex == other.predIndex and \
+               self.isCtxDependent == other.isCtxDependent
+
+    def __str__(self):
+        return "{" + str(self.ruleIndex) + ":" + str(self.predIndex) + "}?"
+
+
+class PrecedencePredicate(SemanticContext):
+
+    def __init__(self, precedence:int=0):
+        self.precedence = precedence
+
+    def eval(self, parser:Recognizer , outerContext:RuleContext ):
+        return parser.precpred(outerContext, self.precedence)
+
+    def evalPrecedence(self, parser:Recognizer, outerContext:RuleContext):
+        if parser.precpred(outerContext, self.precedence):
+            return SemanticContext.NONE
+        else:
+            return None
+
+    def __lt__(self, other):
+        return self.precedence < other.precedence
+
+    def __hash__(self):
+        return 31
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, PrecedencePredicate):
+            return False
+        else:
+            return self.precedence == other.precedence
+
+# A semantic context which is true whenever none of the contained contexts
+# is false.
+del AND
+class AND(SemanticContext):
+    __slots__ = 'opnds'
+
+    def __init__(self, a:SemanticContext, b:SemanticContext):
+        operands = set()
+        if isinstance( a, AND ):
+            operands.update(a.opnds)
+        else:
+            operands.add(a)
+        if isinstance( b, AND ):
+            operands.update(b.opnds)
+        else:
+            operands.add(b)
+
+        precedencePredicates = filterPrecedencePredicates(operands)
+        if len(precedencePredicates)>0:
+            # interested in the transition with the lowest precedence
+            reduced = min(precedencePredicates)
+            operands.add(reduced)
+
+        self.opnds = list(operands)
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, AND):
+            return False
+        else:
+            return self.opnds == other.opnds
+
+    def __hash__(self):
+        h = 0
+        for o in self.opnds:
+            h = hash((h, o))
+        return hash((h, "AND"))
+
+    #
+    # {@inheritDoc}
+    #
+    # <p>
+    # The evaluation of predicates by this context is short-circuiting, but
+    # unordered.</p>
+    #
+    def eval(self, parser:Recognizer, outerContext:RuleContext):
+        return all(opnd.eval(parser, outerContext) for opnd in self.opnds)
+
+    def evalPrecedence(self, parser:Recognizer, outerContext:RuleContext):
+        differs = False
+        operands = []
+        for context in self.opnds:
+            evaluated = context.evalPrecedence(parser, outerContext)
+            differs |= evaluated is not context
+            if evaluated is None:
+                # The AND context is false if any element is false
+                return None
+            elif evaluated is not SemanticContext.NONE:
+                # Reduce the result by skipping true elements
+                operands.append(evaluated)
+
+        if not differs:
+            return self
+
+        if len(operands)==0:
+            # all elements were true, so the AND context is true
+            return SemanticContext.NONE
+
+        result = None
+        for o in operands:
+            result = o if result is None else andContext(result, o)
+
+        return result
+
+    def __str__(self):
+        with StringIO() as buf:
+            first = True
+            for o in self.opnds:
+                if not first:
+                    buf.write("&&")
+                buf.write(str(o))
+                first = False
+            return buf.getvalue()
+
+#
+# A semantic context which is true whenever at least one of the contained
+# contexts is true.
+del OR
+class OR (SemanticContext):
+    __slots__ = 'opnds'
+
+    def __init__(self, a:SemanticContext, b:SemanticContext):
+        operands = set()
+        if isinstance( a, OR ):
+            operands.update(a.opnds)
+        else:
+            operands.add(a)
+        if isinstance( b, OR ):
+            operands.update(b.opnds)
+        else:
+            operands.add(b)
+
+        precedencePredicates = filterPrecedencePredicates(operands)
+        if len(precedencePredicates)>0:
+            # interested in the transition with the highest precedence
+            s = sorted(precedencePredicates)
+            reduced = s[-1]
+            operands.add(reduced)
+
+        self.opnds = list(operands)
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, OR):
+            return False
+        else:
+            return self.opnds == other.opnds
+
+    def __hash__(self):
+        h = 0
+        for o in self.opnds:
+            h = hash((h, o))
+        return hash((h, "OR"))
+
+    # <p>
+    # The evaluation of predicates by this context is short-circuiting, but
+    # unordered.</p>
+    #
+    def eval(self, parser:Recognizer, outerContext:RuleContext):
+        return any(opnd.eval(parser, outerContext) for opnd in self.opnds)
+
+    def evalPrecedence(self, parser:Recognizer, outerContext:RuleContext):
+        differs = False
+        operands = []
+        for context in self.opnds:
+            evaluated = context.evalPrecedence(parser, outerContext)
+            differs |= evaluated is not context
+            if evaluated is SemanticContext.NONE:
+                # The OR context is true if any element is true
+                return SemanticContext.NONE
+            elif evaluated is not None:
+                # Reduce the result by skipping false elements
+                operands.append(evaluated)
+
+        if not differs:
+            return self
+
+        if len(operands)==0:
+            # all elements were false, so the OR context is false
+            return None
+
+        result = None
+        for o in operands:
+            result = o if result is None else orContext(result, o)
+
+        return result
+
+    def __str__(self):
+        with StringIO() as buf:
+            first = True
+            for o in self.opnds:
+                if not first:
+                    buf.write("||")
+                buf.write(str(o))
+                first = False
+            return buf.getvalue()
+
+
+SemanticContext.NONE = Predicate()

cameras/deps/antlr4/atn/Transition.py

@@ -0,0 +1,268 @@
+#
+# 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.
+#
+
+#  An ATN transition between any two ATN states.  Subclasses define
+#  atom, set, epsilon, action, predicate, rule transitions.
+#
+#  <p>This is a one way link.  It emanates from a state (usually via a list of
+#  transitions) and has a target state.</p>
+#
+#  <p>Since we never have to change the ATN transitions once we construct it,
+#  we can fix these transitions as specific classes. The DFA transitions
+#  on the other hand need to update the labels as it adds transitions to
+#  the states. We'll use the term Edge for the DFA to distinguish them from
+#  ATN transitions.</p>
+#
+from antlr4.IntervalSet import IntervalSet
+from antlr4.Token import Token
+
+# need forward declarations
+from antlr4.atn.SemanticContext import Predicate, PrecedencePredicate
+
+ATNState = None
+RuleStartState = None
+
+class Transition (object):
+    __slots__ = ('target','isEpsilon','label')
+
+    # constants for serialization
+    EPSILON			= 1
+    RANGE			= 2
+    RULE			= 3
+    PREDICATE		= 4 # e.g., {isType(input.LT(1))}?
+    ATOM			= 5
+    ACTION			= 6
+    SET				= 7 # ~(A|B) or ~atom, wildcard, which convert to next 2
+    NOT_SET			= 8
+    WILDCARD		= 9
+    PRECEDENCE		= 10
+
+    serializationNames = [
+            "INVALID",
+            "EPSILON",
+            "RANGE",
+            "RULE",
+            "PREDICATE",
+            "ATOM",
+            "ACTION",
+            "SET",
+            "NOT_SET",
+            "WILDCARD",
+            "PRECEDENCE"
+        ]
+
+    serializationTypes = dict()
+
+    def __init__(self, target:ATNState):
+        # The target of this transition.
+        if target is None:
+            raise Exception("target cannot be null.")
+        self.target = target
+        # Are we epsilon, action, sempred?
+        self.isEpsilon = False
+        self.label = None
+
+
+# TODO: make all transitions sets? no, should remove set edges
+class AtomTransition(Transition):
+    __slots__ = ('label_', 'serializationType')
+
+    def __init__(self, target:ATNState, label:int):
+        super().__init__(target)
+        self.label_ = label # The token type or character value; or, signifies special label.
+        self.label = self.makeLabel()
+        self.serializationType = self.ATOM
+
+    def makeLabel(self):
+        s = IntervalSet()
+        s.addOne(self.label_)
+        return s
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return self.label_ == symbol
+
+    def __str__(self):
+        return str(self.label_)
+
+class RuleTransition(Transition):
+    __slots__ = ('ruleIndex', 'precedence', 'followState', 'serializationType')
+
+    def __init__(self, ruleStart:RuleStartState, ruleIndex:int, precedence:int, followState:ATNState):
+        super().__init__(ruleStart)
+        self.ruleIndex = ruleIndex # ptr to the rule definition object for this rule ref
+        self.precedence = precedence
+        self.followState = followState # what node to begin computations following ref to rule
+        self.serializationType = self.RULE
+        self.isEpsilon = True
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return False
+
+
+class EpsilonTransition(Transition):
+    __slots__ = ('serializationType', 'outermostPrecedenceReturn')
+
+    def __init__(self, target, outermostPrecedenceReturn=-1):
+        super(EpsilonTransition, self).__init__(target)
+        self.serializationType = self.EPSILON
+        self.isEpsilon = True
+        self.outermostPrecedenceReturn = outermostPrecedenceReturn
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return False
+
+    def __str__(self):
+        return "epsilon"
+
+class RangeTransition(Transition):
+    __slots__ = ('serializationType', 'start', 'stop')
+
+    def __init__(self, target:ATNState, start:int, stop:int):
+        super().__init__(target)
+        self.serializationType = self.RANGE
+        self.start = start
+        self.stop = stop
+        self.label = self.makeLabel()
+
+    def makeLabel(self):
+        s = IntervalSet()
+        s.addRange(range(self.start, self.stop + 1))
+        return s
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return symbol >= self.start and symbol <= self.stop
+
+    def __str__(self):
+        return "'" + chr(self.start) + "'..'" + chr(self.stop) + "'"
+
+class AbstractPredicateTransition(Transition):
+
+    def __init__(self, target:ATNState):
+        super().__init__(target)
+
+
+class PredicateTransition(AbstractPredicateTransition):
+    __slots__ = ('serializationType', 'ruleIndex', 'predIndex', 'isCtxDependent')
+
+    def __init__(self, target:ATNState, ruleIndex:int, predIndex:int, isCtxDependent:bool):
+        super().__init__(target)
+        self.serializationType = self.PREDICATE
+        self.ruleIndex = ruleIndex
+        self.predIndex = predIndex
+        self.isCtxDependent = isCtxDependent # e.g., $i ref in pred
+        self.isEpsilon = True
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return False
+
+    def getPredicate(self):
+        return Predicate(self.ruleIndex, self.predIndex, self.isCtxDependent)
+
+    def __str__(self):
+        return "pred_" + str(self.ruleIndex) + ":" + str(self.predIndex)
+
+class ActionTransition(Transition):
+    __slots__ = ('serializationType', 'ruleIndex', 'actionIndex', 'isCtxDependent')
+
+    def __init__(self, target:ATNState, ruleIndex:int, actionIndex:int=-1, isCtxDependent:bool=False):
+        super().__init__(target)
+        self.serializationType = self.ACTION
+        self.ruleIndex = ruleIndex
+        self.actionIndex = actionIndex
+        self.isCtxDependent = isCtxDependent # e.g., $i ref in pred
+        self.isEpsilon = True
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return False
+
+    def __str__(self):
+        return "action_"+self.ruleIndex+":"+self.actionIndex
+
+# A transition containing a set of values.
+class SetTransition(Transition):
+    __slots__ = 'serializationType'
+
+    def __init__(self, target:ATNState, set:IntervalSet):
+        super().__init__(target)
+        self.serializationType = self.SET
+        if set is not None:
+            self.label = set
+        else:
+            self.label = IntervalSet()
+            self.label.addRange(range(Token.INVALID_TYPE, Token.INVALID_TYPE + 1))
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return symbol in self.label
+
+    def __str__(self):
+        return str(self.label)
+
+class NotSetTransition(SetTransition):
+
+    def __init__(self, target:ATNState, set:IntervalSet):
+        super().__init__(target, set)
+        self.serializationType = self.NOT_SET
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return symbol >= minVocabSymbol \
+            and symbol <= maxVocabSymbol \
+            and not super(type(self), self).matches(symbol, minVocabSymbol, maxVocabSymbol)
+
+    def __str__(self):
+        return '~' + super(type(self), self).__str__()
+
+
+class WildcardTransition(Transition):
+    __slots__ = 'serializationType'
+
+    def __init__(self, target:ATNState):
+        super().__init__(target)
+        self.serializationType = self.WILDCARD
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return symbol >= minVocabSymbol and symbol <= maxVocabSymbol
+
+    def __str__(self):
+        return "."
+
+
+class PrecedencePredicateTransition(AbstractPredicateTransition):
+    __slots__ = ('serializationType', 'precedence')
+
+    def __init__(self, target:ATNState, precedence:int):
+        super().__init__(target)
+        self.serializationType = self.PRECEDENCE
+        self.precedence = precedence
+        self.isEpsilon = True
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return False
+
+
+    def getPredicate(self):
+        return PrecedencePredicate(self.precedence)
+
+    def __str__(self):
+        return self.precedence + " >= _p"
+
+
+Transition.serializationTypes = {
+             EpsilonTransition: Transition.EPSILON,
+             RangeTransition: Transition.RANGE,
+             RuleTransition: Transition.RULE,
+             PredicateTransition: Transition.PREDICATE,
+             AtomTransition: Transition.ATOM,
+             ActionTransition: Transition.ACTION,
+             SetTransition: Transition.SET,
+             NotSetTransition: Transition.NOT_SET,
+             WildcardTransition: Transition.WILDCARD,
+             PrecedencePredicateTransition: Transition.PRECEDENCE
+         }
+
+del ATNState
+del RuleStartState
+
+from antlr4.atn.ATNState import *

cameras/deps/antlr4/atn/__init__.py

@@ -0,0 +1 @@
+__author__ = 'ericvergnaud'

cameras/deps/antlr4/dfa/DFA.py

@@ -0,0 +1,133 @@
+#
+# 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.
+from antlr4.atn.ATNState import StarLoopEntryState
+
+from antlr4.atn.ATNConfigSet import ATNConfigSet
+from antlr4.atn.ATNState import DecisionState
+from antlr4.dfa.DFAState import DFAState
+from antlr4.error.Errors import IllegalStateException
+
+
+class DFA(object):
+    __slots__ = ('atnStartState', 'decision', '_states', 's0', 'precedenceDfa')
+
+    def __init__(self, atnStartState:DecisionState, decision:int=0):
+        # From which ATN state did we create this DFA?
+        self.atnStartState = atnStartState
+        self.decision = decision
+        # A set of all DFA states. Use {@link Map} so we can get old state back
+        #  ({@link Set} only allows you to see if it's there).
+        self._states = dict()
+        self.s0 = None
+        # {@code true} if this DFA is for a precedence decision; otherwise,
+        # {@code false}. This is the backing field for {@link #isPrecedenceDfa},
+        # {@link #setPrecedenceDfa}.
+        self.precedenceDfa = False
+
+        if isinstance(atnStartState, StarLoopEntryState):
+            if atnStartState.isPrecedenceDecision:
+                self.precedenceDfa = True
+                precedenceState = DFAState(configs=ATNConfigSet())
+                precedenceState.edges = []
+                precedenceState.isAcceptState = False
+                precedenceState.requiresFullContext = False
+                self.s0 = precedenceState
+
+
+    # Get the start state for a specific precedence value.
+    #
+    # @param precedence The current precedence.
+    # @return The start state corresponding to the specified precedence, or
+    # {@code null} if no start state exists for the specified precedence.
+    #
+    # @throws IllegalStateException if this is not a precedence DFA.
+    # @see #isPrecedenceDfa()
+
+    def getPrecedenceStartState(self, precedence:int):
+        if not self.precedenceDfa:
+            raise IllegalStateException("Only precedence DFAs may contain a precedence start state.")
+
+        # s0.edges is never null for a precedence DFA
+        if precedence < 0 or precedence >= len(self.s0.edges):
+            return None
+        return self.s0.edges[precedence]
+
+    # Set the start state for a specific precedence value.
+    #
+    # @param precedence The current precedence.
+    # @param startState The start state corresponding to the specified
+    # precedence.
+    #
+    # @throws IllegalStateException if this is not a precedence DFA.
+    # @see #isPrecedenceDfa()
+    #
+    def setPrecedenceStartState(self, precedence:int, startState:DFAState):
+        if not self.precedenceDfa:
+            raise IllegalStateException("Only precedence DFAs may contain a precedence start state.")
+
+        if precedence < 0:
+            return
+
+        # synchronization on s0 here is ok. when the DFA is turned into a
+        # precedence DFA, s0 will be initialized once and not updated again
+        # s0.edges is never null for a precedence DFA
+        if precedence >= len(self.s0.edges):
+            ext = [None] * (precedence + 1 - len(self.s0.edges))
+            self.s0.edges.extend(ext)
+        self.s0.edges[precedence] = startState
+    #
+    # Sets whether this is a precedence DFA. If the specified value differs
+    # from the current DFA configuration, the following actions are taken;
+    # otherwise no changes are made to the current DFA.
+    #
+    # <ul>
+    # <li>The {@link #states} map is cleared</li>
+    # <li>If {@code precedenceDfa} is {@code false}, the initial state
+    # {@link #s0} is set to {@code null}; otherwise, it is initialized to a new
+    # {@link DFAState} with an empty outgoing {@link DFAState#edges} array to
+    # store the start states for individual precedence values.</li>
+    # <li>The {@link #precedenceDfa} field is updated</li>
+    # </ul>
+    #
+    # @param precedenceDfa {@code true} if this is a precedence DFA; otherwise,
+    # {@code false}
+
+    def setPrecedenceDfa(self, precedenceDfa:bool):
+        if self.precedenceDfa != precedenceDfa:
+            self._states = dict()
+            if precedenceDfa:
+                precedenceState = DFAState(configs=ATNConfigSet())
+                precedenceState.edges = []
+                precedenceState.isAcceptState = False
+                precedenceState.requiresFullContext = False
+                self.s0 = precedenceState
+            else:
+                self.s0 = None
+            self.precedenceDfa = precedenceDfa
+
+    @property
+    def states(self):
+        return self._states
+
+    # Return a list of all states in this DFA, ordered by state number.
+    def sortedStates(self):
+        return sorted(self._states.keys(), key=lambda state: state.stateNumber)
+
+    def __str__(self):
+        return self.toString(None)
+
+    def toString(self, literalNames:list=None, symbolicNames:list=None):
+        if self.s0 is None:
+            return ""
+        from antlr4.dfa.DFASerializer import DFASerializer
+        serializer = DFASerializer(self,literalNames,symbolicNames)
+        return str(serializer)
+
+    def toLexerString(self):
+        if self.s0 is None:
+            return ""
+        from antlr4.dfa.DFASerializer import LexerDFASerializer
+        serializer = LexerDFASerializer(self)
+        return str(serializer)

cameras/deps/antlr4/dfa/DFASerializer.py

@@ -0,0 +1,73 @@
+#
+# 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.
+#/
+
+# A DFA walker that knows how to dump them to serialized strings.#/
+from io import StringIO
+from antlr4 import DFA
+from antlr4.Utils import str_list
+from antlr4.dfa.DFAState import DFAState
+
+
+class DFASerializer(object):
+    __slots__ = ('dfa', 'literalNames', 'symbolicNames')
+
+    def __init__(self, dfa:DFA, literalNames:list=None, symbolicNames:list=None):
+        self.dfa = dfa
+        self.literalNames = literalNames
+        self.symbolicNames = symbolicNames
+
+    def __str__(self):
+        if self.dfa.s0 is None:
+            return None
+        with StringIO() as buf:
+            for s in self.dfa.sortedStates():
+                n = 0
+                if s.edges is not None:
+                    n = len(s.edges)
+                for i in range(0, n):
+                    t = s.edges[i]
+                    if t is not None and t.stateNumber != 0x7FFFFFFF:
+                        buf.write(self.getStateString(s))
+                        label = self.getEdgeLabel(i)
+                        buf.write("-")
+                        buf.write(label)
+                        buf.write("->")
+                        buf.write(self.getStateString(t))
+                        buf.write('\n')
+            output = buf.getvalue()
+            if len(output)==0:
+                return None
+            else:
+                return output
+
+    def getEdgeLabel(self, i:int):
+        if i==0:
+            return "EOF"
+        if self.literalNames is not None and i<=len(self.literalNames):
+            return self.literalNames[i-1]
+        elif self.symbolicNames is not None and i<=len(self.symbolicNames):
+            return self.symbolicNames[i-1]
+        else:
+            return str(i-1)
+
+    def getStateString(self, s:DFAState):
+        n = s.stateNumber
+        baseStateStr = ( ":" if s.isAcceptState else "") + "s" + str(n) + ( "^" if s.requiresFullContext else "")
+        if s.isAcceptState:
+            if s.predicates is not None:
+                return baseStateStr + "=>" + str_list(s.predicates)
+            else:
+                return baseStateStr + "=>" + str(s.prediction)
+        else:
+            return baseStateStr
+
+class LexerDFASerializer(DFASerializer):
+
+    def __init__(self, dfa:DFA):
+        super().__init__(dfa, None)
+
+    def getEdgeLabel(self, i:int):
+        return "'" + chr(i) + "'"

cameras/deps/antlr4/dfa/DFAState.py

@@ -0,0 +1,126 @@
+#
+# 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.
+#/
+
+# Map a predicate to a predicted alternative.#/
+from io import StringIO
+from antlr4.atn.ATNConfigSet import ATNConfigSet
+from antlr4.atn.SemanticContext import SemanticContext
+
+
+class PredPrediction(object):
+    __slots__ = ('alt', 'pred')
+
+    def __init__(self, pred:SemanticContext, alt:int):
+        self.alt = alt
+        self.pred = pred
+
+    def __str__(self):
+        return "(" + str(self.pred) + ", " + str(self.alt) +  ")"
+
+# A DFA state represents a set of possible ATN configurations.
+#  As Aho, Sethi, Ullman p. 117 says "The DFA uses its state
+#  to keep track of all possible states the ATN can be in after
+#  reading each input symbol.  That is to say, after reading
+#  input a1a2..an, the DFA is in a state that represents the
+#  subset T of the states of the ATN that are reachable from the
+#  ATN's start state along some path labeled a1a2..an."
+#  In conventional NFA→DFA conversion, therefore, the subset T
+#  would be a bitset representing the set of states the
+#  ATN could be in.  We need to track the alt predicted by each
+#  state as well, however.  More importantly, we need to maintain
+#  a stack of states, tracking the closure operations as they
+#  jump from rule to rule, emulating rule invocations (method calls).
+#  I have to add a stack to simulate the proper lookahead sequences for
+#  the underlying LL grammar from which the ATN was derived.
+#
+#  <p>I use a set of ATNConfig objects not simple states.  An ATNConfig
+#  is both a state (ala normal conversion) and a RuleContext describing
+#  the chain of rules (if any) followed to arrive at that state.</p>
+#
+#  <p>A DFA state may have multiple references to a particular state,
+#  but with different ATN contexts (with same or different alts)
+#  meaning that state was reached via a different set of rule invocations.</p>
+#/
+class DFAState(object):
+    __slots__ = (
+        'stateNumber', 'configs', 'edges', 'isAcceptState', 'prediction',
+        'lexerActionExecutor', 'requiresFullContext', 'predicates'
+    )
+
+    def __init__(self, stateNumber:int=-1, configs:ATNConfigSet=ATNConfigSet()):
+        self.stateNumber = stateNumber
+        self.configs = configs
+        # {@code edges[symbol]} points to target of symbol. Shift up by 1 so (-1)
+        #  {@link Token#EOF} maps to {@code edges[0]}.
+        self.edges = None
+        self.isAcceptState = False
+        # if accept state, what ttype do we match or alt do we predict?
+        #  This is set to {@link ATN#INVALID_ALT_NUMBER} when {@link #predicates}{@code !=null} or
+        #  {@link #requiresFullContext}.
+        self.prediction = 0
+        self.lexerActionExecutor = None
+        # Indicates that this state was created during SLL prediction that
+        # discovered a conflict between the configurations in the state. Future
+        # {@link ParserATNSimulator#execATN} invocations immediately jumped doing
+        # full context prediction if this field is true.
+        self.requiresFullContext = False
+        # During SLL parsing, this is a list of predicates associated with the
+        #  ATN configurations of the DFA state. When we have predicates,
+        #  {@link #requiresFullContext} is {@code false} since full context prediction evaluates predicates
+        #  on-the-fly. If this is not null, then {@link #prediction} is
+        #  {@link ATN#INVALID_ALT_NUMBER}.
+        #
+        #  <p>We only use these for non-{@link #requiresFullContext} but conflicting states. That
+        #  means we know from the context (it's $ or we don't dip into outer
+        #  context) that it's an ambiguity not a conflict.</p>
+        #
+        #  <p>This list is computed by {@link ParserATNSimulator#predicateDFAState}.</p>
+        self.predicates = None
+
+
+
+    # Get the set of all alts mentioned by all ATN configurations in this
+    #  DFA state.
+    def getAltSet(self):
+        if self.configs is not None:
+            return set(cfg.alt for cfg in self.configs) or None
+        return None
+
+    def __hash__(self):
+        return hash(self.configs)
+
+    # Two {@link DFAState} instances are equal if their ATN configuration sets
+    # are the same. This method is used to see if a state already exists.
+    #
+    # <p>Because the number of alternatives and number of ATN configurations are
+    # finite, there is a finite number of DFA states that can be processed.
+    # This is necessary to show that the algorithm terminates.</p>
+    #
+    # <p>Cannot test the DFA state numbers here because in
+    # {@link ParserATNSimulator#addDFAState} we need to know if any other state
+    # exists that has this exact set of ATN configurations. The
+    # {@link #stateNumber} is irrelevant.</p>
+    def __eq__(self, other):
+        # compare set of ATN configurations in this set with other
+        if self is other:
+            return True
+        elif not isinstance(other, DFAState):
+            return False
+        else:
+            return self.configs==other.configs
+
+    def __str__(self):
+        with StringIO() as buf:
+            buf.write(str(self.stateNumber))
+            buf.write(":")
+            buf.write(str(self.configs))
+            if self.isAcceptState:
+                buf.write("=>")
+                if self.predicates is not None:
+                    buf.write(str(self.predicates))
+                else:
+                    buf.write(str(self.prediction))
+            return buf.getvalue()