re2c::Node Struct Reference

#include <skeleton.h>

Collaboration diagram for re2c::Node:

Public Types
typedef u32lim_t< 1024 *1024 *1024 >	covers_t
typedef u32lim_t< 1024 >	nakeds_t
typedef std::map< Node *, path_t::arc_t >	arcs_t
typedef std::map< Node *, way_arc_t >	arcsets_t
typedef local_increment_t< uint8_t >	local_inc

Public Member Functions
	Node ()
void	init (bool b, RuleOp *r, const std::vector< std::pair< Node *, uint32_t > > &arcs)
	~Node ()
bool	end () const
void	calc_dist ()
void	calc_reachable ()
template<typename cunit_t , typename key_t >
void	cover (path_t &prefix, FILE *input, FILE *keys, covers_t &size)
void	naked_ways (way_t &prefix, std::vector< way_t > &ways, nakeds_t &size)
	FORBID_COPY (Node)

Public Attributes
arcs_t	arcs
arcsets_t	arcsets
uint8_t	loop
rule_t	rule
bool	ctx
uint32_t	dist
std::set< rule_t >	reachable
path_t *	suffix

Static Public Attributes
static const uint32_t	DIST_ERROR = std::numeric_limits<uint32_t>::max()
static const uint32_t	DIST_MAX = DIST_ERROR - 1

Detailed Description

Definition at line 30 of file skeleton.h.

Member Typedef Documentation

typedef std::map<Node *, path_t::arc_t> re2c::Node::arcs_t

Definition at line 65 of file skeleton.h.

typedef std::map<Node *, way_arc_t> re2c::Node::arcsets_t

Definition at line 66 of file skeleton.h.

typedef u32lim_t<1024 * 1024 * 1024> re2c::Node::covers_t

Definition at line 57 of file skeleton.h.

typedef local_increment_t<uint8_t> re2c::Node::local_inc

Definition at line 67 of file skeleton.h.

typedef u32lim_t<1024> re2c::Node::nakeds_t

Definition at line 63 of file skeleton.h.

Constructor & Destructor Documentation

re2c::Node::Node

(

)

Definition at line 15 of file skeleton.cc.

    : arcs ()
    , arcsets ()
    , loop (0)
    , rule (rule_rank_t::none (), false)
    , ctx (false)
    , dist (DIST_ERROR)
    , reachable ()
    , suffix (NULL)
{}

re2c::Node::~Node

(

)

Definition at line 62 of file skeleton.cc.

{
    delete suffix;
}

Member Function Documentation

void re2c::Node::calc_dist

(

)

Definition at line 18 of file maxlen.cc.

{
    if (dist != DIST_ERROR)
    {
        return;
    }
    else if (end ())
    {
        dist = 0;
    }
    else if (loop < 2)
    {
        local_inc _ (loop);
        for (arcs_t::iterator i = arcs.begin (); i != arcs.end (); ++i)
        {
            i->first->calc_dist ();
            if (i->first->dist != DIST_ERROR)
            {
                if (dist == DIST_ERROR)
                {
                    dist = i->first->dist;
                }
                else
                {
                    dist = std::max (dist, i->first->dist);
                }
            }
        }
        dist = std::min (dist + 1, DIST_MAX);
    }
}

Here is the call graph for this function:

void re2c::Node::calc_reachable

(

)

Definition at line 16 of file unreachable.cc.

