blob: ab4831f7abdd055b3d335b24187f956ff9cbad13 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.spark.sql.catalyst.expressions.codegen
/**
* An utility class that indents a block of code based on the curly braces and parentheses.
* This is used to prettify generated code when in debug mode (or exceptions).
*
* Written by Matei Zaharia.
*/
object CodeFormatter {
def format(code: String): String = new CodeFormatter().addLines(code).result()
def stripExtraNewLines(input: String): String = {
val code = new StringBuilder
var lastLine: String = "dummy"
input.split('\n').foreach { l =>
val line = l.trim()
val skip = line == "" && (lastLine == "" || lastLine.endsWith("{"))
if (!skip) {
code.append(line)
code.append("\n")
}
lastLine = line
}
code.result()
}
}
private class CodeFormatter {
private val code = new StringBuilder
private val indentSize = 2
// Tracks the level of indentation in the current line.
private var indentLevel = 0
private var indentString = ""
private var currentLine = 1
// Tracks the level of indentation in multi-line comment blocks.
private var inCommentBlock = false
private var indentLevelOutsideCommentBlock = indentLevel
private def addLine(line: String): Unit = {
// We currently infer the level of indentation of a given line based on a simple heuristic that
// examines the number of parenthesis and braces in that line. This isn't the most robust
// implementation but works for all code that we generate.
val indentChange = line.count(c => "({".indexOf(c) >= 0) - line.count(c => ")}".indexOf(c) >= 0)
var newIndentLevel = math.max(0, indentLevel + indentChange)
// Please note that while we try to format the comment blocks in exactly the same way as the
// rest of the code, once the block ends, we reset the next line's indentation level to what it
// was immediately before entering the comment block.
if (!inCommentBlock) {
if (line.startsWith("/*")) {
// Handle multi-line comments
inCommentBlock = true
indentLevelOutsideCommentBlock = indentLevel
} else if (line.startsWith("//")) {
// Handle single line comments
newIndentLevel = indentLevel
}
}
if (inCommentBlock) {
if (line.endsWith("*/")) {
inCommentBlock = false
newIndentLevel = indentLevelOutsideCommentBlock
}
}
// Lines starting with '}' should be de-indented even if they contain '{' after;
// in addition, lines ending with ':' are typically labels
val thisLineIndent = if (line.startsWith("}") || line.startsWith(")") || line.endsWith(":")) {
" " * (indentSize * (indentLevel - 1))
} else {
indentString
}
code.append(f"/* ${currentLine}%03d */ ")
code.append(thisLineIndent)
code.append(line)
code.append("\n")
indentLevel = newIndentLevel
indentString = " " * (indentSize * newIndentLevel)
currentLine += 1
}
private def addLines(code: String): CodeFormatter = {
code.split('\n').foreach(s => addLine(s.trim()))
this
}
private def result(): String = code.result()
}
|
