Main.cpp File Reference

#include "src/sksl/lex/DFA.h"
#include "src/sksl/lex/LexUtil.h"
#include "src/sksl/lex/NFA.h"
#include "src/sksl/lex/NFAtoDFA.h"
#include "src/sksl/lex/RegexNode.h"
#include "src/sksl/lex/RegexParser.h"
#include "src/sksl/lex/TransitionTable.h"
#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
#include <sstream>
#include <string>
#include <vector>

Go to the source code of this file.

Functions
static void	writeH (const DFA &dfa, const char *lexer, const char *token, const std::vector< std::string > &tokens, const char *hPath)
static void	writeCPP (const DFA &dfa, const char *lexer, const char *token, const char *include, const char *cppPath)
static void	process (const char *inPath, const char *lexer, const char *token, const char *hPath, const char *cppPath)
int	main (int argc, const char **argv)

Variables
static constexpr const char	HEADER []

Function Documentation

main()

int main	(	int	argc,
		const char **	argv
	)

Definition at line 156 of file Main.cpp.

             {
        if (fOffset >= (int32_t)fText.length()) {
            if (startOffset == (int32_t)fText.length() || kAccepts[state] == 255) {
                return )" << token << "(" << token << R"(::Kind::TK_END_OF_FILE, startOffset, 0);

process()

static void process ( const char *  inPath, const char *  lexer, const char *  token, const char *  hPath, const char *  cppPath  )

static

Definition at line 114 of file Main.cpp.

                         : dfa.fTransitions) {
        states = std::max(states, row.size());
    }
    out << "using State = " << (states <= 256 ? "uint8_t" : "uint16_t") << ";\n";
 
    // Find the first character mapped in our DFA.
    size_t startChar = 0;
    for (; startChar < dfa.fCharMappings.size(); ++startChar) {
        if (dfa.fCharMappings[startChar] != 0) {
            break;
        }
    }
 
    // Arbitrarily-chosen character which is greater than startChar, and should not appear in actual
    // input.
    SkASSERT(startChar < 18);
    out << "static constexpr uint8_t kInvalidChar = 18;";
    out << "static constexpr uint8_t kMappings[" << dfa.fCharMappings.size() - startChar << "] = {";
    for (size_t index = startChar; index < dfa.fCharMappings.size(); ++index) {
        out << std::to_string(dfa.fCharMappings[index]) << ", ";
    }
    out << "};\n";
 
    WriteTransitionTable(out, dfa, states);
 
    out << "static const uint8_t kAccepts[" << states << "] = {";
    for (size_t i = 0; i < states; ++i) {
        if (i < dfa.fAccepts.size() && dfa.fAccepts[i] != INVALID) {
            out << " " << dfa.fAccepts[i] << ",";
        } else {
            out << " 255,";
        }
    }
    out << "};\n";
    out << "\n";
 
    out << token << " " << lexer << "::next() {";
    out << R"(
    // Note that we cheat here: normally a lexer needs to worry about the case
    // where a token has a prefix which is not itself a valid token - for instance,

writeCPP()

static void writeCPP ( const DFA &  dfa, const char *  lexer, const char *  token, const char *  include, const char *  cppPath  )

static

Definition at line 63 of file Main.cpp.

    : fKind(kind)
    , fOffset(offset)
    , fLength(length) {}
 
    Kind fKind      = Kind::TK_NONE;
    int32_t fOffset = -1;
    int32_t fLength = -1;
};
 
class )" << lexer << R"( {
public:
    void start(std::string_view text) {
        fText = text;
        fOffset = 0;
    }
 
    )" << token << R"( next();
 
    struct Checkpoint {
        int32_t fOffset;
    };
 
    Checkpoint getCheckpoint() const {
        return {fOffset};
    }
 
    void rewindToCheckpoint(Checkpoint checkpoint) {
        fOffset = checkpoint.fOffset;
    }
 
private:
    std::string_view fText;
    int32_t fOffset;
};
 
} // namespace
#endif
)";
}
 
static void writeCPP(const DFA& dfa, const char* lexer, const char* token, const char* include,
                     const char* cppPath) {
    std::ofstream out(cppPath);
    SkASSERT(out.good());
    out << HEADER;
    out << "#include \"" << include << "\"\n";
    out << "\n";
    out << "namespace SkSL {\n";
    out << "\n";

writeH()

static void writeH ( const DFA &  dfa, const char *  lexer, const char *  token, const std::vector< std::string > &  tokens, const char *  hPath  )

static

Definition at line 41 of file Main.cpp.

                                                                          {
    std::ofstream out(hPath);
    SkASSERT(out.good());
    out << HEADER;
    out << "#ifndef SKSL_" << lexer << "\n";
    out << "#define SKSL_" << lexer << "\n";
    out << "#include <cstdint>\n";
    out << "#include <string_view>\n";
    out << "namespace SkSL {\n";
    out << "\n";
    out << "struct " << token << " {\n";
    out << "    enum class Kind {\n";
    for (const std::string& t : tokens) {
        out << "        TK_" << t << ",\n";
    }
    out << "        TK_NONE,";
    out << R"(
    };
 
    )" << token << "() {}";

Variable Documentation

HEADER

constexpr const char HEADER[]

staticconstexpr

Initial value:

=
    "/*\n"
    " * Copyright 2017 Google Inc.\n"
    " *\n"
    " * Use of this source code is governed by a BSD-style license that can be\n"
    " * found in the LICENSE file.\n"
    " */\n"
    "/*****************************************************************************************\n"
    " ******************** This file was generated by sksllex. Do not edit. *******************\n"
    " *****************************************************************************************/\n"

Processes a .lex file and produces .h and .cpp files which implement a lexical analyzer. The .lex file is a text file with one token definition per line. Each line is of the form: <TOKEN_NAME> = <pattern> where <pattern> is either a regular expression (e.g [0-9]) or a double-quoted literal string.

Definition at line 30 of file Main.cpp.