vkdoom_m/tools/re2c/src/codegen/output.cc

#include <stdio.h>
#include <time.h>
#include <iomanip>

#include "src/codegen/indent.h"
#include "src/codegen/output.h"
#include "src/codegen/print.h"
#include "src/conf/opt.h"
#include "src/conf/warn.h"
#include "src/globals.h"
#include "src/ir/rule_rank.h"

namespace re2c
{

OutputFragment::OutputFragment (type_t t, uint32_t i)
	: type (t)
	, stream ()
	, indent (i)
{}

uint32_t OutputFragment::count_lines ()
{
	uint32_t lines = 0;
	const std::string content = stream.str ();
	const char * p = content.c_str ();
	for (uint32_t i = 0; i < content.size (); ++i)
	{
		if (p[i] == '\n')
		{
			++lines;
		}
	}
	return lines;
}

OutputBlock::OutputBlock ()
	: fragments ()
	, used_yyaccept (false)
	, force_start_label (false)
	, user_start_label ()
	, line (0)
{
	fragments.push_back (new OutputFragment (OutputFragment::CODE, 0));
}

OutputBlock::~OutputBlock ()
{
	for (unsigned int i = 0; i < fragments.size (); ++i)
	{
		delete fragments[i];
	}
}

OutputFile::OutputFile (const char * fn)
	: file_name (fn)
	, file (NULL)
	, blocks ()
	, label_counter ()
	, warn_condition_order (!opts->tFlag) // see note [condition order]
{
	new_block ();
}

bool OutputFile::open ()
{
	if (file_name == NULL)
	{
		file_name = "<stdout>";
		file = stdout;
	}
	else
	{
		file = fopen (file_name, "wb");
	}
	return file != NULL;
}

OutputFile::~OutputFile ()
{
	if (file != NULL && file != stdout)
	{
		fclose (file);
	}
	for (unsigned int i = 0; i < blocks.size (); ++i)
	{
		delete blocks[i];
	}
}

std::ostream & OutputFile::stream ()
{
	return blocks.back ()->fragments.back ()->stream;
}

OutputFile & OutputFile::wraw (const char * s, size_t n)
{
	stream ().write (s, static_cast<std::streamsize> (n));
	return *this;
}

OutputFile & OutputFile::wu32_hex (uint32_t n)
{
	prtHex (stream (), n);
	return *this;
}

OutputFile & OutputFile::wc_hex (uint32_t n)
{
	prtChOrHex (stream (), n);
	return *this;
}

OutputFile & OutputFile::wrange (uint32_t l, uint32_t u)
{
	printSpan (stream (), l, u);
	return *this;
}

OutputFile & OutputFile::wu32_width (uint32_t n, int w)
{
	stream () << std::setw (w);
	stream () << n;
	return *this;
}

OutputFile & OutputFile::wline_info (uint32_t l, const char * fn)
{
	output_line_info (stream (), l, fn);
	return *this;
}

OutputFile & OutputFile::wversion_time ()
{
	output_version_time (stream ());
	return *this;
}

OutputFile & OutputFile::wuser_start_label ()
{
	const std::string label = blocks.back ()->user_start_label;
	if (!label.empty ())
	{
		wstring(label).ws(":\n");
	}
	return *this;
}

OutputFile & OutputFile::wc (char c)
{
	stream () << c;
	return *this;
}

OutputFile & OutputFile::wu32 (uint32_t n)
{
	stream () << n;
	return *this;
}

OutputFile & OutputFile::wu64 (uint64_t n)
{
	stream () << n;
	return *this;
}

OutputFile & OutputFile::wstring (const std::string & s)
{
	stream () << s;
	return *this;
}

OutputFile & OutputFile::ws (const char * s)
{
	stream () << s;
	return *this;
}

OutputFile & OutputFile::wlabel (label_t l)
{
	stream () << l;
	return *this;
}

OutputFile & OutputFile::wrank (rule_rank_t r)
{
	stream () << r;
	return *this;
}

OutputFile & OutputFile::wind (uint32_t ind)
{
	stream () << indent(ind);
	return *this;
}

void OutputFile::insert_code ()
{
	blocks.back ()->fragments.push_back (new OutputFragment (OutputFragment::CODE, 0));
}

OutputFile & OutputFile::wdelay_line_info ()
{
	blocks.back ()->fragments.push_back (new OutputFragment (OutputFragment::LINE_INFO, 0));
	insert_code ();
	return *this;
}

OutputFile & OutputFile::wdelay_state_goto (uint32_t ind)
{
	if (opts->fFlag && !bWroteGetState)
	{
		blocks.back ()->fragments.push_back (new OutputFragment (OutputFragment::STATE_GOTO, ind));
		insert_code ();
		bWroteGetState = true;
	}
	return *this;
}

OutputFile & OutputFile::wdelay_types ()
{
	warn_condition_order = false; // see note [condition order]
	blocks.back ()->fragments.push_back (new OutputFragment (OutputFragment::TYPES, 0));
	insert_code ();
	return *this;
}

OutputFile & OutputFile::wdelay_warn_condition_order ()
{
	blocks.back ()->fragments.push_back (new OutputFragment (OutputFragment::WARN_CONDITION_ORDER, 0));
	insert_code ();
	return *this;
}

OutputFile & OutputFile::wdelay_yyaccept_init (uint32_t ind)
{
	blocks.back ()->fragments.push_back (new OutputFragment (OutputFragment::YYACCEPT_INIT, ind));
	insert_code ();
	return *this;
}

OutputFile & OutputFile::wdelay_yymaxfill ()
{
	blocks.back ()->fragments.push_back (new OutputFragment (OutputFragment::YYMAXFILL, 0));
	insert_code ();
	return *this;
}

void OutputFile::set_used_yyaccept ()
{
	blocks.back ()->used_yyaccept = true;
}

bool OutputFile::get_used_yyaccept () const
{
	return blocks.back ()->used_yyaccept;
}

void OutputFile::set_force_start_label (bool force)
{
	blocks.back ()->force_start_label = force;
}

void OutputFile::set_user_start_label (const std::string & label)
{
	blocks.back ()->user_start_label = label;
}

bool OutputFile::get_force_start_label () const
{
	return blocks.back ()->force_start_label;
}

void OutputFile::set_block_line (uint32_t l)
{
	blocks.back ()->line = l;
}

uint32_t OutputFile::get_block_line () const
{
	return blocks.back ()->line;
}

void OutputFile::new_block ()
{
	blocks.push_back (new OutputBlock ());
	insert_code ();
}

void OutputFile::emit
	( const std::vector<std::string> & types
	, size_t max_fill
	)
{
	if (file != NULL)
	{
		unsigned int line_count = 1;
		for (unsigned int j = 0; j < blocks.size (); ++j)
		{
			OutputBlock & b = * blocks[j];
			for (unsigned int i = 0; i < b.fragments.size (); ++i)
			{
				OutputFragment & f = * b.fragments[i];
				switch (f.type)
				{
					case OutputFragment::CODE:
						break;
					case OutputFragment::LINE_INFO:
						output_line_info (f.stream, line_count + 1, file_name);
						break;
					case OutputFragment::STATE_GOTO:
						output_state_goto (f.stream, f.indent, 0);
						break;
					case OutputFragment::TYPES:
						output_types (f.stream, f.indent, types);
						break;
					case OutputFragment::WARN_CONDITION_ORDER:
						if (warn_condition_order) // see note [condition order]
						{
							warn.condition_order (b.line);
						}
						break;
					case OutputFragment::YYACCEPT_INIT:
						output_yyaccept_init (f.stream, f.indent, b.used_yyaccept);
						break;
					case OutputFragment::YYMAXFILL:
						output_yymaxfill (f.stream, max_fill);
						break;
				}
				std::string content = f.stream.str ();
				fwrite (content.c_str (), 1, content.size (), file);
				line_count += f.count_lines ();
			}
		}
	}
}

HeaderFile::HeaderFile (const char * fn)
	: stream ()
	// header is always generated, but not always dumped to file
	// NULL filename crashes 'operator <<' on some platforms
	// TODO: generate header only if necessary
	, file_name (fn ? fn : "<stdout>.h")
	, file (NULL)
{}

bool HeaderFile::open ()
{
	file = fopen (file_name, "wb");
	return file != NULL;
}

void HeaderFile::emit (const std::vector<std::string> & types)
{
	output_version_time (stream);
	output_line_info (stream, 3, file_name);
	stream << "\n";
	output_types (stream, 0, types);
}

HeaderFile::~HeaderFile ()
{
	if (file != NULL)
	{
		std::string content = stream.str ();
		fwrite (content.c_str (), 1, content.size (), file);
		fclose (file);
	}
}

Output::Output (const char * source_name, const char * header_name)
	: source (source_name)
	, header (header_name)
	, types ()
	, skeletons ()
	, max_fill (1)
{}

Output::~Output ()
{
	if (!warn.error ())
	{
		source.emit (types, max_fill);
		header.emit (types);
	}
}

void output_state_goto (std::ostream & o, uint32_t ind, uint32_t start_label)
{
	o << indent(ind) << "switch (" << output_get_state() << ") {\n";
	if (opts->bUseStateAbort)
	{
		o << indent(ind) << "default: abort();\n";
		o << indent(ind) << "case -1: goto " << opts->labelPrefix << start_label << ";\n";
	}
	else
	{
		o << indent(ind) << "default: goto " << opts->labelPrefix << start_label << ";\n";
	}
	for (uint32_t i = 0; i < last_fill_index; ++i)
	{
		o << indent(ind) << "case " << i << ": goto " << opts->yyfilllabel << i << ";\n";
	}
	o << indent(ind) << "}\n";
	if (opts->bUseStateNext)
	{
		o << opts->yynext << ":\n";
	}
}

void output_yyaccept_init (std::ostream & o, uint32_t ind, bool used_yyaccept)
{
	if (used_yyaccept)
	{
		o << indent (ind) << "unsigned int " << opts->yyaccept << " = 0;\n";
	}
}

void output_yymaxfill (std::ostream & o, size_t max_fill)
{
	o << "#define YYMAXFILL " << max_fill << "\n";
}

void output_line_info (std::ostream & o, uint32_t line_number, const char * file_name)
{
	if (!opts->iFlag)
	{
		o << "#line " << line_number << " \"" << file_name << "\"\n";
	}
}

void output_types (std::ostream & o, uint32_t ind, const std::vector<std::string> & types)
{
	o << indent (ind++) << "enum " << opts->yycondtype << " {\n";
	for (unsigned int i = 0; i < types.size (); ++i)
	{
		o << indent (ind) << opts->condEnumPrefix << types[i] << ",\n";
	}
	o << indent (--ind) << "};\n";
}

void output_version_time (std::ostream & o)
{
	o << "/* Generated by re2c";
	if (opts->version)
	{
		o << " " << PACKAGE_VERSION;
	}
	if (!opts->bNoGenerationDate)
	{
		o << " on ";
		time_t now = time (NULL);
		o.write (ctime (&now), 24);
	}
	o << " */" << "\n";
}

std::string output_get_state ()
{
	return opts->state_get_naked
		? opts->state_get
		: opts->state_get + "()";
}

} // namespace re2c