monkey2.sublime-syntax

%YAML1.2
---
# See http://www.sublimetext.com/docs/3/syntax.html
# http://www.rexegg.com/regex-quickstart.html
# http://regextutorials.com/index.html

# assumptions:
# contants: ALL_CAPS13!
# enums are constants

# single line IF blocks **must** use the keyword THEN. If this is not done,
# the if block is not closed properly.


name: Monkey2
file_extensions:
  - monkey2
scope: source.monkey2

contexts:
  main:
    - include: def-class
    - include: def-enum
    - include: def-function
    - include: def-interface
    - include: def-struct
    - include: block-extern
    - include: language
    - include: modules
    - include: variables

  body-class:
    - include: def-enum
    - include: def-function
    - include: def-method
    - include: def-property
    - include: def-operator
    - include: language
    - include: modules
    - include: variables

  body-struct:
    - include: def-enum
    - include: def-function
    - include: def-method-struct
    - include: def-property
    - include: def-operator
    - include: language
    - include: modules
    - include: variables

  body-enum:
    - include: language
    - include: modules
    - include: variables

  body-function:
    - include: language
    - include: modules
    - include: variables
    - include: def-lambda

  body-interface:
    - include: modules
    - include: line-comments
    - include: block-comments
    - match: ([Mm]ethod)\s+([A-Za-z]\w+)
      captures:
        1: keyword.monkey2
        2: entity.name.class.monkey2
    - match: ([Pp]roperty)\s+([A-Za-z]\w+)
      captures:
        1: keyword.monkey2
        2: entity.name.class.monkey2

    - include: def-parameters

  body-lambda:
    - include: language
    - include: modules
    - include: variables

  body-method:
    - include: language
    - include: modules
    - include: variables
    - include: def-lambda

  body-property:
    - include: language
    - include: modules
    - include: variables
    - include: def-parameters
    - match: \b(?i:Setter|Return)\b
      scope: keyword.monkey2
    - match: \b(?i:Override|Virtual|Final)\b
      scope: keyword.monkey2

  body-operator:
    - include: def-parameters
    - include: language
    - include: modules
    - include: variables

  language:
    - include: block-select
    - include: block-try
    - include: block-comments
    - include: block-if
    - include: line-comments
    - include: constants
    - include: keywords
    - include: monkey-functions
    - include: numerics
    - include: operators
    - include: strings
    - include: def-parameters
    - match: \)
      scope: invalid.illegal.stray-bracket-end

  parameters:
    - include: def-lambda
    - include: constants
    - include: modules
    - include: numerics
    - include: operators
    - include: strings
    - include: variables
    - include: monkey-functions
    - include: line-comments
    - match: \b(?i:Else|New)\b
      scope: keyword.monkey2

