github-linguist-grammars 4.6.0

data/grammars/source.bsv.json

@@ -0,0 +1,283 @@
+{
+  "fileTypes": [
+    "bsv"
+  ],
+  "foldingStartMarker": "(begin)\\s*(//.*)?$",
+  "foldingStopMarker": "^\\s*(end)$",
+  "name": "BSV",
+  "patterns": [
+    {
+      "captures": {
+        "1": {
+          "name": "keyword.control.import.bsv"
+        },
+        "2": {
+          "name": "entity.name.package.bsv"
+        }
+      },
+      "match": "^\\s*(import|export|package)\\s+\\b([a-zA-Z_][a-zA-Z0-9_]*)\\b",
+      "name": "meta.entity.package.bsv"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "keyword.other.bsv"
+        },
+        "2": {
+          "name": "entity.name.type.instance.bsv"
+        },
+        "3": {
+          "name": "meta.module.parameters.bsv"
+        },
+        "4": {
+          "name": "keyword.other.bsv"
+        }
+      },
+      "match": "^\\s*(defparam)\\s+([a-zA-Z_][a-zA-Z0-9_]*)(.[a-zA-Z_][a-zA-Z0-9_]*)\\s*(=)",
+      "name": "meta.definition.defparam.bsv"
+    },
+    {
+      "match": "\\b(automatic|cell|config|deassign|defparam|design|disable|edge|endconfig|endgenerate|endspecify|endtable|endtask|event|generate|genvar|ifnone|incdir|include|liblist|library|localparam|macromodule|negedge|noshowcancelled|posedge|pulsestyle_onevent|pulsestyle_ondetect|real|realtime|scalared|showcancelled|specify|specparam|table|task|time|use|vectored)\\b",
+      "name": "keyword.other.bsv"
+    },
+    {
+      "match": "(#[0-9]+)",
+      "name": "keyword.delay.bsv"
+    },
+    {
+      "match": "\\b(initial|always|wait|force|release|assign)\\b",
+      "name": "keyword.control.bsv"
+    },
+    {
+      "match": "\\b(begin|end|fork|join)\\b",
+      "name": "keyword.other.bsv"
+    },
+    {
+      "match": "\\b(matches|action|endaction|actionvalue|endactionvalue|ancestor|deriving|return|match|par|endpar|provisos|dependencies|determines|seq|endseq|schedule|port|clock|reset|no_reset|clocked_by|reset_by|default_clock|default_reset|output_clock|output_reset|input_clock|input_reset|same_family|import|numeric|type)\\b",
+      "name": "keyword.control.bsv"
+    },
+    {
+      "match": "\\b(TAdd|TSub|TLog|TExp|TMul|TDiv|TMin|TMax)\\b",
+      "name": "keyword.typesystem.math.bsv"
+    },
+    {
+      "match": "\\b(Bits|DefaultValue|Eq|Ord|Bounded|Arith|Literal|Bitwise|BitReduction|BitExtend|IsModule|Add|Max|Log|Mul|Div)\\b",
+      "name": "keyword.typesystem.typeclass.bsv"
+    },
+    {
+      "match": "\\b(forever|repeat|while|for|if|else|case|casex|casez|default|endcase)\\b",
+      "name": "keyword.control.bsv"
+    },
+    {
+      "match": "\\b(endpackage)\\b",
+      "name": "keyword.control.import.bsv"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "meta.preprocessor.bsv"
+        },
+        "2": {
+          "name": "entity.name.type.include.bsv"
+        }
+      },
+      "match": "^\\s*(`include)\\s+([\"<].*[\">])",
+      "name": "meta.include.bsv"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "meta.preprocessor.bsv"
+        },
+        "2": {
+          "name": "constant.other.define.bsv"
+        }
+      },
+      "match": "^\\s*(`ifdef|`ifndef|`undef|`define)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\b",
+      "name": "meta.preprocessor.ifdef.bsv"
+    },
+    {
+      "match": "`(celldefine|default_nettype|define|else|elsif|endcelldefine|endif|ifdef|ifndef|include|line|nounconnected_drive|resetall|timescale|unconnected_drive|undef)\\b",
+      "name": "meta.preprocessor.bsv"
+    },
+    {
+      "match": "[.][_a-zA-Z0-9]+",
+      "name": "meta.module.parameters.bsv"
+    },
+    {
+      "match": "\\b(True|False)\\b",
+      "name": "constant.language.bsv"
+    },
+    {
+      "match": "`\\b([a-zA-Z_][a-zA-Z0-9_]*)\\b",
+      "name": "constant.other.define.bsv"
+    },
+    {
+      "include": "#comments"
+    },
+    {
+      "include": "#pragma-compiler-bsv"
+    },
+    {
+      "match": "\\b(let|module|endmodule|rule|endrule|rules|endrules|interface|endinterface|method|endmethod|function|endfunction|instance|endinstance|typeclass|endtypeclass|primitive|endprimitive)\\b",
+      "name": "storage.type.bsv"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "entity.name.state.bsv"
+        },
+        "2": {
+          "name": "keyword.operator.bitwise.bsv"
+        }
+      },
+      "match": "(?:^|\\{|,)\\s*\\b(?!endmodule|endrule|endinterface|endmethod|endfunction|endinstance|endtypeclass)\\b([a-zA-Z_][a-zA-Z0-9_]*)\\b\\s*(:)(?!:)\\s*",
+      "name": "meta.case.bsv"
+    },
+    {
+      "include": "#all-types"
+    },
+    {
+      "match": "(==|===|!=|!==|<=|>=|<|>)",
+      "name": "keyword.operator.comparison.bsv"
+    },
+    {
+      "match": "(\\-|\\+|\\*|\\/|%)",
+      "name": "keyword.operator.arithmetic.bsv"
+    },
+    {
+      "match": "(!|&&|\\|\\||\\bor\\b)",
+      "name": "keyword.operator.logical.bsv"
+    },
+    {
+      "match": "(&|\\||\\^|~|<<|>>|\\?|:)",
+      "name": "keyword.operator.bitwise.bsv"
+    },
+    {
+      "match": "({|})",
+      "name": "keyword.operator.parenthesis.curly.bsv"
+    },
+    {
+      "match": "(\\(|\\))",
+      "name": "keyword.operator.parenthesis.round.bsv"
+    },
+    {
+      "match": "(\\[|\\])",
+      "name": "keyword.operator.parenthesis.square.bsv"
+    },
+    {
+      "match": "([;,])",
+      "name": "keyword.delimiter.bsv"
+    },
+    {
+      "match": "(#|@|=)",
+      "name": "keyword.other.bsv"
+    },
+    {
+      "match": "\\b(output|input|inout|and|nand|nor|or|xor|xnor|buf|not|bufif[01]|notif[01]|r?[npc]mos|tran|r?tranif[01]|pullup|pulldown)\\b",
+      "name": "support.type.bsv"
+    },
+    {
+      "match": "((\\b\\d+)?'s?([bB]\\s*(([0-1_xXzZ?]+)|(`[A-Z]+[_0-9a-zA-Z]*))|[oO]\\s*(([0-7_xXzZ?]+)|(`[A-Z]+[_0-9a-zA-Z]*))|[dD]\\s*(([0-9_xXzZ?]+)|(`[A-Z]+[_0-9a-zA-Z]*))|[hH]\\s*(([0-9a-fA-F_xXzZ?]+)|(`[A-Z]+[_0-9a-zA-Z]*)))((e|E)(\\+|-)?[0-9]+)?\\b)|(\\b\\d+\\b)",
+      "name": "constant.numeric.bsv"
+    },
+    {
+      "include": "#strings"
+    },
+    {
+      "match": "\\$\\b([a-zA-Z_][a-zA-Z0-9_]*)\\b",
+      "name": "support.function.bsv"
+    }
+  ],
+  "repository": {
+    "all-types": {
+      "patterns": [
+        {
+          "include": "#storage-type-bsv"
+        },
+        {
+          "include": "#storage-type-standard-bsv"
+        },
+        {
+          "include": "#storage-modifier-bsv"
+        }
+      ]
+    },
+    "comments": {
+      "patterns": [
+        {
+          "begin": "/\\*",
+          "captures": {
+            "0": {
+              "name": "punctuation.definition.comment.bsv"
+            }
+          },
+          "end": "\\*/",
+          "name": "comment.block.bsv"
+        },
+        {
+          "captures": {
+            "1": {
+              "name": "punctuation.definition.comment.bsv"
+            }
+          },
+          "match": "(//).*$\\n?",
+          "name": "comment.line.double-slash.bsv"
+        }
+      ]
+    },
+    "pragma-compiler-bsv": {
+      "patterns": [
+        {
+          "begin": "\\(\\*",
+          "captures": {
+            "0": {
+              "name": "punctuation.definition.comment.bsv"
+            }
+          },
+          "end": "\\*\\)",
+          "name": "pragma.compiler.bsv"
+        }
+      ]
+    },
+    "storage-type-bsv": {
+      "match": "\\b(wire|tri|tri[01]|supply[01]|wand|triand|wor|trior|trireg|reg|parameter|integer|typedef|struct|enum|tagged|union)\\b",
+      "name": "storage.type.bsv"
+    },
+    "storage-type-standard-bsv": {
+      "match": "\\b(void|Action|ActionValue|Integer|Nat|Inout|Bit|UInt|Int|Bool|Maybe|String|Either|Rules|Module|Clock|Reset|Power|Empty|Array|Reg|RWire|Wire|BypassWire|DWire|PulseWire|ReadOnly|WriteOnly|Vector|List|RegFile|FIFO|FIFOF|Stmt)\\b",
+      "name": "storage.type.standard.bsv"
+    },
+    "storage-modifier-bsv": {
+      "match": "\\b(signed|unsigned|small|medium|large|supply[01]|strong[01]|pull[01]|weak[01]|highz[01])\\b",
+      "name": "storage.modifier.bsv"
+    },
+    "strings": {
+      "patterns": [
+        {
+          "begin": "\"",
+          "beginCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.begin.bsv"
+            }
+          },
+          "end": "\"",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.end.bsv"
+            }
+          },
+          "name": "string.quoted.double.bsv",
+          "patterns": [
+            {
+              "match": "\\\\.",
+              "name": "constant.character.escape.bsv"
+            }
+          ]
+        }
+      ]
+    }
+  },
+  "scopeName": "source.bsv",
+  "uuid": "7038ab7c-665d-45a4-a700-4ca5e113d9a6"
+}

