jison.cson

"name": "Jison"
scopeName: "source.jison"
fileTypes: ["jison"]

# This grammar is based on the Jison files from
# https://github.com/zaach/ebnf-parser and
# https://github.com/GerHobbelt/ebnf-parser. The original Jison allows
# identifiers to contain (and end with) hyphens. GerHobbelt Jison makes a
# distinction between identifiers, which can’t contain hyphens at all, and
# names, which can contain (but *not* end with) hyphens. As a compromise, this
# grammar uses
#   [[:alpha:]_](?:[\w-]*\w)?
# to match both identifiers and names. This means that identifiers can contain
# hyphens, even when they’re not allowed in GerHobbelt Jison. Use [:alpha:]
# instead of \p{Alpha} for compatibility with GitHub Linguist.

patterns: [
  {
    # Like Bison
    # (https://www.gnu.org/software/bison/manual/html_node/Grammar-Outline.html),
    # Jison files are divided into four sections:
    #   %{
    #     Prologue
    #   %}
    #   Declarations
    #   %%
    #   Grammar rules
    #   %%
    #   Epilogue
    # Because there can be more than one prologue, another way to look at Jison
    # files is that they’re divided into three sections separated by %%, just
    # like Jison Lex files.
    begin: "%%"
    end:   "\\z"
    beginCaptures: 0: name: "meta.separator.section.jison"
    patterns: [
      {
        begin: "%%"
        end:   "\\z"
        beginCaptures: 0: name: "meta.separator.section.jison"
        patterns: [
          {
            name:  "meta.section.epilogue.jison"
            begin: "\\G"
            end:   "\\z"
            contentName: "source.js.embedded.jison"
            patterns: [include: "#epilogue_section"]
          }
        ]
      },{
        name:  "meta.section.rules.jison"
        begin: "\\G"
        end:   "(?=%%)"
        patterns: [include: "#rules_section"]
      }
    ]
  },{
    name:  "meta.section.declarations.jison"
    begin: "^"
    end:   "(?=%%)"
    patterns: [include: "#declarations_section"]
  }
]


