LCOV - code coverage report
Current view: top level - build directory/src/plugins/yanlr - YAML.h (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 13 15 86.7 %
Date: 2019-09-12 12:28:41 Functions: 13 28 46.4 %

          Line data    Source code
       1             : 
       2             : // Generated from /home/jenkins/workspace/libelektra_PR-2949-JSVQFJNQUXFDDEIVMWX2NWLWVTIX5MLFKA62ACPFOA3QLNMROQ7Q/src/plugins/yanlr/YAML.g4 by ANTLR 4.7.2
       3             : 
       4             : #pragma once
       5             : 
       6             : 
       7             : #include "antlr4-runtime.h"
       8             : 
       9             : 
      10             : namespace yanlr {
      11             : 
      12             : 
      13             : class  YAML : public antlr4::Parser {
      14             : public:
      15             :   enum {
      16             :     STREAM_START = 1, STREAM_END = 2, COMMENT = 3, PLAIN_SCALAR = 4, SINGLE_QUOTED_SCALAR = 5, 
      17             :     DOUBLE_QUOTED_SCALAR = 6, MAP_START = 7, MAP_END = 8, KEY = 9, VALUE = 10, 
      18             :     SEQUENCE_START = 11, SEQUENCE_END = 12, ELEMENT = 13
      19             :   };
      20             : 
      21             :   enum {
      22             :     RuleYaml = 0, RuleChild = 1, RuleEmpty = 2, RuleValue = 3, RuleScalar = 4, 
      23             :     RuleMap = 5, RulePairs = 6, RulePair = 7, RuleKey = 8, RuleSequence = 9, 
      24             :     RuleElements = 10, RuleElement = 11, RuleComment = 12
      25             :   };
      26             : 
      27             :   YAML(antlr4::TokenStream *input);
      28             :   ~YAML();
      29             : 
      30             :   virtual std::string getGrammarFileName() const override;
      31         704 :   virtual const antlr4::atn::ATN& getATN() const override { return _atn; };
      32           0 :   virtual const std::vector<std::string>& getTokenNames() const override { return _tokenNames; }; // deprecated: use vocabulary instead.
      33             :   virtual const std::vector<std::string>& getRuleNames() const override;
      34             :   virtual antlr4::dfa::Vocabulary& getVocabulary() const override;
      35             : 
      36             : 
      37             :   class YamlContext;
      38             :   class ChildContext;
      39             :   class EmptyContext;
      40             :   class ValueContext;
      41             :   class ScalarContext;
      42             :   class MapContext;
      43             :   class PairsContext;
      44             :   class PairContext;
      45             :   class KeyContext;
      46             :   class SequenceContext;
      47             :   class ElementsContext;
      48             :   class ElementContext;
      49             :   class CommentContext; 
      50             : 
      51          31 :   class  YamlContext : public antlr4::ParserRuleContext {
      52             :   public:
      53             :     YamlContext(antlr4::ParserRuleContext *parent, size_t invokingState);
      54             :     virtual size_t getRuleIndex() const override;
      55             :     antlr4::tree::TerminalNode *STREAM_START();
      56             :     antlr4::tree::TerminalNode *STREAM_END();
      57             :     antlr4::tree::TerminalNode *EOF();
      58             :     ChildContext *child();
      59             :     EmptyContext *empty();
      60             :     std::vector<CommentContext *> comment();
      61             :     CommentContext* comment(size_t i);
      62             : 
      63             :     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
      64             :     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
      65             :    
      66             :   };
      67             : 
      68             :   YamlContext* yaml();
      69             : 
      70         137 :   class  ChildContext : public antlr4::ParserRuleContext {
      71             :   public:
      72             :     ChildContext(antlr4::ParserRuleContext *parent, size_t invokingState);
      73             :     virtual size_t getRuleIndex() const override;
      74             :     ValueContext *value();
      75             :     MapContext *map();
      76             :     SequenceContext *sequence();
      77             :     std::vector<CommentContext *> comment();
      78             :     CommentContext* comment(size_t i);
      79             : 
      80             :     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
      81             :     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
      82             :    
      83             :   };
      84             : 
      85             :   ChildContext* child();
      86             : 
      87           0 :   class  EmptyContext : public antlr4::ParserRuleContext {
      88             :   public:
      89             :     EmptyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
      90             :     virtual size_t getRuleIndex() const override;
      91             :     std::vector<CommentContext *> comment();
      92             :     CommentContext* comment(size_t i);
      93             : 
      94             :     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
      95             :     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
      96             :    
      97             :   };
      98             : 
      99             :   EmptyContext* empty();
     100             : 
     101          82 :   class  ValueContext : public antlr4::ParserRuleContext {
     102             :   public:
     103             :     ValueContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     104             :     virtual size_t getRuleIndex() const override;
     105             :     ScalarContext *scalar();
     106             : 
     107             :     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
     108             :     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
     109             :    
     110             :   };
     111             : 
     112             :   ValueContext* value();
     113             : 
     114         163 :   class  ScalarContext : public antlr4::ParserRuleContext {
     115             :   public:
     116             :     ScalarContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     117             :     virtual size_t getRuleIndex() const override;
     118             :     antlr4::tree::TerminalNode *PLAIN_SCALAR();
     119             :     antlr4::tree::TerminalNode *SINGLE_QUOTED_SCALAR();
     120             :     antlr4::tree::TerminalNode *DOUBLE_QUOTED_SCALAR();
     121             : 
     122             :     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
     123             :     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
     124             :    
     125             :   };
     126             : 
     127             :   ScalarContext* scalar();
     128             : 
     129          42 :   class  MapContext : public antlr4::ParserRuleContext {
     130             :   public:
     131             :     MapContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     132             :     virtual size_t getRuleIndex() const override;
     133             :     antlr4::tree::TerminalNode *MAP_START();
     134             :     PairsContext *pairs();
     135             :     antlr4::tree::TerminalNode *MAP_END();
     136             : 
     137             :     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
     138             :     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
     139             :    
     140             :   };
     141             : 
     142             :   MapContext* map();
     143             : 
     144          42 :   class  PairsContext : public antlr4::ParserRuleContext {
     145             :   public:
     146             :     PairsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     147             :     virtual size_t getRuleIndex() const override;
     148             :     std::vector<PairContext *> pair();
     149             :     PairContext* pair(size_t i);
     150             : 
     151             :     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
     152             :     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
     153             :    
     154             :   };
     155             : 
     156             :   PairsContext* pairs();
     157             : 
     158          81 :   class  PairContext : public antlr4::ParserRuleContext {
     159             :   public:
     160             :     PairContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     161             :     virtual size_t getRuleIndex() const override;
     162             :     antlr4::tree::TerminalNode *KEY();
     163             :     KeyContext *key();
     164             :     antlr4::tree::TerminalNode *VALUE();
     165             :     std::vector<CommentContext *> comment();
     166             :     CommentContext* comment(size_t i);
     167             :     ChildContext *child();
     168             : 
     169             :     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
     170             :     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
     171             :    
     172             :   };
     173             : 
     174             :   PairContext* pair();
     175             : 
     176          81 :   class  KeyContext : public antlr4::ParserRuleContext {
     177             :   public:
     178             :     KeyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     179             :     virtual size_t getRuleIndex() const override;
     180             :     ScalarContext *scalar();
     181             : 
     182             :     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
     183             :     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
     184             :    
     185             :   };
     186             : 
     187             :   KeyContext* key();
     188             : 
     189          13 :   class  SequenceContext : public antlr4::ParserRuleContext {
     190             :   public:
     191             :     SequenceContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     192             :     virtual size_t getRuleIndex() const override;
     193             :     antlr4::tree::TerminalNode *SEQUENCE_START();
     194             :     ElementsContext *elements();
     195             :     antlr4::tree::TerminalNode *SEQUENCE_END();
     196             : 
     197             :     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
     198             :     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
     199             :    
     200             :   };
     201             : 
     202             :   SequenceContext* sequence();
     203             : 
     204          13 :   class  ElementsContext : public antlr4::ParserRuleContext {
     205             :   public:
     206             :     ElementsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     207             :     virtual size_t getRuleIndex() const override;
     208             :     std::vector<ElementContext *> element();
     209             :     ElementContext* element(size_t i);
     210             : 
     211             :     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
     212             :     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
     213             :    
     214             :   };
     215             : 
     216             :   ElementsContext* elements();
     217             : 
     218          28 :   class  ElementContext : public antlr4::ParserRuleContext {
     219             :   public:
     220             :     ElementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     221             :     virtual size_t getRuleIndex() const override;
     222             :     antlr4::tree::TerminalNode *ELEMENT();
     223             :     ChildContext *child();
     224             :     std::vector<CommentContext *> comment();
     225             :     CommentContext* comment(size_t i);
     226             : 
     227             :     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
     228             :     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
     229             :    
     230             :   };
     231             : 
     232             :   ElementContext* element();
     233             : 
     234           5 :   class  CommentContext : public antlr4::ParserRuleContext {
     235             :   public:
     236             :     CommentContext(antlr4::ParserRuleContext *parent, size_t invokingState);
     237             :     virtual size_t getRuleIndex() const override;
     238             :     antlr4::tree::TerminalNode *COMMENT();
     239             : 
     240             :     virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
     241             :     virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
     242             :    
     243             :   };
     244             : 
     245             :   CommentContext* comment();
     246             : 
     247             : 
     248             : private:
     249             :   static std::vector<antlr4::dfa::DFA> _decisionToDFA;
     250             :   static antlr4::atn::PredictionContextCache _sharedContextCache;
     251             :   static std::vector<std::string> _ruleNames;
     252             :   static std::vector<std::string> _tokenNames;
     253             : 
     254             :   static std::vector<std::string> _literalNames;
     255             :   static std::vector<std::string> _symbolicNames;
     256             :   static antlr4::dfa::Vocabulary _vocabulary;
     257             :   static antlr4::atn::ATN _atn;
     258             :   static std::vector<uint16_t> _serializedATN;
     259             : 
     260             : 
     261             :   struct Initializer {
     262             :     Initializer();
     263             :   };
     264             :   static Initializer _init;
     265             : };
     266             : 
     267             : }  // namespace yanlr

Generated by: LCOV version 1.13