codemirror-rails 3.02 → 3.12

data/vendor/assets/javascripts/codemirror/modes/ecl.js

@@ -75,18 +75,18 @@ CodeMirror.defineMode("ecl", function(config) {
     } else if (builtin.propertyIsEnumerable(cur)) {
       if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
       return "builtin";
-    } else { //Data types are of from KEYWORD## 
-		var i = cur.length - 1;
-		while(i >= 0 && (!isNaN(cur[i]) || cur[i] == '_'))
-			--i;
-		
-		if (i > 0) {
-			var cur2 = cur.substr(0, i + 1);
-	    	if (variable_3.propertyIsEnumerable(cur2)) {
-	      		if (blockKeywords.propertyIsEnumerable(cur2)) curPunc = "newstatement";
-	      		return "variable-3";
-	      	}
-	    }
+    } else { //Data types are of from KEYWORD##
+                var i = cur.length - 1;
+                while(i >= 0 && (!isNaN(cur[i]) || cur[i] == '_'))
+                        --i;
+
+                if (i > 0) {
+                        var cur2 = cur.substr(0, i + 1);
+                if (variable_3.propertyIsEnumerable(cur2)) {
+                        if (blockKeywords.propertyIsEnumerable(cur2)) curPunc = "newstatement";
+                        return "variable-3";
+                }
+            }
     }
     if (atoms.propertyIsEnumerable(cur)) return "atom";
     return null;

data/vendor/assets/javascripts/codemirror/modes/erlang.js

@@ -247,7 +247,7 @@ CodeMirror.defineMode("erlang", function(cmCfg) {
           return rval(state,stream,"function");
         }
       }
-      return rval(state,stream,"atom");               
+      return rval(state,stream,"atom");
     }
 
     // number

data/vendor/assets/javascripts/codemirror/modes/gas.js

