RegexNode Struct Reference

#include <RegexNode.h>

Classes
union	Payload

Public Types
enum	Kind {   kChar_Kind , kCharset_Kind , kConcat_Kind , kDot_Kind ,   kOr_Kind , kPlus_Kind , kRange_Kind , kQuestion_Kind ,   kStar_Kind }

Public Member Functions
	RegexNode (Kind kind)
	RegexNode (Kind kind, char payload)
	RegexNode (Kind kind, const char *children)
	RegexNode (Kind kind, RegexNode child)
	RegexNode (Kind kind, RegexNode child1, RegexNode child2)
std::vector< int >	createStates (NFA *nfa, const std::vector< int > &accept) const
std::string	description () const

Public Attributes
Kind	fKind
union RegexNode::Payload	fPayload
std::vector< RegexNode >	fChildren

Detailed Description

Represents a node in the parse tree of a regular expression.

Definition at line 20 of file RegexNode.h.

Member Enumeration Documentation

Kind

enum RegexNode::Kind

Enumerator
kChar_Kind
kCharset_Kind
kConcat_Kind
kDot_Kind
kOr_Kind
kPlus_Kind
kRange_Kind
kQuestion_Kind
kStar_Kind

Definition at line 21 of file RegexNode.h.

              {
        kChar_Kind,
        kCharset_Kind,
        kConcat_Kind,
        kDot_Kind,
        kOr_Kind,
        kPlus_Kind,
        kRange_Kind,
        kQuestion_Kind,
        kStar_Kind
    };

Constructor & Destructor Documentation

RegexNode() [1/5]

RegexNode::RegexNode ( Kind  kind )

inline

Definition at line 33 of file RegexNode.h.

    : fKind(kind) {}

RegexNode() [2/5]

RegexNode::RegexNode ( Kind  kind, char  payload  )

inline

Definition at line 36 of file RegexNode.h.

    : fKind(kind) {
        fPayload.fChar = payload;
    }

RegexNode() [3/5]

RegexNode::RegexNode ( Kind  kind, const char *  children  )

inline

Definition at line 41 of file RegexNode.h.

    : fKind(kind) {
        fPayload.fBool = false;
        while (*children != '\0') {
            fChildren.emplace_back(kChar_Kind, *children);
            ++children;
        }
    }

RegexNode() [4/5]

RegexNode::RegexNode ( Kind  kind, RegexNode  child  )

inline

Definition at line 50 of file RegexNode.h.

    : fKind(kind) {
        fChildren.push_back(std::move(child));
    }

RegexNode() [5/5]

RegexNode::RegexNode ( Kind  kind, RegexNode  child1, RegexNode  child2  )

inline

Definition at line 55 of file RegexNode.h.

    : fKind(kind) {
        fChildren.push_back(std::move(child1));
        fChildren.push_back(std::move(child2));
    }

Member Function Documentation

createStates()

std::vector< int > RegexNode::createStates	(	NFA *	nfa,
		const std::vector< int > &	accept
	)		const

Creates NFA states for this node, with a successful match against this node resulting in a transition to all of the states in the accept vector.

Definition at line 16 of file RegexNode.cpp.

                                                                                   {
    std::vector<int> result;
    switch (fKind) {
        case kChar_Kind:
            result.push_back(nfa->addState(NFAState(fPayload.fChar, accept)));
            break;
        case kCharset_Kind: {
            std::vector<bool> chars;
            for (const RegexNode& child : fChildren) {
                if (child.fKind == kChar_Kind) {
                    while (chars.size() <= (size_t) child.fPayload.fChar) {
                        chars.push_back(false);
                    }
                    chars[child.fPayload.fChar] = true;
                } else {
                    SkASSERT(child.fKind == kRange_Kind);
                    while (chars.size() <= (size_t) child.fChildren[1].fPayload.fChar) {
                        chars.push_back(false);
                    }
                    for (char c = child.fChildren[0].fPayload.fChar;
                         c <= child.fChildren[1].fPayload.fChar;
                         ++c) {
                        chars[c] = true;
                    }
                }
            }
            result.push_back(nfa->addState(NFAState(fPayload.fBool, chars, accept)));
            break;
        }
        case kConcat_Kind: {
            std::vector<int> right = fChildren[1].createStates(nfa, accept);
            result = fChildren[0].createStates(nfa, right);
            break;
        }
        case kDot_Kind:
            result.push_back(nfa->addState(NFAState(NFAState::kDot_Kind, accept)));
            break;
        case kOr_Kind: {
            std::vector<int> states = fChildren[0].createStates(nfa, accept);
            result.insert(result.end(), states.begin(), states.end());
            states = fChildren[1].createStates(nfa, accept);
            result.insert(result.end(), states.begin(), states.end());
            break;
        }
        case kPlus_Kind: {
            std::vector<int> next = accept;
            std::vector<int> placeholder;
            int id = nfa->addState(NFAState(placeholder));
            next.push_back(id);
            result = fChildren[0].createStates(nfa, next);
            nfa->fStates[id] = NFAState(result);
            break;
        }
        case kQuestion_Kind:
            result = fChildren[0].createStates(nfa, accept);
            result.insert(result.end(), accept.begin(), accept.end());
            break;
        case kRange_Kind:
            SkUNREACHABLE;
        case kStar_Kind: {
            std::vector<int> next = accept;
            std::vector<int> placeholder;
            int id = nfa->addState(NFAState(placeholder));
            next.push_back(id);
            result = fChildren[0].createStates(nfa, next);
            result.insert(result.end(), accept.begin(), accept.end());
            nfa->fStates[id] = NFAState(result);
            break;
        }
    }
    return result;
}

description()

std::string RegexNode::description

(

)

const

Member Data Documentation

fChildren

std::vector<RegexNode> RegexNode::fChildren

Definition at line 76 of file RegexNode.h.

fKind

Kind RegexNode::fKind

Definition at line 69 of file RegexNode.h.

fPayload

union RegexNode::Payload RegexNode::fPayload

---

The documentation for this struct was generated from the following files:

• third_party/skia/src/sksl/lex/RegexNode.h
• third_party/skia/src/sksl/lex/RegexNode.cpp