ver 2009.12.14 → 2010.02

data/config/syntax/F-Script.rb

@@ -0,0 +1,56 @@
+# Encoding: UTF-8
+
+{fileTypes: ["fscript"],
+ foldingStartMarker: /\[/,
+ foldingStopMarker: /\]/,
+ keyEquivalent: "^~F",
+ name: "F-Script",
+ patterns: 
+  [{match: /(:|\w):/, name: "meta.dummy.symbol.ignore.fscript"},
+   {captures: {1 => {name: "punctuation.definition.symbol.fscript"}},
+    match: /(:)\w+\b/,
+    name: "constant.other.symbol.fscript"},
+   {match: /\b((([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)\b/,
+    name: "constant.numeric.fscript"},
+   {match: /#([[:lower:]]|_|[+=\-\/!%&*|><~?])(\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*(\])/,
+    name: "meta.block.empty.fscript"},
+   {begin: /(\[)(?:\s*((?::\w+\s+)*:\w+)\s*\|)?/,
+    beginCaptures: 
+     {1 => {name: "punctuation.section.block.fscript"},
+      2 => {name: "variable.parameter.block.fscript"}},
+    end: "\\]",
+    endCaptures: {0 => {name: "punctuation.section.block.fscript"}},
+    name: "meta.block.fscript",
+    patterns: 
+     [{match: /\s+/, name: "meta.block.header.fscript"},
+      {begin: /(?:\|(\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/,
+    name: "constant.language.fscript"},
+   {captures: {1 => {name: "entity.name.function.fscript"}},
+    comment: "a hack for the symbol popup",
+    match: /^(\w+)\s*:=\s*(?=\[)/},
+   {begin: /"/,
+    beginCaptures: 
+     {0 => {name: "punctuation.definition.comment.begin.fscript"}},
+    end: "\"",
+    endCaptures: {0 => {name: "punctuation.definition.comment.end.fscript"}},
+    name: "comment.block.quotes.fscript"},
+   {begin: /'/,
+    beginCaptures: 
+     {0 => {name: "punctuation.definition.string.begin.fscript"}},
+    end: "'",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.fscript"}},
+    name: "string.quoted.single.fscript",
+    patterns: [{match: /\\./, name: "constant.character.escape.fscript"}]}],
+ scopeName: "source.fscript",
+ uuid: "C2CB9A74-C9FC-4F63-8BAF-E64B72A60DD4"}

data/config/syntax/FXScript.rb

@@ -0,0 +1,140 @@
+# Encoding: UTF-8
+
+{fileTypes: ["fxscript"],
+ foldingStartMarker: /(^|(?<=;)[ \t]*)on[ \t]+(\w+)[ \t]*/,
+ foldingStopMarker: /end(;|;?[ \t]*|;?[ \t]*\/\/.*[ \t]*)/,
+ keyEquivalent: "^~F",
+ name: "FXScript",
+ patterns: 
+  [{begin: /(^|(?<=;)[ \t]*)on[ \t]+(\w+)[ \t]*(?=\([^\)]*\))/,
+    captures: {2 => {name: "entity.name.function.fxscript"}},
+    end: "end(;|;?[ \\t]*\\n|;?[ \\t]*//.*[ \\t]*\\n)",
+    name: "meta.function.fxscript",
+    patterns: 
+     [{begin: /\((?=(?i:clip|color|float|image|point|string|value|point3d))/,
+       end: "\\)",
+       patterns: 
+        [{captures: 
+           {1 => {name: "support.type.fxscript"},
+            2 => {name: "variable.parameter.function.fxscript"}},
+          match: 
+           /((?i:clip|color|float|image|point|string|value|point3d))[ \t]+([^,)]+)/}]},
+      {include: "$self"}]},
+   {begin: /(^|(?<=;)[ \t]*)input[ \t]*/,
+    comment: "Input Controls",
+    end: "\\n",
+    name: "keyword.other.input-control.fxscript",
+    patterns: 
+     [{include: "$self"},
+      {captures: 
+        {1 => {name: "variable.other.global.fxscript"},
+         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),?/}]},
+   {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/,
+    name: "keyword.control.fxscrpt"},
+   {match: 
+     /\/b(?i:AlphaType|EffectID|FullFrame|Group|InformationFlag|InvalEntireItem|KeyType|ProducesAlpha|QTEffect|RenderEachFrameWhenStill|WipeCode)\/b/,
+    name: "keyword.other.definition-statements.fxscript"},
+   {match: 
+     /!|\$|%|&|\*|\-\-|\-|\+\+|\+|~|==|=|!=|!==|<=|>=|<|>|!|&&|\|\||\?\:|\*=|\/=|%=|\+=|\-=|&=|\^=/,
+    name: "keyword.operator.arithmetic.fxscrpt"},
+   {captures: {1 => {name: "punctuation.definition.comment.fxscript"}},
+    match: /(\/\/).*$\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: /(?i:kBlack|kBlue|kCyan|kGray|kGreen|kMagenta|kRed|kWhite|kYellow)/,
+    name: "support.constant.color.fxscript"},
+   {match: 
+     /(?i:k16mm|k24fps|k25fps|k30df|k30fps|k35mm|k60df|k60fps|kFloat2|kFloat4|kFloat6|kInteger|kSize)/,
+    name: "support.constant.formatting.fxscript"},
+   {match: /(?i:false|kAlpha|kNone|kUndefined|true)\b/,
+    name: "support.constant.general.fxscript"},
+   {match: 
+     /(?i:kKeyAdd|kKeyDarken|kKeyDifference|kKeyHardLight|kKeyLighten|kKeyMultiply|kKeyNormal|kKeyOverlay|kKeyScreen|kKeySoftLight|kKeySubtract)/,
+    name: "support.constant.key.fxscript"},
+   {match: 
+     /(?i:k16mm|k24fps|k25fps|k30df|k30fps|k35mm|k60df|k60fps|kFloat2|kFloat4|kFloat6|kInteger|kSize)/,
+    name: "support.constant.formatting.fxscript"},
+   {match: 
+     /\b(?i:clip1|clip2|dest|duration|exposedBackground|fieldNumber|fieldprocessing|fps|frame|linearRamp|previewing|ratio|renderRes|RGBtoYUV|src1|src2|srcIsGap1|srcIsGap2|srcType1|srcType2|topfield|YUVtoRGB)\b/,
+    name: "support.variable.predeclared.fxscript"},
+   {match: 
+     /(?i:kbold|kbolditalic|kcenterjustify|kitalic|kleftjustify|kplain|krightjustify)/,
+    name: "support.constant.text.fxscript"},
+   {match: /(?i:kDiamond|kRound|kSquare)/,
+    name: "support.constant.shapes.fxscript"},
+   {captures: 
+     {1 => {name: "entity.name.function.color.alpha.fxscript"},
+      2 => {name: "entity.name.function.color.red.fxscript"},
+      3 => {name: "entity.name.function.color.green.fxscript"},
+      4 => {name: "entity.name.function.color.blue.fxscript"},
+      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/},
+   {begin: /"/,
+    beginCaptures: 
+     {0 => {name: "punctuation.definition.string.begin.fxscript"}},
+    end: "\"",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.fxscript"}},
+    name: "string.quoted.double.fxscript",
+    patterns: [{match: /\\./, name: "constant.character.escape.fxscript"}]},
+   {match: 
+     /\b(?i:Add|AddOffset|Darken|Difference|ImageAnd|ImageOr|ImageXor|Invert|InvertChannel|Lighten|Matte|Multiply|Overlay|Screen|Subtract|UnMultiply)\b/,
+    name: "support.function.composite.fxscript"},
+   {match: 
+     /\b(?i:Blit|BlitRect|MaskCopy|MeshBlit|MeshBlit3D|PagePeel|RegionCopy)\b/,
+    name: "support.function.blit.fxscript"},
+   {match: /\b(?i:GetLimits|GetReelName|GetTimeCode|GetVideo)/,
+    name: "support.function.clip.fxscript"},
+   {match: 
+     /\b(?i:BumpMap|Cylinder|Displace|Fisheye|OffsetPixels|PondRipple|Ripple|Wave|Whirlpool)\b/,
+    name: "support.function.distort.fxscript"},
+   {match: /\b(?i:Filter|Generator|Transition)\b/,
+    name: "support.function.external.fxscript"},
+   {match: 
+     /\b(?i:AngleTo|AspectOf|BoundsOf|CenterOf|Convert2dto3d|convert3dto2d|DimensionsOf|DistTo|Grid|Interpolate|Mesh)\b/,
+    name: "support.function.geometry.fxscript"},
+   {match: /\b(?i:BGDiff|BlueScreen|GreenScreen|RGBColorKey|YUVColorKey)\b/,
+    name: "support.function.key.fxscript"},
+   {match: /\b(?i:Abs|Integer|Sign|Sqrt|Power)\b/,
+    name: "support.function.math.fxscript"},
+   {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/,
+    name: "support.function.process.fxscript"},
+   {match: 
+     /\b(?i:CurveTo|DrawSoftDot|FillArc|FillOval|FillPoly|FillRegion|FrameArc|FrameOval|FramePoly|FrameRegion|Line|MakeRect|MakeRegion|OvalRegion|RegionIsEmpty)\b/,
+    name: "support.function.shapes.process.fxscript"},
+   {match: 
+     /\b(?i:ASCIIOf|ASCIIToSTring|CharsOf|CountTextLines|FindString|getTextLine|GetTimecodeStringFromClip|Length|NumToString|StringToNum)/,
+    name: "support.function.string.fxscript"},
+   {match: 
+     /\b(?i:DrawString|DrawStringPlain|MeasureString|MeasureStringPlain|ResetText|SetTextFont|SetTextJustify|SetTextSize|SetTextStyle)/,
+    name: "support.function.text.fxscript"},
+   {match: /\b(?i:Offset|Offset3d|Outset3d|Rotate|Rotate3d|Scale|Scale3d)\b/,
+    name: "support.function.transform.fxscript"},
+   {match: 
+     /\b(?i:getNativeAspect|getNativeSize|FilteredBlitRect|BlurChannel_alt)\b/,
+    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/,
+    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/,
+    name: "support.function.joe.fxscript"}],
+ scopeName: "source.fxscript",
+ uuid: "43751327-3FD1-4BE7-AD05-136FC552BABA"}

data/config/syntax/Fortran - Modern.rb

@@ -0,0 +1,147 @@
+# Encoding: UTF-8
+
+{comment: "Specificities of Fortran >= 90",
+ fileTypes: ["f90", "F90", "f95", "F95", "f03", "F03", "f08", "F08"],
+ firstLineMatch: "(?i)-[*]- mode: f90 -[*]-",
+ foldingStartMarker: 
+  /(?x)				# extended mode
+	^\s*						# start of line and some space
+	(?i:						# case insensitive match
+	(
+	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(
+	)
+	 		|					# ...or...
+	(
+	[a-z]*(?<!end)\s*(function|subroutine)	# possibly some letters, but not the word end, and a space, then function
+	)
+	)
+	.*$						# anything until the end of the line
+	/,
+ foldingStopMarker: 
+  /(?x)				# extended mode
+	^\s*						# start of line and some space
+	(?i:(end))				# the word end, was insensitive
+	.*$						# anything until the end of the line
+	/,
+ 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:					# extended mode
+	^
+	\s*					# start of line and possibly some space
+	(?i:(interface))		# 1: word interface
+	\s+					# some space
+	(?i:(operator|assignment))		# 2: the words operator or assignment
+	\(					# opening parenthesis
+	((\.[a-zA-Z0-9_]+\.)|[\+\-\=\/\*]+)	# 3: an operator
+	
+	\)					# closing parenthesis
+	)/,
+    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:					# extended mode
+	^
+	\s*					# start of line and possibly some space
+	(?i:(interface))		# 1: word interface
+	\s+					# some space
+	([A-Za-z_][A-Za-z0-9_]*)	# 1: name
+	)/,
+    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:			# extended mode
+	^\s*			# begining of line and some space
+	(?i:(type))	# 1: word type
+	\s+			# some space
+	([a-zA-Z_][a-zA-Z0-9_]*)	# 2: type name
+	)/,
+    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.rb

@@ -0,0 +1,257 @@
+# Encoding: UTF-8
+
+{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:		# extended mode
+	^\s*						# start of line and some space
+	(?i:						# case insensitive match
+	(
+	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(
+	)
+	|					# ...or...
+	(
+	[a-z]*(?<!end)\s*(function|subroutine)	# possibly some letters, but not the word end, and a space, then function
+	)
+	)
+	.*$						# anything until the end of the line
+	)/,
+ foldingStopMarker: 
+  /(?x:		# extended mode
+	^\s*				# start of line and some space
+	(?i:(end))		# the word end, case insensitive
+	.*$				# anything until the end of the line
+	)/,
+ 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:					# extended mode
+	^
+	\s*					# start of line and possibly some space
+	([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
+	\s+					# some space
+	([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
+	)/,
+    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"}