data/grammars/source.c++.json

@@ -0,0 +1,364 @@
+{
+  "comment": "I don't think anyone uses .hp. .cp tends to be paired with .h. (I could be wrong. :) -- chris",
+  "fileTypes": [
+    "cc",
+    "cpp",
+    "cp",
+    "cxx",
+    "c++",
+    "C",
+    "h",
+    "hh",
+    "hpp",
+    "h++"
+  ],
+  "firstLineMatch": "-\\*- C\\+\\+ -\\*-",
+  "keyEquivalent": "^~C",
+  "name": "C++",
+  "patterns": [
+    {
+      "include": "#special_block"
+    },
+    {
+      "include": "source.c"
+    },
+    {
+      "match": "\\b(friend|explicit|virtual)\\b",
+      "name": "storage.modifier.$1.c++"
+    },
+    {
+      "match": "\\b(private|protected|public):",
+      "name": "storage.modifier.$1.c++"
+    },
+    {
+      "match": "\\b(catch|operator|try|throw|using)\\b",
+      "name": "keyword.control.c++"
+    },
+    {
+      "match": "\\bdelete\\b(\\s*\\[\\])?|\\bnew\\b(?!])",
+      "name": "keyword.control.c++"
+    },
+    {
+      "comment": "common C++ instance var naming idiom -- fMemberName",
+      "match": "\\b(f|m)[A-Z]\\w*\\b",
+      "name": "variable.other.readwrite.member.c++"
+    },
+    {
+      "match": "\\b(this|nullptr)\\b",
+      "name": "variable.language.c++"
+    },
+    {
+      "match": "\\btemplate\\b\\s*",
+      "name": "storage.type.template.c++"
+    },
+    {
+      "match": "\\b(const_cast|dynamic_cast|reinterpret_cast|static_cast)\\b\\s*",
+      "name": "keyword.operator.cast.c++"
+    },
+    {
+      "match": "\\b(and|and_eq|bitand|bitor|compl|not|not_eq|or|or_eq|typeid|xor|xor_eq)\\b",
+      "name": "keyword.operator.c++"
+    },
+    {
+      "match": "\\b(class|wchar_t)\\b",
+      "name": "storage.type.c++"
+    },
+    {
+      "match": "\\b(constexpr|export|mutable|typename|thread_local)\\b",
+      "name": "storage.modifier.c++"
+    },
+    {
+      "begin": "(?x)\n    \t\t\t\t(?:  ^                                 # begin-of-line\n    \t\t\t\t  |  (?: (?<!else|new|=) )             #  or word + space before name\n    \t\t\t\t)\n    \t\t\t\t((?:[A-Za-z_][A-Za-z0-9_]*::)*+~[A-Za-z_][A-Za-z0-9_]*) # actual name\n    \t\t\t\t \\s*(\\()                           # start bracket or end-of-line\n    \t\t\t",
+      "beginCaptures": {
+        "1": {
+          "name": "entity.name.function.c++"
+        },
+        "2": {
+          "name": "punctuation.definition.parameters.begin.c"
+        }
+      },
+      "end": "\\)",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.parameters.end.c"
+        }
+      },
+      "name": "meta.function.destructor.c++",
+      "patterns": [
+        {
+          "include": "$base"
+        }
+      ]
+    },
+    {
+      "begin": "(?x)\n    \t\t\t\t(?:  ^                                 # begin-of-line\n    \t\t\t\t  |  (?: (?<!else|new|=) )             #  or word + space before name\n    \t\t\t\t)\n    \t\t\t\t((?:[A-Za-z_][A-Za-z0-9_]*::)*+~[A-Za-z_][A-Za-z0-9_]*) # actual name\n    \t\t\t\t \\s*(\\()                           # terminating semi-colon\n    \t\t\t",
+      "beginCaptures": {
+        "1": {
+          "name": "entity.name.function.c++"
+        },
+        "2": {
+          "name": "punctuation.definition.parameters.begin.c"
+        }
+      },
+      "end": "\\)",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.parameters.end.c"
+        }
+      },
+      "name": "meta.function.destructor.prototype.c++",
+      "patterns": [
+        {
+          "include": "$base"
+        }
+      ]
+    }
+  ],
+  "repository": {
+    "angle_brackets": {
+      "begin": "<",
+      "end": ">",
+      "name": "meta.angle-brackets.c++",
+      "patterns": [
+        {
+          "include": "#angle_brackets"
+        },
+        {
+          "include": "$base"
+        }
+      ]
+    },
+    "block": {
+      "begin": "\\{",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.section.block.begin.c"
+        }
+      },
+      "end": "\\}",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.section.block.end.c"
+        }
+      },
+      "name": "meta.block.c++",
+      "patterns": [
+        {
+          "captures": {
+            "1": {
+              "name": "support.function.any-method.c"
+            },
+            "2": {
+              "name": "punctuation.definition.parameters.c"
+            }
+          },
+          "match": "(?x)\n    \t\t\t\t(\n    \t\t\t\t\t(?!while|for|do|if|else|switch|catch|enumerate|return|r?iterate)(?: \\b[A-Za-z_][A-Za-z0-9_]*+\\b | :: )*+                  # actual name\n    \t\t\t\t)\n    \t\t\t\t \\s*(\\()",
+          "name": "meta.function-call.c"
+        },
+        {
+          "include": "$base"
+        }
+      ]
+    },
+    "constructor": {
+      "patterns": [
+        {
+          "begin": "(?x)\n    \t\t\t\t(?:  ^\\s*)                             # begin-of-line\n    \t\t\t\t((?!while|for|do|if|else|switch|catch|enumerate|r?iterate)[A-Za-z_][A-Za-z0-9_:]*) # actual name\n    \t\t\t\t \\s*(\\()                            # start bracket or end-of-line\n    \t\t\t",
+          "beginCaptures": {
+            "1": {
+              "name": "entity.name.function.c++"
+            },
+            "2": {
+              "name": "punctuation.definition.parameters.begin.c"
+            }
+          },
+          "end": "\\)",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.definition.parameters.end.c"
+            }
+          },
+          "name": "meta.function.constructor.c++",
+          "patterns": [
+            {
+              "include": "$base"
+            }
+          ]
+        },
+        {
+          "begin": "(?x)\n    \t\t\t\t(:)                            # begin-of-line\n    \t\t\t\t((?=\\s*[A-Za-z_][A-Za-z0-9_:]* # actual name\n    \t\t\t\t \\s*(\\()))                      # start bracket or end-of-line\n    \t\t\t",
+          "beginCaptures": {
+            "1": {
+              "name": "punctuation.definition.parameters.c"
+            }
+          },
+          "end": "(?=\\{)",
+          "name": "meta.function.constructor.initializer-list.c++",
+          "patterns": [
+            {
+              "include": "$base"
+            }
+          ]
+        }
+      ]
+    },
+    "special_block": {
+      "patterns": [
+        {
+          "begin": "\\b(namespace)\\b\\s*([_A-Za-z][_A-Za-z0-9]*\\b)?+",
+          "beginCaptures": {
+            "1": {
+              "name": "storage.type.c++"
+            },
+            "2": {
+              "name": "entity.name.type.c++"
+            }
+          },
+          "captures": {
+            "1": {
+              "name": "keyword.control.namespace.$2"
+            }
+          },
+          "end": "(?<=\\})|(?=(;|,|\\(|\\)|>|\\[|\\]|=))",
+          "name": "meta.namespace-block${2:+.$2}.c++",
+          "patterns": [
+            {
+              "begin": "\\{",
+              "beginCaptures": {
+                "0": {
+                  "name": "punctuation.definition.scope.c++"
+                }
+              },
+              "end": "\\}",
+              "endCaptures": {
+                "0": {
+                  "name": "punctuation.definition.scope.c++"
+                }
+              },
+              "patterns": [
+                {
+                  "include": "#special_block"
+                },
+                {
+                  "include": "#constructor"
+                },
+                {
+                  "include": "$base"
+                }
+              ]
+            },
+            {
+              "include": "$base"
+            }
+          ]
+        },
+        {
+          "begin": "\\b(class|struct)\\b\\s*([_A-Za-z][_A-Za-z0-9]*\\b)?+(\\s*:\\s*(public|protected|private)\\s*([_A-Za-z][_A-Za-z0-9]*\\b)((\\s*,\\s*(public|protected|private)\\s*[_A-Za-z][_A-Za-z0-9]*\\b)*))?",
+          "beginCaptures": {
+            "1": {
+              "name": "storage.type.c++"
+            },
+            "2": {
+              "name": "entity.name.type.c++"
+            },
+            "4": {
+              "name": "storage.type.modifier.c++"
+            },
+            "5": {
+              "name": "entity.name.type.inherited.c++"
+            },
+            "6": {
+              "patterns": [
+                {
+                  "match": "(public|protected|private)",
+                  "name": "storage.type.modifier.c++"
+                },
+                {
+                  "match": "[_A-Za-z][_A-Za-z0-9]*",
+                  "name": "entity.name.type.inherited.c++"
+                }
+              ]
+            }
+          },
+          "end": "(?<=\\})|(?=(;|\\(|\\)|>|\\[|\\]|=))",
+          "name": "meta.class-struct-block.c++",
+          "patterns": [
+            {
+              "include": "#angle_brackets"
+            },
+            {
+              "begin": "\\{",
+              "beginCaptures": {
+                "0": {
+                  "name": "punctuation.section.block.begin.c++"
+                }
+              },
+              "end": "(\\})(\\s*\\n)?",
+              "endCaptures": {
+                "1": {
+                  "name": "punctuation.definition.invalid.c++"
+                },
+                "2": {
+                  "name": "invalid.illegal.you-forgot-semicolon.c++"
+                }
+              },
+              "patterns": [
+                {
+                  "include": "#special_block"
+                },
+                {
+                  "include": "#constructor"
+                },
+                {
+                  "include": "$base"
+                }
+              ]
+            },
+            {
+              "include": "$base"
+            }
+          ]
+        },
+        {
+          "begin": "\\b(extern)(?=\\s*\")",
+          "beginCaptures": {
+            "1": {
+              "name": "storage.modifier.c++"
+            }
+          },
+          "end": "(?<=\\})|(?=\\w)",
+          "name": "meta.extern-block.c++",
+          "patterns": [
+            {
+              "begin": "\\{",
+              "beginCaptures": {
+                "0": {
+                  "name": "punctuation.section.block.begin.c"
+                }
+              },
+              "end": "\\}",
+              "endCaptures": {
+                "0": {
+                  "name": "punctuation.section.block.end.c"
+                }
+              },
+              "patterns": [
+                {
+                  "include": "#special_block"
+                },
+                {
+                  "include": "$base"
+                }
+              ]
+            },
+            {
+              "include": "$base"
+            }
+          ]
+        }
+      ]
+    }
+  },
+  "scopeName": "source.c++",
+  "uuid": "26251B18-6B1D-11D9-AFDB-000D93589AF6"
+}