{
    if (!reachable.empty ())
    {
        return;
    }
    else if (end ())
    {
        reachable.insert (rule);
    }
    else if (loop < 2)
    {
        local_inc _ (loop);
        for (arcs_t::iterator i = arcs.begin (); i != arcs.end (); ++i)
        {
            i->first->calc_reachable ();
            reachable.insert (i->first->reachable.begin (), i->first->reachable.end ());
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename cunit_t , typename key_t >

void re2c::Node::cover	(	path_t &	prefix,
		FILE *	input,
		FILE *	keys,
		covers_t &	size
	)

Definition at line 56 of file generate_data.cc.

{
    if (end () && suffix == NULL)
    {
        suffix = new path_t (rule, ctx);
    }
    if (suffix != NULL)
    {
        prefix.append (suffix);
        size = size + cover_one<cunit_t, key_t> (input, keys, prefix);
    }
    else if (loop < 2)
    {
        local_inc _ (loop);
        for (arcs_t::iterator i = arcs.begin ();
            i != arcs.end () && !size.overflow(); ++i)
        {
            path_t new_prefix = prefix;
            new_prefix.extend (i->first->rule, i->first->ctx, &i->second);
            i->first->cover<cunit_t, key_t> (new_prefix, input, keys, size);
            if (i->first->suffix != NULL && suffix == NULL)
            {
                suffix = new path_t (rule, ctx);
                suffix->extend (i->first->rule, i->first->ctx, &i->second);
                suffix->append (i->first->suffix);
            }
        }
    }
}

Here is the call graph for this function:

bool re2c::Node::end

(

)

const

Definition at line 67 of file skeleton.cc.

{
    return arcs.size () == 0;
}

Here is the caller graph for this function:

re2c::Node::FORBID_COPY

(

Node

)

void re2c::Node::init	(	bool	b,
		RuleOp *	r,
		const std::vector< std::pair< Node *, uint32_t > > &	arcs
	)

Definition at line 26 of file skeleton.cc.

{
    if (r)
    {
        rule.rank = r->rank;
        rule.restorectx = r->ctx->fixedLength () != 0;
    }

    ctx = c;

    uint32_t lb = 0;
    std::vector<std::pair<Node*, uint32_t> >::const_iterator
        i = a.begin(),
        e = a.end();
    for (; i != e; ++i)
    {
        Node *n = i->first;
        const uint32_t ub = i->second - 1;

        // pick at most 0x100 unique edges from this range
        // (for 1-byte code units this covers the whole range: [0 - 0xFF])
        //   - range bounds must be included
        //   - values should be evenly distributed
        //   - values should be deterministic
        const uint32_t step = 1 + (ub - lb) / 0x100;
        for (uint32_t c = lb; c < ub; c += step)
        {
            arcs[n].push_back (c);
        }
        arcs[n].push_back (ub);

        arcsets[n].push_back (std::make_pair (lb, ub));
        lb = ub + 1;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void re2c::Node::naked_ways	(	way_t &	prefix,
		std::vector< way_t > &	ways,
		nakeds_t &	size
	)

Definition at line 19 of file control_flow.cc.

{
    if (!rule.rank.is_none ())
    {
        return;
    }
    else if (end ())
    {
        ways.push_back (prefix);
        size = size + nakeds_t::from64(prefix.size ());
    }
    else if (loop < 2)
    {
        local_inc _ (loop);
        for (arcsets_t::iterator i = arcsets.begin ();
            i != arcsets.end () && !size.overflow (); ++i)
        {
            prefix.push_back (&i->second);
            i->first->naked_ways (prefix, ways, size);
            prefix.pop_back ();
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

arcs_t re2c::Node::arcs

Definition at line 70 of file skeleton.h.

arcsets_t re2c::Node::arcsets

Definition at line 71 of file skeleton.h.

bool re2c::Node::ctx

Definition at line 81 of file skeleton.h.

uint32_t re2c::Node::dist

Definition at line 86 of file skeleton.h.

const uint32_t re2c::Node::DIST_ERROR = std::numeric_limits<uint32_t>::max()

static

Definition at line 84 of file skeleton.h.

const uint32_t re2c::Node::DIST_MAX = DIST_ERROR - 1

static

Definition at line 85 of file skeleton.h.

uint8_t re2c::Node::loop

Definition at line 75 of file skeleton.h.

std::set<rule_t> re2c::Node::reachable

Definition at line 89 of file skeleton.h.

rule_t re2c::Node::rule

Definition at line 78 of file skeleton.h.

path_t* re2c::Node::suffix

Definition at line 92 of file skeleton.h.

---

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

• ir/skeleton/skeleton.h
• ir/skeleton/control_flow.cc
• ir/skeleton/generate_data.cc
• ir/skeleton/maxlen.cc
• ir/skeleton/skeleton.cc
• ir/skeleton/unreachable.cc