GDL.sublime-syntax

%YAML 1.2
---
# See the DOCS: http://www.sublimetext.com/docs/3/syntax.html
# See the REPO: https://github.com/runxel/GDL-sublime
author: Lucas Becker  mail@wilu.be
name: GDL
file_extensions: gdl
scope: source.gdl

variables:
  escaped_byte: '\\(n|t|\\)?'
  units: '(e|(m|c|d)?m|f(f|d)?i|d(f|i)|pt|sq(mm?|cm|f|i)|d(d|ms)|gr|rad|surv|(ga)?l|cu((c|m)?m|f|i|y))'
  subroutine_name: ([0-9]+|(")[a-z_0-9]+("))
  function_names: |-
    (NOT|ABS|CEIL|INT|FRA|ROUND_INT|SGN|ACS|ASN|ATN|COS|SIN|TAN|EXP|LGT|LOG|SQR|MAX|MIN|RND
      |STR\{2\}|STR|SPLIT|STW|STRLEN|STRSTR|STRSUB|STRTOUPPER|STRTOLOWER|VARDIM[12]|BITTEST|BITSET
      |REQ((UEST)(\{[2-4]\})?)?|IND|NTR|VARTYPE|(HAS|REMOVE)KEY)
  addon_function_names: ((INIT|CLOSE)ADDONSCOPE|(CALL|PREPARE)FUNCTION)
  identifier_continue: '[[:alnum:]_]'
  identifier: '\b[[:alpha:]_]{{identifier_continue}}*\b'


contexts:
  main:
    - include: arrays
    - include: global
    - include: hots
    - include: transform
    - include: methods
    - include: attributes
    - include: buffer
    - include: buffer-in
    - include: func
    - include: gdl-globals
    - include: optional
    - include: easyparams
    - include: expression-common      # needs to be last bc of brackets
    - include: dotted-names
    - include: generic-names

# Included in all contexts by default:
# except where - meta_include_prototype: false
  prototype:
    - include: comments

################ General ##################

  comments:
    - match: '!'
      scope: punctuation.definition.comment.gdl
      push:
        - meta_scope: comment.line.gdl
        - match: $\n?
          pop: true

  global:
    - include: subs
    - include: operators
    - include: operators-word
    - include: operators-logical
    - include: escaped-byte
    - include: string
    - include: line-continuation
    - include: statements
    - include: controls

############### Subroutines #################
  subs:
    - match: (?i)(?<=^){{subroutine_name}}(?=:($|\s))
      scope: entity.name.function.gdl
      push:
      - match: ':'
        scope: punctuation.section.function.begin.gdl
        pop: true


