ver 2009.10.14 → 2009.11.28

data/config/syntax/Dylan.json

@@ -8,18 +8,18 @@
   "name": "Dylan",
   "patterns": [
     {
-      "begin": "\/\\*",
+      "begin": "/\\*",
       "captures": {
         "0": {
           "name": "punctuation.definition.comment.dylan"
         }
       },
       "comment": "TODO -- Dylan allows nested comments.",
-      "end": "\\*\/",
+      "end": "\\*/",
       "name": "comment.block.dylan"
     },
     {
-      "begin": "\/\/",
+      "begin": "//",
       "beginCaptures": {
         "0": {
           "name": "punctuation.definition.comment.dylan"
@@ -95,7 +95,7 @@
       "name": "support.class.dylan"
     },
     {
-      "match": "\\b(?<!-)(abort|abs|add|add!|add-method|add-new|add-new!|all-superclasses|always|any?|applicable-method?|apply|aref|aref-setter|as|as-lowercase|as-lowercase!|as-uppercase|as-uppercase!|ash|backward-iteration-protocol|break|ceiling|ceiling\/|cerror|check-type|choose|choose-by|complement|compose|concatenate|concatenate-as|condition-format-arguments|condition-format-string|conjoin|copy-sequence|curry|default-handler|dimension|dimensions|direct-subclasses|direct-superclasses|disjoin|do|do-handlers|element|element-setter|empty?|error|even?|every?|fill!|find-key|find-method|first|first-setter|floor|floor\/|forward-iteration-protocol|function-arguments|function-return-values|function-specializers|gcd|generic-function-mandatory-|keywords|generic-function-methods|head|head-setter|identity|initialize|instance?|integral?|intersection|key-sequence|key-test|last|last-setter|lcm|limited|list|logand|logbit?|logior|lognot|logxor|make|map|map-as|map-into|max|member?|merge-hash-codes|min|modulo|negative|negative?|object-class|object-hash|odd?|pair|pop|pop-last|positive?|push|push-last|range|rank|rcurry|reduce|reduce1|remainder|remove|remove!|remove-duplicates|remove-duplicates!|remove-key!|remove-method|replace-elements!|replace-subsequence!|restart-query|return-allowed?|return-description|return-query|reverse|reverse!|round|round\/|row-major-index|second|second-setter|shallow-copy|signal|singleton|size|size-setter|slot-initialized?|sort|sort!|sorted-applicable-methods|subsequence-position|subtype?|table-protocol|tail|tail-setter|third|third-setter|truncate|truncate\/|type-error-expected-type|type-error-value|type-for-copy|type-union|union|values|vector|zero?)(?![:-])\\b",
+      "match": "\\b(?<!-)(abort|abs|add|add!|add-method|add-new|add-new!|all-superclasses|always|any?|applicable-method?|apply|aref|aref-setter|as|as-lowercase|as-lowercase!|as-uppercase|as-uppercase!|ash|backward-iteration-protocol|break|ceiling|ceiling/|cerror|check-type|choose|choose-by|complement|compose|concatenate|concatenate-as|condition-format-arguments|condition-format-string|conjoin|copy-sequence|curry|default-handler|dimension|dimensions|direct-subclasses|direct-superclasses|disjoin|do|do-handlers|element|element-setter|empty?|error|even?|every?|fill!|find-key|find-method|first|first-setter|floor|floor/|forward-iteration-protocol|function-arguments|function-return-values|function-specializers|gcd|generic-function-mandatory-|keywords|generic-function-methods|head|head-setter|identity|initialize|instance?|integral?|intersection|key-sequence|key-test|last|last-setter|lcm|limited|list|logand|logbit?|logior|lognot|logxor|make|map|map-as|map-into|max|member?|merge-hash-codes|min|modulo|negative|negative?|object-class|object-hash|odd?|pair|pop|pop-last|positive?|push|push-last|range|rank|rcurry|reduce|reduce1|remainder|remove|remove!|remove-duplicates|remove-duplicates!|remove-key!|remove-method|replace-elements!|replace-subsequence!|restart-query|return-allowed?|return-description|return-query|reverse|reverse!|round|round/|row-major-index|second|second-setter|shallow-copy|signal|singleton|size|size-setter|slot-initialized?|sort|sort!|sorted-applicable-methods|subsequence-position|subtype?|table-protocol|tail|tail-setter|third|third-setter|truncate|truncate/|type-error-expected-type|type-error-value|type-for-copy|type-union|union|values|vector|zero?)(?![:-])\\b",
       "name": "support.function.dylan"
     }
   ],

data/config/syntax/Erlang.json

@@ -1,5 +1,5 @@
 {
-  "comment": "The recognition of function definitions and compiler directives (such as module, record and macro definitions) requires that each of the aforementioned constructs must be the first string inside a line (except for whitespace).  Also, the function\/module\/record\/macro names must be given unquoted.  -- desp",
+  "comment": "The recognition of function definitions and compiler directives (such as module, record and macro definitions) requires that each of the aforementioned constructs must be the first string inside a line (except for whitespace).  Also, the function/module/record/macro names must be given unquoted.  -- desp",
   "fileTypes": [
     "erl",
     "hrl"
@@ -448,7 +448,7 @@
               "name": "punctuation.separator.function-arity.erlang"
             }
           },
-          "match": "\\b(fun)\\s*+(([a-z][a-zA-Z\\d@_]*+)\\s*+(:)\\s*+)?([a-z][a-zA-Z\\d@_]*+)\\s*(\/)"
+          "match": "\\b(fun)\\s*+(([a-z][a-zA-Z\\d@_]*+)\\s*+(:)\\s*+)?([a-z][a-zA-Z\\d@_]*+)\\s*(/)"
         },
         {
           "begin": "\\b(fun)\\b",
@@ -761,7 +761,7 @@
       "name": "meta.structure.list.function.erlang",
       "patterns": [
         {
-          "begin": "([a-z][a-zA-Z\\d@_]*+)\\s*+(\/)",
+          "begin": "([a-z][a-zA-Z\\d@_]*+)\\s*+(/)",
           "beginCaptures": {
             "1": {
               "name": "entity.name.function.erlang"
@@ -891,7 +891,7 @@
       ]
     },
     "internal-type-specifiers": {
-      "begin": "(\/)",
+      "begin": "(/)",
       "beginCaptures": {
         "1": {
           "name": "punctuation.separator.value-type.erlang"
@@ -1588,7 +1588,7 @@
       ]
     },
     "symbolic-operator": {
-      "match": "\\+\\+|\\+|--|-|\\*|\/=|\/|=\/=|=:=|==|=<|=|<-|<|>=|>|!",
+      "match": "\\+\\+|\\+|--|-|\\*|/=|/|=/=|=:=|==|=<|=|<-|<|>=|>|!",
       "name": "keyword.operator.symbolic.erlang"
     },
     "textual-operator": {

data/config/syntax/F-Script.json

@@ -25,7 +25,7 @@
       "name": "constant.numeric.fscript"
     },
     {
-      "match": "#([[:lower:]]|_|[+=\\-\/!%&*|><~?])(\\w|[+=\\-\/!%&*|><~?:])*",
+      "match": "#([[:lower:]]|_|[+=\\-/!%&*|><~?])(\\w|[+=\\-/!%&*|><~?:])*",
       "name": "constant.other.block.compact.fscript"
     },
     {

data/config/syntax/FXScript.json

@@ -3,7 +3,7 @@
     "fxscript"
   ],
   "foldingStartMarker": "(^|(?<=;)[ \\t]*)on[ \\t]+(\\w+)[ \\t]*",
-  "foldingStopMarker": "end(;|;?[ \\t]*|;?[ \\t]*\/\/.*[ \\t]*)",
+  "foldingStopMarker": "end(;|;?[ \\t]*|;?[ \\t]*//.*[ \\t]*)",
   "keyEquivalent": "^~F",
   "name": "FXScript",
   "patterns": [
@@ -14,7 +14,7 @@
           "name": "entity.name.function.fxscript"
         }
       },
-      "end": "end(;|;?[ \\t]*\\n|;?[ \\t]*\/\/.*[ \\t]*\\n)",
+      "end": "end(;|;?[ \\t]*\\n|;?[ \\t]*//.*[ \\t]*\\n)",
       "name": "meta.function.fxscript",
       "patterns": [
         {
@@ -74,11 +74,11 @@
       "name": "keyword.control.fxscrpt"
     },
     {
-      "match": "\/b(?i:AlphaType|EffectID|FullFrame|Group|InformationFlag|InvalEntireItem|KeyType|ProducesAlpha|QTEffect|RenderEachFrameWhenStill|WipeCode)\/b",
+      "match": "/b(?i:AlphaType|EffectID|FullFrame|Group|InformationFlag|InvalEntireItem|KeyType|ProducesAlpha|QTEffect|RenderEachFrameWhenStill|WipeCode)/b",
       "name": "keyword.other.definition-statements.fxscript"
     },
     {
-      "match": "!|\\$|%|&|\\*|\\-\\-|\\-|\\+\\+|\\+|~|==|=|!=|!==|<=|>=|<|>|!|&&|\\|\\||\\?\\:|\\*=|\/=|%=|\\+=|\\-=|&=|\\^=",
+      "match": "!|\\$|%|&|\\*|\\-\\-|\\-|\\+\\+|\\+|~|==|=|!=|!==|<=|>=|<|>|!|&&|\\|\\||\\?\\:|\\*=|/=|%=|\\+=|\\-=|&=|\\^=",
       "name": "keyword.operator.arithmetic.fxscrpt"
     },
     {
@@ -87,7 +87,7 @@
           "name": "punctuation.definition.comment.fxscript"
         }
       },
-      "match": "(\/\/).*$\\n?",
+      "match": "(//).*$\\n?",
       "name": "comment.line.double-slash.fxscript"
     },
     {

data/config/syntax/Fortran - Modern.json

@@ -0,0 +1,221 @@
+{
+  "comment": "Specificities of Fortran >= 90",
+  "fileTypes": [
+    "f90",
+    "F90",
+    "f95",
+    "F95",
+    "f03",
+    "F03",
+    "f08",
+    "F08"
+  ],
+  "firstLineMatch": "(?i)-[*]- mode: f90 -[*]-",
+  "foldingStartMarker": "(?x)\t\t\t\t# extended mode\n\t\t\t\t^\\s*\t\t\t\t\t\t# start of line and some space\n\t\t\t\t(?i:\t\t\t\t\t\t# case insensitive match\n\t\t\t\t\t(\n\t\t\t\t\t\tif.*then\t\t\t\t# if ... then\n\t\t\t\t\t\t|for|do|select\\s+case|where|interface\t# some easy keywords\n\t\t\t\t\t\t|module(?!\\s*procedure)\t# module not followed by procedure\n\t\t\t\t\t\t|type(?!\\s*\\()\t\t# type but not type(\n\t\t\t\t\t)\n\t\t\t \t\t|\t\t\t\t\t# ...or...\n\t\t\t\t\t(\n\t\t\t\t\t\t[a-z]*(?<!end)\\s*(function|subroutine)\t# possibly some letters, but not the word end, and a space, then function\n\t\t\t\t\t)\n\t\t\t\t)\n\t\t\t\t.*$\t\t\t\t\t\t# anything until the end of the line\n\t\t\t",
+  "foldingStopMarker": "(?x)\t\t\t\t# extended mode\n\t\t\t\t^\\s*\t\t\t\t\t\t# start of line and some space\n\t\t\t\t(?i:(end))\t\t\t\t# the word end, was insensitive\n\t\t\t\t.*$\t\t\t\t\t\t# anything until the end of the line\n\t\t\t",
+  "keyEquivalent": "^~F",
+  "name": "Fortran - Modern",
+  "patterns": [
+    {
+      "begin": "^[Cc]\\s+",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.comment.fortran"
+        }
+      },
+      "end": "$\\n?",
+      "name": "invalid.deprecated.comment.line.fortran",
+      "patterns": [
+        {
+          "match": "\\\\\\s*\\n"
+        }
+      ]
+    },
+    {
+      "include": "source.fortran"
+    },
+    {
+      "begin": "(?x:\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# start of line and possibly some space\n\t\t\t\t\t(?i:(interface))\t\t# 1: word interface\n\t\t\t\t\t\\s+\t\t\t\t\t# some space\n\t\t\t\t\t(?i:(operator|assignment))\t\t# 2: the words operator or assignment\n\t\t\t\t\t\\(\t\t\t\t\t# opening parenthesis\n\t\t\t\t\t((\\.[a-zA-Z0-9_]+\\.)|[\\+\\-\\=\\/\\*]+)\t# 3: an operator\n\t\t\t\t\t\n\t\t\t\t\t\\)\t\t\t\t\t# closing parenthesis\n\t\t\t\t\t)",
+      "beginCaptures": {
+        "1": {
+          "name": "storage.type.function.fortran"
+        },
+        "2": {
+          "name": "storage.type.fortran"
+        },
+        "3": {
+          "name": "keyword.operator.fortran"
+        }
+      },
+      "comment": "Interface declaration of operator/assignments",
+      "end": "(?x:\n\t\t\t\t\t((?i:end))\t\t\t# 1: the word end\n\t\t\t\t\t\\s*\t\t\t\t\t# possibly some space\n\t\t\t\t\t((?i:interface)?) \t\t# 2: possibly interface\n\t\t\t\t\t)",
+      "endCaptures": {
+        "1": {
+          "name": "keyword.other.fortran"
+        },
+        "2": {
+          "name": "storage.type.function.fortran"
+        }
+      },
+      "name": "meta.function.interface.operator.fortran.modern",
+      "patterns": [
+        {
+          "include": "$self"
+        }
+      ]
+    },
+    {
+      "begin": "(?x:\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# start of line and possibly some space\n\t\t\t\t\t(?i:(interface))\t\t# 1: word interface\n\t\t\t\t\t\\s+\t\t\t\t\t# some space\n\t\t\t\t\t([A-Za-z_][A-Za-z0-9_]*)\t# 1: name\n\t\t\t\t\t)",
+      "beginCaptures": {
+        "1": {
+          "name": "storage.type.function.fortran"
+        },
+        "2": {
+          "name": "entity.name.function.fortran"
+        }
+      },
+      "comment": "Interface declaration of function/subroutines",
+      "end": "(?x:\t\t\t\t# extended mode\n\t\t\t\t\t((?i:end))\t\t# 1: the word end\n\t\t\t\t\t\\s*\t\t\t\t# possibly some space\n\t\t\t\t\t((?i:interface)?) \t# 2: possibly interface\n\t\t\t\t\t)",
+      "endCaptures": {
+        "1": {
+          "name": "keyword.other.fortran"
+        },
+        "2": {
+          "name": "storage.type.function.fortran"
+        }
+      },
+      "name": "meta.function.interface.fortran.modern",
+      "patterns": [
+        {
+          "include": "$self"
+        }
+      ]
+    },
+    {
+      "begin": "(?x:\t\t\t# extended mode\n\t\t\t\t\t^\\s*\t\t\t# begining of line and some space\n\t\t\t\t\t(?i:(type))\t# 1: word type\n\t\t\t\t\t\\s+\t\t\t# some space\n\t\t\t\t\t([a-zA-Z_][a-zA-Z0-9_]*)\t# 2: type name\n\t\t\t\t\t)",
+      "beginCaptures": {
+        "1": {
+          "name": "storage.type.fortran.modern"
+        },
+        "2": {
+          "name": "entity.name.type.fortran.modern"
+        }
+      },
+      "comment": "Type definition",
+      "end": "(?x:\n\t\t\t\t\t((?i:end))\t\t\t# 1: the word end\n\t\t\t\t\t\\s*\t\t\t\t\t# possibly some space\n\t\t\t\t\t(?i:(type))? \t\t\t# 2: possibly the word type\n\t\t\t\t\t(\\s+[A-Za-z_][A-Za-z0-9_]*)?\t# 3: possibly the name\n\t\t\t\t\t)",
+      "endCaptures": {
+        "1": {
+          "name": "keyword.other.fortran"
+        },
+        "2": {
+          "name": "storage.type.fortran.modern"
+        },
+        "3": {
+          "name": "entity.name.type.end.fortran.modern"
+        }
+      },
+      "name": "meta.type-definition.fortran.modern",
+      "patterns": [
+        {
+          "include": "$self"
+        }
+      ]
+    },
+    {
+      "begin": "(!-)",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.comment.fortran"
+        }
+      },
+      "end": "$\\n?",
+      "name": "comment.line.exclamation.mark.fortran.modern",
+      "patterns": [
+        {
+          "match": "\\\\\\s*\\n"
+        }
+      ]
+    },
+    {
+      "begin": "[!]",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.comment.fortran"
+        }
+      },
+      "end": "$\\n?",
+      "name": "comment.line.exclamation.fortran.modern",
+      "patterns": [
+        {
+          "match": "\\\\\\s*\\n"
+        }
+      ]
+    },
+    {
+      "comment": "statements controling the flow of the program",
+      "match": "\\b(?i:(select\\s+case|case(\\s+default)?|end\\s+select|use|(end\\s+)?forall))\\b",
+      "name": "keyword.control.fortran.modern"
+    },
+    {
+      "comment": "input/output instrinsics",
+      "match": "\\b(?i:(access|action|advance|append|apostrophe|asis|blank|delete|delim|direct|end|eor|err|exist|file|fmt|form|formatted|iolength|iostat|keep|name|named|nextrec|new|nml|no|null|number|old|opened|pad|position|quote|read|readwrite|rec|recl|replace|scratch|sequential|size|status|undefined|unformatted|unit|unknown|write|yes|zero|namelist)(?=\\())",
+      "name": "keyword.control.io.fortran.modern"
+    },
+    {
+      "comment": "logical operators in symbolic format",
+      "match": "\\b(\\=\\=|\\/\\=|\\>\\=|\\>|\\<|\\<\\=)\\b",
+      "name": "keyword.operator.logical.fortran.modern"
+    },
+    {
+      "comment": "operators",
+      "match": "(\\%|\\=\\>)",
+      "name": "keyword.operator.fortran.modern"
+    },
+    {
+      "comment": "numeric instrinsics",
+      "match": "\\b(?i:(ceiling|floor|modulo)(?=\\())",
+      "name": "keyword.other.instrinsic.numeric.fortran.modern"
+    },
+    {
+      "comment": "matrix/vector/array instrinsics",
+      "match": "\\b(?i:(allocate|allocated|deallocate)(?=\\())",
+      "name": "keyword.other.instrinsic.array.fortran.modern"
+    },
+    {
+      "comment": "pointer instrinsics",
+      "match": "\\b(?i:(associated)(?=\\())",
+      "name": "keyword.other.instrinsic.pointer.fortran.modern"
+    },
+    {
+      "comment": "programming units",
+      "match": "\\b(?i:((end\\s*)?(interface|procedure|module)))\\b",
+      "name": "keyword.other.programming-units.fortran.modern"
+    },
+    {
+      "begin": "\\b(?i:(type(?=\\s*\\()))\\b(?=.*::)",
+      "beginCaptures": {
+        "1": {
+          "name": "storage.type.fortran.modern"
+        }
+      },
+      "comment": "Line of type specification",
+      "end": "(?=!)|$",
+      "name": "meta.specification.fortran.modern",
+      "patterns": [
+        {
+          "include": "$base"
+        }
+      ]
+    },
+    {
+      "match": "\\b(?i:(type(?=\\s*\\()))\\b",
+      "name": "storage.type.fortran.modern"
+    },
+    {
+      "match": "\\b(?i:(optional|recursive|pointer|allocatable|target|private|public))\\b",
+      "name": "storage.modifier.fortran.modern"
+    }
+  ],
+  "scopeName": "source.fortran.modern",
+  "uuid": "016CA1B6-8351-4B17-9215-29C275D5D973"
+}

