Tidying up.

samples/third_party/codemirror/js/parsejavascript.js

 /* Parse function for JavaScript. Makes use of the tokenizer from
  * tokenizejavascript.js. Note that your parsers do not have to be
  * this complicated -- if you don't want to recognize local variables,
  * in many languages it is enough to just look for braces, semicolons,
  * parentheses, etc, and know when you are inside a string or comment.
  *
  * See manual.html for more info about the parser interface.
  */
 
 var JSParser = Editor.Parser = (function() {
@@ skipping 50 matching lines @@
     // The lexical scope, used mostly for indentation.
     var lexical = new JSLexical((basecolumn || 0) - 2, 0, "block", false);
     // Current column, and the indentation at the start of the current
     // line. Used to create lexical scope objects.
     var column = 0;
     var indented = 0;
     // Variables which are used by the mark, cont, and pass functions
     // below to communicate with the driver loop in the 'next'
     // function.
     var consume, marked;
-  
+
     // The iterator object.
     var parser = {next: next, copy: copy};
 
     function next(){
       // Start by performing any 'lexical' actions (adjusting the
       // lexical variable), or the operations below will be working
       // with the wrong lexical state.
       while(cc[cc.length - 1].lex)
         cc.pop()();
 
@@ skipping 16 matching lines @@
       }
       // No more processing for meaningless tokens.
       if (token.type == "whitespace" || token.type == "comment")
         return token;
       // When a meaningful token is found and the lexical scope's
       // align is undefined, it is an aligned scope.
       if (!("align" in lexical))
         lexical.align = true;
 
       // Execute actions until one 'consumes' the token and we can
-      // return it. Marked is used to 
+      // return it. Marked is used to
       while(true){
         consume = marked = false;
         // Take and execute the topmost action.
         cc.pop()(token.type, token.content);
         if (consume){
           // Marked is used to change the style of the current token.
           if (marked)
             token.style = marked;
           // Here we differentiate between local and global variables.
           else if (token.type == "variable" && inScope(token.content))
             token.style = "js-localvariable";
           return token;
         }
       }
     }
 
     // This makes a copy of the parser state. It stores all the
     // stateful variables in a closure, and returns a function that
     // will restore them when called with a new input stream. Note
     // that the cc array has to be copied, because it is contantly
     // being modified. Lexical objects are not mutated, and context
     // objects are not mutated in a harmful way, so they can be shared
     // between runs of the parser.
     function copy(){
       var _context = context, _lexical = lexical, _cc = cc.concat([]), _tokenState = tokens.state;
-  
+
       return function(input){
         context = _context;
         lexical = _lexical;
         cc = _cc.concat([]); // copies the array
         column = indented = 0;
         tokens = tokenizeJavaScript(input, _tokenState);
         return parser;
       };
     }
 
@@ skipping 38 matching lines @@
     // Check whether a variable is defined in the current scope.
     function inScope(varname){
       var cursor = context;
       while (cursor) {
         if (cursor.vars[varname])
           return true;
         cursor = cursor.prev;
       }
       return false;
     }
-  
+
     // Push a new lexical context of the given type.
     function pushlex(type){
       var result = function(){
         lexical = new JSLexical(indented, column, type, null, lexical)
       };
       result.lex = true;
       return result;
     }
     // Pop off the current lexical context.
     function poplex(){
       lexical = lexical.prev;
     }
     poplex.lex = true;
     // The 'lex' flag on these actions is used by the 'next' function
     // to know they can (and have to) be ran before moving on to the
     // next token.
-  
+
     // Creates an action that discards tokens until it finds one of
     // the given type.
     function expect(wanted){
       return function(type){
         if (type == wanted) cont();
         else cont(arguments.callee);
       };
     }
 
     // Looks for a statement, and then calls itself.
@@ skipping 86 matching lines @@
     }
     // A function definition creates a new context, and the variables
     // in its argument list have to be added to this context.
     function functiondef(type, value){
       if (type == "variable"){register(value); cont(functiondef);}
       else if (type == "(") cont(pushcontext, commasep(funarg), expect(")"), statement, popcontext);
     }
     function funarg(type, value){
       if (type == "variable"){register(value); cont();}
     }
-  
+
     return parser;
   }
 
   return {make: parseJS, electricChars: "{}"};
 })();