# ----------

  block-comments:
    - match: (?i:#rem)
      push:
      - meta_scope: comment.block.monkey2

      - match: (@param|@return|@hidden|monkeydoc)
        scope: constant.language.monkey2

      - include: block-comments

      - match: (?i:#end)
        pop: true

  block-if:
    - match: \b([Ii]f)\b
      scope: keyword.control.monkey2
      push:
        - meta_scope: meta.ifblock.monkey2
        - include: language
        - include: modules
        - include: variables

        - match: \b(?i:End\s*If|End|Then)\b
          scope: punctuation.section.ifblock.end.monkey2
          captures:
            0: keyword.control.monkey2
          pop: true

  block-extern:
    - match: ([Ee]xtern)
      scope: keyword.control.monkey2
      push:
        - meta_scope: meta.externblock.monkey2

        - match: \b(Public|Private)\b
          scope: punctuation.section.externblock.end.monkey2
          captures:
            0: keyword.monkey2
          pop: true

        - include: language
        - include: modules
        - include: variables
        - include: def-class

        - match: \b(?i:Function)
          scope: keyword.monkey2


  # select-blocks can contain select-blocks
  # so block selection is a bit different here, we must
  # absorb the keyword right away
  block-select:
    - match: \b([Ss]elect)\b
      scope: keyword.control.monkey2
      push:
        - meta_scope: meta.selectblock.monkey2
        - include: language
        - include: modules
        - include: variables

        - match: \b(?i:End\s+Select|End)\b
          scope: punctuation.section.selectblock.end.monkey2
          captures:
            0: keyword.control.monkey2
          pop: true

  block-try:
    - match: \b([Tt]ry)\b
      scope: keyword.control.monkey2
      push:
        - meta_scope: meta.tryblock.monkey2
        - include: language
        - include: modules
        - include: variables

        - match: \b(?i:End\s+Try|End)\b
          scope: punctuation.section.tryblock.end.monkey2
          captures:
            0: keyword.control.monkey2
          pop: true

  constants:
    - match: \b(?i:true|false)\b
      scope: constant.language.monkey2
    - match: \b([A-Z0-9_]+)\b
      scope: constant.language.monkey2

  line-comments:
    - match: "'.*$"
      scope: comment.line.monkey2

  def-class:
    - match: \b(?=[Cc]lass)\b
      push:
        - meta_scope: meta.class.monkey2
        - include: body-class

        - match: (([Cc]lass)\s+([A-Za-z]\w*))
          scope: meta.class.identifier.monkey2
          captures:
            2: keyword.monkey2
            3: entity.name.class.monkey2

        - match: \b(?i:abstract|extension|virtual|final|field|protected|static)\b
          scope: keyword.monkey2

        - match: \b(?i:extends)\s+([A-Za-z]\w+)\b
          scope: meta.class.modifier.monkey2
          captures:
            0: keyword.monkey2
            1: entity.other.inherited-class.monkey2

        # multiple interfaces possible
        # so using a block and using extend, modifiers and EOL to pop

        - match: (?=[Ii]mplements)
          push:
            - meta_scope: meta.interface.extend.monkey2

            - match: (?=[Ee]xtends|[Aa]bstract|[Ff]inal|$)
              scope: punctuation.section.interface.end.monkey2
              pop: true

            - match: (?i:Implements)
              scope: keyword.monkey2
            - match: ([A-Za-z]\w+)
              scope: entity.other.inherited-class.monkey2


        - match: \b(?i:end\s+class|end)\b
          scope: punctuation.section.class.end.monkey2
          captures:
            0: keyword.monkey2
          pop: true

  def-struct:
    - match: \b(?=[Ss]truct)\b
      push:
        - meta_scope: meta.struct.monkey2
        - include: body-struct

        - match: (([Ss]truct)\s+([A-Za-z]\w*))
          scope: meta.class.identifier.monkey2
          captures:
            2: keyword.monkey2
            3: entity.name.class.monkey2

        - match: \b(?i:abstract|extension|final|field|protected|static)\b
          scope: keyword.monkey2

        - match: \b(?i:end\s+struct|end)\b
          scope: punctuation.section.struct.end.monkey2
          captures:
            0: keyword.monkey2
          pop: true

  def-enum:
    - match: \b(?=[Ee]num)\b
      push:
        - meta_scope: meta.enum.monkey2
        - include: body-enum
        - match: (?i:enum)\s+(\w+)
          scope: meta.enum.identifier.monkey2
          captures:
            0: keyword.monkey2
            1: entity.name.class.monkey2

        - match: \b(?i:end\s+enum|end)\b
          scope: punctuation.section.enum.end.monkey2
          captures:
            0: keyword.monkey2
          pop: true

  def-function:
    - match: (?=[Ff]unction\s+([A-Za-z]\w+))
      push:
        - meta_scope: meta.function.monkey2

        - match: ([Ff]unction)\s+([A-Za-z]\w+)
          scope: meta.function.identifier.monkey2
          captures:
            1: keyword.monkey2
            2: entity.name.function.monkey2

        - include: body-function

        - match: \b(?i:end\s+function|end)\b
          scope: punctuation.section.function.end.monkey2
          captures:
            0: keyword.monkey2
          pop: true

  def-interface:
    - match: (?=[Ii]nterface\s+([A-Za-z]\w+))
      push:
        - meta_scope: meta.interface.monkey2
        - include: body-interface

        - match: (([Ii]nterface)\s+([A-Za-z]\w+))
          scope: meta.interface.identifier.monkey2
          captures:
            2: keyword.monkey2
            3: entity.name.class.monkey2

        # interface can extend multiple interfaces

        - match: (?=[Ee]xtends)
          push:
            - meta_scope: meta.interface.extend.monkey2

            - match: (?i:extends)
              scope: keyword.monkey2
            - match: ([A-Za-z]\w+)
              scope: entity.other.inherited-class.monkey2

            - match: $
              scope: punctuation.section.parameters.end.monkey2
              pop: true

        - match: \b(?i:end\s+interface|end)\b
          scope: punctuation.section.interface.end.monkey2
          captures:
            0: keyword.monkey2
          pop: true

  # lambda: essentially the same as functions
  # except no name

  def-lambda:
    - match: (?=[Ll]ambda)
      push:
        - meta_scope: meta.lambda.monkey2
        - include: def-parameters

        - match: (([Ll]ambda)\s*(:(\w+))?)
          scope: meta.lambda.identifier.monkey2
          captures:
            2: keyword.monkey2
            4: storage.type.class.monkey2
        - match: \b(?i:end\s+lambda|end)\b
          scope: punctuation.section.lambda.end.monkey2
          captures:
            0: keyword.monkey2
          pop: true

        - include: body-lambda

  def-method:
    - match: (?=[Mm]ethod\s+([A-Za-z]\w+))
      push:
        - meta_scope: meta.method.monkey2
        - match: ([Mm]ethod)\s+([A-Za-z]\w+)
          scope: meta.method.identifier.monkey2
          captures:
            1: keyword.monkey2
            2: entity.name.method.monkey2

        - match: \b(?i:abstract|final|override|virtual)\b
          scope: keyword.monkey2

        - include: body-method

        - match: \b(?i:end\s+method|end)\b
          scope: punctuation.section.method.end.monkey2
          captures:
            0: keyword.monkey2
          pop: true

  def-method-struct:
    - match: (?=[Mm]ethod\s+([A-Za-z]\w+))
      push:
        - meta_scope: meta.method.monkey2
        - match: ([Mm]ethod)\s+([A-Za-z]\w+)
          scope: meta.method.identifier.monkey2
          captures:
            1: keyword.monkey2
            2: entity.name.method-struct.monkey2

        - include: body-method

        - match: \b(?i:end\s+method|end)\b
          scope: punctuation.section.method.end.monkey2
          captures:
            0: keyword.monkey2
          pop: true

  def-parameters:
    - match: \(
      push:
        - meta_scope: meta.parameters.monkey2
        - include: parameters
        - include: def-parameters
        - match: \)
          scope: punctuation.section.parameters.end.monkey2
          pop: true

  def-operator:
    - match: (?=[Oo]perator|[Oo]perator [Tt]o)
      push:
        - meta_scope: meta.operator.monkey2
        - include: body-operator
        - match: ([Oo]perator|[Oo]perator [Tt]o)
          scope: meta.operator.identifier.monkey2
          captures:
            1: keyword.monkey2
        - match: \b(?i:end\s+operator|end)\b
          scope: punctuation.section.operator.end.monkey2
          captures:
            0: keyword.monkey2
          pop: true

  def-property:
    - match: (?=[Pp]roperty)
      push:
        - meta_scope: meta.property.monkey2
        - include: body-property

        - match: ([Pp]roperty)(\s+([A-Za-z]\w*))?
          scope: meta.property.identifier.monkey2
          captures:
            1: keyword.monkey2
            2: entity.name.property.monkey2

        - match: \b(?i:end\s+property|end)\b
          scope: punctuation.section.property.end.monkey2
          captures:
            0: keyword.monkey2
          pop: true

  keywords:
    - match: \b(?i:import|using|namespace|extern|alias|new|reflect)\b
      scope: keyword.monkey2

    - match: \b(?i:local|global|const)\b
      scope: keyword.monkey2

    - match: \b(?i:case|catch|continue|default|delete|eachin|else|elseif|exit|for|forever|next|private|public|repeat|return|step|throw|try|to|until|wend|while)\b
      scope: keyword.control.monkey2

  modules:
    - include: module-monkey
    - include: module-std
    - include: module-mojo
    - include: module-mojox
    - include: module-mojo3d
    - include: module-httprequest
    - include: module-reflection
    - include: module-theoraplayer

  module-httprequest:
    - match: \b(ReadyState)\b
      scope: support.constant.httprequest.monkey2
    - match: \b(HttpRequest|HttpRequestBase)\b
      scope: support.class.httprequest.monkey2
    - match: \b(Hello)\b
      scope: support.function.httprequest.monkey2

  module-monkey:
    # debug
    - match: \b(Assert|DebugAssert|GetDebugStack|DebugLog|DebugStop|RuntimeError)\b
      scope: support.function.debug.monkey2

    # gc
    - match: \b(GCCollect|GCFree|GCMalloc|GCResume|GCSetTrigger|GCSuspend)\b
      scope: support.function.gc.monkey2

    # math
    - match: \b(ACos|ASin|ATan|ATan2|Abs|Ceil|Clamp|Cos|Exp|Floor|Log|Log10|Log2|Max|Min|Pow|Round|Sgn|Sin|Sqrt|Tan)\b
      scope: support.function.math.monkey2
    - match: \b(TwoPi|Pi)\b
      scope: constant.math.monkey2

    # types
    - match: \b(?i:Array|Bool|Byte|Double|Float|Int|Long|Null|Short|String|UByte|UInt|ULong|UShort|CString|Utf8String|Variant|Void|WString|Exception|Object|Throwable|TypeInfo|DeclInfo|WeakRef)\b
      scope: storage.type.class.monkey2
    - match: \b(?i:IIntegral|INumeric|IReal)\b
      scope: interface.types.monkey2

  module-std:
    # audio
    - match: \b(AudioFormat|AudioData)\b
      scope: support.class.audio.monkey2
    - match: \b(?i:BytesPerSample|LoadAudioData_OGG|LoadAudioData_WAV)\b
      scope: support.function.audio.monkey2
    - match: \b(AudioFormat)\b
      scope: support.constant.audio.monkey2

    # base64
    - match: \b(?i:DecodeBase64|EncodeBase64)\b
      scope: support.function.base64.monkey2

    # collections
    - match: \b(FloatDeque|FloatList|FloatMap|FloatStack|IntDeque|IntList|IntMap|IntStack|StringDeque|StringList|StringMap|StringStack|Deque|List|Map|Stack)\b
      scope: support.class.collections.monkey2
    - match: \b(?i:IContainer|IIterator)\b
      scope: support.interface.collections.monkey2

    # digest
    - match: \b(?i:MD5|SHA1|SHA256)\b
      scope: support.function.digest.monkey2

    # fiber
    - match: \b(Fiber|Future)\b
      scope: support.class.fiber.monkey2

    # filesystem
    - match: \b(FileType)\b
      scope: support.class.filesystem.monkey2
    - match: \b(?i:AppArgs|AppDir|AppPath|AssetsDir|ChangeDir|CopyFile|CreateDir|CurrentDir|DeleteDir|DeleteFile|ExtractDir|ExtractExt|ExtractRootDir|GetFileTime|GetFileType|IsRootDir|LoadDir|RealPath|Rename|StripDir|StripExt|StripSlashes)\b
      scope: support.function.filesystem.monkey2

    # geom
    - match: \b(AffineMat3f|Mat3f|Mat4f|Rectf|Recti|Vec2f|Vec2i|Vec3f|Vec4f|AffineMat3|Mat3|Mat4|Rect|Vec2|Vec3|Vec4)\b
      scope: support.class.geom.monkey2
    - match: \b(?i:TransformRecti|TransformVec2i)\b
      scope: support.function.geom.monkey2
    - match: \b(Axis)\b
      scope: support.constant.geom.monkey2

    # graphics
    - match: \b(PixelFormat)\b
      scope: support.constant.graphics.monkey2
    - match: \b(PixelFormat|Color|Pixmap)\b
      scope: support.class.graphics.monkey2
    - match: \b(?i:IsAlphaPixelFormat|IsDepthPixelFormat|IsFloatPixelFormat|PixelFormatDepth)\b
      scope: support.function.graphics.monkey2

    # json
    - match: \b(JsonArray|JsonBool|JsonError|JsonNumber|JsonObject|JsonParser|JsonString|JsonValue)\b
      scope: support.class.json.monkey2

    # jsonify
    - match: \b(ToJson|ToRecti)\b
      scope: support.function.jsonify.monkey2

    # memory
    - match: \b(ByteOrder)\b
      scope: support.constant.memory.monkey2
    - match: \b(DataBuffer|DataStream)\b
      scope: support.class.memory.monkey2

    # process
    - match: \b(Process|ProcessStream)\b
      scope: support.class.process.monkey2

    # random
    - match: \b(Rnd|RndULong|SeedRnd)\b
      scope: support.function.random.monkey2

    # requesters
    - match: \b(?i:Confirm|Notify|Proceed|RequestDir|RequestFile)\b
      scope: support.function.requesters.monkey2

    # resource
    - match: \b(Resource)\b
      scope: support.class.resource.monkey2
    - match: \b(SafeDiscard)\b
      scope: support.function.resource.monkey2

    # sockets
    - match: \b(Socket|SocketAddress|SocketStream)\b
      scope: support.class.sockets.monkey2
    - match: \b(SocketFlags|SocketType)\b
      scope: support.constant.sockets.monkey2

    # stream
    - match: \b(FileStream|Stream)\b
      scope: support.class.stream.monkey2

    # stringio
    - match: \b(?i:Bin|Hex|IsAlpha|IsDigit|IsHexDigit|IsIdent|IsSpace|LoadString|SaveString|StringToULong|ULongToString)\b
      scope: support.function.stringio.monkey2

    # thread
    - match: \b(Classes|Condvar|Mutex|Semaphore|Thread)\b
      scope: support.class.thread.monkey2

    # time
    - match: \b(TimeSpanTime|TimeParser)\b
      scope: support.class.time.monkey2
    - match: \b(Microsecs|Millisecs|Now|Sleep)\b
      scope: support.function.time.monkey2

    # timer
    - match: \b(Timer)\b
      scope: support.class.timer.monkey2

    # zipfile
    - match: \b(ZipFile)
      scope: support.class.zipfile.monkey2
    - match: \b(ExtractZip)\b
      scope: support.function.zipfile.monkey2

  module-mojo:
    # app
    - match: \b(EventType|WindowFlags)\b
      scope: support.constant.app.monkey2
    - match: \b(DisplayMode|AppInstance|Event|GLWindow|KeyEvent|MouseEvent|Skin|Style|Theme|TouchEvent|View|Window|WindowEvent)\b
      scope: support.class.app.monkey2
    - match: \b(App|ResourceManager)\b
      scope: support.class.app.monkey2

    # audio
    - match: \b(ChannelFlags)\b
      scope: support.constant.audio.monkey2
    - match: \b(Audio|AudioDevice|Channel|Sound)\b
      scope: support.class.audio.monkey2

      # enum = constant
    - match: \b(ChannelFlags)\b
      scope: support.constant.language.monkey2

    # graphics
    - match: \b(BlendMode|CubeFace|CullMode|DepthFunc|IndexFormat|OutlineMode|TextureFlags)\b
      scope: support.constant.graphics.monkey2
    - match: \b(Vertex2f|Vertex3f|AngelFont|Canvas|Font|Image|IndexBuffer|RenderTarget|Shader|ShadowCaster|Texture|UniformBlock|Vertex2fFormat|Vertex3fFormat|VertexBuffer)\b
      scope: support.class.graphics.monkey2

    # input
    - match: \b(JoystickHat|Key|Modifier|MouseButton|MouseCursor)\b
      scope: support.constant.input.monkey2
    - match: \b(|Joystick|KeyboardDevice|MouseDevice|TouchDevice)\b
      scope: support.class.input.monkey2
    - match: \b(Keyboard|Mouse|Touch)\b
      scope: support.class.input.monkey2

  module-mojo3d:
    - match: \b(AnimationMode|ComponentTypeFlags|LightType|SpriteMode|VRAxis|VRButton|VRTrackingSpace)\b
      scope: support.constant.mojo3d.monkey2
    - match: \b(Animator|BallSocketJoint|Behaviour|BloomEffect|BoxCollider|Camera|CapsuleCollider|Collider|Component|ComponentType|ConcaveCollider|ConeCollider|ConvexCollider|ConvexHullCollider|CylinderCollider|Entity|FXAAEffect|FixedJoint|FlyBehaviour|GodraysEffect|HingeJoint|Joint|Light|Material|Mesh|MeshCollider|Model|MonochromeEffect|MoveBehaviour|ParticleBuffer|ParticleMaterial|ParticleSystem|PbrMaterial|Pivot|PostEffect|RayCastResult|ReflectionEffect|RenderQueue|Renderable|Renderer|RigidBody|RotateBehaviour|Scene|SphereCollider|Sprite|SpriteMaterial|TerrainCollider|WaterMaterial|World|Mesh|Model|Entity)\b
      scope: support.class.mojo3d.monkey2
    - match: \b(Main)\b
      scope: support.function.mojo3d.monkey2
    - match: \b(Invocation|InvocationJsonifierExt|Jsonifier|JsonifierExt|MojoJsonifierExt|StdJsonifierExt)\b
      scope: support.class.mojo3d.jsonifier.monkey2
    - match: \b(CompareJson)\b
      scope: support.function.mojo3d.jsonifier.monkey2
    - match: \b(AssimpLoader)\b
      scope: support.class.mojo3d-loaders.monkey2
    - match: \b(VRControllerState|VRRenderer|HmdMatrix34_t|HmdMatrix44_t|HmdVector3_t|AffineMat4f|Mat4f|Vec3f)\b
      scope: support.class.mojo3d-vr.monkey2
    - match: \b(Frustum)\b
      scope: support.function.mojo3d-vr.monkey2

  module-mojox:
    - match: \b(CursorType|TabViewFlags)\b
      scope: support.constant.mojox.monkey2
    - match: \b(Action|Button|CheckButton|CheckGroup|Console|Dialog|DockingView|FileBrowser|FilePathView|GridView|HtmlView|Label|ListView|Menu|MenuBar|OptionsField|ProgressBar|ProgressDialog|PushButton|ScrollBar|ScrollView|TabView|TableView|TextDialog|TextDocument|TextField|TextView|ToolBar|ToolButton|TreeView|ViewCell|document_container)\b
      scope: support.class.mojox.monkey2
    - match: \b(?i:Alert|RequestInt|RequestOkay|RequestString)\b
      scope: support.function.mojox.monkey2

  module-reflection:
    - match: \b(?i:DebugTypes|GetProperty|GetTypeExtensions|SetProperty)\b
      scope: support.function.reflection.monkey2

  module-theoraplayer:
    - match: \b(OutputMode)\b
      scope: support.constant.theoraplayer.monkey2
    - match: \b(?i:AudioInterfaceFactory|OpenAL_AudioInterfaceFactory|VideoClip|VideoFrame|VideoManager)\b
      scope: support.class.theoraplayer.monkey2

  monkey-functions:
    - match: \b(?i:Print|Cast)\b
      scope: entity.name.function.monkey2
    - match: \b(?i:MarkdownToHtml)\b
      scope: function.markdown.monkey2

  numerics:
    - match: -?(\b\d+\b)
      scope: constant.numeric.integer.monkey2
    - match: -?((?<!\.)\.?\b\d+(?:e?-?\d*)|\b\d+(?:e-?\d*)|\b\d*\.\d+(?:e?-?\d*))\b
      scope: constant.numeric.float.monkey2
    - match: -?(%\b[01]+\b)
      scope: constant.numeric.binary.monkey2
    - match: -?(\$\b[0-9a-fA-F]+)\b
      scope: constant.numeric.hexadecimal.monkey2

  operators:
     - match: (:=|=|\b[Pp]tr\b)
       scope: keyword.operator.assignment.monkey2
     - match: (-=|-:|\*=|\*:|~=|/=|/:|\+=|\+:|&=|(?i):Shl|(?i):Shr|(?i):Mod\b|:\|)
       scope: keyword.operator.arithmetic.monkey2
     - match: (-|\*|~|/|\+|&|(?i)Shl|(?i)Shr|(?i)Mod |\|)
       scope: keyword.operator.arithmetic.monkey2
     - match: (=|<>|<|>|<=|>=|<=>)
       scope: keyword.operator.comparison.monkey2
     - match: \b(?i:And|Not|Or)\b
       scope: keyword.operator.logical.monkey2
     - match: \bTypeof\b
       scope: keyword.operator.reflection.monkey2

  storage-modifiers:
    - match: \b(?i:final|abstract|extends|implements|override)\b
      scope: storage.modifier.monkey2

  strings:
    - match: '"'
      push:
      - meta_scope: string.quoted.double.monkey2
      - match: ~.
        scope: constant.character.escape.monkey2
      - match: '"'
        pop: true

  variables:
    - match: \b(?i:Self|Super)\b
      scope: variable.language.monkey2