#############################################
  operators:
    - match: \+|\-|\^|\*|\/|=|(<|>)=?|<>|\#
      scope: keyword.operator.gdl

  operators-word:
    - match: (?i)\b(MOD|AND|OR|EXOR)\b
      scope: keyword.operator.word.gdl

  operators-logical:
    - match: (%|&|\||@)
      scope: keyword.operator.logical.gdl

  escaped-byte:
    - match: '{{escaped_byte}}'
      scope: constant.character.escape.gdl

  string:
    # strings should not be affected by comments
    - match: '"'
      scope: punctuation.definition.string.begin.gdl
      push:
        - meta_include_prototype: false
        - meta_scope: string.quoted.double.gdl
        - match: '"'
          scope: punctuation.definition.string.end.gdl
          pop: true
        - include: escaped-byte
        - include: string_placeholder
        - include: request-param-deprecated
        - include: request-param
        - include: autotext
        - include: optional
        - include: easyparams
    - match: "'"
      scope: punctuation.definition.string.begin.localized.gdl
      push:
        - meta_include_prototype: false
        - meta_scope: string.quoted.single.gdl
        - match: "'"
          scope: punctuation.definition.string.end.localized.gdl
          pop: true
        - include: escaped-byte
        - include: string_placeholder
        - include: request-param-deprecated
        - include: request-param
        - include: autotext
        - include: optional
    - match: "`"
      scope: punctuation.definition.string.begin.localized.gdl
      push:
        - meta_include_prototype: false
        - meta_scope: string.quoted.single.gdl
        - match: "`"
          scope: punctuation.definition.string.end.localized.gdl
          pop: true
        - include: escaped-byte
        - include: string_placeholder
        - include: request-param-deprecated
        - include: request-param
        - include: autotext
        - include: optional

  string_placeholder:
    - match: |-
        (?x)%                     # always begins with %
          ((\#|~|\*|\^|\+|-|\s)*  # atleast one marker
          (\d+)?                  # might have number with...
          (\.)?                   # ...decimal point
          (\d+)                   # at least one number
          {{units}}?              # unitmarker possible
          |{{units}}              # unit alone
          |(~|\.|n|s))?           # possible without number and unit
      scope: constant.other.placeholder.gdl

  autotext:
    - match: |-
        (?ix)(<(
          project(name|number|status)|dateOfIssue|
          site(fullAddress|address[1-3]|city|state|postcode|country)|
          keywords|notes|
          (architect(name|position|company|fullAddress|address[1-3]|city|state|postcode|country|email|phone|fax|web)|
          cadTechnician|
          (client(name|company|fullAddress|address[1-3]|city|state|postcode|country|email|phone|fax))|
          (short|long)date)|time|lastSaved(at|by)|
          (file(name|path)|layout(name|ID|number)|subset(name|ID)|drawing(name|ID|scale)|originalScale|magnification|renovationFilter|
          marker(sheet|drawing)number(90|110)?|backRefSheetNumber)(_R)?|
          numOfLayouts|change(ID|description)|
          revisionID|(current)?issue(ID|description|date|dby)|currentRevisionID
          )>)
      scope: constant.other.autotext.gdl

  line-continuation:
    - match: (?<=\s)(:)
      scope: punctuation.separator.continuation.inline.gdl

  statements:
    - match: \b(true|false)\b
      scope: constant.language.gdl

    - match: (?i)\b(\!NOCONTOUR|BAS|BOX|CONT|FILLA|FILTER|GDLBIN|HIP_ROOFS|(LIN|NOD)(E)?|ORIGO|PARS|PAUSE|PLOTMAKER|PLOTTER|RECT_|SFLINE|TET(RA)?|TRI|UI_(CANCEL|OK)|VOCA|WALL_)\b
      scope: invalid.deprecated.gdl

  controls:
    - match: (?i)(?<=^|\s)((END)?GROUP)\b
      scope: keyword.control.group.gdl

    - match: (?i)(?<=^|\s)(GOTO|RETURN|EXIT|BREAKPOINT|END)\b
      scope: keyword.control.flow.gdl

    - match: (?i)(?<=^|\s)GOSUB
      scope: keyword.control.flow.gdl
      push:
        - meta_scope: meta.function-call.gdl
        - match: (?i)({{subroutine_name}})
          scope: variable.function.gdl
          pop: true
        - include: main
        - match: (?i)\b(\w+)\b
          scope: variable.gdl
          pop: true

    - match: (?i)(?<=^|\s)(FOR|TO|NEXT|DO|(END)?WHILE|REPEAT|UNTIL)\b
      scope: keyword.control.flow.gdl

    - match: (?i)(?<=^|\s)((END)?IF|THEN|ELSE)\b
      scope: keyword.control.conditional.gdl

  number:
    # handles integer and decimal numbers
    - match: |-
        \b(?x:
          -?         # an optional minus
          (?:
            0        # a zero
            |        # ...or...
            [1-9]    # a 1-9 character
            \d*      # followed by zero or more digits
          )
          (?:
            (?:
              \.     # a period
              \d+    # followed by one or more digits
            )?
            (?:
              [eE]   # an e character
              [+-]?  # followed by optional +/-
              \d+    # followed by one or more digits
            )?       # exponent optional
          )?         # decimal portion optional
        )
      scope: constant.numeric.gdl

  expression-common:
    - include: number
    - match: \(
      scope: punctuation.section.group.begin.gdl
      push:
        - meta_scope: meta.group.gdl
        - match: \)
          scope: punctuation.section.group.end.gdl
          pop: true
        - match: ','
          scope: punctuation.separator.gdl
        - include: main
    - match: \)
      scope: invalid.illegal.stray.brace.round.gdl
    - match: \]
      scope: invalid.illegal.stray.brace.square.gdl
    - match: \}
      scope: invalid.illegal.stray.brace.curly.gdl

  dotted-names:
    - match: '(\.)(?={{identifier}})'
      captures:
        1: punctuation.accessor.dot.gdl
      push:
        - include: arrays
        - include: generic-names
        - match: ''
          pop: true

  generic-names:
    - match: '{{identifier}}'
      scope: meta.generic-name.gdl

################ Hotspots ##################
  hots:
    - match: (?i)\b(HOTSPOT[2]?|HOTLINE[2]?|HOTARC[2]?)\b
      scope: keyword.hotedits.gdl

################ Transform ##################
  transform:
    - match: (?i)\b(ADD[2XYZ]?|ROT[2XYZ]?|MUL[2XYZ]?|XFORM|DEL(\sTOP)?)\b
      scope: keyword.transform.gdl

