Last commit: Sun Dec 17 01:14:09 2017 +0100	Jan Dankert	Integration eines weiteren Code-Editors: Codemirror. Demnächst müssen wir hier mal aufräumen und andere Editoren rauswerfen.


      // 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")
    });


Download modules/editor/codemirror/mode/swift/swift.js

History
Sun, 17 Dec 2017 01:14:09 +0100	Jan Dankert	Integration eines weiteren Code-Editors: Codemirror. Demnächst müssen wir hier mal aufräumen und andere Editoren rauswerfen.