File indexing completed on 2024-05-19 04:00:09

 var katescript = {
     "name": "Python",
     "author": "Paul Giannaros <paul@giannaros.org>, Gerald Senarclens de Grancy <oss@senarclens.eu>",
     "license": "LGPL",
     "revision": 4,
     "kate-version": "5.1",
     "indent-languages": ["Python"]
 }; // kate-script-header, must be at the start of the file without comments, pure json
 
 // required katepart js libraries
 require ("range.js");
 require ("string.js");
 
 openings = ['(', '[', '{'];
 closings = [')', ']', '}'];  // requires same order as in openings
 unindenters = /\b(continue|pass|raise|return|break)\b/;
 immediate_unindenters = new Set(["else", "elif", "finally", "except"])
 
 triggerCharacters = ": ";
 
 var debugMode = false;
 
 function dbg() {
     if (debugMode) {
         debug.apply(this, arguments);
     }
 }
 
 // Return the given line without comments and leading or trailing whitespace.
 // Eg.
 // getCode(x) -> "for i in range(3):"
 //     if document.line(x) == "  for i in range(3):"
 // getCode(x) -> "for i in range(3):"
 //     if document.line(x) == "for i in range(3):  "
 // getCode(x) -> "for i in range(3):"
 //     if document.line(x) == "for i in range(3):  # grand"
 function getCode(lineNr, virtcol=-1) {
     var line = document.line(lineNr);
     var code = '';
     virtcol = virtcol >= 0 ? virtcol : document.firstVirtualColumn(lineNr);
     if (virtcol < 0)
         return code;
     for (; virtcol < line.length; ++virtcol) {
         if (document.isCode(lineNr, virtcol)) {
             code += line[virtcol];
         }
     }
     return code.trim();
 }
 
 
 // Return the indent if a opening bracket is not closed (incomplete sequence).
 // The calculated intent is the innermost opening bracket's position plus 1.
 // `lineNr`: the number of the line on which the brackets should be counted
 function _calcOpeningIndent(lineNr) {
     var line = document.line(lineNr);
     var countClosing = new Array();
     closings.forEach(function(elem) {
         countClosing[elem] = 0;
     });
     for (i = line.length - 1; i >= 0; --i) {
         if (document.isComment(lineNr, i) || document.isString(lineNr, i))
             continue;
         if (closings.indexOf(line[i]) > -1)
             countClosing[line[i]]++;
         var index = openings.indexOf(line[i]);
         if (index > -1) {
             if (countClosing[closings[index]] == 0) {
                 return i + 1;
             }
             countClosing[closings[index]]--;
         }
     }
     return -1;
 }
 
 
 // Return the indent if a closing bracket not opened (incomplete sequence).
 // The intent is the same as on the line with the unmatched opening bracket.
 // `lineNr`: the number of the line on which the brackets should be counted
 function _calcClosingIndent(lineNr, indentWidth) {
     var line = document.line(lineNr);
     var countClosing = new Array();
     closings.forEach(function(elem) {
         countClosing[elem] = 0;
     });
     for (i = line.length - 1; i >= 0; --i) {
         if (document.isComment(lineNr, i) || document.isString(lineNr, i))
             continue;
         if (closings.indexOf(line[i]) > -1)
             countClosing[line[i]]++;
         var index = openings.indexOf(line[i]);
         if (index > -1)
             countClosing[closings[index]]--;
     }
     for (var key in countClosing) {
         if (countClosing[key] > 0) {  // unmatched closing bracket
             for (--lineNr; lineNr >= 0; --lineNr) {
                 if (_calcOpeningIndent(lineNr) > -1) {
                     var indent = document.firstVirtualColumn(lineNr);
                     if (shouldUnindent(lineNr + 1))
                         return Math.max(0, indent - indentWidth);
                     return indent;
                 }
             }
         }
     }
     return -1;
 }
 
 
 // Returns the indent for mismatched (opening or closing) brackets.
 // If there are no mismatched brackets, -1 is returned.
 // `lineNr`: number of the line for which the indent is calculated
 function calcBracketIndent(lineNr, indentWidth) {
     var indent = _calcOpeningIndent(lineNr - 1);
     if (indent > -1)
         return indent
     indent = _calcClosingIndent(lineNr - 1, indentWidth);
     if (indent > -1)
         return indent
     return -1;
 }
 
 
 // Return true if a single unindent should occur.
 function shouldUnindent(LineNr) {
     lastLine = getCode(LineNr - 1);
     if (lastLine.match(unindenters))
         return 1;
 
     // unindent if the last line was indented b/c of a backslash
     if (LineNr >= 2) {
         secondLastLine = getCode(LineNr - 2);
         if (secondLastLine.length && secondLastLine.substr(-1) == "\\")
             return 1;
     }
     return 0;
 }
 
 function findLastIndent(lineNr) {
     for (; getCode(lineNr).length == 0; --lineNr);
     return document.firstVirtualColumn(lineNr);
 }
 
 function getDocStringStart(line) {
     var currentLine = line;
     var currentString;
 
     if (!document.isComment(line, document.firstVirtualColumn(line)) || document.line(currentLine).charAt(document.firstVirtualColumn(line)) === '#') {
         return -1;
     }
 
     while (currentLine >= 0) {
         currentString = document.line(currentLine - 1);
         if (currentString.charAt(document.firstVirtualColumn(currentLine - 1)) !== '#') {
             if (currentString.includes("'''") || currentString.includes('"""')) {
                 break;
             }
         }
         --currentLine;
     }
     return currentLine - 1;
 }
 
 function getPrevDocStringEnd(line) {
     var currentLine = line;
     var currentString;
 
     while (currentLine >= 0) {
         currentString = document.line(currentLine - 1);
         if (currentString.includes("'''") || currentString.includes('"""')) {
             break;
         } else if (getCode(currentLine - 1, 0).length) {
             return -1;
         }
         --currentLine;
     }
     return currentLine - 1;
 }
 
 function getMultiLineStringStart(line) {
     var currentLine = line;
     var currentString;
 
     if (!document.isString(line, document.firstVirtualColumn(line))) {
         return -1;
     }
 
     while (currentLine >= 0) {
         currentString = document.line(currentLine - 1);
         if (!document.isComment(currentLine - 1, document.firstVirtualColumn(currentLine - 1))) {
             if (currentString.includes("'''") || currentString.includes('"""')) {
                 break;
             }
         }
         --currentLine;
     }
     return currentLine - 1;
 }
 
 function getPrevMultiLineStringEnd(line) {
     var currentLine = line;
     var currentString;
 
     while (currentLine >= 0) {
         currentString = document.line(currentLine - 1);
         currentCode = getCode(document.line(currentLine - 1), 0);
         if (!document.isComment(currentLine - 1, document.firstVirtualColumn(currentLine - 1))) {
             if (currentString.includes("'''") || currentString.includes('"""')) {
                 break;
             } else if (getCode(currentLine - 1, 0).length) {
                 return -1;
             }
         }
         --currentLine;
     }
     return currentLine - 1;
 }
 
 // Return the amount of characters (in spaces) to be indented.
 // Special indent() return values:
 //   -2 = no indent
 //   -1 = keep last indent
 // Follow PEP8 for unfinished sequences and argument lists.
 // Nested sequences are not implemented. (neither by Emacs' python-mode)
 function indent(line, indentWidth, character) {
     if (line == 0)  // don't ever act on document's first line
         return -2;
     if (!document.line(line - 1).length)  // empty line
         return -2;
 
     if (triggerCharacters.indexOf(character) > -1 && character.length) {
         var virtcol = document.firstVirtualColumn(line);
         var lline = getCode(line, virtcol);
         if (character != " ")
             lline = lline.substring(0, lline.length - 1);
         if (immediate_unindenters.has(lline) && virtcol == findLastIndent(line - 1) && lline.length == document.line(line).length - virtcol - 1)
             return Math.max(0, virtcol - indentWidth);
         else
             return -2
     }
 
     var virtcol = document.firstVirtualColumn(line - 1);
     var lastLine = getCode(line - 1, virtcol);
     var lastChar = lastLine.substr(-1);
 
     // indent when opening bracket or backslash is at the end the previous line
     if (openings.indexOf(lastChar) >= 0 || lastChar == "\\") {
         return virtcol + indentWidth;
     }
     var indent = calcBracketIndent(line, indentWidth);
     if (lastLine.endsWith(':')) {
         if (indent > -1)
             indent += indentWidth;
         else
             indent = virtcol + indentWidth;
     }
     docStringStart = getDocStringStart(line);
     if (docStringStart > -1) {
         if (docStringStart === line) {
             return -1;
         }
         dbg("line = {" + document.line(line) + "} docStringStart = {" + document.line(docStringStart) + "}" + " dsno = " + docStringStart);
         return document.firstVirtualColumn(line) + document.firstVirtualColumn(docStringStart) - indentWidth;
     }
     multiLineStringStart = getMultiLineStringStart(line);
     dbg("docStringStart = " + docStringStart);
     dbg("multiLineStringStart = " + multiLineStringStart);
     if (multiLineStringStart > -1) {
         if (multiLineStringStart === line) {
             return -1;
         }
         return -2;
     }
     if (indent === -1) {
         prevMultiLineStringEnd = getPrevMultiLineStringEnd(line);
         if (prevMultiLineStringEnd > -1) {
             prevMultiLineStringStart = getMultiLineStringStart(prevMultiLineStringEnd);
             return document.firstVirtualColumn(prevMultiLineStringStart);
         }
     }
     if (indent === -1) {
         prevDocStringEnd = getPrevDocStringEnd(line);
         if (prevDocStringEnd > -1) {
             prevDocStringStart = getDocStringStart(prevDocStringEnd);
             return document.firstVirtualColumn(prevDocStringStart);
         }
     }
     // continue, pass, raise, return etc. should unindent
     if (shouldUnindent(line) && (indent == -1)) {
         indent = Math.max(0, virtcol - indentWidth);
     }
     return indent;
 }
 
 // kate: space-indent on; indent-width 4; replace-tabs on;