repository:
  declarations_section:
    patterns: [
      {include: "#comments"}

      # Jison declarations sections can have lexers embedded between %lex and
      # /lex.
      {
        begin: "^\\s*(%lex)\\s*$"
        end:   "^\\s*(/lex)\\b"
        # There may be a better choice of scope than “entity.name.tag”, but
        # using a tag scope makes the start and end matches stand out. Also, the
        # end match “/lex” is somewhat like an end tag.
        beginCaptures: 1: name: "entity.name.tag.lexer.begin.jison"
        endCaptures:   1: name: "entity.name.tag.lexer.end.jison"
        # Simply setting the patterns object to {include: "source.jisonlex"}
        # here doesn’t work for several reasons:
        # - The Jison Lex grammar’s rules section treats /lex as a valid regex
        #   pattern; /lex is the same as (?=lex).
        # - The user-code section treats /lex as a division operator followed by
        #   the identifier “lex”.
        # - The user-code section ends at the end of the Jison Lex file.
        # This is the Jison Lex grammar with end patterns that circumvent these
        # issues.
        patterns: [
          {
            begin: "%%"
            end:   "(?=/lex)"
            beginCaptures: 0: name: "meta.separator.section.jisonlex"
            patterns: [
              {
                begin: "^%%"
                end:   "(?=/lex)"
                beginCaptures: 0: name: "meta.separator.section.jisonlex"
                patterns: [
                  {
                    name:  "meta.section.user-code.jisonlex"
                    begin: "\\G"
                    end:   "(?=/lex)"
                    contentName: "source.js.embedded.jisonlex"
                    patterns: [include: "source.jisonlex#user_code_section"]
                  }
                ]
              },{
                name:  "meta.section.rules.jisonlex"
                begin: "\\G"
                end:   "^(?=%%|/lex)"
                patterns: [include: "source.jisonlex#rules_section"]
              }
            ]
          },{
            name:  "meta.section.definitions.jisonlex"
            begin: "^"
            end:   "(?=%%|/lex)"
            patterns: [include: "source.jisonlex#definitions_section"]
          }
        ]
      }

      {
        name:  "meta.section.prologue.jison"
        begin: "(?=%\\{)"
        end:   "(?<=%\\})"
        patterns: [include: "#user_code_blocks"]
      }

      # These declarations are supported by the original Jison.
      {include: "#options_declarations"}
      {
        name:  "keyword.other.declaration.$1.jison"
        match: "%(ebnf|left|nonassoc|parse-param|right|start)\\b"
      }

      # These declarations are supported by the GerHobbelt fork.
      {include: "#include_declarations"}
      {
        name:  "meta.code.jison"
        begin: "%(code)\\b"
        end:   "$"
        beginCaptures: 0: name: "keyword.other.declaration.$1.jison"
        patterns: [
          # Note that GerHobbelt Jison supports
          #   %code qualifier {code}
          # but not Bison’s
          #   %code {code}
          # (https://www.gnu.org/software/bison/manual/html_node/_0025code-Summary.html).
          {include: "#comments"}
          {include: "#rule_actions"}
          {
            # GerHobbelt Jison supports “required”, Bison supports “requires”
            # (https://www.gnu.org/software/bison/manual/html_node/_0025code-Summary.html).
            name:  "keyword.other.code-qualifier.$1.jison"
            match: "(init|required)"
          }
          {include: "#quoted_strings"}
          {
            name:  "string.unquoted.jison"
            match: "\\b[[:alpha:]_](?:[\\w-]*\\w)?\\b"
          }
        ]
      },{
        name:  "meta.parser-type.jison"
        begin: "%(parser-type)\\b"
        end:   "$"
        beginCaptures: 0: name: "keyword.other.declaration.$1.jison"
        patterns: [
          {include: "#comments"}
          {include: "#quoted_strings"}
          {
            name:  "string.unquoted.jison"
            match: "\\b[[:alpha:]_](?:[\\w-]*\\w)?\\b"
          }
        ]
      },{
        # https://www.gnu.org/software/bison/manual/html_node/Token-Decl.html
        name:  "meta.token.jison"
        begin: "%(token)\\b"
        end:   "$|(%%|;)"
        beginCaptures: 0: name: "keyword.other.declaration.$1.jison"
        endCaptures:   1: name: "punctuation.terminator.declaration.token.jison"
        patterns: [
          {include: "#comments"}
          {include: "#numbers"}
          {include: "#quoted_strings"}
          {
            name:  "invalid.unimplemented.jison"
            match: "<[[:alpha:]_](?:[\\w-]*\\w)?>"
          },{
            name:  "entity.other.token.jison"
            match: "\\S+"
          }
        ]
      },{
        name:  "keyword.other.declaration.$1.jison"
        match: "%(debug|import)\\b"
      }

      {
        name:  "invalid.illegal.jison"
        match: "%prec\\b"
      },{
        name:  "invalid.unimplemented.jison"
        match: "%[[:alpha:]_](?:[\\w-]*\\w)?\\b"
      }

      {include: "#numbers"}
      {include: "#quoted_strings"}
    ]

  rules_section:
    patterns: [
      {include: "#comments"}
      {include: "#actions"}
      {include: "#include_declarations"}
      {
        name:  "meta.rule.jison"
        begin: "\\b[[:alpha:]_](?:[\\w-]*\\w)?\\b"
        end:   ";"
        beginCaptures: 0: name: "entity.name.constant.rule-result.jison"
        endCaptures:   0: name: "punctuation.terminator.rule.jison"
        patterns: [
          {include: "#comments"}
          {
            name:  "meta.rule-components.jison"
            begin: ":"
            end:   "(?=;)"
            beginCaptures: 0: name: "keyword.operator.rule-components.assignment.jison"
            patterns: [
              {include: "#comments"}
              {include: "#quoted_strings"}
              {
                match: "(\\[)([[:alpha:]_](?:[\\w-]*\\w)?)(\\])"
                captures:
                  1: name: "punctuation.definition.named-reference.begin.jison"
                  2: name: "entity.name.other.reference.jison"
                  3: name: "punctuation.definition.named-reference.end.jison"
              },{
                name:  "meta.prec.jison"
                begin: "(%(prec))\\s*"
                end:   "(?<=['\"])|(?=\\s)"
                beginCaptures: 1: name: "keyword.other.$2.jison"
                patterns: [
                  {include: "#comments"}
                  {include: "#quoted_strings"}
                  {
                    name:  "constant.other.token.jison"
                    begin: "(?=\\S)"
                    end:   "(?=\\s)"
                  }
                ]
              },{
                name:  "keyword.operator.rule-components.separator.jison"
                match: "\\|"
              },{
                name:  "keyword.other.$0.jison"
                match: "\\b(?:EOF|error)\\b"
              },{
                # In addition to Bison’s %empty
                # (https://www.gnu.org/software/bison/manual/html_node/Empty-Rules.html),
                # GerHobbelt Jison supports %epsilon, ε (U+03B5 GREEK SMALL
                # LETTER EPSILON), and these variants of the epsilon character:
                # Ɛ U+0190 LATIN CAPITAL LETTER OPEN E
                # ɛ U+025B LATIN SMALL LETTER OPEN E
                # ϵ U+03F5 GREEK LUNATE EPSILON SYMBOL
                name:  "keyword.other.empty.jison"
                match: "(?:%(?:e(?:mpty|psilon))|\\b[\u0190\u025B\u03B5\u03F5])\\b"
              }
              {include: "#rule_actions"}
            ]
          }
        ]
      }
    ]

  epilogue_section:
    patterns: [
      {include: "#user_code_include_declarations"}
      {include: "source.js"}
    ]


  actions:
    patterns: [
      {
        name:  "meta.action.jison"
        begin: "\\{\\{"
        end:   "\\}\\}"
        beginCaptures: 0: name: "punctuation.definition.action.begin.jison"
        endCaptures:   0: name: "punctuation.definition.action.end.jison"
        contentName: "source.js.embedded.jison"
        patterns: [include: "source.js"]
      },{
        name:  "meta.action.jison"
        begin: "(?=%\\{)"
        end:   "(?<=%\\})"
        patterns: [include: "#user_code_blocks"]
      }
    ]
  rule_actions:
    patterns: [
      {include: "#actions"}
      {
        name:  "meta.action.jison"
        begin: "\\{"
        end:   "\\}"
        beginCaptures: 0: name: "punctuation.definition.action.begin.jison"
        endCaptures:   0: name: "punctuation.definition.action.end.jison"
        contentName: "source.js.embedded.jison"
        patterns: [include: "source.js"]
      }
      {include: "#include_declarations"}
      {
        name:  "meta.action.jison"
        # GerHobbelt Jison supports -> and → (U+2192 RIGHTWARDS ARROW).
        begin: "->|→"
        end:   "$"
        beginCaptures: 0: name: "punctuation.definition.action.arrow.jison"
        contentName: "source.js.embedded.jison"
        patterns: [include: "source.js"]
      }
    ]

  comments:
    patterns: [
      {
        name:  "comment.line.double-slash.jison"
        begin: "//"
        end:   "$"
        beginCaptures: 0: name: "punctuation.definition.comment.jison"
      },{
        name:  "comment.block.jison"
        begin: "/\\*"
        end:   "\\*/"
        beginCaptures: 0: name: "punctuation.definition.comment.begin.jison"
        endCaptures:   0: name: "punctuation.definition.comment.end.jison"
      }
    ]

  include_declarations:
    patterns: [
      {
        name:  "meta.include.jison"
        begin: "(%(include))\\s*"
        end:   "(?<=['\"])|(?=\\s)"
        beginCaptures: 1: name: "keyword.other.declaration.$2.jison"
        patterns: [include: "#include_paths"]
      }
    ]
  user_code_include_declarations:
    patterns: [
      {
        # This is almost identical to the patterns in the include_declarations
        # object, but an %include must be at the beginning of a line in a user-
        # code section.
        name:  "meta.include.jison"
        begin: "^(%(include))\\s*"
        end:   "(?<=['\"])|(?=\\s)"
        beginCaptures: 1: name: "keyword.other.declaration.$2.jison"
        patterns: [include: "#include_paths"]
      }
    ]

  include_paths:
    patterns: [
      {include: "#quoted_strings"}
      {
        name:  "string.unquoted.jison"
        begin: "(?=\\S)"
        end:   "(?=\\s)"
        # https://github.com/atom/language-javascript/blob/master/grammars/javascript.cson
        patterns: [include: "source.js#string_escapes"]
      }
    ]

  numbers:
    patterns: [
      {
        match: "(0[Xx])([0-9A-Fa-f]+)"
        captures:
          1: name: "storage.type.number.jison"
          2: name: "constant.numeric.integer.hexadecimal.jison"
      },{
        name:  "constant.numeric.integer.decimal.jison"
        match: "\\d+"
      }
    ]

  options_declarations:
    patterns: [
      {
        name:  "meta.options.jison"
        begin: "%options\\b"
        end:   "^(?=\\S|\\s*$)"
        beginCaptures: 0: name: "keyword.other.options.jison"
        patterns: [
          {include: "#comments"}
          {
            name:  "entity.name.constant.jison"
            match: "\\b[[:alpha:]_](?:[\\w-]*\\w)?\\b"
          },{
            begin: "(=)\\s*"
            end:   "(?<=['\"])|(?=\\s)"
            beginCaptures: 1: name: "keyword.operator.option.assignment.jison"
            patterns: [
              {include: "#comments"}
              {
                name:  "constant.language.boolean.$1.jison"
                match: "\\b(true|false)\\b"
              }
              {include: "#numbers"}
              {include: "#quoted_strings"}
              {
                name:  "string.unquoted.jison"
                match: "\\S+"
              }
            ]
          }
          {include: "#quoted_strings"}
        ]
      }
    ]

  quoted_strings:
    patterns: [
      {
        name:  "string.quoted.double.jison"
        begin: '"'
        end:   '"'
        # https://github.com/atom/language-javascript/blob/master/grammars/javascript.cson
        patterns: [include: "source.js#string_escapes"]
      },{
        name:  "string.quoted.single.jison"
        begin: "'"
        end:   "'"
        patterns: [include: "source.js#string_escapes"]
      }
    ]

  user_code_blocks:
    patterns: [
      {
        name:  "meta.user-code-block.jison"
        begin: "%\\{"
        end:   "%\\}"
        beginCaptures: 0: name: "punctuation.definition.user-code-block.begin.jison"
        endCaptures:   0: name: "punctuation.definition.user-code-block.end.jison"
        contentName: "source.js.embedded.jison"
        patterns: [include: "source.js"]
      }
    ]