@@ -0,0 +1,326 @@
+CodeMirror.defineMode("gas", function(_config, parserConfig) {
+  'use strict';
+
+  // If an architecture is specified, its initialization function may
+  // populate this array with custom parsing functions which will be
+  // tried in the event that the standard functions do not find a match.
+  var custom = [];
+
+  // The symbol used to start a line comment changes based on the target
+  // architecture.
+  // If no architecture is pased in "parserConfig" then only multiline
+  // comments will have syntax support.
+  var lineCommentStartSymbol = "";
+
+  // These directives are architecture independent.
+  // Machine specific directives should go in their respective
+  // architecture initialization function.
+  // Reference:
+  // http://sourceware.org/binutils/docs/as/Pseudo-Ops.html#Pseudo-Ops
+  var directives = {
+    ".abort" : "builtin",
+    ".align" : "builtin",
+    ".altmacro" : "builtin",
+    ".ascii" : "builtin",
+    ".asciz" : "builtin",
+    ".balign" : "builtin",
+    ".balignw" : "builtin",
+    ".balignl" : "builtin",
+    ".bundle_align_mode" : "builtin",
+    ".bundle_lock" : "builtin",
+    ".bundle_unlock" : "builtin",
+    ".byte" : "builtin",
+    ".cfi_startproc" : "builtin",
+    ".comm" : "builtin",
+    ".data" : "builtin",
+    ".def" : "builtin",
+    ".desc" : "builtin",
+    ".dim" : "builtin",
+    ".double" : "builtin",
+    ".eject" : "builtin",
+    ".else" : "builtin",
+    ".elseif" : "builtin",
+    ".end" : "builtin",
+    ".endef" : "builtin",
+    ".endfunc" : "builtin",
+    ".endif" : "builtin",
+    ".equ" : "builtin",
+    ".equiv" : "builtin",
+    ".eqv" : "builtin",
+    ".err" : "builtin",
+    ".error" : "builtin",
+    ".exitm" : "builtin",
+    ".extern" : "builtin",
+    ".fail" : "builtin",
+    ".file" : "builtin",
+    ".fill" : "builtin",
+    ".float" : "builtin",
+    ".func" : "builtin",
+    ".global" : "builtin",
+    ".gnu_attribute" : "builtin",
+    ".hidden" : "builtin",
+    ".hword" : "builtin",
+    ".ident" : "builtin",
+    ".if" : "builtin",
+    ".incbin" : "builtin",
+    ".include" : "builtin",
+    ".int" : "builtin",
+    ".internal" : "builtin",
+    ".irp" : "builtin",
+    ".irpc" : "builtin",
+    ".lcomm" : "builtin",
+    ".lflags" : "builtin",
+    ".line" : "builtin",
+    ".linkonce" : "builtin",
+    ".list" : "builtin",
+    ".ln" : "builtin",
+    ".loc" : "builtin",
+    ".loc_mark_labels" : "builtin",
+    ".local" : "builtin",
+    ".long" : "builtin",
+    ".macro" : "builtin",
+    ".mri" : "builtin",
+    ".noaltmacro" : "builtin",
+    ".nolist" : "builtin",
+    ".octa" : "builtin",
+    ".offset" : "builtin",
+    ".org" : "builtin",
+    ".p2align" : "builtin",
+    ".popsection" : "builtin",
+    ".previous" : "builtin",
+    ".print" : "builtin",
+    ".protected" : "builtin",
+    ".psize" : "builtin",
+    ".purgem" : "builtin",
+    ".pushsection" : "builtin",
+    ".quad" : "builtin",
+    ".reloc" : "builtin",
+    ".rept" : "builtin",
+    ".sbttl" : "builtin",
+    ".scl" : "builtin",
+    ".section" : "builtin",
+    ".set" : "builtin",
+    ".short" : "builtin",
+    ".single" : "builtin",
+    ".size" : "builtin",
+    ".skip" : "builtin",
+    ".sleb128" : "builtin",
+    ".space" : "builtin",
+    ".stab" : "builtin",
+    ".string" : "builtin",
+    ".struct" : "builtin",
+    ".subsection" : "builtin",
+    ".symver" : "builtin",
+    ".tag" : "builtin",
+    ".text" : "builtin",
+    ".title" : "builtin",
+    ".type" : "builtin",
+    ".uleb128" : "builtin",
+    ".val" : "builtin",
+    ".version" : "builtin",
+    ".vtable_entry" : "builtin",
+    ".vtable_inherit" : "builtin",
+    ".warning" : "builtin",
+    ".weak" : "builtin",
+    ".weakref" : "builtin",
+    ".word" : "builtin"
+  };
+
+  var registers = {};
+
+  function x86(_parserConfig) {
+    lineCommentStartSymbol = "#";
+
+    registers.ax  = "variable";
+    registers.eax = "variable-2";
+    registers.rax = "variable-3";
+
+    registers.bx  = "variable";
+    registers.ebx = "variable-2";
+    registers.rbx = "variable-3";
+
+    registers.cx  = "variable";
+    registers.ecx = "variable-2";
+    registers.rcx = "variable-3";
+
+    registers.dx  = "variable";
+    registers.edx = "variable-2";
+    registers.rdx = "variable-3";
+
+    registers.si  = "variable";
+    registers.esi = "variable-2";
+    registers.rsi = "variable-3";
+
+    registers.di  = "variable";
+    registers.edi = "variable-2";
+    registers.rdi = "variable-3";
+
+    registers.sp  = "variable";
+    registers.esp = "variable-2";
+    registers.rsp = "variable-3";
+
+    registers.bp  = "variable";
+    registers.ebp = "variable-2";
+    registers.rbp = "variable-3";
+
+    registers.ip  = "variable";
+    registers.eip = "variable-2";
+    registers.rip = "variable-3";
+
+    registers.cs  = "keyword";
+    registers.ds  = "keyword";
+    registers.ss  = "keyword";
+    registers.es  = "keyword";
+    registers.fs  = "keyword";
+    registers.gs  = "keyword";
+  }
+
+  function armv6(_parserConfig) {
+    // Reference:
+    // http://infocenter.arm.com/help/topic/com.arm.doc.qrc0001l/QRC0001_UAL.pdf
+    // http://infocenter.arm.com/help/topic/com.arm.doc.ddi0301h/DDI0301H_arm1176jzfs_r0p7_trm.pdf
+    lineCommentStartSymbol = "@";
+    directives.syntax = "builtin";
+
+    registers.r0  = "variable";
+    registers.r1  = "variable";
+    registers.r2  = "variable";
+    registers.r3  = "variable";
+    registers.r4  = "variable";
+    registers.r5  = "variable";
+    registers.r6  = "variable";
+    registers.r7  = "variable";
+    registers.r8  = "variable";
+    registers.r9  = "variable";
+    registers.r10 = "variable";
+    registers.r11 = "variable";
+    registers.r12 = "variable";
+
+    registers.sp  = "variable-2";
+    registers.lr  = "variable-2";
+    registers.pc  = "variable-2";
+    registers.r13 = registers.sp;
+    registers.r14 = registers.lr;
+    registers.r15 = registers.pc;
+
+    custom.push(function(ch, stream) {
+      if (ch === '#') {
+        stream.eatWhile(/\w/);
+        return "number";
+      }
+    });
+  }
+
+  var arch = parserConfig.architecture.toLowerCase();
+  if (arch === "x86") {
+    x86(parserConfig);
+  } else if (arch === "arm" || arch === "armv6") {
+    armv6(parserConfig);
+  }
+
+  function nextUntilUnescaped(stream, end) {
+    var escaped = false, next;
+    while ((next = stream.next()) != null) {
+      if (next === end && !escaped) {
+        return false;
+      }
+      escaped = !escaped && next === "\\";
+    }
+    return escaped;
+  }
+
+  function clikeComment(stream, state) {
+    var maybeEnd = false, ch;
+    while ((ch = stream.next()) != null) {
+      if (ch === "/" && maybeEnd) {
+        state.tokenize = null;
+        break;
+      }
+      maybeEnd = (ch === "*");
+    }
+    return "comment";
+  }
+
+  return {
+    startState: function() {
+      return {
+        tokenize: null
+      };
+    },
+
+    token: function(stream, state) {
+      if (state.tokenize) {
+        return state.tokenize(stream, state);
+      }
+
+      if (stream.eatSpace()) {
+        return null;
+      }
+
+      var style, cur, ch = stream.next();
+
+      if (ch === "/") {
+        if (stream.eat("*")) {
+          state.tokenize = clikeComment;
+          return clikeComment(stream, state);
+        }
+      }
+
+      if (ch === lineCommentStartSymbol) {
+        stream.skipToEnd();
+        return "comment";
+      }
+
+      if (ch === '"') {
+        nextUntilUnescaped(stream, '"');
+        return "string";
+      }
+
+      if (ch === '.') {
+        stream.eatWhile(/\w/);
+        cur = stream.current().toLowerCase();
+        style = directives[cur];
+        return style || null;
+      }
+
+      if (ch === '=') {
+        stream.eatWhile(/\w/);
+        return "tag";
+      }
+
+      if (ch === '{') {
+        return "braket";
+      }
+
+      if (ch === '}') {
+        return "braket";
+      }
+
+      if (/\d/.test(ch)) {
+        if (ch === "0" && stream.eat("x")) {
+          stream.eatWhile(/[0-9a-fA-F]/);
+          return "number";
+        }
+        stream.eatWhile(/\d/);
+        return "number";
+      }
+
+      if (/\w/.test(ch)) {
+        stream.eatWhile(/\w/);
+        if (stream.eat(":")) {
+          return 'tag';
+        }
+        cur = stream.current().toLowerCase();
+        style = registers[cur];
+        return style || null;
+      }
+
+      for (var i = 0; i < custom.length; i++) {
+        style = custom[i](ch, stream, state);
+        if (style) {
+          return style;
+        }
+      }
+    }
+  };
+});

