SkShaderUtils::GLSLPrettyPrint Class Reference

Public Member Functions
	GLSLPrettyPrint ()
std::string	prettify (const std::string &string)

Detailed Description

Definition at line 22 of file SkShaderUtils.cpp.

Constructor & Destructor Documentation

GLSLPrettyPrint()

SkShaderUtils::GLSLPrettyPrint::GLSLPrettyPrint ( )

inline

Definition at line 24 of file SkShaderUtils.cpp.

{}

Member Function Documentation

prettify()

std::string SkShaderUtils::GLSLPrettyPrint::prettify ( const std::string &  string )

inline

Definition at line 26 of file SkShaderUtils.cpp.

                                                {
        fTabs = 0;
        fFreshline = true;
 
        // If a string breaks while in the middle 'parse until' we need to continue parsing on the
        // next string
        fInParseUntilNewline = false;
        fInParseUntil = false;
 
        int parensDepth = 0;
 
        // setup pretty state
        fIndex = 0;
        fLength = string.length();
        fInput = string.c_str();
 
        while (fLength > fIndex) {
            /* The heart and soul of our prettification algorithm.  The rules should hopefully
             * be self explanatory.  For '#' and '//' tokens, we parse until we reach a newline.
             *
             * For long style comments like this one, we search for the ending token.  We also
             * preserve whitespace in these comments WITH THE CAVEAT that we do the newlines
             * ourselves.  This allows us to remain in control of line numbers, and matching
             * tabs.  Existing tabs in the input string are copied over too, but this will look
             * funny.
             *
             * '{' and '}' are handled in basically the same way.  We add a newline if we aren't
             * on a fresh line, dirty the line, then add a second newline, i.e. braces are always
             * on their own lines indented properly.
             *
             * '(' and ')' are basically ignored, except as a sign that we need to ignore ';', since
             * we want to keep for loops on a single line.
             *
             * ';' means add a new line.  If the previous character was a '}', we make sure that the
             * semicolon comes directly after the brace, not on a newline.
             *
             * ',' doesn't add a new line, but does have special handling to ensure it is on the
             * same line as a '}', much like the semicolon.
             *
             * '\t' and '\n' are ignored in general parsing for backwards compatibility with
             * existing shader code.  We also have a special case for handling whitespace at the
             * beginning of fresh lines.
             *
             * Otherwise, just add the new character to the pretty string, indenting if
             * necessary.
             */
            if (fInParseUntilNewline) {
                this->parseUntilNewline();
                continue;
            }
            if (fInParseUntil) {
                this->parseUntil(fInParseUntilToken);
                continue;
            }
            if (this->hasToken("#") || this->hasToken("//")) {
                this->parseUntilNewline();
                continue;
            }
            if (this->hasToken("/*")) {
                this->parseUntil("*/");
                continue;
            }
            if (fInput[fIndex] == '{') {
                this->newline();
                this->appendChar('{');
                fTabs++;
                this->newline();
                continue;
            }
            if (fInput[fIndex] == '}') {
                fTabs--;
                this->newline();
                this->appendChar('}');
                this->newline();
                continue;
            }
            if (fFreshline && fInput[fIndex] == ';') {
                this->undoNewlineAfter('}');
                this->appendChar(fInput[fIndex]);
                this->newline();
                continue;
            }
            if (fFreshline && fInput[fIndex] == ',') {
                this->undoNewlineAfter('}');
                this->appendChar(fInput[fIndex]);
                continue;
            }
            if (this->hasToken(")")) {
                parensDepth--;
                continue;
            }
            if (this->hasToken("(")) {
                parensDepth++;
                continue;
            }
            if (this->hasToken(")")) {
                parensDepth--;
                continue;
            }
            if (!parensDepth && this->hasToken(";")) {
                this->newline();
                continue;
            }
            if (fInput[fIndex] == '\t' || fInput[fIndex] == '\n' ||
                (fFreshline && fInput[fIndex] == ' ')) {
                fIndex++;
                continue;
            }
 
            this->appendChar(fInput[fIndex]);
        }
 
        return fPretty;
    }

---

The documentation for this class was generated from the following file:

• third_party/skia/src/utils/SkShaderUtils.cpp