github-linguist-grammars 4.6.0

data/grammars/source.nim_filter.json

@@ -0,0 +1,133 @@
+{
+  "fileTypes": [
+    "nimf"
+  ],
+  "name": "Nim Source Code Filter",
+  "patterns": [
+    {
+      "begin": "\\A(#!)",
+      "end": "\\z(!?\\n)",
+      "name": "meta.start.nim_filter",
+      "patterns": [
+        {
+          "begin": "^\\s*#",
+          "end": "\\n",
+          "name": "comment.line.nim_filter",
+          "patterns": [
+            {
+              "match": "\\b((\\d[_\\d]*\\.[_\\d]+([eE][\\+\\-]?\\d[_\\d]*)?)|([eE][\\+\\-]?\\d[_\\d]*))('[fF](32|64))?",
+              "name": "constant.numeric.float.decimal.nim_filter"
+            },
+            {
+              "match": "\\b(0[xX]\\h[_\\h]*)('[iIuU](8|16|32|64))?",
+              "name": "constant.numeric.integer.hexadecimal.nim_filter"
+            },
+            {
+              "comment": "For simplicity's sake, we don't enforce floats only having 32 and 64 prefix types.",
+              "match": "\\b(0o[0-7][_0-7]*)('[iIuUfF](8|16|32|64))?",
+              "name": "constant.numeric.integer.octal.nim_filter"
+            },
+            {
+              "match": "\\b(0(b|B)[01][_01]*)('[iIuUfF](8|16|32|64))?",
+              "name": "constant.numeric.integer.binary.nim_filter"
+            },
+            {
+              "match": "\\b(\\d[_\\d]*)('[iIuUfF](8|16|32|64))?",
+              "name": "constant.numeric.integer.decimal.nim_filter"
+            },
+            {
+              "comment": "Language Constants.",
+              "match": "\\b(true|false|inf|nil)\\b",
+              "name": "constant.language.nim_filter"
+            },
+            {
+              "comment": "Keywords that affect program control flow or scope.",
+              "match": "\\b(block|break|case|continue|do|elif|else|end|except|finally|for|if|raise|return|try|when|while|yield)\\b",
+              "name": "keyword.control.nim_filter"
+            },
+            {
+              "comment": "Keyword boolean operators for expressions.",
+              "match": "(\\b(and|in|is|isnot|not|notin|or|xor)\\b)",
+              "name": "keyword.operator.boolean.nim_filter"
+            },
+            {
+              "comment": "Generic operators for expressions.",
+              "match": "(\\b()\\b|(=|\\+|-|\\*|/|<|>|@|\\$|~|&|%|!|\\?|\\^|\\.|:|\\\\)+)",
+              "name": "keyword.operator.nim_filter"
+            },
+            {
+              "comment": "Other keywords.",
+              "match": "(\\b(addr|as|asm|atomic|bind|cast|concept|const|discard|distinct|div|enum|export|from|import|include|let|mod|object|of|ptr|ref|shl|shr|static|tuple|type|var)\\b)",
+              "name": "keyword.other.nim_filter"
+            },
+            {
+              "comment": "Invalid and unused keywords.",
+              "match": "(\\b(converter|generic|interface|lambda|mixin|out|shared|with|without)\\b)",
+              "name": "keyword.invalid.nim_filter"
+            },
+            {
+              "comment": "Built-in, concrete types.",
+              "match": "\\b(((uint|int|float)(8|16|32|64)?)|bool|string|cstring|char|tobject|typedesc)\\b",
+              "name": "storage.type.concrete.nim_filter"
+            },
+            {
+              "comment": "Built-in, generic types.",
+              "match": "\\b(range|array|seq|natural|set|ref|ptr)\\b",
+              "name": "storage.type.generic.nim_filter"
+            },
+            {
+              "comment": "Function types",
+              "match": "\\b(proc|iterator|method|template|macro)\\b",
+              "name": "storage.type.function.nim_filter"
+            },
+            {
+              "comment": "Common functions",
+              "match": "\\b(echo|newException)\\b",
+              "name": "keyword.function.nim_filter"
+            },
+            {
+              "comment": "Special types.",
+              "match": "\\b(openarray|varargs|void)\\b",
+              "name": "storage.type.generic.nim_filter"
+            },
+            {
+              "begin": "(\\w[_\\w]*)?\\\"\\\"\\\"",
+              "comment": "(Raw) Triple Quoted String",
+              "end": "\\\"\\\"\\\"[^\"]",
+              "name": "string.quoted.triple.nim_filter"
+            },
+            {
+              "begin": "r\\\"",
+              "comment": "Raw Double Quoted String",
+              "end": "\\\"",
+              "name": "string.quoted.double.raw.nim_filter",
+              "patterns": [
+                {
+                  "match": "\\\"\\\""
+                }
+              ]
+            },
+            {
+              "begin": "(\\w[_\\w]*)?\\\"",
+              "comment": "Double Quoted String",
+              "end": "\\\"",
+              "name": "string.quoted.double.nim_filter",
+              "patterns": [
+                {
+                  "match": "(\\\\([abenrclftv]|[\"']|[0-9])|x\\h\\h)"
+                }
+              ]
+            },
+            {
+              "comment": "Single quoted character literal",
+              "match": "\\'(\\\\\\d{1,3}|\\\\?[^\\n]?)\\'",
+              "name": "string.quoted.single.nim_filter"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "scopeName": "source.nim_filter",
+  "uuid": "c6396a10-4bb4-4929-aee5-1d893828b098"
+}

data/grammars/source.nimcfg.json

@@ -0,0 +1,116 @@
+{
+  "fileTypes": [
+    "cfg"
+  ],
+  "name": "Nim Config",
+  "patterns": [
+    {
+      "captures": {
+        "1": {
+          "name": "punctuation.definition.comment.nimcfg"
+        },
+        "2": {
+          "name": "invalid.illegal.TODO.nimcfg"
+        }
+      },
+      "match": "(#\\s*(TODO|todo)?).*$\\n?",
+      "name": "comment.line.number-sign.nimcfg"
+    },
+    {
+      "comment": "Section declarations",
+      "match": "\\[.+\\]",
+      "name": "support.type.nimcfg"
+    },
+    {
+      "begin": "\\@\\b(if|elif|else)\\b",
+      "captures": {
+        "0": {
+          "name": "keyword.control.nimcfg"
+        }
+      },
+      "comment": "Keywords that affect program control flow or scope.",
+      "end": "\\@\\b(end)",
+      "patterns": [
+        {
+          "include": "source.nimcfg"
+        }
+      ]
+    },
+    {
+      "begin": "([a-zA-Z0-9_\\.]+)\\s*(\\=)",
+      "comment": "Key declarations",
+      "end": "\\n",
+      "patterns": [
+        {
+          "match": "\\b((\\d[_\\d]*\\.[_\\d]+([eE][\\+\\-]?\\d[_\\d]*)?)|([eE][\\+\\-]?\\d[_\\d]*))('[fF](32|64))?",
+          "name": "constant.numeric.float.decimal.nimcfg"
+        },
+        {
+          "match": "\\b(0[xX]\\h[_\\h]*)('[iIuU](8|16|32|64))?",
+          "name": "constant.numeric.integer.hexadecimal.nimcfg"
+        },
+        {
+          "comment": "For simplicity's sake, we don't enforce floats only having 32 and 64 prefix types.",
+          "match": "\\b(0o[0-7][_0-7]*)",
+          "name": "constant.numeric.integer.octal.nimcfg"
+        },
+        {
+          "match": "\\b(0(b|B)[01][_01]*)",
+          "name": "constant.numeric.integer.binary.nimcfg"
+        },
+        {
+          "match": "\\b(\\d[_\\d]*)",
+          "name": "constant.numeric.integer.decimal.nimcfg"
+        },
+        {
+          "comment": "Language Constants.",
+          "match": "\\b(true|false)\\b",
+          "name": "constant.language.nimcfg"
+        },
+        {
+          "begin": "r\\\"",
+          "comment": "Raw Double Quoted String",
+          "end": "\\\"",
+          "name": "string.quoted.double.raw.nimcfg",
+          "patterns": [
+            {
+              "match": "\\\"\\\""
+            }
+          ]
+        },
+        {
+          "begin": "\\\"",
+          "captures": {
+            "1": {
+              "name": "storage.type.function.nimcfg"
+            }
+          },
+          "comment": "Double Quoted String",
+          "end": "\\\"",
+          "name": "string.quoted.double.nimcfg",
+          "patterns": [
+            {
+              "match": "(\\\\([abenrclftv\\\\]|[\"']|[0-9])|x\\h\\h)"
+            }
+          ]
+        },
+        {
+          "comment": "Single quoted character literal",
+          "match": "\\'(\\\\\\d{1,3}|\\\\?[^\\n]?)\\'",
+          "name": "string.quoted.single.nimcfg"
+        },
+        {
+          "captures": {
+            "1": {
+              "name": "string.raw.nimcfg"
+            }
+          },
+          "comment": "Value declarations",
+          "match": "\\b(.+)\\b"
+        }
+      ]
+    }
+  ],
+  "scopeName": "source.nimcfg",
+  "uuid": "8fb54f5c-6f67-4d13-9dcc-52650ea4cb3e"
+}

data/grammars/source.ninja.json

@@ -0,0 +1,66 @@
+{
+  "fileTypes": [
+    "ninja"
+  ],
+  "keyEquivalent": "^~N",
+  "name": "Ninja",
+  "patterns": [
+    {
+      "match": "^\\t+(?![#\\t]).*\\n?",
+      "name": "invalid.illegal.tab-not-allowed-here.ninja"
+    },
+    {
+      "match": "$[$: ]",
+      "name": "constant.character.escape.ninja"
+    },
+    {
+      "match": "\\b(build|rule|default)\\b",
+      "name": "storage.type.$1.ninja"
+    },
+    {
+      "match": "\\b(include|subninja)\\b",
+      "name": "keyword.control.$1.ninja"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "punctuation.definition.variable.ninja"
+        }
+      },
+      "match": "(\\$)[a-zA-Z_][a-zA-Z0-9_]*",
+      "name": "variable.other.normal.ninja"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "punctuation.definition.variable.ninja"
+        }
+      },
+      "match": "(\\$)\\{.*?\\}",
+      "name": "variable.other.bracket.ninja"
+    },
+    {
+      "begin": "^([ \\t]+)?(?=#)",
+      "beginCaptures": {
+        "1": {
+          "name": "punctuation.whitespace.comment.leading.ninja"
+        }
+      },
+      "end": "(?!\\G)",
+      "patterns": [
+        {
+          "begin": "#",
+          "beginCaptures": {
+            "0": {
+              "name": "punctuation.definition.comment.ninja"
+            }
+          },
+          "end": "\\n",
+          "name": "comment.line.number-sign.ninja"
+        }
+      ]
+    }
+  ],
+  "scopeName": "source.ninja",
+  "uuid": "012183BB-F02F-496D-9910-3B2504674FEC"
+}

data/grammars/source.nit.json

@@ -0,0 +1,238 @@
+{
+  "fileTypes": [
+    "nit"
+  ],
+  "name": "Nit",
+  "patterns": [
+    {
+      "include": "#strings"
+    },
+    {
+      "include": "#markup"
+    },
+    {
+      "include": "#comments"
+    },
+    {
+      "include": "#keyword"
+    },
+    {
+      "include": "#constant"
+    },
+    {
+      "include": "#storage"
+    },
+    {
+      "include": "#variable"
+    },
+    {
+      "include": "#entity"
+    }
+  ],
+  "repository": {
+    "character": {
+      "match": "('[^\\\\']'|'\\\\.')",
+      "name": "string.character.nit"
+    },
+    "comment-single-line": {
+      "match": "#.*",
+      "name": "comment.singleline.nit"
+    },
+    "comments": {
+      "patterns": [
+        {
+          "include": "#comment-single-line"
+        }
+      ]
+    },
+    "constant": {
+      "patterns": [
+        {
+          "match": "-?(([0-9]*.[0-9])|([0-9]+))+e-?[0-9]+",
+          "name": "constant.numeric.float_exp.nit"
+        },
+        {
+          "match": "-?[0-9]*\\.[0-9]+",
+          "name": "constant.numeric.float.nit"
+        },
+        {
+          "match": "-?0(x|X)[0-9A-Fa-f_]+((u|i)(8|(16)|(32)))?",
+          "name": "constant.numeric.hex.nit"
+        },
+        {
+          "match": "-?0(o|O)[0-7_]+((u|i)(8|(16)|(32)))?",
+          "name": "constant.numeric.oct.nit"
+        },
+        {
+          "match": "-?0(b|B)[0-1_]+((u|i)(8|(16)|(32)))?",
+          "name": "constant.numeric.bin.nit"
+        },
+        {
+          "match": "-?[0-9][0-9_]*((u|i)(8|(16)|(32)))?",
+          "name": "constant.numeric.dec.nit"
+        },
+        {
+          "match": "\\b(true|false|null)\\b",
+          "name": "constant.language.nit"
+        }
+      ]
+    },
+    "entity": {
+      "patterns": [
+        {
+          "match": "[A-Z][a-zA-Z0-9_]*",
+          "name": "entity.name.type.nit"
+        },
+        {
+          "match": "_[a-z][a-zA-Z0-9_]*",
+          "name": "entity.other.attribute-name.nit"
+        }
+      ]
+    },
+    "inlongstring-code": {
+      "begin": "{{{",
+      "end": "}}}",
+      "name": "incode.nit",
+      "patterns": [
+        {
+          "include": "$self"
+        }
+      ]
+    },
+    "inshortstring-code": {
+      "begin": "{",
+      "end": "}",
+      "name": "string.quoted.double.untitled",
+      "patterns": [
+        {
+          "include": "$self"
+        }
+      ]
+    },
+    "keyword": {
+      "patterns": [
+        {
+          "match": "\\b(label|if|then|loop|else|while|for|do|end|in)\\b",
+          "name": "keyword.control.nit"
+        },
+        {
+          "match": "\\b(return|continue|break|abort)\\b",
+          "name": "keyword.breaks.nit"
+        },
+        {
+          "match": "\\b(nullable|once|new|var)\\b",
+          "name": "keyword.declaration.nit"
+        },
+        {
+          "match": "\\b(is)\\b",
+          "name": "keyword.annot.nit"
+        },
+        {
+          "match": "\\b(isa|as|type|isset)\\b",
+          "name": "keyword.types.nit"
+        },
+        {
+          "match": "\\b(assert|__debug__|super|implies)\\b",
+          "name": "keyword.misc.nit"
+        },
+        {
+          "match": "(==|\\+=|-=|!=|=|!|@|<=>|<=|<<|<|>=|>>|>|\\(|\\)|\\[|\\]|,|::|:|\\.\\.\\.|\\.\\.|\\.|\\+|-|\\*\\*|\\*|/|%|)",
+          "name": "keyword.operator.nit"
+        },
+        {
+          "match": "\\b(and|not|or)\\b",
+          "name": "keyword.operator.boolean.nit"
+        }
+      ]
+    },
+    "long-tquote-alt-string": {
+      "begin": "'''",
+      "end": "'''",
+      "name": "string.triple.alt.nit",
+      "patterns": [
+        {
+          "include": "#inlongstring-code"
+        }
+      ]
+    },
+    "long-tquote-string": {
+      "begin": "\\\"\\\"\\\"",
+      "end": "\\\"\\\"\\\"",
+      "name": "string.triple.nit",
+      "patterns": [
+        {
+          "include": "#inlongstring-code"
+        },
+        {
+          "match": "([^\\\\]|\\\\.)",
+          "name": "string.char.nit"
+        }
+      ]
+    },
+    "markup": {
+      "patterns": [
+        {
+          "begin": "`{",
+          "end": "`}",
+          "name": "markup.raw.nit"
+        }
+      ]
+    },
+    "simple-string": {
+      "begin": "\\\"",
+      "end": "\\\"",
+      "name": "string.quoted.double.untitled",
+      "patterns": [
+        {
+          "include": "#inshortstring-code"
+        },
+        {
+          "match": "([^\\\\]|\\\\.)",
+          "name": "string.char.nit"
+        }
+      ]
+    },
+    "storage": {
+      "patterns": [
+        {
+          "match": "\\b(fun|init|redef|class|interface|module|import|package|abstract|universal|enum)\\b",
+          "name": "storage.type.nit"
+        },
+        {
+          "match": "\\b(private|protected|public|intrude|extern)\\b",
+          "name": "storage.modifier.nit"
+        }
+      ]
+    },
+    "strings": {
+      "patterns": [
+        {
+          "include": "#long-tquote-alt-string"
+        },
+        {
+          "include": "#long-tquote-string"
+        },
+        {
+          "include": "#simple-string"
+        },
+        {
+          "include": "#character"
+        }
+      ]
+    },
+    "variable": {
+      "patterns": [
+        {
+          "match": "\\b(self)\\b",
+          "name": "variable.language.nit"
+        },
+        {
+          "match": "[a-z][a-zA-Z0-9_]*",
+          "name": "variable.other.nit"
+        }
+      ]
+    }
+  },
+  "scopeName": "source.nit",
+  "uuid": "6b33d803-1dfa-4063-b203-abc0409bd1bb"
+}