data/vendor/assets/javascripts/codemirror/modes/gfm.js

@@ -89,6 +89,7 @@ CodeMirror.defineMode("gfm", function(config) {
   CodeMirror.defineMIME("gfmBase", {
     name: "markdown",
     underscoresBreakWords: false,
+    taskLists: true,
     fencedCodeBlocks: true
   });
   return CodeMirror.overlayMode(CodeMirror.getMode(config, "gfmBase"), gfmOverlay);

data/vendor/assets/javascripts/codemirror/modes/haskell.js

@@ -4,7 +4,7 @@ CodeMirror.defineMode("haskell", function() {
     setState(f);
     return f(source, setState);
   }
-  
+
   // These should all be Unicode extended, as per the Haskell 2010 report
   var smallRE = /[a-z_]/;
   var largeRE = /[A-Z]/;
@@ -15,12 +15,12 @@ CodeMirror.defineMode("haskell", function() {
   var symbolRE = /[-!#$%&*+.\/<=>?@\\^|~:]/;
   var specialRE = /[(),;[\]`{}]/;
   var whiteCharRE = /[ \t\v\f]/; // newlines are handled in tokenizer
-    
+
   function normal(source, setState) {
     if (source.eatWhile(whiteCharRE)) {
       return null;
     }
-      
+
     var ch = source.next();
     if (specialRE.test(ch)) {
       if (ch == '{' && source.eat('-')) {
@@ -32,7 +32,7 @@ CodeMirror.defineMode("haskell", function() {
       }
       return null;
     }
-    
+
     if (ch == '\'') {
       if (source.eat('\\')) {
         source.next();  // should handle other escapes here
@@ -45,11 +45,11 @@ CodeMirror.defineMode("haskell", function() {
       }
       return "error";
     }
-    
+
     if (ch == '"') {
       return switchState(source, setState, stringLiteral);
     }
-      
+
     if (largeRE.test(ch)) {
       source.eatWhile(idRE);
       if (source.eat('.')) {
@@ -57,12 +57,12 @@ CodeMirror.defineMode("haskell", function() {
       }
       return "variable-2";
     }
-      
+
     if (smallRE.test(ch)) {
       source.eatWhile(idRE);
       return "variable";
     }
-      
+
     if (digitRE.test(ch)) {
       if (ch == '0') {
         if (source.eat(/[xX]/)) {
@@ -87,7 +87,7 @@ CodeMirror.defineMode("haskell", function() {
       }
       return t;
     }
-      
+
     if (symbolRE.test(ch)) {
       if (ch == '-' && source.eat(/-/)) {
         source.eatWhile(/-/);
@@ -101,12 +101,12 @@ CodeMirror.defineMode("haskell", function() {
         t = "variable-2";
       }
       source.eatWhile(symbolRE);
-      return t;    
+      return t;
     }
-      
+
     return "error";
   }
-    
+
   function ncomment(type, nest) {
     if (nest == 0) {
       return normal;
@@ -130,7 +130,7 @@ CodeMirror.defineMode("haskell", function() {
       return type;
     };
   }
-    
+
   function stringLiteral(source, setState) {
     while (!source.eol()) {
       var ch = source.next();
@@ -153,7 +153,7 @@ CodeMirror.defineMode("haskell", function() {
     setState(normal);
     return "error";
   }
-  
+
   function stringGap(source, setState) {
     if (source.eat('\\')) {
       return switchState(source, setState, stringLiteral);
@@ -162,8 +162,8 @@ CodeMirror.defineMode("haskell", function() {
     setState(normal);
     return "error";
   }
-  
-  
+
+
   var wellKnownWords = (function() {
     var wkw = {};
     function setType(t) {
@@ -172,19 +172,19 @@ CodeMirror.defineMode("haskell", function() {
           wkw[arguments[i]] = t;
       };
     }
-    
+
     setType("keyword")(
       "case", "class", "data", "default", "deriving", "do", "else", "foreign",
       "if", "import", "in", "infix", "infixl", "infixr", "instance", "let",
       "module", "newtype", "of", "then", "type", "where", "_");
-      
+
     setType("keyword")(
       "\.\.", ":", "::", "=", "\\", "\"", "<-", "->", "@", "~", "=>");
-      
+
     setType("builtin")(
       "!!", "$!", "$", "&&", "+", "++", "-", ".", "/", "/=", "<", "<=", "=<<",
       "==", ">", ">=", ">>", ">>=", "^", "^^", "||", "*", "**");
-      
+
     setType("builtin")(
       "Bool", "Bounded", "Char", "Double", "EQ", "Either", "Enum", "Eq",
       "False", "FilePath", "Float", "Floating", "Fractional", "Functor", "GT",
@@ -192,7 +192,7 @@ CodeMirror.defineMode("haskell", function() {
       "Maybe", "Monad", "Nothing", "Num", "Ord", "Ordering", "Rational", "Read",
       "ReadS", "Real", "RealFloat", "RealFrac", "Right", "Show", "ShowS",
       "String", "True");
-      
+
     setType("builtin")(
       "abs", "acos", "acosh", "all", "and", "any", "appendFile", "asTypeOf",
       "asin", "asinh", "atan", "atan2", "atanh", "break", "catch", "ceiling",
@@ -220,16 +220,16 @@ CodeMirror.defineMode("haskell", function() {
       "toRational", "truncate", "uncurry", "undefined", "unlines", "until",
       "unwords", "unzip", "unzip3", "userError", "words", "writeFile", "zip",
       "zip3", "zipWith", "zipWith3");
-      
+
     return wkw;
   })();
-    
-  
-  
+
+
+
   return {
     startState: function ()  { return { f: normal }; },
     copyState:  function (s) { return { f: s.f }; },
-    
+
     token: function(stream, state) {
       var t = state.f(stream, function(s) { state.f = s; });
       var w = stream.current();

data/vendor/assets/javascripts/codemirror/modes/haxe.js

@@ -1,6 +1,6 @@
 CodeMirror.defineMode("haxe", function(config, parserConfig) {
   var indentUnit = config.indentUnit;
-  
+
   // Tokenizer
 
   var keywords = function(){
@@ -12,10 +12,10 @@ CodeMirror.defineMode("haxe", function(config, parserConfig) {
       "if": A, "while": A, "else": B, "do": B, "try": B,
       "return": C, "break": C, "continue": C, "new": C, "throw": C,
       "var": kw("var"), "inline":attribute, "static": attribute, "using":kw("import"),
-    "public": attribute, "private": attribute, "cast": kw("cast"), "import": kw("import"), "macro": kw("macro"), 
+    "public": attribute, "private": attribute, "cast": kw("cast"), "import": kw("import"), "macro": kw("macro"),
       "function": kw("function"), "catch": kw("catch"), "untyped": kw("untyped"), "callback": kw("cb"),
       "for": kw("for"), "switch": kw("switch"), "case": kw("case"), "default": kw("default"),
-      "in": operator, "never": kw("property_access"), "trace":kw("trace"), 
+      "in": operator, "never": kw("property_access"), "trace":kw("trace"),
     "class": type, "enum":type, "interface":type, "typedef":type, "extends":type, "implements":type, "dynamic":type,
       "true": atom, "false": atom, "null": atom
     };
@@ -55,14 +55,14 @@ CodeMirror.defineMode("haxe", function(config, parserConfig) {
     else if (ch == "0" && stream.eat(/x/i)) {
       stream.eatWhile(/[\da-f]/i);
       return ret("number", "number");
-    }      
+    }
     else if (/\d/.test(ch) || ch == "-" && stream.eat(/\d/)) {
       stream.match(/^\d*(?:\.\d*)?(?:[eE][+\-]?\d+)?/);
       return ret("number", "number");
     }
     else if (state.reAllowed && (ch == "~" && stream.eat(/\//))) {
       nextUntilUnescaped(stream, "/");
-      stream.eatWhile(/[gimsu]/); 
+      stream.eatWhile(/[gimsu]/);
       return ret("regexp", "string-2");
     }
     else if (ch == "/") {
@@ -146,13 +146,13 @@ CodeMirror.defineMode("haxe", function(config, parserConfig) {
     for (var v = state.localVars; v; v = v.next)
       if (v.name == varname) return true;
   }
-  
+
   function parseHaxe(state, style, type, content, stream) {
     var cc = state.cc;
     // Communicate our context to the combinators.
     // (Less wasteful than consing up a hundred closures on every call.)
     cx.state = state; cx.stream = stream; cx.marked = null, cx.cc = cc;
-  
+
     if (!state.lexical.hasOwnProperty("align"))
       state.lexical.align = true;
 
@@ -168,7 +168,7 @@ CodeMirror.defineMode("haxe", function(config, parserConfig) {
       }
     }
   }
-  
+
   function imported(state, typename)
   {
   if (/[a-z]/.test(typename.charAt(0)))
@@ -177,8 +177,8 @@ CodeMirror.defineMode("haxe", function(config, parserConfig) {
   for (var i = 0; i<len; i++)
     if(state.importedtypes[i]==typename) return true;
   }
-  
-  
+
+
   function registerimport(importname) {
   var state = cx.state;
   for (var t = state.importedtypes; t; t = t.next)
@@ -235,7 +235,7 @@ CodeMirror.defineMode("haxe", function(config, parserConfig) {
   poplex.lex = true;
 
   function expect(wanted) {
-    return function expecting(type) {
+    return function(type) {
       if (type == wanted) return cont();
       else if (wanted == ";") return pass();
       else return cont(arguments.callee);
@@ -278,7 +278,7 @@ CodeMirror.defineMode("haxe", function(config, parserConfig) {
     if (type.match(/[;\}\)\],]/)) return pass();
     return pass(expression);
   }
-    
+
   function maybeoperator(type, value) {
     if (type == "operator" && /\+\+|--/.test(value)) return cont(maybeoperator);
     if (type == "operator" || type == ":") return cont(expression);
@@ -302,17 +302,17 @@ CodeMirror.defineMode("haxe", function(config, parserConfig) {
   function metaargs(type) {
     if(type == "variable") return cont();
   }
-  
+
   function importdef (type, value) {
   if(type == "variable" && /[A-Z]/.test(value.charAt(0))) { registerimport(value); return cont(); }
   else if(type == "variable" || type == "property" || type == ".") return cont(importdef);
   }
-  
+
   function typedef (type, value)
   {
   if(type == "variable" && /[A-Z]/.test(value.charAt(0))) { registerimport(value); return cont(); }
   }
-  
+
   function maybelabel(type) {
     if (type == ":") return cont(poplex, statement);
     return pass(maybeoperator, expect(";"), poplex);
@@ -330,7 +330,7 @@ CodeMirror.defineMode("haxe", function(config, parserConfig) {
       if (type == end) return cont();
       return cont(expect(end));
     }
-    return function commaSeparated(type) {
+    return function(type) {
       if (type == end) return cont();
       else return pass(what, proceed);
     };
@@ -388,7 +388,7 @@ CodeMirror.defineMode("haxe", function(config, parserConfig) {
         cc: [],
         lexical: new HaxeLexical((basecolumn || 0) - indentUnit, 0, "block", false),
         localVars: parserConfig.localVars,
-    importedtypes: defaulttypes, 
+    importedtypes: defaulttypes,
         context: parserConfig.localVars && {vars: parserConfig.localVars},
         indented: 0
       };