output.h

Go to the documentation of this file.

#ifndef _RE2C_CODEGEN_OUTPUT_
#define _RE2C_CODEGEN_OUTPUT_

#include "src/util/c99_stdint.h"
#include <stddef.h>
#include <stdio.h>
#include <fstream>
#include <set>
#include <sstream>
#include <string>
#include <vector>

#include "src/codegen/label.h"
#include "src/util/counter.h"
#include "src/util/forbid_copy.h"

namespace re2c
{

class rule_rank_t;

struct OutputFragment
{
    enum type_t
        { CODE
//      , CONFIG
        , LINE_INFO
        , STATE_GOTO
        , TYPES
        , WARN_CONDITION_ORDER
        , YYACCEPT_INIT
        , YYMAXFILL
        };

    type_t type;
    std::ostringstream stream;
    uint32_t indent;

    OutputFragment (type_t t, uint32_t i);
    uint32_t count_lines ();
};

struct OutputBlock
{
    std::vector<OutputFragment *> fragments;
    bool used_yyaccept;
    bool force_start_label;
    std::string user_start_label;
    uint32_t line;

    OutputBlock ();
    ~OutputBlock ();
};

struct OutputFile
{
public:
    const char * file_name;

private:
    FILE * file;
    std::vector<OutputBlock *> blocks;

public:
    counter_t<label_t> label_counter;
    bool warn_condition_order;

private:
    std::ostream & stream ();
    void insert_code ();

public:
    OutputFile (const char * fn);
    ~OutputFile ();

    bool open ();

    void new_block ();

    // immediate output
    OutputFile & wraw (const char * s, size_t n);
    OutputFile & wc (char c);
    OutputFile & wc_hex (uint32_t n);
    OutputFile & wu32 (uint32_t n);
    OutputFile & wu32_hex (uint32_t n);
    OutputFile & wu32_width (uint32_t n, int w);
    OutputFile & wu64 (uint64_t n);
    OutputFile & wstring (const std::string & s);
    OutputFile & ws (const char * s);
    OutputFile & wlabel (label_t l);
    OutputFile & wrank (rule_rank_t l);
    OutputFile & wrange (uint32_t u, uint32_t l);
    OutputFile & wline_info (uint32_t l, const char * fn);
    OutputFile & wversion_time ();
    OutputFile & wuser_start_label ();
    OutputFile & wind (uint32_t ind);

    // delayed output
    OutputFile & wdelay_line_info ();
    OutputFile & wdelay_state_goto (uint32_t ind);
    OutputFile & wdelay_types ();
    OutputFile & wdelay_warn_condition_order ();
    OutputFile & wdelay_yyaccept_init (uint32_t ind);
    OutputFile & wdelay_yymaxfill ();

    void set_used_yyaccept ();
    bool get_used_yyaccept () const;
    void set_force_start_label (bool force);
    void set_user_start_label (const std::string & label);
    bool get_force_start_label () const;
    void set_block_line (uint32_t l);
    uint32_t get_block_line () const;

    void emit (const std::vector<std::string> & types, size_t max_fill);

    FORBID_COPY (OutputFile);
};

struct HeaderFile
{
    HeaderFile (const char * fn);
    ~HeaderFile ();
    bool open ();
    void emit (const std::vector<std::string> & types);

private:
    std::ostringstream stream;
    const char * file_name;
    FILE * file;

    FORBID_COPY (HeaderFile);
};

struct Output
{
    OutputFile source;
    HeaderFile header;
    std::vector<std::string> types;
    std::set<std::string> skeletons;
    size_t max_fill;

    Output (const char * source_name, const char * header_name);
    ~Output ();
};

void output_line_info (std::ostream &, uint32_t, const char *);
void output_state_goto (std::ostream &, uint32_t, uint32_t);
void output_types (std::ostream &, uint32_t, const std::vector<std::string> &);
void output_version_time (std::ostream &);
void output_yyaccept_init (std::ostream &, uint32_t, bool);
void output_yymaxfill (std::ostream &, size_t);

// helpers
std::string output_get_state ();

} // namespace re2c

#endif // _RE2C_CODEGEN_OUTPUT_