path.h

Go to the documentation of this file.

#ifndef _RE2C_IR_SKELETON_PATH_
#define _RE2C_IR_SKELETON_PATH_

#include <vector>

#include "src/ir/rule_rank.h"
#include "src/util/c99_stdint.h"

namespace re2c
{

struct rule_t
{
    rule_rank_t rank;
    bool restorectx;

    rule_t (rule_rank_t r, bool c)
        : rank (r)
        , restorectx (c)
    {}

    // needed by STL containers
    // same as 'std::pair' comparator
    bool operator < (const rule_t & r) const
    {
        return rank < r.rank
            || (!(r.rank < rank) && restorectx < r.restorectx);
    }
};

class path_t
{
public:
    typedef std::vector<uint32_t> arc_t;

private:
    std::vector<const arc_t *> arcs;

    rule_t rule;
    size_t rule_pos;

    bool ctx;
    size_t ctx_pos;

public:
    explicit path_t (rule_t r, bool c)
        : arcs ()
        , rule (r)
        , rule_pos (0)
        , ctx (c)
        , ctx_pos (0)
    {}
    size_t len () const
    {
        return arcs.size ();
    }
    size_t len_matching () const
    {
        return rule.restorectx
            ? ctx_pos
            : rule_pos;
    }
    rule_rank_t match () const
    {
        return rule.rank;
    }
    const arc_t * operator [] (size_t i) const
    {
        return arcs[i];
    }
    void extend (rule_t r, bool c, const arc_t * a)
    {
        arcs.push_back (a);
        if (!r.rank.is_none ())
        {
            rule = r;
            rule_pos = arcs.size ();
        }
        if (c)
        {
            ctx = true;
            ctx_pos = arcs.size ();
        }
    }
    void append (const path_t * p)
    {
        if (!p->rule.rank.is_none ())
        {
            rule = p->rule;
            rule_pos = arcs.size () + p->rule_pos;
        }
        if (p->ctx)
        {
            ctx = true;
            ctx_pos = arcs.size () + p->ctx_pos;
        }
        arcs.insert (arcs.end (), p->arcs.begin (), p->arcs.end ());
    }
};

} // namespace re2c

#endif // _RE2C_IR_SKELETON_PATH_