data/config/syntax/Fortran - Punchcard.json

@@ -0,0 +1,468 @@
+{
+  "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"
+  ],
+  "foldingStartMarker": "(?x:\t\t# extended mode\n\t\t^\\s*\t\t\t\t\t\t# start of line and some space\n\t\t(?i:\t\t\t\t\t\t# case insensitive match\n\t\t\t(\n\t\t\t\tif.*then\t\t\t# if ... then\n\t\t\t\t|for|do|select\\s+case|where|interface\t# some easy keywords\n\t\t\t\t|module(?!\\s*procedure)\t\t\t\t# module not followed by procedure\n\t\t\t\t|type(?!\\s*\\()\t# type but not type(\n\t\t\t)\n\t\t\t|\t\t\t\t\t# ...or...\n\t\t\t(\n\t\t\t\t[a-z]*(?<!end)\\s*(function|subroutine)\t# possibly some letters, but not the word end, and a space, then function\n\t\t\t)\n\t\t)\n\t\t.*$\t\t\t\t\t\t# anything until the end of the line\n\t\t)",
+  "foldingStopMarker": "(?x:\t\t# extended mode\n\t\t^\\s*\t\t\t\t# start of line and some space\n\t\t(?i:(end))\t\t# the word end, case insensitive\n\t\t.*$\t\t\t\t# anything until the end of the line\n\t\t)",
+  "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# extended mode\n\t\t\t\t\t^\n\t\t\t\t\t\\s*\t\t\t\t\t# start of line and possibly some space\n\t\t\t\t\t([a-zA-Z\\(\\)]*)(?<!end)\t# 1: possibly some type specification but not the word end\n\t\t\t\t\t\\s*\t\t\t\t\t# possibly some space\n\t\t\t\t\t(?i:(function|subroutine))\\b\t# 2: function or subroutine\n\t\t\t\t\t\\s+\t\t\t\t\t# some space\n\t\t\t\t\t([A-Za-z_][A-Za-z0-9_]*)\t\t# 3: name\n\t\t\t\t\t\\s*\t\t\t\t\t# possibly some space\n\t\t\t\t\t(\\()\t\t\t\t\t# 4: opening parenthesis\n\t\t\t\t\t([^)]*)?  \t\t# 5: arguments (anything but a parenthesis)\n\t\t\t\t\t(\\))?\t\t\t\t\t# 6: closing parenthesis\n\t\t\t\t\t)",
+      "beginCaptures": {
+        "1": {
+          "name": "storage.type.fortran"
+        },
+        "2": {
+          "name": "storage.type.function.fortran"
+        },
+        "3": {
+          "name": "entity.name.function.fortran"
+        },
+        "4": {
+          "name": "punctuation.definition.parameters.fortran"
+        },
+        "5": {
+          "name": "variable.parameter.fortran"
+        },
+        "6": {
+          "name": "punctuation.definition.parameters.fortran"
+        }
+      },
+      "comment": "First line of function/subroutine definition",
+      "end": "(?x:\t\t\t\t\t# extended mode\n\t\t\t\t\t((?i:end))\t\t\t# 1: the word end\n\t\t\t\t\t(\t\t\t\t\t# followed by\n\t\t\t\t\t\t$\t\t\t\t# end of line\n\t\t\t\t\t|\t\t\t\t\t# or\n\t\t\t\t\t\t\\s*\t\t\t\t# possibly some space\n\t\t\t\t\t\t(?i:(function|subroutine))\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": [
+        {
+          "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|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]",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.comment.fortran"
+        }
+      },
+      "end": "$\\n?",
+      "name": "comment.line.c.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"
+}