# These are from https://github.com/GerHobbelt/jison/blob/master/lib/jison.js.
injections:
  # Putting parentheses around the selector following L: may be required; see
  # https://github.com/github/linguist/issues/3612.
  "L:(meta.action.jison - (comment | string)), source.js.embedded.jison - (comment | string), source.js.embedded.source - (comment | string.quoted.double | string.quoted.single)":
    patterns: [
      {
        name:  "variable.language.semantic-value.jison"
        match: "\\${2}"
      },{
        name:  "variable.language.result-location.jison"
        match: "@\\$"
      },{
        name:  "variable.language.stack-index-0.jison"
        match: "##\\$|\\byysp\\b"
      },{
        name:  "support.variable.token-reference.jison"
        match: "#\\S+#"
      },{
        name:  "variable.language.result-id.jison"
        match: "#\\$"
      },{
        name:  "support.variable.token-value.jison"
        match: "\\$(?:-?\\d+|[[:alpha:]_](?:[\\w-]*\\w)?)"
      },{
        name:  "support.variable.token-location.jison"
        match: "@(?:-?\\d+|[[:alpha:]_](?:[\\w-]*\\w)?)"
      },{
        name:  "support.variable.stack-index.jison"
        match: "##(?:-?\\d+|[[:alpha:]_](?:[\\w-]*\\w)?)"
      },{
        name:  "support.variable.token-id.jison"
        match: "#(?:-?\\d+|[[:alpha:]_](?:[\\w-]*\\w)?)"
      },{
        name:  "variable.language.jison"
        match: "\\byy(?:l(?:eng|ineno|oc|stack)|rulelength|s(?:tate|s?tack)|text|vstack)\\b"
      },{
        name:  "keyword.other.jison"
        match: "\\byy(?:clearin|erro[kr])\\b"
      }
    ]