OLD | NEW |
(Empty) | |
| 1 /* |
| 2 * Copyright 2014 Google Inc. |
| 3 * |
| 4 * Use of this source code is governed by a BSD-style license that can be |
| 5 * found in the LICENSE file. |
| 6 */ |
| 7 #include "gl/GrGLSLPrettyPrint.h" |
| 8 |
| 9 namespace GrGLSLPrettyPrint { |
| 10 |
| 11 class GLSLPrettyPrint { |
| 12 public: |
| 13 GLSLPrettyPrint() {} |
| 14 |
| 15 SkString prettify(const SkString& input, bool countlines) { |
| 16 // setup pretty state |
| 17 fIndex = 0; |
| 18 fLength = input.size(); |
| 19 fInput = input; |
| 20 fCountlines = countlines; |
| 21 fTabs = 0; |
| 22 fLinecount = 1; |
| 23 fFreshline = true; |
| 24 |
| 25 int parensDepth = 0; |
| 26 // number 1st line |
| 27 this->lineNumbering(); |
| 28 while (fLength > fIndex) { |
| 29 /* the heart and soul of our prettification algorithm. The rules sh
ould hopefully be |
| 30 * self explanatory. For '#' and '//' tokens we parse until we reac
h a newline. |
| 31 * |
| 32 * For long style comments like this one, we search for the ending t
oken. We also |
| 33 * preserve whitespace in these comments WITH THE CAVEAT that we do
the newlines |
| 34 * ourselves. This allows us to remain in control of line numbers,
and matching tabs |
| 35 * Existing tabs in the input string are copied over too, but this w
ill look funny |
| 36 * |
| 37 * '{' and '}' are handled in basically the same way. We add a newl
ine if we aren't |
| 38 * on a fresh line, dirty the line, then add a second newline, ie br
aces are always |
| 39 * on their own lines indented properly. The one funkiness here is
structs print with |
| 40 * the semicolon on its own line. Its not a problem for a glsl comp
iler though |
| 41 * |
| 42 * '(' and ')' are basically ignored, except as a sign we need to ig
nore ';' ala |
| 43 * in for loops. |
| 44 * |
| 45 * ';' means add a new line |
| 46 * |
| 47 * '\t' and '\n' are ignored in general parsing for backwards compat
ability with |
| 48 * existing shader code and we also have a special case for handling
whitespace |
| 49 * at the beginning of fresh lines. |
| 50 * |
| 51 * Otherwise just add the new character to the pretty string, indent
ing if necessary. |
| 52 */ |
| 53 if (this->hasToken("#") || this->hasToken("//")) { |
| 54 this->parseUntilNewline(); |
| 55 } else if (this->hasToken("/*")) { |
| 56 this->parseUntil("*/"); |
| 57 } else if ('{' == fInput[fIndex]) { |
| 58 this->newline(); |
| 59 this->appendChar('{'); |
| 60 fTabs++; |
| 61 this->newline(); |
| 62 } else if ('}' == fInput[fIndex]) { |
| 63 fTabs--; |
| 64 this->newline(); |
| 65 this->appendChar('}'); |
| 66 this->newline(); |
| 67 } else if (this->hasToken(")")) { |
| 68 parensDepth--; |
| 69 } else if (this->hasToken("(")) { |
| 70 parensDepth++; |
| 71 } else if (!parensDepth && this->hasToken(";")) { |
| 72 this->newline(); |
| 73 } else if ('\t' == fInput[fIndex] || '\n' == fInput[fIndex] || |
| 74 (fFreshline && ' ' == fInput[fIndex])) { |
| 75 fIndex++; |
| 76 } else { |
| 77 this->appendChar(input[fIndex]); |
| 78 } |
| 79 } |
| 80 return fPretty; |
| 81 } |
| 82 private: |
| 83 void appendChar(char c) { |
| 84 this->tabString(); |
| 85 fPretty.appendf("%c", fInput[fIndex++]); |
| 86 fFreshline = false; |
| 87 } |
| 88 |
| 89 // hasToken automatically consumes the next token, if it is a match, and the
n tabs |
| 90 // if necessary, before inserting the token into the pretty string |
| 91 bool hasToken(const char* token) { |
| 92 size_t i = fIndex; |
| 93 for (size_t j = 0; token[j] && fLength > i; i++, j++) { |
| 94 if (token[j] != fInput[i]) { |
| 95 return false; |
| 96 } |
| 97 } |
| 98 this->tabString(); |
| 99 fIndex = i; |
| 100 fPretty.append(token); |
| 101 fFreshline = false; |
| 102 return true; |
| 103 } |
| 104 |
| 105 void parseUntilNewline() { |
| 106 while (fLength > fIndex) { |
| 107 if ('\n' == fInput[fIndex]) { |
| 108 fIndex++; |
| 109 this->newline(); |
| 110 break; |
| 111 } |
| 112 fPretty.appendf("%c", fInput[fIndex++]); |
| 113 } |
| 114 } |
| 115 |
| 116 // this code assumes it is not actually searching for a newline. If you nee
d to search for a |
| 117 // newline, then use the function above. If you do search for a newline wit
h this function |
| 118 // it will consume the entire string and the output will certainly not be pr
ettified |
| 119 void parseUntil(const char* token) { |
| 120 while (fLength > fIndex) { |
| 121 // For embedded newlines, this code will make sure to embed the new
line in the |
| 122 // pretty string, increase the linecount, and tab out the next line
to the appropriate |
| 123 // place |
| 124 if ('\n' == fInput[fIndex]) { |
| 125 this->newline(); |
| 126 this->tabString(); |
| 127 fIndex++; |
| 128 } |
| 129 if (this->hasToken(token)) { |
| 130 break; |
| 131 } |
| 132 fFreshline = false; |
| 133 fPretty.appendf("%c", fInput[fIndex++]); |
| 134 } |
| 135 } |
| 136 |
| 137 // We only tab if on a newline, otherwise consider the line tabbed |
| 138 void tabString() { |
| 139 if (fFreshline) { |
| 140 for (int t = 0; t < fTabs; t++) { |
| 141 fPretty.append("\t"); |
| 142 } |
| 143 } |
| 144 } |
| 145 |
| 146 // newline is really a request to add a newline, if we are on a fresh line t
here is no reason |
| 147 // to add another newline |
| 148 void newline() { |
| 149 if (!fFreshline) { |
| 150 fFreshline = true; |
| 151 fPretty.append("\n"); |
| 152 this->lineNumbering(); |
| 153 } |
| 154 } |
| 155 |
| 156 void lineNumbering() { |
| 157 if (fCountlines) { |
| 158 fPretty.appendf("%4d\t", fLinecount++); |
| 159 } |
| 160 } |
| 161 |
| 162 bool fCountlines, fFreshline; |
| 163 int fTabs, fLinecount; |
| 164 size_t fIndex, fLength; |
| 165 SkString fInput, fPretty; |
| 166 }; |
| 167 |
| 168 SkString PrettyPrintGLSL(const SkString& input, bool countlines) { |
| 169 GLSLPrettyPrint pp; |
| 170 return pp.prettify(input, countlines); |
| 171 } |
| 172 |
| 173 } // end namespace |
OLD | NEW |