github-linguist-grammars 4.6.0

data/grammars/source.forth.json

@@ -0,0 +1,101 @@
+{
+  "fileTypes": [
+    "frt",
+    "fs"
+  ],
+  "foldingStartMarker": "/\\*\\*|\\{\\s*$",
+  "foldingStopMarker": "\\*\\*/|^\\s*\\}",
+  "keyEquivalent": "^~F",
+  "name": "Forth",
+  "patterns": [
+    {
+      "match": "(?i:(?<=^|\\s)(TRUE|FALSE|BL|PI|CELL|C/L|R/O|W/O|R/W)(?=\\s))",
+      "name": "constant.language.forth"
+    },
+    {
+      "match": "(?<=^|\\s)([$#%]?[-+]?[0-9]+(\\.[0-9]*e(-?[0-9]+)|\\.?[0-9a-fA-F]*))(?=\\s)",
+      "name": "constant.numeric.forth"
+    },
+    {
+      "match": "(?<=^|\\s)(([&^]\\S)|((\"|')\\S(\"|')))(?=\\s)",
+      "name": "constant.character.forth"
+    },
+    {
+      "comment": "line comments for iForth",
+      "match": "(?<=^|\\s)(-- .*$)",
+      "name": "comment.line.double-dash.forth"
+    },
+    {
+      "comment": "ANSI line comment",
+      "match": "(?<=^|\\s)(\\\\ .*$)",
+      "name": "comment.line.backslash.forth"
+    },
+    {
+      "comment": "gForth line comment",
+      "match": "(?<=^|\\s)(\\\\[Gg] .*$)",
+      "name": "comment.line.backslash-g.forth"
+    },
+    {
+      "begin": "(?<=^|\\s)(\\(\\*)(?=\\s)",
+      "comment": "multiline comments for iForth",
+      "end": "(?<=^|\\s)(\\*\\))(?=\\s)",
+      "name": "comment.block.forth"
+    },
+    {
+      "begin": "\\b(?i:DOC)\\b",
+      "comment": "documentation comments for iForth",
+      "end": "\\b(?i:ENDDOC)\\b",
+      "name": "comment.block.documentation.forth"
+    },
+    {
+      "comment": "ANSI line comment",
+      "match": "(?<=^|\\s)(\\.?\\( [^)]*\\))",
+      "name": "comment.line.parentheses.forth"
+    },
+    {
+      "comment": "",
+      "match": "(?i:((?<=ABORT\" )|(?<=BREAK\" )|(?<=\\.\" )|(C\" )|(S\\\\?\" )))[^\"]+\"",
+      "name": "string.quoted.double.forth"
+    },
+    {
+      "comment": "",
+      "match": "(?i:((?<=INCLUDE)|(?<=NEEDS)|(?<=REQUIRE)|(?<=USE)))[ ]\\S+(?=\\s)",
+      "name": "string.unquoted.forth"
+    },
+    {
+      "match": "(?<=^|\\s)\\[(?i:(\\?DO|\\+LOOP|AGAIN|BEGIN|DO|ELSE|ENDIF|FOR|IF|IFDEF|IFUNDEF|LOOP|NEXT|REPEAT|THEN|UNTIL|WHILE))\\](?=\\s)",
+      "name": "keyword.control.immediate.forth"
+    },
+    {
+      "match": "(?<=^|\\s)(?i:(COMPILE-ONLY|IMMEDIATE|IS|RESTRICT|TO|WHAT'S))(?=\\s)",
+      "name": "keyword.other.immediate.forth"
+    },
+    {
+      "match": "(?<=^|\\s)(?i:(-DO|\\-LOOP|\\?DO|\\?LEAVE|\\+DO|\\+LOOP|ABORT\\\"|AGAIN|AHEAD|BEGIN|CASE|DO|ELSE|ENDCASE|ENDIF|ENDOF|ENDTRY\\-IFERROR|ENDTRY|FOR|IF|IFERROR|LEAVE|LOOP|NEXT|RECOVER|REPEAT|RESTORE|THEN|TRY|U\\-DO|U\\+DO|UNTIL|WHILE))(?=\\s)",
+      "name": "keyword.control.compile-only.forth"
+    },
+    {
+      "match": "(?<=^|\\s)(?i:(\\?DUP-0=-IF|\\?DUP-IF|\\)|\\['\\]|\\[CHAR\\]|\\[COMPILE\\]|\\[IS\\]|\\[TO\\]|<COMPILATION|<INTERPRETATION|ASSERT\\(|ASSERT0\\(|ASSERT1\\(|ASSERT2\\(|ASSERT3\\(|COMPILATION>|DEFERS|DOES>|INTERPRETATION>|OF|POSTPONE))(?=\\s)",
+      "name": "keyword.other.compile-only.forth"
+    },
+    {
+      "match": "(?<=^|\\s)(?i:('|<IS>|<TO>|CHAR|END-STRUCT|INCLUDE[D]?|LOAD|NEEDS|REQUIRE[D]?|REVISION|SEE|STRUCT|THRU|USE))(?=\\s)",
+      "name": "keyword.other.non-immediate.forth"
+    },
+    {
+      "match": "(?<=^|\\s)(?i:(~~|BREAK:|BREAK\"|DBG))(?=\\s)",
+      "name": "keyword.other.warning.forth"
+    },
+    {
+      "match": "\\b(?i:I|J)\\b",
+      "name": "variable.language.forth"
+    },
+    {
+      "comment": "",
+      "match": "(?<=^|\\s)(?i:(2CONSTANT|2VARIABLE|ALIAS|CONSTANT|CREATE-INTERPRET/COMPILE[:]?|CREATE|DEFER|FCONSTANT|FIELD|FVARIABLE|USER|VALUE|VARIABLE|VOCABULARY))(?=\\s)",
+      "name": "storage.type.forth"
+    }
+  ],
+  "scopeName": "source.forth",
+  "uuid": "0AAA4CFD-D621-4B33-BB76-E5D9EDE64E84"
+}

