{

if (width > 0) {

std::cout << std::setw(width) << std::left;

}

std::cout << s;

{

static std::string indent_str = std::string( 1024, ' ' ); // "1K should be enough for everyone"

if (padding < 1) {

return "";

}

return {

indent_str.c_str(),

as<size_t>( std::min( padding, as<int>(std::ssize(indent_str))) )

};

std::string text;

source_position pos;

text_with_pos(std::string const& t, source_position p) : text{t}, pos{p} { }

o << file ;

if (where.lineno > 0) {

if (flag_print_colon_errors) {

o << ":"<< (where.lineno);

if (where.colno >= 0) {

o << ":" << where.colno;

}

}

else {

o << "("<< (where.lineno);

if (where.colno >= 0) {

o << "," << where.colno;

}

o << ")";

}

}

o << ":";

if (internal) {

o << " internal compiler";

}

o << " error: " << msg << "\n";

{

// Core information

std::ofstream out_file = {}; // Cpp1 syntax output file

std::ostream* out = {}; // will point to out_file or cout

std::string cpp2_filename = {};

std::string cpp1_filename = {};

std::vector<comment> const* pcomments = {}; // Cpp2 comments data

source_position curr_pos = {}; // current (line,col) in output

int next_comment = 0; // index of the next comment not yet printed

bool last_was_cpp2 = false;

bool source_has_cpp2 = false;

struct req_act_info {

colno_t requested;

colno_t offset;

req_act_info(colno_t r, colno_t o) : requested{r}, offset{o} { }

};

struct {

lineno_t line = {};

std::vector<req_act_info> requests = {};

} prev_line_info = {};

// Position override information

std::vector<source_position> preempt_pos = {}; // use this position instead of the next supplied one

int pad_for_this_line = 0; // extra padding to add/subtract for this line only

bool ignore_align = false;

int ignore_align_indent = 0;

lineno_t ignore_align_lineno = 0;

bool enable_indent_heuristic = true;

// Modal information

bool declarations_only = true; // print only declarations in the first pass

std::vector<std::string*> emit_string_targets; // option to emit to string instead of out file

std::vector<std::vector<text_with_pos>*> emit_text_chunks_targets; // similar for vector<text_pos>

enum class target_type { string, chunks };

std::vector<target_type> emit_target_stack; // to interleave them sensibly

//-----------------------------------------------------------------------

// Print text

//

auto print( std::string_view s, source_position pos = source_position{}) -> void

{

// If the caller is capturing this output, emit to the

// current target instead and skip most positioning logic

if (!emit_target_stack.empty())

{

// If capturing to a string, emit to the specified string

if (emit_target_stack.back() == target_type::string) {

assert(!emit_string_targets.empty());

*emit_string_targets.back() += s;

}

// If capturing to a vector of chunks, emit to that

else {

assert(!emit_text_chunks_targets.empty());

emit_text_chunks_targets.back()->insert( emit_text_chunks_targets.back()->begin(), text_with_pos(std::string(s), pos) );

}

return;

}

// Otherwise, we'll actually print the string to the output file

// and update our curr_pos position

// Output the string

assert (out);

*out << s;

// Update curr_pos by finding how many line breaks s contained,

// and where the last one was which determines our current colno

auto last_newline = std::string::npos; // the last newline we found in the string

auto newline_pos = std::size_t(0); // the current newline we found in the string

while ((newline_pos = s.find('\n', newline_pos)) != std::string::npos)

{

// For each line break we find, reset pad and inc current lineno

pad_for_this_line = 0;

++curr_pos.lineno;

last_newline = newline_pos;

++newline_pos;

}

// Now also adjust the colno

if (last_newline != std::string::npos) {

// If we found a newline, it's the distance from the last newline to EOL

curr_pos.colno = s.length() - last_newline;

}

else {

// Else add the length of the string

curr_pos.colno += s.length();

}

}

//-----------------------------------------------------------------------

// Internal helpers

// Start a new line if we're not in col 1 already

//

auto ensure_at_start_of_new_line() -> void

{

if (curr_pos.colno > 1) {

auto old_pos = curr_pos;

print( "\n" );

assert(curr_pos.lineno == old_pos.lineno+1);

assert(curr_pos.colno == 1);

}

}

// Print a #line directive

//

auto print_line_directive( lineno_t line ) -> void

{

prev_line_info = { curr_pos.lineno, { } };

ensure_at_start_of_new_line();

// Not using print() here because this is transparent to the curr_pos

if (!flag_clean_cpp1) {

assert (out);

*out << "#line " << line << " " << std::quoted(cpp2_filename) << "\n";

}

}

// Catch up with comment/blank lines

//

auto flush_comments( source_position pos ) -> void

{

if (!pcomments) {

return;

}

// For convenience

auto& comments = *pcomments;

// Don't emit comments while in the first declarations-only pass

if (declarations_only) {

return;

}

// Add unprinted comments and blank lines as needed to catch up vertically

//

while (curr_pos.lineno < pos.lineno)

{

// If a comment goes on this line, print it

assert( next_comment >= std::ssize(comments) || comments[next_comment].start.lineno >= curr_pos.lineno );

if (next_comment < std::ssize(comments) && comments[next_comment].start.lineno == curr_pos.lineno)

{

// For a line comment, start it at the right indentation and print it

// with a newline end

if (comments[next_comment].kind == comment::comment_kind::line_comment) {

print( pad( comments[next_comment].start.colno - curr_pos.colno + 1 ) );

print( comments[next_comment].text );

assert( comments[next_comment].text.find("\n") == std::string::npos ); // we shouldn't have newlines

print("\n");

}

// For a stream comment, pad out to its column (if we haven't passed it already)

// and emit it there

else {

print( pad( comments[next_comment].start.colno - curr_pos.colno ) );

print( comments[next_comment].text );

assert(curr_pos.lineno <= pos.lineno); // we shouldn't have overshot

}

++next_comment;

}

// Otherwise, just print a blank line

else {

print("\n");

}

}

}

// Position ourselves as close to pos as possible,

// and catch up with displaying comments

//

auto align_to( source_position pos ) -> void

{

// Ignoring this logic is used when we're generating new code sections,

// such as return value structs

if (ignore_align) {

print( pad( ignore_align_indent - curr_pos.colno ) );

return;

}

// Otherwise, we need to apply our usual alignment logic

// Catch up with displaying comments

flush_comments( pos );

// If we're not on the right line, move forward one line

if (curr_pos.lineno < pos.lineno) {

ensure_at_start_of_new_line();

assert (curr_pos.lineno <= pos.lineno);

curr_pos.lineno = pos.lineno; // re-sync

}

// Finally, align to the target column

if (curr_pos.lineno == pos.lineno) {

pos.colno = std::max( 1, pos.colno + pad_for_this_line );

print( pad( pos.colno - curr_pos.colno ) );

}

}

//-----------------------------------------------------------------------

// Destructor

//

~positional_printer() {

flush_comments( {curr_pos.lineno+1, 1} );

if (is_open() && source_has_cpp2) {

// Always make sure the last line ends with a newline

// (not really necessary but makes some tools quieter)

// -- but only if there's any Cpp2, otherwise don't

// because passing through all-Cpp1 code should always

// remain diff-identical

print_extra("\n");

}

}

//-----------------------------------------------------------------------

// Open

//

auto open(

std::string cpp2_filename_,

std::string cpp1_filename_,

std::vector<comment> const& comments,

bool has_cpp2

)

-> void

{

source_has_cpp2 = has_cpp2;

cpp2_filename = cpp2_filename_;

assert (!is_open() && !pcomments && "ICE: tried to call .open twice");

cpp1_filename = cpp1_filename_;

if (cpp1_filename == "stdout") {

out = &std::cout;

}

else {

out_file.open(cpp1_filename);

out = &out_file;

}

pcomments = &comments;

}

auto reopen() -> void

{

assert (is_open() && "ICE: tried to call .reopen without first calling .open");

assert(cpp1_filename.ends_with(".h"));

out_file.close();

out_file.open(cpp1_filename + "pp");

}

auto is_open() -> bool {

if (out) {

assert (pcomments && "ICE: if is_open, pcomments should also be set");

}

return out;

}

//-----------------------------------------------------------------------

// Abandon: close and delete

//

auto abandon() -> void

{

if (!is_open()) {

return;

}

if (out_file.is_open()) {

out_file.close();

std::remove(cpp1_filename.c_str());

}

}

//-----------------------------------------------------------------------

// Print extra text and don't track positions

// Used for Cpp2 boundary comment and prelude and final newline

//

auto print_extra( std::string_view s ) -> void

{

assert (is_open() && "ICE: printer must be open before printing");

print( s );

}

//-----------------------------------------------------------------------

// Print a Cpp1 line, which should be at lineno

//

auto print_cpp1( std::string_view s, lineno_t line ) -> void

{

assert (is_open() && "ICE: printer must be open before printing");

// Keep track of whether the last thing we printed was Cpp2

last_was_cpp2 = false;

// Always start a Cpp1 line on its own new line

ensure_at_start_of_new_line();

// If we are out of sync with the current logical line number,

// emit a #line directive to re-sync

if (curr_pos.lineno != line) {

print_line_directive( line );

curr_pos.lineno = line;

}

// Print the line

assert (curr_pos.colno == 1);

print( s );

print( "\n" );

}

//-----------------------------------------------------------------------

// Start a new Cpp2 section, which should start at lineno

//

auto start_cpp2(lineno_t line) -> void

{

assert (is_open() && "ICE: printer must be open before printing");

// Because the blank/comment lines before a Cpp2 code section are part

// of the Cpp2 section, and not printed in thedeclarations-only pass

if (!last_was_cpp2 && declarations_only) {

print ("\n");

}

// Keep track of whether the last thing we printed was Cpp2

last_was_cpp2 = true;

// Always start a Cpp2 section on its own new line

ensure_at_start_of_new_line();

// If we are out of sync with the current logical line number,

// emit a #line directive to re-sync

if (curr_pos.lineno != line) {

print_line_directive( line );

curr_pos.lineno = line;

}

assert (curr_pos.colno == 1);

}

//-----------------------------------------------------------------------

// Print a Cpp2 item, which should be at pos

//

auto print_cpp2(std::string_view s, source_position pos) -> void

{

assert (is_open() && "ICE: printer must be open before printing");

// Keep track of whether the last thing we printed was Cpp2

// Note: We should have been switched to Cpp2 with a `start_cpp2` call

assert(last_was_cpp2 && "ICE: didn't call start_cpp2 to begin a Cpp2 section");

last_was_cpp2 = true;

// Skip alignment work if we're capturing emitted text

if (emit_target_stack.empty())

{

// Remember where we are

auto last_pos = curr_pos;

// We may want to adjust the position based on (1) a position preemption request

// or else (2) to repeat a similar adjustment we discovered on the previous line

auto adjusted_pos = pos;

// (1) See if there's a position preemption request, if so use it up

// For now, the preempt position use cases are about overriding colno

// and only on the same line. In the future, we might have more use cases.

if (!preempt_pos.empty()) {

if (preempt_pos.back().lineno == pos.lineno) {

adjusted_pos.colno = preempt_pos.back().colno;

}

}

// (2) Otherwise, see if there's a previous line's offset to repeat

// If we moved to a new line, then this is the first

// non-comment non-whitespace text on the new line

else if (last_pos.lineno == pos.lineno-1 && enable_indent_heuristic) {

// If the last line had a request for this colno, remember its actual offset

constexpr int sentinel = -100;

auto last_line_offset = sentinel;

for(auto i = 0;

i < std::ssize(prev_line_info.requests) && prev_line_info.requests[i].requested <= pos.colno;

++i

)

{

if (prev_line_info.requests[i].requested == pos.colno) {

last_line_offset = prev_line_info.requests[i].offset;

break;

}

}

// If there was one, apply the actual column number offset

if (last_line_offset > sentinel) {

adjusted_pos.colno += last_line_offset;

}

}

enable_indent_heuristic = true;

// If we're changing lines, start accumulating this new line's request/actual adjustment info

if (last_pos.lineno < adjusted_pos.lineno) {

prev_line_info = { curr_pos.lineno, { } };

}

align_to(adjusted_pos);

// Remember the requested and actual offset columns for this item

prev_line_info.requests.push_back( req_act_info( pos.colno /*requested*/ , curr_pos.colno /*actual*/ - pos.colno ) );

}

print(s, pos);

}

//-----------------------------------------------------------------------

// Position override control functions

//

// Use this position instead of the next supplied one

// Useful when Cpp1 syntax is emitted in a different order/verbosity

// than Cpp2 such as with declarations

//

auto preempt_position_push(source_position pos) -> void

{

preempt_pos.push_back( pos );

}

auto preempt_position_pop() -> void

{

assert(!preempt_pos.empty());

preempt_pos.pop_back();

}

// Add (or, if negative, subtract) padding for the current line only

//

auto add_pad_in_this_line(colno_t extra) -> void

{

pad_for_this_line += extra;

}

// Enable indent heuristic for just this line

//

auto disable_indent_heuristic_for_next_text() -> void {

enable_indent_heuristic = false;

}

// Ignore position information, usually when emitting generated code

// such as generated multi-return type structs

//

auto ignore_alignment(bool ignore, int indent = 0) -> void

{

// We'll only ever call this in local non-nested true/false pairs.

// If we ever want to generalize (support nesting, or make it non-brittle),

// wrap this in a push/pop stack.

if (ignore) {

ignore_align = true;

ignore_align_indent = indent;

ignore_align_lineno = curr_pos.lineno; // push state

}

else {

ignore_align = false;

ignore_align_indent = 0;

if (ignore_align_lineno != curr_pos.lineno) {

ensure_at_start_of_new_line();

print_line_directive(ignore_align_lineno+1);

}

curr_pos.lineno = ignore_align_lineno+1; // pop state

}

}

//-----------------------------------------------------------------------

// Modal state control functions

//

// In the first pass we will print only declarations (the default)

// For the second pass this function enables printing definitions

//

auto enable_definitions() -> void {

declarations_only = false;

}

auto doing_declarations_only() const -> bool {

return declarations_only;

}

// Provide an option to store to a given string instead, which is

// useful for capturing Cpp1-formatted output for generated code

//

auto emit_to_string( std::string* target = {} ) -> void {

if (target) {

emit_string_targets.push_back( target );

emit_target_stack.push_back(target_type::string);

}

else {

emit_string_targets.pop_back();

emit_target_stack.pop_back();

}

}

// Provide an option to store to a vector<text_with_pos>, which is

// useful for postfix expression which have to mix unwrapping operators

// with emitting sub-elements such as expression lists

//

auto emit_to_text_chunks( std::vector<text_with_pos>* target = {} ) -> void {

if (target) {

emit_text_chunks_targets.push_back( target );

emit_target_stack.push_back(target_type::chunks);

}

else {

emit_text_chunks_targets.pop_back();

emit_target_stack.pop_back();

}

}

{

std::string sourcefile;

std::vector<error> errors;

// For building

//

cpp2::source source;

cpp2::tokens tokens;

cpp2::parser parser;

cpp2::sema sema;

bool source_loaded = true;

bool last_postfix_expr_was_pointer = false;

bool violates_bounds_safety = false;

bool violates_initialization_safety = false;

bool suppress_move_from_last_use = false;

struct arg_info {

passing_style pass = passing_style::in;

token const* ptoken = {};

};

std::vector<arg_info> current_args = { {} };

// For lowering

//

positional_printer printer;

bool in_definite_init = false;

bool in_parameter_list = false;

std::string function_return_name;

std::vector<parameter_declaration_list_node*> function_returns;

parameter_declaration_list_node single_anon;

// special value - hack for now to note single-anon-return type kind in this function_returns working list

std::vector<std::string> function_requires_conditions;

struct iter_info {

iteration_statement_node const* stmt;

bool used = false;

};

std::vector<iter_info> iteration_statements;

std::vector<bool> in_non_rvalue_context = { false };

std::vector<bool> need_expression_list_parens = { true };

auto push_need_expression_list_parens( bool b ) -> void { need_expression_list_parens.push_back(b); }

auto pop_need_expression_list_parens() -> void { assert(std::ssize(need_expression_list_parens) > 1);

need_expression_list_parens.pop_back(); }

auto should_add_expression_list_parens() -> bool { assert(!need_expression_list_parens.empty());

return need_expression_list_parens.back(); }

auto consumed_expression_list_parens() -> void { if( std::ssize(need_expression_list_parens) > 1 )

need_expression_list_parens.back() = false; }

//-----------------------------------------------------------------------

// Constructor

//

// filename the source file to be processed

//

cppfront(std::string const& filename)

: sourcefile{ filename }

, source{ errors }

, tokens{ errors }

, parser{ errors }

, sema{ errors }

{

// "Constraints enable creativity in the right directions"

// sort of applies here

//

if (!sourcefile.ends_with(".cpp2") && !sourcefile.ends_with(".h2"))

{

errors.emplace_back(

source_position(-1, -1),

"source filename must end with .cpp2 or .h2: " + sourcefile

);

}

// Load the program file into memory

//

else if (!source.load(sourcefile))

{

if (errors.empty()) {

errors.emplace_back(

source_position(-1, -1),

"file not found: " + sourcefile

);

}

source_loaded = false;

}

else

{

// Tokenize

//

tokens.lex(source.get_lines());

// Parse

//

try

{

for (auto const& [line, entry] : tokens.get_map()) {

if (!parser.parse(entry, tokens.get_generated())) {

errors.emplace_back(

source_position(line, 0),

"parse failed for section starting here"

);

}

}

// Sema

parser.visit(sema);

if (!sema.apply_local_rules()) {

violates_initialization_safety = true;

}

}

catch (std::runtime_error& e) {

errors.emplace_back(

source_position(-1, -1),

e.what()

);

}

}

}

//-----------------------------------------------------------------------

// lower_to_cpp1

//

// Emits the target file with the last '2' stripped

//

struct lower_to_cpp1_ret {

lineno_t cpp1_lines = 0;

lineno_t cpp2_lines = 0;

};

auto lower_to_cpp1() -> lower_to_cpp1_ret

{

auto ret = lower_to_cpp1_ret{};

// Only lower to Cpp1 if we haven't already encountered errors

if (!errors.empty()) {

return {};

}

// Now we'll open the Cpp1 file

auto cpp1_filename = sourcefile.substr(0, std::ssize(sourcefile) - 1);

if (!flag_cpp1_filename.empty()) {

cpp1_filename = flag_cpp1_filename; // use override if present

}

printer.open(

sourcefile,

cpp1_filename,

tokens.get_comments(),

source.has_cpp2()

);

if (!printer.is_open()) {

errors.emplace_back(

source_position{},

"could not open output file " + cpp1_filename

);

return {};

}

// Generate a reasonable macroized name

auto cpp1_FILENAME = to_upper_and_underbar(cpp1_filename);

// Only emit extra lines if we actually have Cpp2, because

// we want pure-Cpp1 files to pass through with zero changes

if (source.has_cpp2())

{

printer.print_extra( "\n" );

if (cpp1_filename.back() == 'h') {

printer.print_extra( "#ifndef " + cpp1_FILENAME+"__CPP2\n");

printer.print_extra( "#define " + cpp1_FILENAME+"__CPP2" + "\n\n" );

}

if (flag_use_source_location) {

printer.print_extra( "#define CPP2_USE_SOURCE_LOCATION Yes\n" );

}

if (flag_cpp2_only) {

printer.print_extra( "#define CPP2_USE_MODULES Yes\n" );

}

if (flag_no_exceptions) {

printer.print_extra( "#define CPP2_NO_EXCEPTIONS Yes\n" );

}

if (flag_no_rtti) {

printer.print_extra( "#define CPP2_NO_RTTI Yes\n" );

}

}

auto map_iter = tokens.get_map().cbegin();

auto hpp_includes = std::string{};

// First, echo the non-Cpp2 parts

//

for (

lineno_t curr_lineno = 0;

auto const& line : source.get_lines()

)

{

// Skip dummy line we added to make 0-vs-1-based offsets readable

if (curr_lineno != 0)

{

// If it's a Cpp1 line, emit it

if (line.cat != source_line::category::cpp2)

{

++ret.cpp1_lines;

if (flag_cpp2_only &&

!line.text.empty() &&

line.cat != source_line::category::comment &&

line.cat != source_line::category::import

)

{

if (line.cat == source_line::category::preprocessor) {

if (!line.text.ends_with(".h2\"")) {

errors.emplace_back(

source_position(curr_lineno, 1),

"pure-cpp2 switch disables the preprocessor, including #include (except of .h2 files) - use import instead (note: 'import std;' is implicit in -pure-cpp2)"

);

return {};

}

}

else {

errors.emplace_back(

source_position(curr_lineno, 1),

"pure-cpp2 switch disables Cpp1 syntax"

);

return {};

}

}

if (line.cat == source_line::category::preprocessor && line.text.ends_with(".h2\"")) {

// Strip off the 2"

auto h_include = line.text.substr(0, line.text.size()-2);

printer.print_cpp1( h_include + "\"", curr_lineno );

hpp_includes += h_include + "pp\"\n";

}

else {

printer.print_cpp1( line.text, curr_lineno );

}

}

// If it's a Cpp2 line...

else {

++ret.cpp2_lines;

if (ret.cpp2_lines == 1)

{

printer.print_extra( "\n#include \"cpp2util.h\"\n\n" );

}

// We should be in a position to emit a set of Cpp2 declarations

if (map_iter != tokens.get_map().cend() && map_iter->first /*line*/ <= curr_lineno)

{

// We should be here only when we're at exactly the first line of a Cpp2 section

assert (map_iter->first == curr_lineno);

assert (!map_iter->second.empty());

// Get the parse tree for this section and emit each forward declaration

auto decls = parser.get_parse_tree(map_iter->second);

for (auto& decl : decls) {

assert(decl);

// Treat each declaration as the start of a Cpp2 section (so we get #line)

printer.start_cpp2( decl->position().lineno );

emit(*decl);

}

++map_iter;

}

}

}

++curr_lineno;

}

// We can stop here if there's no Cpp2 code -- a file with no Cpp2

// should have perfect passthrough verifiable with diff, including