ver 2010.02 → 2010.08

data/config/syntax/F-Script.rb

@@ -6,21 +6,23 @@
  keyEquivalent: "^~F",
  name: "F-Script",
  patterns: 
-  [{match: /(:|\w):/, name: "meta.dummy.symbol.ignore.fscript"},
+  [{match: /(?<_1>:|\w):/, name: "meta.dummy.symbol.ignore.fscript"},
    {captures: {1 => {name: "punctuation.definition.symbol.fscript"}},
-    match: /(:)\w+\b/,
+    match: /(?<_1>:)\w+\b/,
     name: "constant.other.symbol.fscript"},
-   {match: /\b((([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)\b/,
+   {match: 
+     /\b(?<_1>(?<_2>(?<_3>[0-9]+\.?[0-9]*)|(?<_4>\.[0-9]+))(?<_5>(?<_6>e|E)(?<_7>\+|-)?[0-9]+)?)\b/,
     name: "constant.numeric.fscript"},
-   {match: /#([[:lower:]]|_|[+=\-\/!%&*|><~?])(\w|[+=\-\/!%&*|><~?:])*/,
+   {match: 
+     /#(?<_1>[[:lower:]]|_|[+=\-\/!%&*|><~?])(?<_2>\w|[+=\-\/!%&*|><~?:])*/,
     name: "constant.other.block.compact.fscript"},
    {captures: 
      {1 => {name: "punctuation.section.block.fscript"},
       2 => {name: "variable.parameter.block.fscript"},
       3 => {name: "punctuation.section.block.fscript"}},
-    match: /(\[)(?:\s*((?::\w+\s+)*:\w+)\s*\|)?\s*(\])/,
+    match: /(?<_1>\[)(?:\s*(?<_2>(?::\w+\s+)*:\w+)\s*\|)?\s*(?<_3>\])/,
     name: "meta.block.empty.fscript"},
-   {begin: /(\[)(?:\s*((?::\w+\s+)*:\w+)\s*\|)?/,
+   {begin: /(?<_1>\[)(?:\s*(?<_2>(?::\w+\s+)*:\w+)\s*\|)?/,
     beginCaptures: 
      {1 => {name: "punctuation.section.block.fscript"},
       2 => {name: "variable.parameter.block.fscript"}},
@@ -29,16 +31,16 @@
     name: "meta.block.fscript",
     patterns: 
      [{match: /\s+/, name: "meta.block.header.fscript"},
-      {begin: /(?:\|(\s*(?:\w+\s+)*\w+\s*)?\||(?=[^\s|]))/,
+      {begin: /(?:\|(?<_1>\s*(?:\w+\s+)*\w+\s*)?\||(?=[^\s|]))/,
        captures: {1 => {name: "variable.other.local.fscript"}},
        end: "(?=\\])",
        name: "meta.block.content.fscript",
        patterns: [{include: "$base"}]}]},
-   {match: /\b(true|YES|false|NO|sys|nil)\b/,
+   {match: /\b(?<_1>true|YES|false|NO|sys|nil)\b/,
     name: "constant.language.fscript"},
    {captures: {1 => {name: "entity.name.function.fscript"}},
     comment: "a hack for the symbol popup",
-    match: /^(\w+)\s*:=\s*(?=\[)/},
+    match: /^(?<_1>\w+)\s*:=\s*(?=\[)/},
    {begin: /"/,
     beginCaptures: 
      {0 => {name: "punctuation.definition.comment.begin.fscript"}},

data/config/syntax/FXScript.rb

@@ -1,12 +1,12 @@
 # Encoding: UTF-8
 
 {fileTypes: ["fxscript"],
- foldingStartMarker: /(^|(?<=;)[ \t]*)on[ \t]+(\w+)[ \t]*/,
- foldingStopMarker: /end(;|;?[ \t]*|;?[ \t]*\/\/.*[ \t]*)/,
+ foldingStartMarker: /(?<_1>^|(?<=;)[ \t]*)on[ \t]+(?<_2>\w+)[ \t]*/,
+ foldingStopMarker: /end(?<_1>;|;?[ \t]*|;?[ \t]*\/\/.*[ \t]*)/,
  keyEquivalent: "^~F",
  name: "FXScript",
  patterns: 
-  [{begin: /(^|(?<=;)[ \t]*)on[ \t]+(\w+)[ \t]*(?=\([^\)]*\))/,
+  [{begin: /(?<_1>^|(?<=;)[ \t]*)on[ \t]+(?<_2>\w+)[ \t]*(?=\([^\)]*\))/,
     captures: {2 => {name: "entity.name.function.fxscript"}},
     end: "end(;|;?[ \\t]*\\n|;?[ \\t]*//.*[ \\t]*\\n)",
     name: "meta.function.fxscript",
@@ -18,9 +18,9 @@
            {1 => {name: "support.type.fxscript"},
             2 => {name: "variable.parameter.function.fxscript"}},
           match: 
-           /((?i:clip|color|float|image|point|string|value|point3d))[ \t]+([^,)]+)/}]},
+           /(?<_1>(?i:clip|color|float|image|point|string|value|point3d))[ \t]+(?<_2>[^,)]+)/}]},
       {include: "$self"}]},
-   {begin: /(^|(?<=;)[ \t]*)input[ \t]*/,
+   {begin: /(?<_1>^|(?<=;)[ \t]*)input[ \t]*/,
     comment: "Input Controls",
     end: "\\n",
     name: "keyword.other.input-control.fxscript",
@@ -31,12 +31,12 @@
          2 => {name: "string.quoted.double.fxscript"},
          3 => {name: "support.type.fxscript"}},
        match: 
-        /\b(\w+),[ \t]+("[^"]+"),[ \t]+(?i:Angle|CheckBox|Clip|Color|FontList|Label|Point|Popup|RadioGroup|Slider|Text),?/}]},
+        /\b(?<_1>\w+),[ \t]+(?<_2>"[^"]+"),[ \t]+(?i:Angle|CheckBox|Clip|Color|FontList|Label|Point|Popup|RadioGroup|Slider|Text),?/}]},
    {comment: "Data Types",
     match: /(?i:float|image|point|point3d|region|string|value|YUVcolor)\b/,
     name: "storage.type.fxscript"},
    {match: 
-     /\b(?i:if|(end|else)( if)?|for|next|return|repeat( While| With (Counter|List)))\b/,
+     /\b(?i:if|(?<_1>end|else)(?<_2> if)?|for|next|return|repeat(?<_3> While| With (?<_4>Counter|List)))\b/,
     name: "keyword.control.fxscrpt"},
    {match: 
      /\/b(?i:AlphaType|EffectID|FullFrame|Group|InformationFlag|InvalEntireItem|KeyType|ProducesAlpha|QTEffect|RenderEachFrameWhenStill|WipeCode)\/b/,
@@ -45,12 +45,13 @@
      /!|\$|%|&|\*|\-\-|\-|\+\+|\+|~|==|=|!=|!==|<=|>=|<|>|!|&&|\|\||\?\:|\*=|\/=|%=|\+=|\-=|&=|\^=/,
     name: "keyword.operator.arithmetic.fxscrpt"},
    {captures: {1 => {name: "punctuation.definition.comment.fxscript"}},
-    match: /(\/\/).*$\n?/,
+    match: /(?<_1>\/\/).*$\n?/,
     name: "comment.line.double-slash.fxscript"},
    {match: /(?i:kFormatRGB219|kFormatRGB255|kFormatYUV219)/,
     name: "support.constant.colorspace.fxscript"},
-   {match: /\b[0-9]+(\.[0-9]*)?\b/, name: "constant.numeric.fxscript"},
-   {match: /\b0x([a-fA-F0-9]*)?\b/, name: "constant.numeric.hex.fxscript"},
+   {match: /\b[0-9]+(?<_1>\.[0-9]*)?\b/, name: "constant.numeric.fxscript"},
+   {match: /\b0x(?<_1>[a-fA-F0-9]*)?\b/,
+    name: "constant.numeric.hex.fxscript"},
    {match: /(?i:kBlack|kBlue|kCyan|kGray|kGreen|kMagenta|kRed|kWhite|kYellow)/,
     name: "support.constant.color.fxscript"},
    {match: 
@@ -80,7 +81,8 @@
       5 => {name: "entity.name.function.color.luma.fxscript"},
       6 => {name: "entity.name.function.color.chroma-u.fxscript"},
       7 => {name: "entity.name.function.color.chroma-v.fxscript"}},
-    match: /\b\w+\.(?i:(a)|(r)|(g)|(b)|(y)|(u)|(v))\b/},
+    match: 
+     /\b\w+\.(?i:(?<_1>a)|(?<_2>r)|(?<_3>g)|(?<_4>b)|(?<_5>y)|(?<_6>u)|(?<_7>v))\b/},
    {begin: /"/,
     beginCaptures: 
      {0 => {name: "punctuation.definition.string.begin.fxscript"}},
@@ -111,7 +113,7 @@
    {match: /\b(?i:BezToLevelMap|ChromaAngleKey)/,
     name: "support.function.parser.fxscript"},
    {match: 
-     /\b(?i:Blend|Blur|BlurChannel|Channel(Copy|Fill|Multiply)|ColorTransform|Convolve|Desaturate|Diffuse|DiffuseOffset|LevelMap|MotionBlur|RadialBlur)\b/,
+     /\b(?i:Blend|Blur|BlurChannel|Channel(?<_1>Copy|Fill|Multiply)|ColorTransform|Convolve|Desaturate|Diffuse|DiffuseOffset|LevelMap|MotionBlur|RadialBlur)\b/,
     name: "support.function.process.fxscript"},
    {match: 
      /\b(?i:CurveTo|DrawSoftDot|FillArc|FillOval|FillPoly|FillRegion|FrameArc|FrameOval|FramePoly|FrameRegion|Line|MakeRect|MakeRegion|OvalRegion|RegionIsEmpty)\b/,
@@ -129,12 +131,12 @@
     name: "support.function.undocumented.fxscript"},
    {match: /\b(?i:debugtext)\b/, name: "support.function.debug.fxscript"},
    {match: 
-     /\b(?i:Assert|CircleLight|ColorOf|ConvertImage|GetConversionMatrix|GetPixelFormat|Highlight|MatrixConcat|PointTrack|Random(Noise|Seed|Table)?|SetPixelFormat|SysTime|Truncate)\b/,
+     /\b(?i:Assert|CircleLight|ColorOf|ConvertImage|GetConversionMatrix|GetPixelFormat|Highlight|MatrixConcat|PointTrack|Random(?<_1>Noise|Seed|Table)?|SetPixelFormat|SysTime|Truncate)\b/,
     name: "support.function.utility.fxscript"},
    {comment: 
      "Joe Maller’s personal FXScript Functions, these will be appearing on the FXScript Reference site someday.",
     match: 
-     /\b((?i:absNoInt|ArrayFloatAbs|ArrayFloatAverage|ArrayFloatCount|ArrayFloatCountAll|ArrayFloatFlatten|ArrayFloatIndexExists|ArrayFloatInsertionSort|ArrayFloatMax|ArrayFloatMin|ArrayFloatNormalize|ArrayFloatPrint_r|ArrayFloatQuickSort|ArrayFloatSum|ArrayPointCount|ArrayPointReverse|ArrayPointWrap|BlurChannelInPlace|BoundsOfPoly|ceil|CenterOfPoly|ChannelCopyFit|ChannelMultiplyYUV|ChannelScreen|ChannelView|ColorRampImage|ColorReporter|DeInterlace|DeInterlaceFast|DeInterlaceInterpolate|DifferenceMask|DimensionsOfPoly|DrawGridFrames|ease|easeIn|easeMiddle|easeOut|easeS|ErrorReporter|factorial|factorialabsNoInt|FastRotate|FieldDouble|fitPoly|fitRange|fitRect|floor|gcd|getField|indexExistsPt|isFloatArray|isIndexFloat|isIndexFloatArray|makeLevelMapBez|makeThresholdMapBez|max|min|mirrorRect|NumReporter|PlaceFrame|PointInPoly|pt3dReporter|PtReporter|RandomNoiseScaled|RandomSeedFPS|RGBtoYUVcolor|round|scaleToFit|sumNaturals|T_borderFade|whattype|YUVtoRGBcolor))\b/,
+     /\b(?<_1>(?i:absNoInt|ArrayFloatAbs|ArrayFloatAverage|ArrayFloatCount|ArrayFloatCountAll|ArrayFloatFlatten|ArrayFloatIndexExists|ArrayFloatInsertionSort|ArrayFloatMax|ArrayFloatMin|ArrayFloatNormalize|ArrayFloatPrint_r|ArrayFloatQuickSort|ArrayFloatSum|ArrayPointCount|ArrayPointReverse|ArrayPointWrap|BlurChannelInPlace|BoundsOfPoly|ceil|CenterOfPoly|ChannelCopyFit|ChannelMultiplyYUV|ChannelScreen|ChannelView|ColorRampImage|ColorReporter|DeInterlace|DeInterlaceFast|DeInterlaceInterpolate|DifferenceMask|DimensionsOfPoly|DrawGridFrames|ease|easeIn|easeMiddle|easeOut|easeS|ErrorReporter|factorial|factorialabsNoInt|FastRotate|FieldDouble|fitPoly|fitRange|fitRect|floor|gcd|getField|indexExistsPt|isFloatArray|isIndexFloat|isIndexFloatArray|makeLevelMapBez|makeThresholdMapBez|max|min|mirrorRect|NumReporter|PlaceFrame|PointInPoly|pt3dReporter|PtReporter|RandomNoiseScaled|RandomSeedFPS|RGBtoYUVcolor|round|scaleToFit|sumNaturals|T_borderFade|whattype|YUVtoRGBcolor))\b/,
     name: "support.function.joe.fxscript"}],
  scopeName: "source.fxscript",
  uuid: "43751327-3FD1-4BE7-AD05-136FC552BABA"}

data/config/syntax/Fortran - Modern.rb

@@ -7,15 +7,15 @@
   /(?x)				# extended mode
 	^\s*						# start of line and some space
 	(?i:						# case insensitive match
-	(
+	(?<_1>
 	if.*then				# if ... then
 	|for|do|select\s+case|where|interface	# some easy keywords
 	|module(?!\s*procedure)	# module not followed by procedure
-	|type(?!\s*\()		# type but not type(
+	|type(?!\s*\()		# type but not type(?<_2>
 	)
 	 		|					# ...or...
-	(
-	[a-z]*(?<!end)\s*(function|subroutine)	# possibly some letters, but not the word end, and a space, then function
+	(?<_3>
+	[a-z]*(?<!end)\s*(?<_4>function|subroutine)	# possibly some letters, but not the word end, and a space, then function
 	)
 	)
 	.*$						# anything until the end of the line
@@ -23,7 +23,7 @@
  foldingStopMarker: 
   /(?x)				# extended mode
 	^\s*						# start of line and some space
-	(?i:(end))				# the word end, was insensitive
+	(?i:(?<_1>end))				# the word end, was insensitive
 	.*$						# anything until the end of the line
 	/,
  keyEquivalent: "^~F",
@@ -39,11 +39,11 @@
      /(?x:					# extended mode
 	^
 	\s*					# start of line and possibly some space
-	(?i:(interface))		# 1: word interface
+	(?i:(?<_1>interface))		# 1: word interface
 	\s+					# some space
-	(?i:(operator|assignment))		# 2: the words operator or assignment
+	(?i:(?<_2>operator|assignment))		# 2: the words operator or assignment
 	\(					# opening parenthesis
-	((\.[a-zA-Z0-9_]+\.)|[\+\-\=\/\*]+)	# 3: an operator
+	(?<_3>(?<_4>\.[a-zA-Z0-9_]+\.)|[\+\-\=\/\*]+)	# 3: an operator
 	
 	\)					# closing parenthesis
 	)/,
@@ -63,9 +63,9 @@
      /(?x:					# extended mode
 	^
 	\s*					# start of line and possibly some space
-	(?i:(interface))		# 1: word interface
+	(?i:(?<_1>interface))		# 1: word interface
 	\s+					# some space
-	([A-Za-z_][A-Za-z0-9_]*)	# 1: name
+	(?<_2>[A-Za-z_][A-Za-z0-9_]*)	# 1: name
 	)/,
     beginCaptures: 
      {1 => {name: "storage.type.function.fortran"},
@@ -81,9 +81,9 @@
    {begin: 
      /(?x:			# extended mode
 	^\s*			# begining of line and some space
-	(?i:(type))	# 1: word type
+	(?i:(?<_1>type))	# 1: word type
 	\s+			# some space
-	([a-zA-Z_][a-zA-Z0-9_]*)	# 2: type name
+	(?<_2>[a-zA-Z_][a-zA-Z0-9_]*)	# 2: type name
 	)/,
     beginCaptures: 
      {1 => {name: "storage.type.fortran.modern"},
@@ -97,7 +97,7 @@
       3 => {name: "entity.name.type.end.fortran.modern"}},
     name: "meta.type-definition.fortran.modern",
     patterns: [{include: "$self"}]},
-   {begin: /(!-)/,
+   {begin: /(?<_1>!-)/,
     beginCaptures: {0 => {name: "punctuation.definition.comment.fortran"}},
     end: "$\\n?",
     name: "comment.line.exclamation.mark.fortran.modern",
@@ -109,39 +109,40 @@
     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/,
+     /\b(?i:(?<_1>select\s+case|case(?<_2>\s+default)?|end\s+select|use|(?<_3>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)(?=\())/,
+     /\b(?i:(?<_1>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/,
+    match: /\b(?<_1>\=\=|\/\=|\>\=|\>|\<|\<\=)\b/,
     name: "keyword.operator.logical.fortran.modern"},
    {comment: "operators",
-    match: /(\%|\=\>)/,
+    match: /(?<_1>\%|\=\>)/,
     name: "keyword.operator.fortran.modern"},
    {comment: "numeric instrinsics",
-    match: /\b(?i:(ceiling|floor|modulo)(?=\())/,
+    match: /\b(?i:(?<_1>ceiling|floor|modulo)(?=\())/,
     name: "keyword.other.instrinsic.numeric.fortran.modern"},
    {comment: "matrix/vector/array instrinsics",
-    match: /\b(?i:(allocate|allocated|deallocate)(?=\())/,
+    match: /\b(?i:(?<_1>allocate|allocated|deallocate)(?=\())/,
     name: "keyword.other.instrinsic.array.fortran.modern"},
    {comment: "pointer instrinsics",
-    match: /\b(?i:(associated)(?=\())/,
+    match: /\b(?i:(?<_1>associated)(?=\())/,
     name: "keyword.other.instrinsic.pointer.fortran.modern"},
    {comment: "programming units",
-    match: /\b(?i:((end\s*)?(interface|procedure|module)))\b/,
+    match: /\b(?i:(?<_1>(?<_2>end\s*)?(?<_3>interface|procedure|module)))\b/,
     name: "keyword.other.programming-units.fortran.modern"},
-   {begin: /\b(?i:(type(?=\s*\()))\b(?=.*::)/,
+   {begin: /\b(?i:(?<_1>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:(?<_1>type(?=\s*\()))\b/,
+    name: "storage.type.fortran.modern"},
    {match: 
-     /\b(?i:(optional|recursive|pointer|allocatable|target|private|public))\b/,
+     /\b(?i:(?<_1>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.rb

@@ -7,15 +7,15 @@
   /(?x:		# extended mode
 	^\s*						# start of line and some space
 	(?i:						# case insensitive match
-	(
+	(?<_1>
 	if.*then			# if ... then
 	|for|do|select\s+case|where|interface	# some easy keywords
 	|module(?!\s*procedure)				# module not followed by procedure
-	|type(?!\s*\()	# type but not type(
+	|type(?!\s*\()	# type but not type(?<_2>
 	)
 	|					# ...or...
-	(
-	[a-z]*(?<!end)\s*(function|subroutine)	# possibly some letters, but not the word end, and a space, then function
+	(?<_3>
+	[a-z]*(?<!end)\s*(?<_4>function|subroutine)	# possibly some letters, but not the word end, and a space, then function
 	)
 	)
 	.*$						# anything until the end of the line
@@ -23,7 +23,7 @@
  foldingStopMarker: 
   /(?x:		# extended mode
 	^\s*				# start of line and some space
-	(?i:(end))		# the word end, case insensitive
+	(?i:(?<_1>end))		# the word end, case insensitive
 	.*$				# anything until the end of the line
 	)/,
  name: "Fortran - Punchcard",
@@ -32,7 +32,7 @@
    {include: "#preprocessor-rule-disabled"},
    {include: "#preprocessor-rule-other"},
    {comment: "built-in constants",
-    match: /(?i:(r8|r4|\.TRUE\.|\.FALSE\.))/,
+    match: /(?i:(?<_1>r8|r4|\.TRUE\.|\.FALSE\.))/,
     name: "constant.language.fortran"},
    {comment: "numbers",
     match: /\b[\+\-]?[0-9]+\.?[0-9a-zA-Z_]*\b/,
@@ -41,15 +41,15 @@
      /(?x:					# extended mode
 	^
 	\s*					# start of line and possibly some space
-	([a-zA-Z\(\)]*)(?<!end)	# 1: possibly some type specification but not the word end
+	(?<_1>[a-zA-Z\(\)]*)(?<!end)	# 1: possibly some type specification but not the word end
 	\s*					# possibly some space
-	(?i:(function|subroutine))\b	# 2: function or subroutine
+	(?i:(?<_2>function|subroutine))\b	# 2: function or subroutine
 	\s+					# some space
-	([A-Za-z_][A-Za-z0-9_]*)		# 3: name
+	(?<_3>[A-Za-z_][A-Za-z0-9_]*)		# 3: name
 	\s*					# possibly some space
-	(\()					# 4: opening parenthesis
-	([^)]*)?  		# 5: arguments (anything but a parenthesis)
-	(\))?					# 6: closing parenthesis
+	(?<_4>\()					# 4: opening parenthesis
+	(?<_5>[^)]*)?  		# 5: arguments (?<_6>anything but a parenthesis)
+	(?<_7>\))?					# 6: closing parenthesis
 	)/,
     beginCaptures: 
      {1 => {name: "storage.type.fortran"},
@@ -68,7 +68,7 @@
     name: "meta.function.fortran",
     patterns: [{include: "$self"}, {include: "source.fortran.modern"}]},
    {begin: 
-     /\b(?i:(integer|real|double\s+precision|complex|logical|character))\b(?=.*::)/,
+     /\b(?i:(?<_1>integer|real|double\s+precision|complex|logical|character))\b(?=.*::)/,
     beginCaptures: {1 => {name: "storage.type.fortran"}},
     comment: "Line of type specification",
     end: "(?=!)|$",
@@ -76,66 +76,68 @@
     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/,
+     /\b(?i:(?<_1>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/,
+     /\b(?i:(?<_1>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/,
+     /\b(?i:(?<_1>open|close|read|write|print|inquire|backspace|endfile|format))\b/,
     name: "keyword.control.io.fortran"},
    {comment: "operators",
-    match: /((?<!\=)\=(?!\=)|\-|\+|\/\/|\/|\*|::)/,
+    match: /(?<_1>(?<!\=)\=(?!\=)|\-|\+|\/\/|\/|\*|::)/,
     name: "keyword.operator.fortran"},
    {comment: "logical operators",
     match: 
-     /(?i:(\.and\.|\.or\.|\.eq\.|\.lt\.|\.le\.|\.gt\.|\.ge\.|\.ne\.|\.not\.|\.eqv\.|\.neqv\.))/,
+     /(?i:(?<_1>\.and\.|\.or\.|\.eq\.|\.lt\.|\.le\.|\.gt\.|\.ge\.|\.ne\.|\.not\.|\.eqv\.|\.neqv\.))/,
     name: "keyword.operator.logical.fortran"},
    {comment: "argument related intrisics",
-    match: /\b(?i:(present)(?=\())/,
+    match: /\b(?i:(?<_1>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)(?=\())/,
+     /\b(?i:(?<_1>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)(?=\())/,
+     /\b(?i:(?<_1>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/,
+     /\b(?i:(?<_1>(?<_2>(?<_3>acos|asin|atan|atan2|cos|cosh|exp|log|log10|sin|sinh|sqrt|tan|tanh)(?=\())|(?<_4>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)(?=\())/,
+    match: 
+     /\b(?i:(?<_1>kind|selected_int_kind|selected_real_kind|transfer)(?=\())/,
     name: "keyword.other.instrisic.data.fortran"},
    {comment: "logical intrinsics",
-    match: /\b(?i:(logical)(?=\())/,
+    match: /\b(?i:(?<_1>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/,
+     /\b(?i:(?<_1>(?<_2>(?<_3>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)(?=\())/,
+     /\b(?i:(?<_1>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/,
+     /\b(?i:(?<_1>(?<_2>(?<_3>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)(?=\())|(?<_4>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/,
+    match: 
+     /\b(?i:(?<_1>(?<_2>(?<_3>dtime)(?=\())|(?<_4>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/,
+     /\b(?i:(?<_1>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/,
+     /\b(?i:(?<_1>dimension|common|equivalence|parameter|external|intrinsic|save|data|implicit\s*none|implicit|intent|in|out|inout))\b/,
     name: "storage.modifier.fortran"},
    {applyEndPatternLast: 1,
     begin: /'/,
@@ -162,14 +164,14 @@
     end: "$\\n?",
     name: "comment.line.c.fortran",
     patterns: [{match: /\\\s*\n/}]},
-   {begin: /^\s*#\s*(error|warning)\b/,
+   {begin: /^\s*#\s*(?<_1>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+/,
+   {begin: /^\s*#\s*(?<_1>include|import)\b\s+/,
     captures: {1 => {name: "keyword.control.import.include.fortran"}},
     end: "(?=(?://|/\\*))|$\\n?",
     name: "meta.preprocessor.fortran.include",
@@ -190,7 +192,7 @@
        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/,
+     /^\s*#\s*(?<_1>define|defined|elif|else|if|ifdef|ifndef|line|pragma|undef)\b/,
     captures: {1 => {name: "keyword.control.import.fortran"}},
     end: "(?=(?://|/\\*))|$\\n?",
     name: "meta.preprocessor.fortran",
@@ -199,7 +201,7 @@
        name: "punctuation.separator.continuation.fortran"}]}],
  repository: 
   {disabled: 
-    {begin: /^\s*#\s*if(n?def)?\b.*$/,
+    {begin: /^\s*#\s*if(?<_1>n?def)?\b.*$/,
      comment: "eat nested preprocessor if(def)s",
      end: "^\\s*#\\s*endif\\b.*$",
      patterns: [{include: "#disabled"}, {include: "#pragma-mark"}]},
@@ -208,17 +210,17 @@
       {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+(.*))/,
+     match: /^\s*(?<_1>#\s*(?<_2>pragma\s+mark)\s+(?<_3>.*))/,
      name: "meta.section"},
    :"preprocessor-rule-disabled" => 
-    {begin: /^\s*(#(if)\s+(0)\b).*/,
+    {begin: /^\s*(?<_1>#(?<_2>if)\s+(?<_3>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)/,
+      [{begin: /^\s*(?<_1>#\s*(?<_2>else)\b)/,
         captures: 
          {1 => {name: "meta.preprocessor.fortran"},
           2 => {name: "keyword.control.import.else.fortran"}},
@@ -229,14 +231,14 @@
         name: "comment.block.preprocessor.if-branch",
         patterns: [{include: "#disabled"}, {include: "#pragma-mark"}]}]},
    :"preprocessor-rule-enabled" => 
-    {begin: /^\s*(#(if)\s+(0*1)\b)/,
+    {begin: /^\s*(?<_1>#(?<_2>if)\s+(?<_3>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).*/,
+      [{begin: /^\s*(?<_1>#\s*(?<_2>else)\b).*/,
         captures: 
          {1 => {name: "meta.preprocessor.fortran"},
           2 => {name: "keyword.control.import.else.fortran"}},
@@ -247,7 +249,8 @@
         end: "(?=^\\s*#\\s*(else|endif)\\b.*$)",
         patterns: [{include: "$base"}]}]},
    :"preprocessor-rule-other" => 
-    {begin: /^\s*(#\s*(if(n?def)?)\b.*?(?:(?=(?:\/\/|\/\*))|$))/,
+    {begin: 
+      /^\s*(?<_1>#\s*(?<_2>if(?<_3>n?def)?)\b.*?(?:(?=(?:\/\/|\/\*))|$))/,
      captures: 
       {1 => {name: "meta.preprocessor.fortran"},
        2 => {name: "keyword.control.import.fortran"}},