diff --git a/src/editor/EditorCommandHandlers.js b/src/editor/EditorCommandHandlers.js
index 5cb11d464c9..2b4caed3529 100644
--- a/src/editor/EditorCommandHandlers.js
+++ b/src/editor/EditorCommandHandlers.js
@@ -47,16 +47,55 @@ define(function (require, exports, module) {
     var DIRECTION_UP    = -1;
     var DIRECTION_DOWN  = +1;
         
+    /**
+     * @private
+     * Creates special regular expressions that matches the line prefix but not the block prefix or suffix
+     * @param {!string} lineSyntax  a line comment prefix
+     * @param {!string} blockSyntax  a block comment prefix or suffix
+     * @return {RegExp}
+     */
+    function _createSpecialLineExp(lineSyntax, blockSyntax) {
+        var i, character,
+            subExps   = [],
+            prevChars = "";
+        
+        for (i = lineSyntax.length; i < blockSyntax.length; i++) {
+            character = blockSyntax.charAt(i);
+            subExps.push(prevChars + "[^" + StringUtils.regexEscape(character) + "]");
+            if (prevChars) {
+                subExps.push(prevChars + "$");
+            }
+            prevChars += character;
+        }
+        return new RegExp("^\\s*" + StringUtils.regexEscape(lineSyntax) + "($|" + subExps.join("|") + ")");
+    }
+    
     /**
      * @private
      * Creates regular expressions for multiple line comment prefixes
-     * @param {!Array.<string>} prefixes - the line comment prefixes
+     * @param {!Array.<string>} prefixes  the line comment prefixes
+     * @param {string=} blockPrefix  the block comment prefix
+     * @param {string=} blockSuffix  the block comment suffix
      * @return {Array.<RegExp>}
      */
-    function _createLineExpressions(prefixes) {
-        var lineExp = [];
+    function _createLineExpressions(prefixes, blockPrefix, blockSuffix) {
+        var lineExp = [], escapedPrefix, nothingPushed;
+        
         prefixes.forEach(function (prefix) {
-            lineExp.push(new RegExp("^\\s*" + StringUtils.regexEscape(prefix)));
+            escapedPrefix = StringUtils.regexEscape(prefix);
+            nothingPushed = true;
+            
+            if (blockPrefix && blockPrefix.indexOf(prefix) === 0) {
+                lineExp.push(_createSpecialLineExp(prefix, blockPrefix));
+                nothingPushed = false;
+            }
+            if (blockSuffix && blockPrefix !== blockSuffix && blockSuffix.indexOf(prefix) === 0) {
+                lineExp.push(_createSpecialLineExp(prefix, blockSuffix));
+                nothingPushed = false;
+            }
+            if (nothingPushed) {
+                lineExp.push(new RegExp("^\\s*" + escapedPrefix));
+            }
         });
         return lineExp;
     }
@@ -64,8 +103,8 @@ define(function (require, exports, module) {
     /**
      * @private
      * Returns true if any regular expression matches the given string
-     * @param {!string} string - where to look
-     * @param {!Array.<RegExp>} expressions - what to look
+     * @param {!string} string  where to look
+     * @param {!Array.<RegExp>} expressions  what to look
      * @return {boolean}
      */
     function _matchExpressions(string, expressions) {
@@ -77,11 +116,11 @@ define(function (require, exports, module) {
     /**
      * @private
      * Returns the line comment prefix that best matches the string. Since there might be line comment prefixes
-     * that are prefixes of other line comment prefixes, it searches throught all and returns the longest line
+     * that are prefixes of other line comment prefixes, it searches through all and returns the longest line
      * comment prefix that matches the string.
-     * @param {!string} string - where to look
-     * @param {!Array.<RegExp>} expressions - the line comment regular expressions
-     * @param {!Array.<string>} prefixes - the line comment prefixes
+     * @param {!string} string  where to look
+     * @param {!Array.<RegExp>} expressions  the line comment regular expressions
+     * @param {!Array.<string>} prefixes  the line comment prefixes
      * @return {string}
      */
     function _getLinePrefix(string, expressions, prefixes) {
@@ -96,27 +135,27 @@ define(function (require, exports, module) {
     
     /**
      * @private
-     * Searchs for an uncommented line between startLine and endLine
+     * Searches between startLine and endLine to check if there is at least one line commented with a line comment, and
+     * skips all the block comments.
      * @param {!Editor} editor
-     * @param {!number} startLine - valid line inside the document
-     * @param {!number} endLine - valid line inside the document
-     * @param {!Array.<string>} lineExp - an array of line comment prefixes regular expressions
+     * @param {!number} startLine  valid line inside the document
+     * @param {!number} endLine  valid line inside the document
+     * @param {!Array.<RegExp>} lineExp  an array of line comment prefixes regular expressions
      * @return {boolean} true if there is at least one uncommented line
      */
-    function _containsUncommented(editor, startLine, endLine, lineExp) {
-        var containsUncommented = false;
-        var i;
-        var line;
+    function _containsNotLineComment(editor, startLine, endLine, lineExp) {
+        var i, line,
+            containsNotLineComment = false;
         
         for (i = startLine; i <= endLine; i++) {
             line = editor.document.getLine(i);
             // A line is commented out if it starts with 0-N whitespace chars, then a line comment prefix
             if (line.match(/\S/) && !_matchExpressions(line, lineExp)) {
-                containsUncommented = true;
+                containsNotLineComment = true;
                 break;
             }
         }
-        return containsUncommented;
+        return containsNotLineComment;
     }
     
     /**
@@ -131,6 +170,8 @@ define(function (require, exports, module) {
      *
      * @param {!Editor} editor
      * @param {!Array.<string>} prefixes, e.g. ["//"]
+     * @param {string=} blockPrefix, e.g. "<!--"
+     * @param {string=} blockSuffix, e.g. "-->"
      * @param {!Editor} editor The editor to edit within.
      * @param {!{selectionForEdit: {start:{line:number, ch:number}, end:{line:number, ch:number}, reversed:boolean, primary:boolean}, 
      *           selectionsToTrack: Array.<{start:{line:number, ch:number}, end:{line:number, ch:number}, reversed:boolean, primary:boolean}>}}
@@ -138,14 +179,15 @@ define(function (require, exports, module) {
      *      the line comment operation on, and `selectionsToTrack` are a set of selections associated with this line that need to be
      *      tracked through the edit.
      * @return {{edit: {text: string, start:{line: number, ch: number}, end:?{line: number, ch: number}}|Array.<{text: string, start:{line: number, ch: number}, end:?{line: number, ch: number}}>,
-     *                  selection: {start:{line:number, ch:number}, end:{line:number, ch:number}, primary:boolean, reversed: boolean, isBeforeEdit: boolean}>}|Array.<{start:{line:number, ch:number}, end:{line:number, ch:number}, primary:boolean, reversed: boolean, isBeforeEdit: boolean}>}}
+     *                  selection: {start:{line:number, ch:number}, end:{line:number, ch:number}, primary:boolean, reversed: boolean, isBeforeEdit: boolean}>}|
+     *                  Array.<{start:{line:number, ch:number}, end:{line:number, ch:number}, primary:boolean, reversed: boolean, isBeforeEdit: boolean}>}}
      *      An edit description suitable for including in the edits array passed to `Document.doMultipleEdits()`.
      */
-    function _getLineCommentPrefixEdit(editor, prefixes, lineSel) {
+    function _getLineCommentPrefixEdit(editor, prefixes, blockPrefix, blockSuffix, lineSel) {
         var doc         = editor.document,
             sel         = lineSel.selectionForEdit,
             trackedSels = lineSel.selectionsToTrack,
-            lineExp     = _createLineExpressions(prefixes),
+            lineExp     = _createLineExpressions(prefixes, blockPrefix, blockSuffix),
             startLine   = sel.start.line,
             endLine     = sel.end.line,
             editGroup   = [];
@@ -158,14 +200,11 @@ define(function (require, exports, module) {
         // Decide if we're commenting vs. un-commenting
         // Are there any non-blank lines that aren't commented out? (We ignore blank lines because
         // some editors like Sublime don't comment them out)
-        var containsUncommented = _containsUncommented(editor, startLine, endLine, lineExp);
-        var i;
-        var line;
-        var prefix;
-        var commentI;
-        var updateSelection = false;
-
-        if (containsUncommented) {
+        var i, line, prefix, commentI,
+            containsNotLineComment = _containsNotLineComment(editor, startLine, endLine, lineExp),
+            updateSelection        = false;
+        
+        if (containsNotLineComment) {
             // Comment out - prepend the first prefix to each line
             for (i = startLine; i <= endLine; i++) {
                 editGroup.push({text: prefixes[0], start: {line: i, ch: 0}});
@@ -200,72 +239,59 @@ define(function (require, exports, module) {
     
     /**
      * @private
-     * Moves the token context to the token that starts the block-comment. Ctx starts in a block-comment.
-     * Returns the position of the prefix or null if gets to the start of the document and didn't found it.
-     * @param {!{editor:{CodeMirror}, pos:{ch:{string}, line:{number}}, token:{object}}} ctx - token context
-     * @param {!RegExp} prefixExp - a valid regular expression
-     * @return {?{line: number, ch: number}}
+     * Given a token context it will search backwards to determine if the given token is part of a block comment
+     * that doesn't start at the initial token. This is used to know if a line comment is part of a block comment
+     * or if a block delimiter is the prefix or suffix, by passing a token context at that position. Since the
+     * token context will be moved backwards a lot, it is better to pass a new context.
+     * 
+     * @param {!{editor:{CodeMirror}, pos:{ch:{number}, line:{number}}, token:{object}}} ctx  token context
+     * @param {!string} prefix  the block comment prefix
+     * @param {!string} suffix  the block comment suffix
+     * @param {!RegExp} prefixExp  a block comment prefix regular expression
+     * @param {!RegExp} suffixExp  a block comment suffix regular expression
+     * @param {!Array.<RegExp>} lineExp  an array of line comment prefixes regular expressions
+     * @return {boolean}
      */
-    function _findCommentStart(ctx, prefixExp) {
-        var result = true;
+    function _isPrevTokenABlockComment(ctx, prefix, suffix, prefixExp, suffixExp, lineExp) {
+        // Start searching from the previous token
+        var result = TokenUtils.moveSkippingWhitespace(TokenUtils.movePrevToken, ctx);
         
-        while (result && !ctx.token.string.match(prefixExp)) {
+        // Look backwards until we find a none line comment token
+        while (result && _matchExpressions(ctx.token.string, lineExp)) {
             result = TokenUtils.moveSkippingWhitespace(TokenUtils.movePrevToken, ctx);
         }
-        return result ? {line: ctx.pos.line, ch: ctx.token.start} : null;
-    }
-    
-    /**
-     * @private
-     * Moves the token context to the token that ends the block-comment. Ctx starts in a block-comment.
-     * Returns the position of the sufix or null if gets to the end of the document and didn't found it.
-     * @param {!{editor:{CodeMirror}, pos:{ch:{string}, line:{number}}, token:{object}}} ctx - token context
-     * @param {!RegExp} suffixExp - a valid regular expression
-     * @param {!number} suffixLen - length of the suffix
-     * @return {?{line: number, ch: number}}
-     */
-    function _findCommentEnd(ctx, suffixExp, suffixLen) {
-        var result = true;
-        
-        while (result && !ctx.token.string.match(suffixExp)) {
-            result = TokenUtils.moveSkippingWhitespace(TokenUtils.moveNextToken, ctx);
-        }
-        return result ? {line: ctx.pos.line, ch: ctx.token.end - suffixLen} : null;
-    }
-    
-    /**
-     * @private
-     * Moves the token context to the next block-comment if there is one before end.
-     * @param {!{editor:{CodeMirror}, pos:{ch:{string}, line:{number}}, token:{object}}} ctx - token context
-     * @param {!{line: number, ch: number}} end - where to stop searching
-     * @param {!RegExp} prefixExp - a valid regular expression
-     * @return {boolean} - true if it found a block-comment
-     */
-    function _findNextBlockComment(ctx, end, prefixExp) {
-        var index  = ctx.editor.indexFromPos(end),
-            inside = ctx.editor.indexFromPos(ctx.pos) <= index,
-            result = true;
         
-        while (result && inside && !ctx.token.string.match(prefixExp)) {
-            result = TokenUtils.moveSkippingWhitespace(TokenUtils.moveNextToken, ctx);
-            inside = ctx.editor.indexFromPos(ctx.pos) <= index;
+        // If we are now in a block comment token
+        if (result && ctx.token.type === "comment") {
+            // If it doesnt matches either prefix or suffix, we know is a block comment
+            if (!ctx.token.string.match(prefixExp) && !ctx.token.string.match(suffixExp)) {
+                return true;
+            // We found a line with just a block comment delimiter, but we can't tell which one it is, so we will
+            // keep searching recursively and return the opposite value
+            } else if (prefix === suffix && ctx.token.string.length === prefix.length) {
+                return !_isPrevTokenABlockComment(ctx, prefix, suffix, prefixExp, suffixExp, lineExp);
+            // We can just now the result by checking if the string matches the prefix
+            } else {
+                return ctx.token.string.match(prefixExp);
+            }
         }
-        return result && inside && !!ctx.token.string.match(prefixExp);
+        return false;
     }
     
+
     /**
      * Generates an edit that adds or removes block-comment tokens to the selection, preserving selection
      * and cursor position. Applies to the currently focused Editor.
      * 
-     * If the selection is inside a block-comment or one block-comment is inside or partially
-     * inside the selection we uncomment; otherwise we comment out.
+     * If the selection is inside a block-comment or one block-comment is inside or partially inside the selection
+     * it will uncomment, otherwise it will comment out, unless if there are multiple block comments inside the selection,
+     * where it does nothing.
      * Commenting out adds the prefix before the selection and the suffix after.
      * Uncommenting removes them.
      * 
-     * As a special case, if slashComment is true and the start or end of the selection is inside a 
-     * line-comment it needs to do a line uncomment if is not actually inside a bigger block comment and all
-     * the lines in the selection are line-commented. In this case, we return null to indicate to the caller
-     * that it needs to handle this selection as a line comment.
+     * If all the lines inside the selection are line-comment and if the selection is not inside a block-comment, it will
+     * line uncomment all the lines, otherwise it will block comment/uncomment. In the first case, we return null to
+     * indicate to the caller that it needs to handle this selection as a line comment.
      *
      * @param {!Editor} editor
      * @param {!string} prefix, e.g. "<!--"
@@ -276,124 +302,133 @@ define(function (require, exports, module) {
      * @param {?Array.<{!{start:{line:number, ch:number}, end:{line:number, ch:number}, reversed:boolean, primary:boolean}}>} selectionsToTrack
      *      An array of selections that should be tracked through this edit.
      * @return {{edit: {text: string, start:{line: number, ch: number}, end:?{line: number, ch: number}}|Array.<{text: string, start:{line: number, ch: number}, end:?{line: number, ch: number}}>,
-     *                  selection: {start:{line:number, ch:number}, end:{line:number, ch:number}, primary:boolean, reversed: boolean, isBeforeEdit: boolean}>}|Array.<{start:{line:number, ch:number}, end:{line:number, ch:number}, primary:boolean, reversed: boolean, isBeforeEdit: boolean}>}}
+     *                  selection: {start:{line:number, ch:number}, end:{line:number, ch:number}, primary:boolean, reversed: boolean, isBeforeEdit: boolean}>}|
+     *                  Array.<{start:{line:number, ch:number}, end:{line:number, ch:number}, primary:boolean, reversed: boolean, isBeforeEdit: boolean}>}}
      *      An edit description suitable for including in the edits array passed to `Document.doMultipleEdits()`.
      */
     function _getBlockCommentPrefixSuffixEdit(editor, prefix, suffix, linePrefixes, sel, selectionsToTrack) {
         var doc            = editor.document,
             ctx            = TokenUtils.getInitialContext(editor._codeMirror, {line: sel.start.line, ch: sel.start.ch}),
-            startCtx       = TokenUtils.getInitialContext(editor._codeMirror, {line: sel.start.line, ch: sel.start.ch}),
-            endCtx         = TokenUtils.getInitialContext(editor._codeMirror, {line: sel.end.line, ch: sel.end.ch}),
+            selEndIndex    = editor.indexFromPos(sel.end),
+            lineExp        = _createLineExpressions(linePrefixes, prefix, suffix),
             prefixExp      = new RegExp("^" + StringUtils.regexEscape(prefix), "g"),
             suffixExp      = new RegExp(StringUtils.regexEscape(suffix) + "$", "g"),
-            lineExp        = _createLineExpressions(linePrefixes),
             prefixPos      = null,
             suffixPos      = null,
+            commentAtStart = true,
+            isBlockComment = false,
             canComment     = false,
             invalidComment = false,
             lineUncomment  = false,
+            result         = true,
             editGroup      = [],
             edit;
         
+        var searchCtx, atSuffix, suffixEnd, initialPos, endLine;
+        
         if (!selectionsToTrack) {
             // Track the original selection.
             selectionsToTrack = [_.cloneDeep(sel)];
         }
-
-        var result, text, line;
-
-        // Move the context to the first non-empty token.
+        
+        // First move the context to the first none white-space token
         if (!ctx.token.type && !/\S/.test(ctx.token.string)) {
             result = TokenUtils.moveSkippingWhitespace(TokenUtils.moveNextToken, ctx);
         }
-
-        // Check if we should just do a line uncomment (if all lines in the selection are commented).
-        if (lineExp.length && (_matchExpressions(ctx.token.string, lineExp) || _matchExpressions(endCtx.token.string, lineExp))) {
-            var startCtxIndex = editor.indexFromPos({line: ctx.pos.line, ch: ctx.token.start});
-            var endCtxIndex   = editor.indexFromPos({line: endCtx.pos.line, ch: endCtx.token.start + endCtx.token.string.length});
-
-            // Find if we aren't actually inside a block-comment
-            result = true;
-            while (result && _matchExpressions(ctx.token.string, lineExp)) {
-                result = TokenUtils.moveSkippingWhitespace(TokenUtils.movePrevToken, ctx);
-            }
-
-            // If we aren't in a block-comment.
-            if (!result || ctx.token.type !== "comment" || ctx.token.string.match(suffixExp)) {
-                // Is a range of text selected? (vs just an insertion pt)
-                var hasSelection = (sel.start.line !== sel.end.line) || (sel.start.ch !== sel.end.ch);
-
-                // In full-line selection, cursor pos is start of next line - but don't want to modify that line
-                var endLine = sel.end.line;
-                if (sel.end.ch === 0 && hasSelection) {
-                    endLine--;
-                }
-
-                // Find if all the lines are line-commented.
-                if (!_containsUncommented(editor, sel.start.line, endLine, lineExp)) {
-                    lineUncomment = true;
-
-                // Block-comment in all the other cases
+        
+        // Next, move forwards until we find a comment inside the selection
+        while (result && ctx.token.type !== "comment") {
+            result = TokenUtils.moveSkippingWhitespace(TokenUtils.moveNextToken, ctx) && editor.indexFromPos(ctx.pos) <= selEndIndex;
+            commentAtStart = false;
+        }
+        
+        // We are now in a comment, lets check if it is a block or a line comment
+        if (result && ctx.token.type === "comment") {
+            // This token might be at a line comment, but we can't be sure yet
+            if (_matchExpressions(ctx.token.string, lineExp)) {
+                // If the token starts at ch 0 with no starting white spaces, then this might be a block comment or a line
+                // comment over the whole line, and if we found this comment at the start of the selection, we need to search
+                // backwards until we get can tell if we are in a block or a line comment
+                if (ctx.token.start === 0 && !ctx.token.string.match(/^\\s*/) && commentAtStart) {
+                    searchCtx      = TokenUtils.getInitialContext(editor._codeMirror, {line: ctx.pos.line, ch: ctx.token.start});
+                    isBlockComment = _isPrevTokenABlockComment(searchCtx, prefix, suffix, prefixExp, suffixExp, lineExp);
+                
+                // If not, we already know that is a line comment
                 } else {
-                    canComment = true;
+                    isBlockComment = false;
                 }
+                
+            // If it was not a line comment, it has to be a block comment
             } else {
-                prefixPos = _findCommentStart(startCtx, prefixExp);
-                suffixPos = _findCommentEnd(startCtx, suffixExp, suffix.length);
+                isBlockComment = true;
+                
+                // If we are in a line that only has a prefix or a suffix and the prefix and suffix are the same string,
+                // lets find first if this is a prefix or suffix and move the context position to the inside of the block comment.
+                // This means that the token will be anywere inside the block comment, including the lines with the delimiters.
+                // This is required so that later we can find the prefix by moving backwards and the suffix by moving forwards.
+                if (ctx.token.string === prefix && prefix === suffix) {
+                    searchCtx = TokenUtils.getInitialContext(editor._codeMirror, {line: ctx.pos.line, ch: ctx.token.start});
+                    atSuffix  = _isPrevTokenABlockComment(searchCtx, prefix, suffix, prefixExp, suffixExp, lineExp);
+                    if (atSuffix) {
+                        TokenUtils.moveSkippingWhitespace(TokenUtils.movePrevToken, ctx);
+                    } else {
+                        TokenUtils.moveSkippingWhitespace(TokenUtils.moveNextToken, ctx);
+                    }
+                }
             }
-
-        // If we are in a selection starting and ending in invalid tokens and with no content (not considering spaces),
-        // find if we are inside a block-comment.
-        } else if (startCtx.token.type === null && endCtx.token.type === null &&
-                !editor.posWithinRange(ctx.pos, startCtx.pos, endCtx.pos, true)) {
-            result = TokenUtils.moveSkippingWhitespace(TokenUtils.moveNextToken, startCtx);
-
-            // We found a comment, find the start and end and check if the selection is inside the block-comment.
-            if (startCtx.token.type === "comment") {
-                prefixPos = _findCommentStart(startCtx, prefixExp);
-                suffixPos = _findCommentEnd(startCtx, suffixExp, suffix.length);
-
-                if (prefixPos !== null && suffix !== null && !editor.posWithinRange(sel.start, prefixPos, suffixPos, true)) {
+            
+            if (isBlockComment) {
+                // Save the initial position to start searching for the suffix from here
+                initialPos = _.cloneDeep(ctx.pos);
+                
+                // Find the position of the start of the prefix
+                result = true;
+                while (result && !ctx.token.string.match(prefixExp)) {
+                    result = TokenUtils.moveSkippingWhitespace(TokenUtils.movePrevToken, ctx);
+                }
+                prefixPos = result && {line: ctx.pos.line, ch: ctx.token.start};
+                
+                // Restore the context at the initial position to find the position of the start of the suffix,
+                // but only when we found the prefix alone in one line
+                if (ctx.token.string === prefix && prefix === suffix) {
+                    ctx = TokenUtils.getInitialContext(editor._codeMirror, _.cloneDeep(initialPos));
+                }
+                
+                while (result && !ctx.token.string.match(suffixExp)) {
+                    result = TokenUtils.moveSkippingWhitespace(TokenUtils.moveNextToken, ctx);
+                }
+                suffixPos = result && {line: ctx.pos.line, ch: ctx.token.end - suffix.length};
+                
+                // Lets check if there are more comments in the selection. We do nothing if there is one
+                do {
+                    result = TokenUtils.moveSkippingWhitespace(TokenUtils.moveNextToken, ctx) &&
+                        editor.indexFromPos(ctx.pos) <= selEndIndex;
+                } while (result && !ctx.token.string.match(prefixExp));
+                invalidComment = result && !!ctx.token.string.match(prefixExp);
+                
+                // Make sure we didn't search so far backward or forward that we actually found a block comment
+                // that's entirely before or after the selection.
+                suffixEnd = suffixPos && { line: suffixPos.line, ch: suffixPos.ch + suffix.length };
+                if ((suffixEnd && CodeMirror.cmpPos(sel.start, suffixEnd) > 0) || (prefixPos && CodeMirror.cmpPos(sel.end, prefixPos) < 0)) {
                     canComment = true;
                 }
-            } else {
-                canComment = true;
-            }
 
-        // If the start is inside a comment, find the prefix and suffix positions.
-        } else if (ctx.token.type === "comment") {
-            prefixPos = _findCommentStart(ctx, prefixExp);
-            suffixPos = _findCommentEnd(ctx, suffixExp, suffix.length);
-
-        // If not try to find the first comment inside the selection.
-        } else {
-            result = _findNextBlockComment(ctx, sel.end, prefixExp);
-
-            // If nothing was found is ok to comment.
-            if (!result) {
-                canComment = true;
             } else {
-                if (!ctx.token.string.match(prefixExp)) {
-                    prefixPos = _findCommentStart(ctx, prefixExp);
-                } else {
-                    prefixPos = {line: ctx.pos.line, ch: ctx.token.start};
+                // In full-line selection, cursor pos is at the start of next line - but don't want to modify that line
+                endLine = sel.end.line;
+                if (sel.end.ch === 0 && editor.hasSelection()) {
+                    endLine--;
                 }
-                suffixPos = _findCommentEnd(ctx, suffixExp, suffix.length);
-            }
-        }
-
-        // Search if there is another comment in the selection. Do nothing if there is one.
-        if (!canComment && !invalidComment && !lineUncomment && suffixPos) {
-            var start = {line: suffixPos.line, ch: suffixPos.ch + suffix.length + 1};
-            if (editor.posWithinRange(start, sel.start, sel.end, true)) {
-                // Start searching at the next token, if there is one.
-                result = TokenUtils.moveSkippingWhitespace(TokenUtils.moveNextToken, ctx) &&
-                         _findNextBlockComment(ctx, sel.end, prefixExp);
-
-                if (result) {
-                    invalidComment = true;
+                // Find if all the lines are line-commented.
+                if (!_containsNotLineComment(editor, sel.start.line, endLine, lineExp)) {
+                    lineUncomment = true;
+                } else {
+                    canComment = true;
                 }
             }
+        // If not, we can comment
+        } else {
+            canComment = true;
         }
 
 
@@ -410,8 +445,8 @@ define(function (require, exports, module) {
             edit = null;
 
         } else {
+            // Comment out - add the suffix to the start and the prefix to the end.
             if (canComment) {
-                // Comment out - add the suffix to the start and the prefix to the end.
                 var completeLineSel = sel.start.ch === 0 && sel.end.ch === 0 && sel.start.line < sel.end.line;
                 if (completeLineSel) {
                     editGroup.push({text: suffix + "\n", start: sel.end});
@@ -457,10 +492,10 @@ define(function (require, exports, module) {
             } else {
                 // Find if the prefix and suffix are at the ch 0 and if they are the only thing in the line.
                 // If both are found we assume that a complete line selection comment added new lines, so we remove them.
-                var prefixAtStart = false, suffixAtStart = false;
-
-                line = doc.getLine(prefixPos.line).trim();
-                prefixAtStart = prefixPos.ch === 0 && prefix.length === line.length;
+                var line          = doc.getLine(prefixPos.line).trim(),
+                    prefixAtStart = prefixPos.ch === 0 && prefix.length === line.length,
+                    suffixAtStart = false;
+                
                 if (suffixPos) {
                     line = doc.getLine(suffixPos.line).trim();
                     suffixAtStart = suffixPos.ch === 0 && suffix.length === line.length;
@@ -513,7 +548,8 @@ define(function (require, exports, module) {
      *      the line comment operation on, and `selectionsToTrack` are a set of selections associated with this line that need to be
      *      tracked through the edit.
      * @return {{edit: {text: string, start:{line: number, ch: number}, end:?{line: number, ch: number}}|Array.<{text: string, start:{line: number, ch: number}, end:?{line: number, ch: number}}>,
-     *                  selection: {start:{line:number, ch:number}, end:{line:number, ch:number}, primary:boolean, reversed: boolean, isBeforeEdit: boolean}>}|Array.<{start:{line:number, ch:number}, end:{line:number, ch:number}, primary:boolean, reversed: boolean, isBeforeEdit: boolean}>}}
+     *                  selection: {start:{line:number, ch:number}, end:{line:number, ch:number}, primary:boolean, reversed: boolean, isBeforeEdit: boolean}>}|
+     *                  Array.<{start:{line:number, ch:number}, end:{line:number, ch:number}, primary:boolean, reversed: boolean, isBeforeEdit: boolean}>}}
      *      An edit description suitable for including in the edits array passed to `Document.doMultipleEdits()`.
      */
     function _getLineCommentPrefixSuffixEdit(editor, prefix, suffix, lineSel) {
@@ -540,7 +576,8 @@ define(function (require, exports, module) {
      * @param {Array.<{start:{line:number, ch:number}, end:{line:number, ch:number}, primary:boolean, reversed: boolean, isBeforeEdit: boolean}>}
      *      selections The selections we want to line-comment.
      * @return {Array.<{edit: {text: string, start:{line: number, ch: number}, end:?{line: number, ch: number}}|Array.<{text: string, start:{line: number, ch: number}, end:?{line: number, ch: number}}>,
-     *                  selection: {start:{line:number, ch:number}, end:{line:number, ch:number}, primary:boolean, reversed: boolean, isBeforeEdit: boolean}>}|Array.<{start:{line:number, ch:number}, end:{line:number, ch:number}, primary:boolean, reversed: boolean, isBeforeEdit: boolean}>}>}
+     *                  selection: {start:{line:number, ch:number}, end:{line:number, ch:number}, primary:boolean, reversed: boolean, isBeforeEdit: boolean}>}|
+     *                  Array.<{start:{line:number, ch:number}, end:{line:number, ch:number}, primary:boolean, reversed: boolean, isBeforeEdit: boolean}>}>}
      *      An array of edit descriptions suitable for including in the edits array passed to `Document.doMultipleEdits()`.
      */
     function _getLineCommentEdits(editor, selections) {
@@ -556,7 +593,7 @@ define(function (require, exports, module) {
                 var language = editor.document.getLanguage().getLanguageForMode(mode.name || mode);
 
                 if (language.hasLineCommentSyntax()) {
-                    edit = _getLineCommentPrefixEdit(editor, language.getLineCommentPrefixes(), lineSel);
+                    edit = _getLineCommentPrefixEdit(editor, language.getLineCommentPrefixes(), language.getBlockCommentPrefix(), language.getBlockCommentSuffix(), lineSel);
                 } else if (language.hasBlockCommentSyntax()) {
                     edit = _getLineCommentPrefixSuffixEdit(editor, language.getBlockCommentPrefix(), language.getBlockCommentSuffix(), lineSel);
                 }
diff --git a/src/language/languages.json b/src/language/languages.json
index 136781fa8bb..50fd6e6d1eb 100644
--- a/src/language/languages.json
+++ b/src/language/languages.json
@@ -142,7 +142,9 @@
         "name": "CoffeeScript",
         "mode": "coffeescript",
         "fileExtensions": ["coffee", "cf", "cson", "_coffee"],
-        "fileNames": ["Cakefile"]
+        "fileNames": ["Cakefile"],
+        "blockComment": ["###", "###"],
+        "lineComment": ["#"]
     },
 
     "clojure": {
@@ -185,7 +187,9 @@
     "lua": {
         "name": "Lua",
         "mode": "lua",
-        "fileExtensions": ["lua"]
+        "fileExtensions": ["lua"],
+        "blockComment": ["--[[", "]]"],
+        "lineComment": ["--"]
     },
 
     "sql": {
diff --git a/test/spec/EditorCommandHandlers-test.js b/test/spec/EditorCommandHandlers-test.js
index 15a3e33906b..849539f2abf 100644
--- a/test/spec/EditorCommandHandlers-test.js
+++ b/test/spec/EditorCommandHandlers-test.js
@@ -419,6 +419,31 @@ define(function (require, exports, module) {
                 expectSelection({start: {line: 1, ch: 0}, end: {line: 6, ch: 0}});
             });
             
+            it("should uncomment ragged partial comments with empty lines in-between", function () {
+                // Start with lines 1-5 commented out, with "//" snug up against each non-blank line's code
+                var lines = defaultContent.split("\n");
+                lines[1] = "    //function bar() {";
+                lines[2] = "";
+                lines[3] = "        //a();";
+                lines[4] = "";
+                lines[5] = "    //}";
+                var startingContent = lines.join("\n");
+                myDocument.setText(startingContent);
+                
+                // select lines 1-5
+                myEditor.setSelection({line: 1, ch: 0}, {line: 6, ch: 0});
+                
+                lines = defaultContent.split("\n");
+                lines[2] = "";
+                lines[4] = "";
+                var expectedText = lines.join("\n");
+                
+                CommandManager.execute(Commands.EDIT_LINE_COMMENT, myEditor);
+                
+                expect(myDocument.getText()).toEqual(expectedText);
+                expectSelection({start: {line: 1, ch: 0}, end: {line: 6, ch: 0}});
+            });
+            
             it("should uncomment ragged partial comments", function () {
                 // Start with lines 1-5 commented out, with "//" snug up against each non-blank line's code
                 var lines = defaultContent.split("\n");
@@ -630,6 +655,7 @@ define(function (require, exports, module) {
                 expectSelection({start: {line: 1, ch: 0}, end: {line: 4, ch: 0}});
             });
         });
+        
         describe("Line comment in languages with no given line comment prefix", function () {
             beforeEach(function () {
                 setupFullEditor(null, "unknown");
@@ -742,6 +768,22 @@ define(function (require, exports, module) {
                 expect(myDocument.getText()).toEqual(defaultContent);
                 expectCursorAt({line: 1, ch: 16});
             });
+            
+            it("should block uncomment, cursor within existing block comment suffix", function () {
+                // Start with part of line 1 wrapped in a block comment
+                var lines = defaultContent.split("\n");
+                lines[1] = "    function /*bar()*/ {";
+                var startingContent = lines.join("\n");
+                myDocument.setText(startingContent);
+
+                // put cursor within block
+                myEditor.setCursorPos(1, 21);
+                
+                CommandManager.execute(Commands.EDIT_BLOCK_COMMENT, myEditor);
+                
+                expect(myDocument.getText()).toEqual(defaultContent);
+                expectCursorAt({line: 1, ch: 18});
+            });
 
             it("should block uncomment, selection covering whole sub-line block comment", function () {
                 // Start with part of line 1 wrapped in a block comment
@@ -1895,6 +1937,248 @@ define(function (require, exports, module) {
         });
         
         
+        describe("Comment/uncomment on languages with equal prefix and suffix and a line prefix being prefix of a block prefix/suffix", function () {
+            // Define a new CoffeeScript language for testing purposes
+            LanguageManager.defineLanguage("coffeescript2", {
+                "name": "CoffeeScript2",
+                "mode": "coffeescript",
+                "fileExtensions": ["coffee2"],
+                "blockComment": ["###", "###"],
+                "lineComment": ["#"]
+            });
+            
+            var coffeeContent = "foo = 42\n" +
+                                "bar = true\n" +
+                                "baz = \"hello\"\n" +
+                                "number = -42\n" +
+                                "if bar square = (x) -> x * x";
+            
+            function getContentCommented(startLine, endLine, content) {
+                var lines = (content || coffeeContent).split("\n");
+                lines.splice(endLine, 0, "###");
+                lines.splice(startLine, 0, "###");
+                return lines.join("\n");
+            }
+            
+            beforeEach(function () {
+                setupFullEditor(coffeeContent, "coffeescript2");
+            });
+            
+            it("should block comment/uncomment selecting part of lines", function () {
+                myEditor.setSelection({line: 2, ch: 2}, {line: 3, ch: 5});
+                
+                var lines = coffeeContent.split("\n");
+                lines[2] = "ba###z = \"hello\"";
+                lines[3] = "numbe###r = -42";
+                var expectedText = lines.join("\n");
+                
+                testToggleBlock(expectedText, {start: {line: 2, ch: 5}, end: {line: 3, ch: 5}});
+            });
+            
+            it("should block comment/uncomment selecting full lines", function () {
+                myEditor.setSelection({line: 1, ch: 0}, {line: 3, ch: 0});
+                var expectedText = getContentCommented(1, 3);
+                
+                testToggleBlock(expectedText, {start: {line: 2, ch: 0}, end: {line: 4, ch: 0}});
+            });
+            
+            it("should block uncomment when selecting the prefix and suffix", function () {
+                myDocument.setText(getContentCommented(1, 3));
+                myEditor.setSelection({line: 1, ch: 0}, {line: 5, ch: 0});
+                
+                CommandManager.execute(Commands.EDIT_BLOCK_COMMENT, myEditor);
+                
+                expect(myDocument.getText()).toEqual(coffeeContent);
+                expectSelection({start: {line: 1, ch: 0}, end: {line: 3, ch: 0}});
+            });
+            
+            it("should block uncomment when selecting only the prefix", function () {
+                myDocument.setText(getContentCommented(1, 3));
+                myEditor.setSelection({line: 1, ch: 0}, {line: 2, ch: 0});
+                
+                CommandManager.execute(Commands.EDIT_BLOCK_COMMENT, myEditor);
+                
+                expect(myDocument.getText()).toEqual(coffeeContent);
+                expectSelection({start: {line: 1, ch: 0}, end: {line: 1, ch: 0}});
+            });
+            
+            it("should block uncomment when selecting only the suffix", function () {
+                myDocument.setText(getContentCommented(1, 3));
+                myEditor.setSelection({line: 4, ch: 0}, {line: 5, ch: 0});
+                
+                CommandManager.execute(Commands.EDIT_BLOCK_COMMENT, myEditor);
+                
+                expect(myDocument.getText()).toEqual(coffeeContent);
+                expectSelection({start: {line: 3, ch: 0}, end: {line: 3, ch: 0}});
+            });
+            
+            it("should do nothing when selecting from a suffix to a prefix", function () {
+                var expectedText = getContentCommented(0, 1, getContentCommented(4, 5));
+                myDocument.setText(expectedText);
+                myEditor.setSelection({line: 2, ch: 0}, {line: 7, ch: 0});
+                
+                CommandManager.execute(Commands.EDIT_BLOCK_COMMENT, myEditor);
+                
+                expect(myDocument.getText()).toEqual(expectedText);
+                expectSelection({start: {line: 2, ch: 0}, end: {line: 7, ch: 0}});
+            });
+            
+            it("should block uncomment with line comments around the block comment", function () {
+                var lines = coffeeContent.split("\n");
+                lines[0] = "#foo = 42";
+                lines[3] = "#number = -42";
+                var expectedText = lines.join("\n");
+                
+                myDocument.setText(getContentCommented(1, 3, expectedText));
+                myEditor.setSelection({line: 1, ch: 0}, {line: 3, ch: 0});
+                
+                CommandManager.execute(Commands.EDIT_BLOCK_COMMENT, myEditor);
+                
+                expect(myDocument.getText()).toEqual(expectedText);
+                expectSelection({start: {line: 1, ch: 0}, end: {line: 2, ch: 0}});
+            });
+            
+            it("should block uncomment when the lines inside the block comment are line commented", function () {
+                var lines = coffeeContent.split("\n");
+                lines[2] = "#baz = \"hello\"";
+                var expectedText = lines.join("\n");
+                
+                myDocument.setText(getContentCommented(1, 3, expectedText));
+                myEditor.setSelection({line: 3, ch: 0}, {line: 4, ch: 0});
+                
+                CommandManager.execute(Commands.EDIT_BLOCK_COMMENT, myEditor);
+                
+                expect(myDocument.getText()).toEqual(expectedText);
+                expectSelection({start: {line: 2, ch: 0}, end: {line: 3, ch: 0}});
+            });
+            
+            it("should block uncomment a second block comment", function () {
+                var expectedText = getContentCommented(0, 1);
+                myDocument.setText(getContentCommented(6, 7, expectedText));
+                myEditor.setSelection({line: 7, ch: 0}, {line: 8, ch: 0});
+                
+                CommandManager.execute(Commands.EDIT_BLOCK_COMMENT, myEditor);
+                
+                expect(myDocument.getText()).toEqual(expectedText + "\n");
+                expectSelection({start: {line: 6, ch: 0}, end: {line: 7, ch: 0}});
+            });
+            
+            it("should block uncomment with line comments in between the block comments", function () {
+                var lines = coffeeContent.split("\n");
+                lines[1] = "#bar = true";
+                lines[2] = "#baz = \"hello\"";
+                lines[3] = "#number = -42";
+                var expectedText = getContentCommented(0, 1, lines.join("\n"));
+                
+                myDocument.setText(getContentCommented(6, 7, expectedText));
+                myEditor.setSelection({line: 7, ch: 0}, {line: 8, ch: 0});
+                
+                CommandManager.execute(Commands.EDIT_BLOCK_COMMENT, myEditor);
+                
+                expect(myDocument.getText()).toEqual(expectedText + "\n");
+                expectSelection({start: {line: 6, ch: 0}, end: {line: 7, ch: 0}});
+            });
+            
+            it("should block comment on an empty line around comments", function () {
+                var lines = coffeeContent.split("\n");
+                lines[2] = "###baz = \"hello\"###";
+                lines[3] = "";
+                lines[4] = "#number = -42";
+                var text = lines.join("\n");
+                
+                lines[3] = "######";
+                var expectedText = lines.join("\n");
+                
+                myDocument.setText(text);
+                myEditor.setCursorPos(3, 0);
+                
+                CommandManager.execute(Commands.EDIT_BLOCK_COMMENT, myEditor);
+                
+                expect(myDocument.getText()).toEqual(expectedText);
+                expectCursorAt({line: 3, ch: 3});
+            });
+            
+            it("should block uncomment on an empty line inside a block comment", function () {
+                var lines = coffeeContent.split("\n");
+                lines[1] = "###bar = true";
+                lines[2] = "";
+                lines[3] = "number = -42###";
+                var text = lines.join("\n");
+                
+                lines = coffeeContent.split("\n");
+                lines[2] = "";
+                var expectedText = lines.join("\n");
+                
+                myDocument.setText(text);
+                myEditor.setCursorPos(2, 0);
+                
+                CommandManager.execute(Commands.EDIT_BLOCK_COMMENT, myEditor);
+                
+                expect(myDocument.getText()).toEqual(expectedText);
+                expectCursorAt({line: 2, ch: 0});
+            });
+            
+            it("should line uncomment on line comments around a block comment", function () {
+                var lines = getContentCommented(1, 3).split("\n");
+                lines[5] = "#number = -42";
+                var text = lines.join("\n");
+                
+                lines = text.split("\n");
+                lines[5] = "number = -42";
+                var expectedText = lines.join("\n");
+                
+                myDocument.setText(text);
+                myEditor.setSelection({line: 5, ch: 0}, {line: 6, ch: 0});
+                
+                CommandManager.execute(Commands.EDIT_BLOCK_COMMENT, myEditor);
+                
+                expect(myDocument.getText()).toEqual(expectedText);
+                expectSelection({start: {line: 5, ch: 0}, end: {line: 6, ch: 0}});
+            });
+            
+            it("should line comment block commented lines", function () {
+                var lines = coffeeContent.split("\n");
+                lines[2] = "###baz = \"hello\"###";
+                var text = lines.join("\n");
+                
+                lines = text.split("\n");
+                lines[2] = "####baz = \"hello\"###";
+                var expectedText = lines.join("\n");
+                
+                myDocument.setText(text);
+                myEditor.setSelection({line: 2, ch: 0}, {line: 2, ch: 5});
+                CommandManager.execute(Commands.EDIT_LINE_COMMENT, myEditor);
+                
+                expect(myDocument.getText()).toEqual(expectedText);
+                expectSelection({start: {line: 2, ch: 0}, end: {line: 2, ch: 6}});
+            });
+            
+            it("should line comment in block comment prefix or sufix starting lines", function () {
+                var lines = coffeeContent.split("\n");
+                lines[0] = "#foo = 42";
+                lines[3] = "#number = -42";
+                var text = getContentCommented(1, 3, lines.join("\n"));
+                
+                lines = text.split("\n");
+                lines[0] = "##foo = 42";
+                lines[1] = "####";
+                lines[4] = "####";
+                lines[5] = "##number = -42";
+                var expectedText = lines.join("\n");
+                
+                myDocument.setText(text);
+                myEditor.setSelection({line: 0, ch: 0}, {line: 2, ch: 0});
+                CommandManager.execute(Commands.EDIT_LINE_COMMENT, myEditor);
+                
+                myEditor.setSelection({line: 4, ch: 0}, {line: 6, ch: 0});
+                CommandManager.execute(Commands.EDIT_LINE_COMMENT, myEditor);
+                
+                expect(myDocument.getText()).toEqual(expectedText);
+                expectSelection({start: {line: 4, ch: 0}, end: {line: 6, ch: 0}});
+            });
+        });
+        
+        
         describe("Duplicate", function () {
             beforeEach(setupFullEditor);
 
diff --git a/test/spec/LanguageManager-test.js b/test/spec/LanguageManager-test.js
index 0eb415642e3..e9d05fff9af 100644
--- a/test/spec/LanguageManager-test.js
+++ b/test/spec/LanguageManager-test.js
@@ -122,7 +122,9 @@ define(function (require, exports, module) {
                     "name": "CoffeeScript",
                     "mode": "coffeescript",
                     "fileExtensions": ["coffee", "cf", "cson"],
-                    "fileNames": ["cakefile"]
+                    "fileNames": ["cakefile"],
+                    "lineComment": ["#"],
+                    "blockComment": {prefix: "###", suffix: "###"}
                 };
 
                 validateLanguage(def, coffee);