################ METHODS ##################
  methods:
    - include: methods-2d
    - include: methods-3d

  ################ 2D #################
  methods-2d:
    - match: (?i)(?<=^|\s)((LINE|RECT|ARC|CIRCLE|WALLLINE[2]?|WALLARC)2|SPLINE2[A]?|(PICTURE|WALLHOLE|WALLBLOCK)2(\{2\})?|POLY2(_?(A|B(\{[2-6]\})?)?))(?=$|\s)
      scope: keyword.shape.2D.gdl

    - match: (?i)(?<=^|\s)((TEXT|RICHTEXT)2)(?=$|\s)
      scope: keyword.text.2D.text.gdl

  ################ 3D #################
  methods-3d:
    - match: (?i)(?<=^|\s)(BLOCK|BRICK|CYLIND|CONE|SPHERE|ELLIPS|ELBOW|ARMC|ARME)(?=$|\s)
      scope: keyword.shape.3D.basic.gdl

    - match: (?i)(?<=^|\s)((PLANE|POLY)(_?)|ARC|CIRCLE|LIN_|RECT)(?=$|\s)
      scope: keyword.shape.3D.planar.gdl

    - match: (?i)(?<=^|\s)(SLAB(_?)|CSLAB_|CROOF_(\{[2-4]\})?|[CB]WALL_|XWALL_(\{[23]\})?|BEAM|MESH|POLYROOF(\{[2-4]\})?)(?=$|\s)
      scope: keyword.shape.3D.complex.gdl

    - match: (?i)(?<=^|\s)(BASE|BODY|COOR(\{[23]\})?|EDGE|PGON(\{[23]\})?|PIPG|TEVE|VECT|VERT(\{2\})?)(?=$|\s)
      scope: keyword.shape.3D.primitive.gdl

    - match: (?i)(?<=^|\s)(POINTCLOUD)(?=$|\s)
      scope: keyword.shape.3D.pointcloud.gdl

    - match: (?i)(?<=^|\s)(PRISM_?|[BFH]PRISM_|[CS]PRISM_(\{[234]\})?)(?=$|\s)
      scope: keyword.shape.3D.prisms.gdl

    - match: (?i)(?<=^|\s)(PYRAMID|RULED(\{2\}|SEGMENTED(\{2\})?)?|EXTRUDE|SWEEP|TUBE([A]|\{2\})?|MASS(\{2\})?|COONS(\{2\})?|REVOLVE(\{[2-5]\})?|(EXTRUDED|REVOLVED|RULED)SHELL(\{[23]\})?|REVOLVEDSHELLANGULAR(\{[23]\})?)(?=$|\s)
      scope: keyword.shape.3D.poly.gdl

    - match: (?i)(?<=^|\s)(CUT(PLANE(\{[2-4]\})?|POLY[A]?|FORM(\{2\})?|SHAPE|END)|WALL(HOLE|NICHE))(?=$|\s)
      scope: keyword.shape.3D.cut.gdl

    - match: (?i)(?<=^|\b)((place|kill)group|(add|isect|sub)group(\{[23]\})?|sweepgroup(\{[2-5]\})?|isectlines|creategroupwithmaterial)(?=$|\s|\()
      scope: keyword.shape.3D.seo.gdl

    - match: (?i)(?<=^|\s)(TEXT|RICHTEXT)(?=$|\s)
      scope: keyword.shape.3D.text.gdl

    - match: (?i)(?<=^|\s)(LIGHT|PICTURE|BINARY)(?=$|\s)
      scope: keyword.shape.3D.other.gdl

    - match: (?i)(?<=^|\s)(NURBS(CURVE[23]D|(SUR)?FACE|VERT|EDGE|TRIM(SINGULAR)?|LUMP|BODY))(?=$|\s)
      scope: keyword.shape.nurbs.gdl

    - match: (?i)(?<=^|\s)(FRAGMENT[2]?|PROJECT2(\{[2-4]\})?|DRAWING(2|3(\{[2-3]\})?))(?=$|\s)
      scope: keyword.symbol.gdl

############### Attributes #################
  attributes:
    - include: ident-keyword
    - include: attribute-set
    - include: attribute
    - include: model
    - include: shadow
    - include: nongeo

  ident-keyword:
    - match: (?i)(?<=^|\s)(LET|DIM|DICT)(\b)
      scope: storage.type.ident-keyword.gdl

  attribute-set:
    - match: (?i)\b(DEFINE|SET|BASED_ON)\b
      scope: storage.type.function.gdl

  attribute:
    - match: |-
        (?ix)\b(PEN|RESOL|RADIUS|TOLER|MODEL|SHADOW|DRAWINDEX|LINE_(TYPE|PROPERTY)|
          |SYMBOL_(LINE|FILL)|FILL[A]?|(SOLID|EMPTY|TRANSLUCENT|IMAGE|(LINEAR|RADIAL)_GRADIENT)_FILL|
          |FILLTYPES_MASK|(BUILDING_)?MATERIAL|TEXTURE|STYLE(\{2\})?|(END)?PARAGRAPH|
          |TEXTBLOCK_?|ADDITIONAL_DATA|SECT_(FILL|ATTRS(\{2\})?))
          (?=$|\s)
      scope: support.type.attribute.gdl

  model:
    - match: (?i)\b(SOLID|SURFACE|WIRE)\b
      scope: support.other.variable.model.gdl

  shadow:
    - match: (?i)\b(ON|OFF|AUTO)\b
      scope: support.other.variable.shadow.gdl

  range:
    - match: (?i)\b(RANGE)(?=\s)
      scope: keyword.nongeo.parameters.range.gdl

  nongeo:
    - match: (?i)\b(VALUES(\{2\})?|STEP|(RETURNED_)?PARAMETERS|LOCK|HIDEPARAMETER|PARVALUE_DESCRIPTION|(PROFILE|FILL)TYPES_MASK)(?=$|\s)
      scope: keyword.nongeo.parameters.gdl

    - include: range
    - match: (?i)(?<=RANGE)\s(\(|\[)
      scope: punctuation.section.range.left-delimiter.gdl
      push:
        - meta_scope: meta.section-range.gdl
        - match: (\)|\])
          scope: punctuation.section.range.right-delimiter.gdl
          pop: true
        - match: ','
          scope: punctuation.separator.arguments.gdl
        - include: main

    - match: (?i)\b(CUSTOM)\b
      scope: support.other.variable.parameters.custom.gdl

    - match: (?i)(?<=hideparameter\s)(\s*all)\b
      scope: support.other.variable.parameters.all.gdl

    - match: (?i)\b(UI_(Next|Prev|Function|Link))\b
      scope: support.other.variable.ui.gdl

    - match: (?i)\b((REF\s+)?(COMPONENT|DESCRIPTOR)|BINARYPROP|DATABASE_SET|POSITION|REF_(COMPONENT|DESCRIPTOR)|(SURFACE|VOLUME)3D|DRAWING[2]?)\b
      scope: keyword.nongeo.properties.gdl

    - match: |-
        (?ix)\b(UI_(dialog|(current_)?page|button|pict(_button)?|separator|groupbox|style|outfield|tooltip|listfield|
          infield(\{[2-4]\})?|
          ((pict_)?radiobutton|pict_pushcheckbutton|listitem|colorpicker|slider|textstyle_infield|custom_popup_(infield|listitem))(\{[2]\})?))
          (?=$|\s)
      scope: keyword.nongeo.ui.gdl

    - match: (?i)\b(MIGRATIONWARNING|NEWPARAMETER|SETMIGRATIONGUID|DELETED_PAR_VALUE|STORED_PAR_VALUE)\b
      scope: keyword.nongeo.migration.gdl

    - match: (?i)\b(PRINT|OUTPUT|CLOSE|CALL|FILE_DEPENDENCE)\b
      scope: keyword.extern.gdl

    - match: (?i)\b({{addon_function_names}})\b
      scope: keyword.addon.gdl

    - match: (?i)((OPEN|INPUT)\s?(?=\())
      captures:
        2:  keyword.extern.gdl
      push:
        - match: \(
          scope: punctuation.section.arguments.begin.gdl
          set:
          - match: \)
            scope: punctuation.section.arguments.end.gdl
            pop: true
          - match: ','
            scope: punctuation.separator.arguments.gdl
          - include: func
          - include: operators
          - include: expression-common
          - include: string
          - include: arrays

############### Params #################
  optional:
    - match: (?i)\b([ABCDEFG]|ZZYZX|(ac|gs|ifc|ROOM|FM)_\w+)\b
      scope: keyword.optionalparameters.fixed.gdl

  easyparams:
    - match: (?i)\b((x|y|z)_\w+)\b
      scope: meta.parameters.length.gdl
    - match: (?i)\b((i|int)_\w+)\b
      scope: meta.parameters.integer.gdl
    - match: (?i)\b((f|float|real)_\w+)\b
      scope: meta.parameters.float.gdl
    - match: (?i)\b(ang_\w+)\b
      scope: meta.parameters.angle.gdl
    - match: (?i)\b((b|bool)_\w+)\b
      scope: meta.parameters.bool.gdl
    - match: (?i)\b(str_\w+)\b
      scope: meta.parameters.string.gdl
    - match: (?i)\b(fill_\w+)\b
      scope: meta.parameters.fill.gdl
    - match: (?i)\b(mat_\w+)\b
      scope: meta.parameters.material.gdl
    - match: (?i)\b(pen_\w+)\b
      scope: meta.parameters.pen.gdl
    - match: (?i)\b((lt|line)_\w+)\b
      scope: meta.parameters.linetype.gdl
    - match: (?i)\b(bm_\w+)\b
      scope: meta.parameters.bmat.gdl
    - match: (?i)\b(prof_\w+)\b
      scope: meta.parameters.profile.gdl
    - match: (?i)\b(dict_\w+)\b
      scope: meta.parameters.dict.gdl
    - match: (?i)\b(g_\w+)\b
      scope: meta.parameters.flag.gdl
    - match: (?i)\b(id(x)?_\w+)\b
      scope: meta.parameters.index.gdl

############### GDL globals #################
  gdl-globals:
    - include: gdl-global-param
    - include: request-param
    - include: request-param-deprecated
    - include: globals-deprecated
    - match: (?i)\b(APPLICATION_QUERY|LIBRARYGLOBAL)\b
      scope: keyword.request.gdl

  gdl-global-param:
    - match: |-
        (?ix)\b(GLOB_(SCRIPT_TYPE|CONTEXT|SCALE|DRAWING_BGD_PEN|MODPAR_NAME|WORLD_ORIGO_OFFSET_[XY]
          |FRAME_NR|(FIRST|LAST)_FRAME|(EYE|TARG)POS_[XYZ]|SUN_A(ZIMUTH|LTITUDE)|UI_BUTTON_ID|CUTPLANES_INFO
          |STRUCTURE_DISPLAY|VIEW_TYPE|(PREVIEW|FEEDBACK|SEO_TOOL|DIAGNOSTICS)_MODE))
          \b
      scope: keyword.globals.general.gdl

    - match: (?i)\b(GLOB_([HC]STORY_(ELEV|HEIGHT)|CH_STORY_DIST))\b
      scope: keyword.globals.story.gdl

    - match: (?i)\b(GLOB_(LAYER|ID|INT(GU)?ID|ELEVATION|ELEM_TYPE))\b
      scope: keyword.globals.elementparameters.gdl

    - match: (?i)\b(SYMB_((LINETYPE|FILL(_PEN)?)|(FBGD|SECT|VIEW)+_PEN|MAT|POS_[XYZ]|ROTANGLE|MIRRORED|[ABZ]+_SIZE))\b
      scope: keyword.globals.objectparameters.gdl

    - match: |-
        (?ix)\b(WIDO_(REVEAL_(ON|SIDE)|SILL(_HEIGHT)?|(R|OPR)SIDE_SILL_HEIGHT|(RIGHT|LEFT)_JAMB|(THRES|HEAD)_DEPTH|((R|OPR)SIDE_)?HEAD_HEIGHT
          |(FRAME|SUBFL)_THICKNESS|POSITION|ORIENTATION|MARKER_TXT|PREFIX|CUSTOM_MARKER|ORIG_DIST|PWALL_INSET|(N_)?(R|OPR)SIDE_(WIDTH|HEIGHT|SURF)|VOLUME|GROSS_(SURFACE|VOLUME)))
          \b
      scope: keyword.globals.window.gdl

    - match: |-
        (?ix)\b(LABEL_
          (Position|Custom_Arrow|Arrow((Head)?_Pen|_LINETYPE)
          |Font_(Name|Style(2)?)
          |Text_(Size|(BG_)?Pen|Align|Leading|Width_Fact|Wrap|Charspace_Fact)
          |Wrap_Text|Charspace_Fact|Frame_(On|Offset)
          |Anchor_Pos|Rotangle|Always_Readable
          |Has_Pointer
          |Assoc_Elem_(Orientation|Geometry)
        ))\b
      scope: keyword.globals.label.gdl

    - match: |-
        (?ix)(?<=^|\s|\+|\-|\^|\*|\*\*|\/|\=|<|>|<\=|>\=|<>|\#)
          (WALL_((INTGU)?ID|RESOL|((START|END)_)?THICKNESS|INCL|((MIN|MAX)_)?HEIGHT|MAT_(A|B|EDGE)|LINETYPE|FILL(_PEN)?
          |(COMPS|BMAT)_NAME|SKINS_(PARAMS|NUMBER|BMAT_NAMES)|BMAT|(SECT|VIEW|FBGD)_PEN|DIRECTION|POSITION|(LENGTH|(GROSS_)?SURFACE)_[AB](_CON)?|CENTER_LENGTH|AREA|PERIMETER
          |EDGE_SURF|GROSS_VOLUME|VOLUME(_[AB])?(_CON)?|(DOORS|WINDS|HOLES|COLUMNS)_NR|(DOORS|WINDS)_SURF|HOLES_(SURF(_[AB])?|VOLUME)|(WINDS|DOORS)_WID|CROSSSECTION_TYPE
          |SKIN_((MIN|MAX)_HEIGHT|THICKNESS)_(A|B)|(INSU|AIR)_THICKNESS|Texture_Wrap
          |Flipped))\b
      scope: keyword.globals.wall.gdl

    - match: |-
        (?ix)\b(COLU_(CORE(_(X|Y|FILL(_PEN)?|FBGD_PEN|((GROSS|TOP|BOT)_)?SURF|(GROSS_)?VOL|GROSS_TOPBOT_SURF|BMAT(_NAME)?))?
          |VENEER_(FILL(_PEN)?|FBGD_PEN|WIDTH|VOL|(TOP_|BOT_)?SURF|GROSS_((TOPBOT_)?SURF|VOL)|BMAT(_NAME)?)|((MIN|MAX)_)?HEIGHT|DIM[12]|MAT|LINETYPE|(SECT|VIEW)_PEN
          |PERIMETER|AREA|(GROSS_)?VOLUME|CROSSSECTION_TYPE|PROFILE_NAME|SEGMENT_(INDEX|INFO)))
          \b
      scope: keyword.globals.column.gdl

    - match: |-
        (?ix)\b(BEAM_(
          Thickness|Height|Refline_Offset|Priority
          |Mat_(Right|Left|Top|Bottom|End)
          |Bmat(_Name)?|(Outline|Axes)_Linetype
          |Fill(_Pen)?|(Sect|FBGD)_Pen
          |Direction|Position|Length_(Right|Left)
          |(Right|Left|Top|Bottom|End)_Surf
          |Volume(_Con)?
          |Hole(s_(Nr|Surf|Volume)|_Edge_Surf)
          |Crosssection_Type|Profile_Name
          |Segment_(Index|Info)
          |Elevation_(Top|Bottom)))
          (?=$|\s)
      scope: keyword.globals.beam.gdl

    - match: |-
        (?ix)\b(SLAB_(THICKNESS|MAT_(TOP|EDGE|BOTT)|LINETYPE|FILL(_PEN)?|ELEVATION_(TOP|BOTTOM)|BMAT(_NAME)?|(FBGD|SECT|VIEW)+_PEN|COMPS_NAME|SKINS_(NUMBER|PARAMS|BMAT_NAMES)
          |PERIMETER|(GROSS_)?(TOP|BOT|EDGE)_SURF|(TOP|BOT)_SURF_CON|VOLUME(_CON)?|GROSS_VOLUME|GROSS_((TOP|BOT|EDGE)_SURF|VOLUME)_WITH_HOLES|SEGMENTS_NR|HOLES_(NR|AREA|PRM)))
          \b
      scope: keyword.globals.slab.gdl

    - match: |-
        (?ix)\b(ROOF_(THICKNESS|ANGLE|MAT_(TOP|EDGE|BOTT)|LINETYPE|FILL(_PEN)?|BMAT(_NAME)?|(FBGD|SECT|VIEW)+_PEN|COMPS_NAME|SKINS_(NUMBER|PARAMS|BMAT_NAMES)
          |(GROSS_)?(TOP|BOTTOM|EDGE)_SURF|(TOP|BOTTOM)_SURF_CON|PERIMETER|VOLUME(_CON)?|GROSS_VOLUME|SEGMENTS_NR|HOLES_(NR|AREA|PRM)|CONTOUR_AREA|INSU_THICKNESS
          |RIDGE|VALLEY|GABLE|HIP|EAVES|PEAK|(SIDE|END)_WALL|TRANSITION_(DOME|HOLLOW)))
          \b
      scope: keyword.globals.roof.gdl

    - match: (?i)\b(FILL_(Linetype|Fill(_Pen|_Category)?|Pen|Bmat(_Name)?|FBGD_Pen|Surf|Perimeter|Segment_Nr|Holes_(Nr|Area|Prm)))\b
      scope: keyword.globals.fill.gdl

    - match: (?i)\b(MESH_((LINE)?TYPE|BASE_OFFSET|(USEREDGE|TRIEDGE|SECT|VIEW)_PEN|MAT_(TOP|EDGE|BOTT)|FILL(_PEN)?|BMAT(_NAME)?|FBGD_PEN|(TOP|EDGE|BOTTOM)_SURF|PERIMETER|VOLUME|SEGMENTS_NR|HOLES_(NR|AREA|PRM)))\b
      scope: keyword.globals.mesh.gdl

    - match: |-
        (?ix)\b(STAIR_(
          Area|Volume|Height|Walkline_Length
          |Default_(Width|Going_Depth|Riser_Height|Tread_Thickness)
          |Nr_of_(Risers|treads)(_in_Flights)?
          |Landing_Number|Stair_Gradient
          |Rule_(Limits|Flags)
          |(Start|End)_with_Riser
          |(Tread|Riser|Nosing)_Exist
          |Breakmark_Geometry
          ))\b
      scope: keyword.globals.stair.general.gdl

    - match: (?i)\b(TREAD_((FRONT_)?AREA|VOLUME|STEP_INDEX|ELEVATION|GOING|THICKNESS|BMATS|(LOWER|UPPER)_RISER_(THICKNESS|HEIGHT|SLANT_ANGLE)|NOSING(_METHOD|_BY_SLANTING)?)|STAIR_TREAD_(GEOMETRY|FLAGS))\b
      scope: keyword.globals.stair.tread.gdl

    - match: (?i)\b(RISER_(FRONT_AREA|VOLUME|STEP_INDEX|WIDTH|HEIGHT|THICKNESS|BMATS|CUT|SLANT_ANGLE)|STAIR_RISER_GEOMETRY)\b
      scope: keyword.globals.stair.riser.gdl

    - match: (?i)\b(STRUCTURE_(3DLENGTH|VOLUME|WIDTH|HEIGHT|THICKNESS)|STAIR_(STRUCTURE_(GEOMETRY|FLAGS|CONN_(OFFSETS|FLAGS))|STRINGER_PATH_OFFSET))\b
      scope: keyword.globals.stair.structure.gdl

    - match: |-
        (?ix)\b(STAIR2D_(
          (Full|Lower|Middle|Upper)_((TPolygon|RPolyline|Walkline)_(Geom|Flags)|Boundary_Geom)
          |Full_SPoly(gon|line)_(Geom|Flags)
          |Breakmark_(Geom|Flags|Angle)
          |(Ext_(TPolygon|RPOlyline)|Drain_TPolygon|Polylines)_(Geom|Flags)
          |(Struct|Monolith)_Attributes
          |Layout_Types|Description_Position
          |Currstory_Location|Visibility|Customdisplay
          ))\b
      scope: keyword.globals.stair.2D.gdl

    - match: |-
        (?ix)\b(
          RAILING_(
            Height|(3D|Horizontal_)Length|Volume
            |Nr_of_(Segments|Posts|Balusters|Panels|Rails))
          |RAIL_Disconnected_Cuts)
          \b
      scope: keyword.globals.railing.general.gdl

    - match: |-
        (?ix)(RAIL(_(CONNECTING_POSTS(_NUM)?|TYPE|POLYLINE_GEOMETRY|SEGMENT_FLAGS|CUTS|COMPONENTS|SLANT_ANGLE)|ING(_REFLINE_DISTANCE|PANEL_(TYPE|(UNCUT_)?GEOMETRY|FLAGS|SIDE_OFFSETS
            |(SLANT|SKEW)_ANGLE)|POST_(TYPE|TOP_COORD|(SEGMENT_)?CUTS)|END_DIRECTION_AND_ANGLE)))
            \b
      scope: keyword.globals.railing.3D.gdl

    - match: (?i)\b(RAIL2D_((FULL|LOWER|MIDDLE|UPPER)_((POLY(LINE|GON)_(GEOM|FLAGS))|VISIBILITY)|CUSTOMDISPLAY)|RAILPOST2D_VISIBILITY)\b
      scope: keyword.globals.railing.2D.gdl

    - match: |-
        (?ix)\b(
          (CWALL_(
          ID
          |(((Contour|Mainaxis|Secaxis|Custom)_)?Frames_)?Length
          |Surf(_Boundary)?|Panels_(Surf(_([Nsew]|NE|NW|SE|SW))?|Nr)
          |Height|Slant_Angle|Thickness|Pattern_Angle))
          |(CWJunc|CWAcc)_Type
          |CW_Boundary_Placement
          )\b
      scope: keyword.globals.facade.general.gdl

    - match: |-
        (?ix)\b(CWFRAME_(
          Type|Class|Position|Direction
          |Width|Depth|Length|Mat
          |(Top|Bottom)_Cut(type|plane|polyline)
          ))\b
      scope: keyword.globals.facade.profile.gdl

    - match: (?i)\b(CWPANEL_(TYPE|CLASS|(VERTICAL|HORIZONTAL)_DIRECTION|(NOMINAL_)?(WIDTH|HEIGHT)|THICKNESS|(GROSS_|NOMINAL_)?SURF|PERIMETER|MAT_(OUTER|INNER|CUT)|FUNCTION|ORIENTATION))\b
      scope: keyword.globals.facade.panel.gdl

    - match: |-
        (?ix)\b(SHELLBASE_(THICKNESS|MAT_(REFERENCE|EDGE|OPPOSITE)|LINETYPE|FILL(_PEN)?|FBGD_PEN|(COMPS|BMAT)_NAME|BMAT|SKINS_(NUMBER|PARAMS|BMAT_NAMES)|(SECT|VIEW)_PEN
            |(COND_|GROSS_)?(REFERENCE|OPPOSITE)_SURF|(GROSS_)?EDGE_SURF|PERIMETER|(GROSS_|COND_)?VOLUME|HOLES_(NR|SURF|PRM)|OPENINGS_(NR|SURF)|INSU_THICKNESS
            |RIDGE|VALLEY|GABLE|HIP|EAVES|PEAK|(END|SIDE)_WALL|TRANSITION_(DOME|HOLLOW)))
            \b
      scope: keyword.globals.shell.gdl

    - match: (?i)\b(OPENING_(SYMBOL_(DISPLAY|BOUNDINGBOX|GEOMETRY)|POLYGON|HEIGHT|WIDTH|(HEADER|CENTER|SILL)HEIGHT_VALUES))\b
      scope: keyword.globals.opening.gdl

    - match: (?i)\b(MORPH_(LINETYPE|FILL(_PEN)?|BMAT(_NAME)?|FBGD_PEN|SECT_LINETYPE|(SECT|VIEW)_PEN|SOLID|MAT_DEFAULT|(CASTS|RECEIVES)_SHADOW|SURFACE|VOLUME|FLOOR_PERIMETER))\b
      scope: keyword.globals.morph.gdl

    - match: (?i)\b(LIGHT_(ON|RED|GREEN|BLUE|INTENSITY))\b
      scope: keyword.globals.light.gdl

    - match: |-
        (?ix)\b(
          GDL_WallZ_(Length|Surf|(Doors|Winds)_(Surf|Width))
          |(From|To)_Guid
          |Skyl_(Marker_Txt|Opening_(Surf|Volume|Height|Width)|(Header|Sill)_Height|Rotangle)
          |Marker_Head_(Rot_Mode|Angle)
          |GLOB_Fill_Index_(Background|Solid)
        )\b
      scope: keyword.globals.misc.gdl

    - match: (?i)\b(GLOB_MVO_(Stair_Floor_Plan_(Opt|Comp)|Railing_Plan_Comp|CW(Frame|Panel|Junct|Acc)_Detlevel))\b
      scope: keyword.globals.mvo.gdl

    - match: (?i)\b((GLOB_((Issue|Change)_Scheme))|Layout_((Revision|Change)_History|Current(Version|Revision)_Open))\b
      scope: keyword.globals.layout.gdl

    - match: (?i)\b(GLOB_(PROJECT_((LONG|LAT|ALT)ITUDE|DATE)|NORTH_DIR))\b
      scope: keyword.globals.project.gdl

    - match: (?i)\b(GLOB_USER_([1-9]|[1][0-9]|20))\b
      scope: keyword.globals.user.gdl

  request-param:
    - match: |-
        (?ix)\b(
          (Blue|Red|Green)_of_(Pen|Material)
          |RGB_Of_(Material|Pen)
          |GDL_Version|Model_Size|Pen_of_RGB
          |Program(_Info)?|(Serial|Configuration)_Number
          |Ancestry_Info
          |(Angular_(Length_)?|Area_|Radial_|Sill_Height_)Dimension
          |(Assocel|Matching)_Properties
          |Assoclp_(Name|Parvalue(_with_Description)?)
          |Calc_(Angle|Area|Length|Volume)_Unit
          |Clean_Intersections|Custom_Auto_Label
          |Datetime
          |(Elevation|Level|Linear)_Dimension
          |Fontnames_List|Height_of_Style
          |Home(_Story(_of_Opening)?|DB_Info)
          |Story(_Info)?
          |ID_of_Main|Full_ID_of_Parent
          |Name_of_(Fill|Line_Type|Listed|Macro|Main|Material|Plan|Program|Style|Building_Material|Profile)
          |Class_of_Fill
          |Reference_Level_Data
          |(Style|Textblock)_Info
          |Floor_Plan_Option|View_Rotangle
          |Window_(Door_(Dimension|Show_Dim|Zone_Relev(_of_Owner)?)|Show_Dim)
          |Door_Show_Dim
          |Zone_Relations_of_Owner
          |Working_(Angle|Length)_Unit|Zone_(Category|Colus_Area|Relations)
          |(Building_)?Material_Info|Component_(Projected_Area|Volume)
          |(Component_Ids|((Component_)?(Property_Value(s)?|Properties)))_Of_Parent|Property_Name
          |(Profile_(Components|Default_(Boundingbox|Geometry)|Component_Info))
          |((Model|Layout)_(length|text_size)_unit)
          |Autotext_List|Sum_with_rounding
          |Document_Feature
          )\b
      scope: keyword.globals.request.gdl

  request-param-deprecated:
    - match: |-
        (?ix)\b(Constr_Fills_Display|Internal_Id)\b
      scope: keyword.globals.deprecated.gdl

  globals-deprecated:
    - match: (?i)\b([A-Z](_\b|~))
      scope: keyword.globals.deprecated.gdl

################# Buffer ##################
  buffer-out:
    - match: (?i)\b(GET|USE)\b
      scope: keyword.buffer.gdl

  buffer:
    - include: buffer-out
    - match: (?i)(?<=(GET|USE))\s?\(
      scope: punctuation.section.buffer.begin.gdl
      push:
        - meta_scope: meta.buffer.gdl
        - match: \)
          scope: punctuation.section.buffer.end.gdl
          pop: true
        - include: main

  buffer-in:
    # now buffer coms without ()
    - match: (?i)(\b)(PUT|NSP)(\b)
      scope: keyword.buffer.gdl

############### FUNCTIONS #################
  func:
    - include: functions
    - include: functions-special

  functions:
    - match: (?ix)(({{function_names}})\s?(?=\())
      captures:
        2: keyword.other.special-method.functions.gdl
      push:
        - match: \(
          scope: punctuation.section.arguments.begin.gdl
          set:
          - match: \)
            scope: punctuation.section.arguments.end.gdl
            pop: true
          - match: ','
            scope: punctuation.separator.arguments.gdl
          - include: main

  functions-special:
  - match: (?i)(\b)(PI)(\b)
    scope: keyword.other.special-method.functions.gdl

################### Item Access ######################
  arrays:
    - include: gdl-global-param
    - match: (?i)(?=\[)
      push:
        - match: \[
          scope: punctuation.section.array.begin.gdl
          set:
          - meta_scope: section.array.gdl
          - match: \]
            scope: punctuation.section.array.end.gdl
            set: after-array
          - include: func
          - include: operators
          - include: expression-common
          - include: easyparams
          - include: string
          - include: arrays

  after-array:
    - match: \[
      scope: punctuation.section.array.begin.gdl
      set:                      # we want only one possible bracket
        - meta_scope: section.array.gdl
        - match: \]
          scope: punctuation.section.array.end.gdl
          pop: true
        - include: func
        - include: operators
        - include: expression-common
        - include: easyparams
        - include: string
    - match: ''                 # if no second bracket pop out
      pop: true