re2c::Go Struct Reference

#include <go.h>

Collaboration diagram for re2c::Go:

Public Types
enum	{   EMPTY, SWITCH_IF, BITMAP, CPGOTO,   DOT }

Public Member Functions
	Go ()
	~Go ()
void	init (const State *from)
void	emit (OutputFile &o, uint32_t ind, bool &readCh)
void	used_labels (std::set< label_t > &used)
	Go (const Go &g)
Go &	operator= (const Go &g)

Public Attributes
uint32_t	nSpans
Span *	span
enum re2c::Go:: { ... }	type
union {
SwitchIf *   switchif
GoBitmap *   bitmap
Cpgoto *   cpgoto
Dot *   dot
}	info

Detailed Description

Definition at line 172 of file go.h.

Member Enumeration Documentation

anonymous enum

Enumerator
EMPTY
SWITCH_IF
BITMAP
CPGOTO
DOT

Definition at line 176 of file go.h.

    {
        EMPTY,
        SWITCH_IF,
        BITMAP,
        CPGOTO,
        DOT
    } type;

Constructor & Destructor Documentation

re2c::Go::Go

(

)

Definition at line 183 of file go_construct.cc.

    : nSpans (0)
    , span (NULL)
    , type (EMPTY)
    , info ()
{}

re2c::Go::~Go

(

)

Definition at line 78 of file go_destruct.cc.

{
    switch (type)
    {
        case EMPTY:
            break;
        case SWITCH_IF:
            delete info.switchif;
            break;
        case BITMAP:
            delete info.bitmap;
            break;
        case CPGOTO:
            delete info.cpgoto;
            break;
        case DOT:
            delete info.dot;
            break;
    }
}

re2c::Go::Go ( const Go &  g )

inline

Definition at line 198 of file go.h.

        : nSpans (g.nSpans)
        , span (g.span)
        , type (g.type)
        , info (g.info)
    {}

Member Function Documentation

void re2c::Go::emit	(	OutputFile &	o,
		uint32_t	ind,
		bool &	readCh
	)

Definition at line 250 of file go_emit.cc.

{
    switch (type)
    {
        case EMPTY:
            break;
        case SWITCH_IF:
            info.switchif->emit (o, ind, readCh);
            break;
        case BITMAP:
            info.bitmap->emit (o, ind, readCh);
            break;
        case CPGOTO:
            info.cpgoto->emit (o, ind, readCh);
            break;
        case DOT:
            info.dot->emit (o);
            break;
    }
}

void re2c::Go::init

(

const State *

from

)

Definition at line 190 of file go_construct.cc.

{
    if (nSpans == 0)
    {
        return;
    }

    // initialize high (wide) spans
    uint32_t hSpans = 0;
    const Span * hspan = NULL;
    for (uint32_t i = 0; i < nSpans; ++i)
    {
        if (span[i].ub > 0x100)
        {
            hspan = &span[i];
            hSpans = nSpans - i;
            break;
        }
    }

    // initialize bitmaps
    uint32_t nBitmaps = 0;
    const BitMap * bitmap = NULL;
    const State * bitmap_state = NULL;
    for (uint32_t i = 0; i < nSpans; ++i)
    {
        if (span[i].to->isBase)
        {
            const BitMap *b = BitMap::find (span[i].to);
            if (b && matches(b->go->span, b->go->nSpans, b->on, span, nSpans, span[i].to))
            {
                if (bitmap == NULL)
                {
                    bitmap = b;
                    bitmap_state = span[i].to;
                }
                nBitmaps++;
            }
        }
    }

    const uint32_t dSpans = nSpans - hSpans - nBitmaps;
    if (opts->target == opt_t::DOT)
    {
        type = DOT;
        info.dot = new Dot (span, nSpans, from);
    }
    else if (opts->gFlag && (dSpans >= opts->cGotoThreshold))
    {
        type = CPGOTO;
        info.cpgoto = new Cpgoto (span, nSpans, hspan, hSpans, from->next);
    }
    else if (opts->bFlag && (nBitmaps > 0))
    {
        type = BITMAP;
        info.bitmap = new GoBitmap (span, nSpans, hspan, hSpans, bitmap, bitmap_state, from->next);
        bUsedYYBitmap = true;
    }
    else
    {
        type = SWITCH_IF;
        info.switchif = new SwitchIf (span, nSpans, from->next);
    }
}

Here is the call graph for this function:

Go& re2c::Go::operator= ( const Go &  g )

inline

Definition at line 204 of file go.h.

    {
        nSpans = g.nSpans;
        span = g.span;
        type = g.type;
        info = g.info;
        return * this;
    }

void re2c::Go::used_labels

(

std::set< label_t > &

used

)

Definition at line 92 of file go_used_labels.cc.

{
    switch (type)
    {
        case EMPTY:
        case DOT:
            break;
        case SWITCH_IF:
            info.switchif->used_labels (used);
            break;
        case BITMAP:
            info.bitmap->used_labels (used);
            break;
        case CPGOTO:
            info.cpgoto->used_labels (used);
            break;
    }
}

Member Data Documentation

GoBitmap* re2c::Go::bitmap

Definition at line 187 of file go.h.

Cpgoto* re2c::Go::cpgoto

Definition at line 188 of file go.h.

Dot* re2c::Go::dot

Definition at line 189 of file go.h.

union { ... } re2c::Go::info

uint32_t re2c::Go::nSpans

Definition at line 174 of file go.h.

Span* re2c::Go::span

Definition at line 175 of file go.h.

SwitchIf* re2c::Go::switchif

Definition at line 186 of file go.h.

enum { ... } re2c::Go::type

---

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

• codegen/go.h
• codegen/go_construct.cc
• codegen/go_destruct.cc
• codegen/go_emit.cc
• codegen/go_used_labels.cc