data/grammars/source.fortran.json

@@ -0,0 +1,499 @@
+{
+  "comment": "?i: has to be added everywhere because fortran is case insensitive; NB: order of matching matters",
+  "fileTypes": [
+    "f",
+    "F",
+    "f77",
+    "F77",
+    "for",
+    "FOR",
+    "fpp",
+    "FPP"
+  ],
+  "name": "Fortran - Punchcard",
+  "patterns": [
+    {
+      "include": "#preprocessor-rule-enabled"
+    },
+    {
+      "include": "#preprocessor-rule-disabled"
+    },
+    {
+      "include": "#preprocessor-rule-other"
+    },
+    {
+      "comment": "built-in constants",
+      "match": "(?i:(r8|r4|\\.TRUE\\.|\\.FALSE\\.))",
+      "name": "constant.language.fortran"
+    },
+    {
+      "comment": "numbers",
+      "match": "\\b[\\+\\-]?[0-9]+\\.?[0-9a-zA-Z_]*\\b",
+      "name": "constant.numeric.fortran"
+    },
+    {
+      "begin": "(?x:\t\t\t\t\t\t\t\t# extended mode\n\t\t\t\t\t^\n\t\t\t\t\t\\s*\t\t\t\t\t\t\t\t\t# start of line and possibly some space\n\t\t\t\t\t([a-zA-Z\\(\\)]*)(?<!end)\t\t\t\t# 1: possibly some type specification but not the word end\n\t\t\t\t\t\\s*\t\t\t\t\t\t\t\t\t# possibly some space\n\t\t\t\t\t(?i:(function|subroutine))\\b\t\t# 2: function or subroutine\n\t\t\t\t\t\\s+\t\t\t\t\t\t\t\t\t# some space\n\t\t\t\t\t([A-Za-z_][A-Za-z0-9_]*)\t\t\t# 3: name\n\t\t\t\t\t)",
+      "beginCaptures": {
+        "1": {
+          "name": "storage.type.fortran"
+        },
+        "2": {
+          "name": "storage.type.function.fortran"
+        },
+        "3": {
+          "name": "entity.name.function.fortran"
+        }
+      },
+      "comment": "First line of function/subroutine definition",
+      "end": "(?x:\t\t\t\t\t\t\t\t\t# extended mode\n\t\t\t\t\t((?i:end))\t\t\t\t\t\t\t# 1: the word end\n\t\t\t\t\t(\t\t\t\t\t\t\t\t\t# followed by\n\t\t\t\t\t\t$\t\t\t\t\t\t\t\t# end of line\n\t\t\t\t\t|\t\t\t\t\t\t\t\t\t# or\n\t\t\t\t\t\t\\s*\t\t\t\t\t\t\t\t# possibly some space\n\t\t\t\t\t\t(?i:(function|subroutine))\t\t# 2: function or subroutine\n\t\t\t\t\t\t((\\s+[A-Za-z_][A-Za-z0-9_]*)?)\t# 3: possibly the name\n\t\t\t\t\t)\n\t\t\t\t\t)",
+      "endCaptures": {
+        "1": {
+          "name": "keyword.other.fortran"
+        },
+        "3": {
+          "name": "storage.type.function.fortran"
+        },
+        "4": {
+          "name": "entity.name.function.end.fortran"
+        }
+      },
+      "name": "meta.function.fortran",
+      "patterns": [
+        {
+          "begin": "\\G\\s*(\\()",
+          "beginCaptures": {
+            "1": {
+              "name": "punctuation.definition.parameters.begin.fortran"
+            }
+          },
+          "end": "\\)",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.definition.parameters.end.fortran"
+            }
+          },
+          "patterns": [
+            {
+              "captures": {
+                "1": {
+                  "name": "variable.parameter.fortran"
+                },
+                "2": {
+                  "name": "punctuation.separator.arguments.fortan"
+                }
+              },
+              "match": "([^\\s),]*)\\s*(,)?"
+            }
+          ]
+        },
+        {
+          "include": "$self"
+        },
+        {
+          "include": "source.fortran.modern"
+        }
+      ]
+    },
+    {
+      "begin": "\\b(?i:(integer|real|double\\s+precision|complex|logical|character))\\b(?=.*::)",
+      "beginCaptures": {
+        "1": {
+          "name": "storage.type.fortran"
+        }
+      },
+      "comment": "Line of type specification",
+      "end": "(?=!)|$",
+      "name": "meta.specification.fortran",
+      "patterns": [
+        {
+          "include": "$self"
+        }
+      ]
+    },
+    {
+      "comment": "statements controling the flow of the program",
+      "match": "\\b(?i:(go\\s*to|assign|to|if|then|else|elseif|end\\s*if|continue|stop|pause|do|end\\s*do|while|cycle))\\b",
+      "name": "keyword.control.fortran"
+    },
+    {
+      "comment": "programming units",
+      "match": "\\b(?i:(program|end\\s+program|entry|block\\s+data|call|return|contains|include))\\b",
+      "name": "keyword.control.programming-units.fortran"
+    },
+    {
+      "comment": "i/o statements",
+      "match": "\\b(?i:(open|close|read|write|print|inquire|backspace|endfile|format))\\b",
+      "name": "keyword.control.io.fortran"
+    },
+    {
+      "comment": "operators",
+      "match": "((?<!\\=)\\=(?!\\=)|\\-|\\+|\\/\\/|\\/|(?!^)\\*|::)",
+      "name": "keyword.operator.fortran"
+    },
+    {
+      "comment": "logical operators",
+      "match": "(?i:(\\.and\\.|\\.or\\.|\\.eq\\.|\\.lt\\.|\\.le\\.|\\.gt\\.|\\.ge\\.|\\.ne\\.|\\.not\\.|\\.eqv\\.|\\.neqv\\.))",
+      "name": "keyword.operator.logical.fortran"
+    },
+    {
+      "comment": "argument related intrisics",
+      "match": "\\b(?i:(present)(?=\\())",
+      "name": "keyword.other.instrisic.argument.fortran"
+    },
+    {
+      "comment": "numeric intrisics",
+      "match": "\\b(?i:(abs|aimag|aint|anint|cmplx|conjg|dble|dim|dprod|int|max|min|mod|nint|real|sign|digits|epsilon|huge|maxexponent|minexponent|precision|radix|range|tiny)(?=\\())",
+      "name": "keyword.other.instrisic.numeric.fortran"
+    },
+    {
+      "comment": "character string intrinsics",
+      "match": "\\b(?i:(achar|adjustl|adjustr|char|iachar|ichar|index|len_trim|repeat|scan|string|trim|verify|len)(?=\\())",
+      "name": "keyword.other.instrisic.string.fortran"
+    },
+    {
+      "comment": "mathematical intrisics",
+      "match": "\\b(?i:(((acos|asin|atan|atan2|cos|cosh|exp|log|log10|sin|sinh|sqrt|tan|tanh)(?=\\())|(random_number|random_seed)))\\b",
+      "name": "keyword.other.instrisic.math.fortran"
+    },
+    {
+      "comment": "data kind intrinsics",
+      "match": "\\b(?i:(kind|selected_int_kind|selected_real_kind|transfer)(?=\\())",
+      "name": "keyword.other.instrisic.data.fortran"
+    },
+    {
+      "comment": "logical intrinsics",
+      "match": "\\b(?i:(logical)(?=\\())",
+      "name": "keyword.other.instrisic.logical.fortran"
+    },
+    {
+      "comment": "bit operations intrinsics",
+      "match": "\\b(?i:(((bit_size|btest|iand|ibclr|ibits|ibset|ieor|ior|ishift|ishiftc|not)(?=\\())|mvbits))\\b",
+      "name": "keyword.other.instrisic.bit.fortran"
+    },
+    {
+      "comment": "floating point intrinsics",
+      "match": "\\b(?i:(exponent|fraction|nearest|rrspacing|scale|set_exponent|spacing)(?=\\())",
+      "name": "keyword.other.instrisic.floating-point.fortran"
+    },
+    {
+      "comment": "matrix/vector/array intrisics",
+      "match": "\\b(?i:(((dot_product|sum|matmul|transpose|all|any|count|maxval|minval|maxloc|minloc|product|sum|lbound|ubound|shape|size|merge|pack|unpack|reshape|spread|cshift|eoshift)(?=\\())|(where|elsewhere|end\\s*where)))\\b",
+      "name": "keyword.other.instrisic.array.fortran"
+    },
+    {
+      "comment": "other intrisics",
+      "match": "\\b(?i:(((dtime)(?=\\())|(date_and_time|system_clock)))\\b",
+      "name": "keyword.other.instrisic.fortran"
+    },
+    {
+      "comment": "data specification",
+      "match": "\\b(?i:(integer|real|double\\s+precision|complex|logical|character|block\\sdata|operator|assignment))\\b",
+      "name": "storage.type.fortran"
+    },
+    {
+      "comment": "data type attributes",
+      "match": "\\b(?i:(dimension|common|equivalence|parameter|external|intrinsic|save|data|implicit\\s*none|implicit|intent|in|out|inout))\\b",
+      "name": "storage.modifier.fortran"
+    },
+    {
+      "applyEndPatternLast": 1,
+      "begin": "'",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.begin.fortran"
+        }
+      },
+      "comment": "String",
+      "end": "'",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.end.fortran"
+        }
+      },
+      "name": "string.quoted.single.fortran",
+      "patterns": [
+        {
+          "match": "''",
+          "name": "constant.character.escape.apostrophe.fortran"
+        }
+      ]
+    },
+    {
+      "applyEndPatternLast": 1,
+      "begin": "\"",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.begin.fortran"
+        }
+      },
+      "comment": "String",
+      "end": "\"",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.end.fortran"
+        }
+      },
+      "name": "string.quoted.double.fortran",
+      "patterns": [
+        {
+          "match": "\"\"",
+          "name": "constant.character.escape.quote.fortran"
+        }
+      ]
+    },
+    {
+      "begin": "^[Cc](?=\\b|[Cc])",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.comment.fortran"
+        }
+      },
+      "end": "$\\n?",
+      "name": "comment.line.c.fortran",
+      "patterns": [
+        {
+          "match": "\\\\\\s*\\n"
+        }
+      ]
+    },
+    {
+      "begin": "^\\*",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.comment.fortran"
+        }
+      },
+      "end": "$\\n?",
+      "name": "comment.line.asterisk.fortran",
+      "patterns": [
+        {
+          "match": "\\\\\\s*\\n"
+        }
+      ]
+    },
+    {
+      "begin": "^\\s*#\\s*(error|warning)\\b",
+      "captures": {
+        "1": {
+          "name": "keyword.control.import.error.fortran"
+        }
+      },
+      "end": "$\\n?",
+      "name": "meta.preprocessor.diagnostic.fortran",
+      "patterns": [
+        {
+          "match": "(?>\\\\\\s*\\n)",
+          "name": "punctuation.separator.continuation.fortran"
+        }
+      ]
+    },
+    {
+      "begin": "^\\s*#\\s*(include|import)\\b\\s+",
+      "captures": {
+        "1": {
+          "name": "keyword.control.import.include.fortran"
+        }
+      },
+      "end": "(?=(?://|/\\*))|$\\n?",
+      "name": "meta.preprocessor.fortran.include",
+      "patterns": [
+        {
+          "match": "(?>\\\\\\s*\\n)",
+          "name": "punctuation.separator.continuation.fortran"
+        },
+        {
+          "begin": "\"",
+          "beginCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.begin.fortran"
+            }
+          },
+          "end": "\"",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.end.fortran"
+            }
+          },
+          "name": "string.quoted.double.include.fortran"
+        },
+        {
+          "begin": "<",
+          "beginCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.begin.fortran"
+            }
+          },
+          "end": ">",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.end.fortran"
+            }
+          },
+          "name": "string.quoted.other.lt-gt.include.fortran"
+        }
+      ]
+    },
+    {
+      "include": "#pragma-mark"
+    },
+    {
+      "begin": "^\\s*#\\s*(define|defined|elif|else|if|ifdef|ifndef|line|pragma|undef)\\b",
+      "captures": {
+        "1": {
+          "name": "keyword.control.import.fortran"
+        }
+      },
+      "end": "(?=(?://|/\\*))|$\\n?",
+      "name": "meta.preprocessor.fortran",
+      "patterns": [
+        {
+          "match": "(?>\\\\\\s*\\n)",
+          "name": "punctuation.separator.continuation.fortran"
+        }
+      ]
+    }
+  ],
+  "repository": {
+    "disabled": {
+      "begin": "^\\s*#\\s*if(n?def)?\\b.*$",
+      "comment": "eat nested preprocessor if(def)s",
+      "end": "^\\s*#\\s*endif\\b.*$",
+      "patterns": [
+        {
+          "include": "#disabled"
+        },
+        {
+          "include": "#pragma-mark"
+        }
+      ]
+    },
+    "pragma-mark": {
+      "captures": {
+        "1": {
+          "name": "meta.preprocessor.fortran"
+        },
+        "2": {
+          "name": "keyword.control.import.pragma.fortran"
+        },
+        "3": {
+          "name": "meta.toc-list.pragma-mark.fortran"
+        }
+      },
+      "match": "^\\s*(#\\s*(pragma\\s+mark)\\s+(.*))",
+      "name": "meta.section"
+    },
+    "preprocessor-rule-disabled": {
+      "begin": "^\\s*(#(if)\\s+(0)\\b).*",
+      "captures": {
+        "1": {
+          "name": "meta.preprocessor.fortran"
+        },
+        "2": {
+          "name": "keyword.control.import.if.fortran"
+        },
+        "3": {
+          "name": "constant.numeric.preprocessor.fortran"
+        }
+      },
+      "end": "^\\s*(#\\s*(endif)\\b)",
+      "patterns": [
+        {
+          "begin": "^\\s*(#\\s*(else)\\b)",
+          "captures": {
+            "1": {
+              "name": "meta.preprocessor.fortran"
+            },
+            "2": {
+              "name": "keyword.control.import.else.fortran"
+            }
+          },
+          "end": "(?=^\\s*#\\s*endif\\b.*$)",
+          "patterns": [
+            {
+              "include": "$base"
+            }
+          ]
+        },
+        {
+          "begin": "",
+          "end": "(?=^\\s*#\\s*(else|endif)\\b.*$)",
+          "name": "comment.block.preprocessor.if-branch",
+          "patterns": [
+            {
+              "include": "#disabled"
+            },
+            {
+              "include": "#pragma-mark"
+            }
+          ]
+        }
+      ]
+    },
+    "preprocessor-rule-enabled": {
+      "begin": "^\\s*(#(if)\\s+(0*1)\\b)",
+      "captures": {
+        "1": {
+          "name": "meta.preprocessor.fortran"
+        },
+        "2": {
+          "name": "keyword.control.import.if.fortran"
+        },
+        "3": {
+          "name": "constant.numeric.preprocessor.fortran"
+        }
+      },
+      "end": "^\\s*(#\\s*(endif)\\b)",
+      "patterns": [
+        {
+          "begin": "^\\s*(#\\s*(else)\\b).*",
+          "captures": {
+            "1": {
+              "name": "meta.preprocessor.fortran"
+            },
+            "2": {
+              "name": "keyword.control.import.else.fortran"
+            }
+          },
+          "contentName": "comment.block.preprocessor.else-branch",
+          "end": "(?=^\\s*#\\s*endif\\b.*$)",
+          "patterns": [
+            {
+              "include": "#disabled"
+            },
+            {
+              "include": "#pragma-mark"
+            }
+          ]
+        },
+        {
+          "begin": "",
+          "end": "(?=^\\s*#\\s*(else|endif)\\b.*$)",
+          "patterns": [
+            {
+              "include": "$base"
+            }
+          ]
+        }
+      ]
+    },
+    "preprocessor-rule-other": {
+      "begin": "^\\s*(#\\s*(if(n?def)?)\\b.*?(?:(?=(?://|/\\*))|$))",
+      "captures": {
+        "1": {
+          "name": "meta.preprocessor.fortran"
+        },
+        "2": {
+          "name": "keyword.control.import.fortran"
+        }
+      },
+      "end": "^\\s*(#\\s*(endif)\\b).*$",
+      "patterns": [
+        {
+          "include": "$base"
+        }
+      ]
+    }
+  },
+  "scopeName": "source.fortran",
+  "uuid": "45253F88-F7CC-49C5-9C32-F3FADD2AB579"
+}