openrat-cms

swift.js (7168B)

---

 // CodeMirror, copyright (c) by Marijn Haverbeke and others
 // Distributed under an MIT license: http://codemirror.net/LICENSE
 
 // Swift mode created by Michael Kaminsky https://github.com/mkaminsky11
 
 (function(mod) {
   if (typeof exports == "object" && typeof module == "object")
     mod(require("../../lib/codemirror"))
   else if (typeof define == "function" && define.amd)
     define(["../../lib/codemirror"], mod)
   else
     mod(CodeMirror)
 })(function(CodeMirror) {
   "use strict"
 
   function wordSet(words) {
     var set = {}
     for (var i = 0; i < words.length; i++) set[words[i]] = true
     return set
   }
 
   var keywords = wordSet(["_","var","let","class","enum","extension","import","protocol","struct","func","typealias","associatedtype",
                           "open","public","internal","fileprivate","private","deinit","init","new","override","self","subscript","super",
                           "convenience","dynamic","final","indirect","lazy","required","static","unowned","unowned(safe)","unowned(unsafe)","weak","as","is",
                           "break","case","continue","default","else","fallthrough","for","guard","if","in","repeat","switch","where","while",
                           "defer","return","inout","mutating","nonmutating","catch","do","rethrows","throw","throws","try","didSet","get","set","willSet",
                           "assignment","associativity","infix","left","none","operator","postfix","precedence","precedencegroup","prefix","right",
                           "Any","AnyObject","Type","dynamicType","Self","Protocol","__COLUMN__","__FILE__","__FUNCTION__","__LINE__"])
   var definingKeywords = wordSet(["var","let","class","enum","extension","import","protocol","struct","func","typealias","associatedtype","for"])
   var atoms = wordSet(["true","false","nil","self","super","_"])
   var types = wordSet(["Array","Bool","Character","Dictionary","Double","Float","Int","Int8","Int16","Int32","Int64","Never","Optional","Set","String",
                        "UInt8","UInt16","UInt32","UInt64","Void"])
   var operators = "+-/*%=|&<>~^?!"
   var punc = ":;,.(){}[]"
   var binary = /^\-?0b[01][01_]*/
   var octal = /^\-?0o[0-7][0-7_]*/
   var hexadecimal = /^\-?0x[\dA-Fa-f][\dA-Fa-f_]*(?:(?:\.[\dA-Fa-f][\dA-Fa-f_]*)?[Pp]\-?\d[\d_]*)?/
   var decimal = /^\-?\d[\d_]*(?:\.\d[\d_]*)?(?:[Ee]\-?\d[\d_]*)?/
   var identifier = /^\$\d+|(`?)[_A-Za-z][_A-Za-z$0-9]*\1/
   var property = /^\.(?:\$\d+|(`?)[_A-Za-z][_A-Za-z$0-9]*\1)/
   var instruction = /^\#[A-Za-z]+/
   var attribute = /^@(?:\$\d+|(`?)[_A-Za-z][_A-Za-z$0-9]*\1)/
   //var regexp = /^\/(?!\s)(?:\/\/)?(?:\\.|[^\/])+\//
 
   function tokenBase(stream, state, prev) {
     if (stream.sol()) state.indented = stream.indentation()
     if (stream.eatSpace()) return null
 
     var ch = stream.peek()
     if (ch == "/") {
       if (stream.match("//")) {
         stream.skipToEnd()
         return "comment"
       }
       if (stream.match("/*")) {
         state.tokenize.push(tokenComment)
         return tokenComment(stream, state)
       }
     }
     if (stream.match(instruction)) return "builtin"
     if (stream.match(attribute)) return "attribute"
     if (stream.match(binary)) return "number"
     if (stream.match(octal)) return "number"
     if (stream.match(hexadecimal)) return "number"
     if (stream.match(decimal)) return "number"
     if (stream.match(property)) return "property"
     if (operators.indexOf(ch) > -1) {
       stream.next()
       return "operator"
     }
     if (punc.indexOf(ch) > -1) {
       stream.next()
       stream.match("..")
       return "punctuation"
     }
     if (ch == '"' || ch == "'") {
       stream.next()
       var tokenize = tokenString(ch)
       state.tokenize.push(tokenize)
       return tokenize(stream, state)
     }
 
     if (stream.match(identifier)) {
       var ident = stream.current()
       if (types.hasOwnProperty(ident)) return "variable-2"
       if (atoms.hasOwnProperty(ident)) return "atom"
       if (keywords.hasOwnProperty(ident)) {
         if (definingKeywords.hasOwnProperty(ident))
           state.prev = "define"
         return "keyword"
       }
       if (prev == "define") return "def"
       return "variable"
     }
 
     stream.next()
     return null
   }
 
   function tokenUntilClosingParen() {
     var depth = 0
     return function(stream, state, prev) {
       var inner = tokenBase(stream, state, prev)
       if (inner == "punctuation") {
         if (stream.current() == "(") ++depth
         else if (stream.current() == ")") {
           if (depth == 0) {
             stream.backUp(1)
             state.tokenize.pop()
             return state.tokenize[state.tokenize.length - 1](stream, state)
           }
           else --depth
         }
       }
       return inner
     }
   }
 
   function tokenString(quote) {
     return function(stream, state) {
       var ch, escaped = false
       while (ch = stream.next()) {
         if (escaped) {
           if (ch == "(") {
             state.tokenize.push(tokenUntilClosingParen())
             return "string"
           }
           escaped = false
         } else if (ch == quote) {
           break
         } else {
           escaped = ch == "\\"
         }
       }
       state.tokenize.pop()
       return "string"
     }
   }
 
   function tokenComment(stream, state) {
     stream.match(/^(?:[^*]|\*(?!\/))*/)
     if (stream.match("*/")) state.tokenize.pop()
     return "comment"
   }
 
   function Context(prev, align, indented) {
     this.prev = prev
     this.align = align
     this.indented = indented
   }
 
   function pushContext(state, stream) {
     var align = stream.match(/^\s*($|\/[\/\*])/, false) ? null : stream.column() + 1
     state.context = new Context(state.context, align, state.indented)
   }
 
   function popContext(state) {
     if (state.context) {
       state.indented = state.context.indented
       state.context = state.context.prev
     }
   }
 
   CodeMirror.defineMode("swift", function(config) {
     return {
       startState: function() {
         return {
           prev: null,
           context: null,
           indented: 0,
           tokenize: []
         }
       },
 
       token: function(stream, state) {
         var prev = state.prev
         state.prev = null
         var tokenize = state.tokenize[state.tokenize.length - 1] || tokenBase
         var style = tokenize(stream, state, prev)
         if (!style || style == "comment") state.prev = prev
         else if (!state.prev) state.prev = style
 
         if (style == "punctuation") {
           var bracket = /[\(\[\{]|([\]\)\}])/.exec(stream.current())
           if (bracket) (bracket[1] ? popContext : pushContext)(state, stream)
         }
 
         return style
       },
 
       indent: function(state, textAfter) {
         var cx = state.context
         if (!cx) return 0
         var closing = /^[\]\}\)]/.test(textAfter)
         if (cx.align != null) return cx.align - (closing ? 1 : 0)
         return cx.indented + (closing ? 0 : config.indentUnit)
       },
 
       electricInput: /^\s*[\)\}\]]$/,
 
       lineComment: "//",
       blockCommentStart: "/*",
       blockCommentEnd: "*/",
       fold: "brace",
       closeBrackets: "()[]{}''\"\"``"
     }
   })
 
   CodeMirror.defineMIME("text/x-swift","swift")
 });