{

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} { }

{

// Core information

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

std::string 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;

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

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

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 = 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) {

out << "#line " << line << " \"" << filename << "2\"\n";

}

}

// Catch up with comment/blank lines

//

auto flush_comments( source_position pos ) -> void

{

assert(pcomments);

// 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

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 ) );

}

}

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

// Open

//

auto open(

std::string cpp1_filename,

std::vector<comment> const& comments

)

-> void

{

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

filename = cpp1_filename;

out.open(filename);

pcomments = &comments;

}

auto is_open() -> bool {

if (out.is_open()) {

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

}

return out.is_open();

}

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

// Abandon: close and delete

//

auto abandon() -> void

{

if (!out.is_open()) {

return;

}

out.close();

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

}

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

// Print extra text and don't track positions

// Used for Cpp2 boundary comment and prelude

//

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 != source_position{}) {

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

adjusted_pos.colno = preempt_pos.colno;

}

preempt_pos = {};

assert (preempt_pos == source_position{});

}

// (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(source_position pos) -> void

{

preempt_pos = pos;

}

// 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 = nullptr ) -> 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 = nullptr ) -> 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;

// 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;

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

// 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"))

{

errors.emplace_back(

source_position(-1, -1),

"source filename must end with .cpp2: " + 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)) {

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 -> .cpp

//

auto lower_to_cpp1() -> void

{

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

if (!errors.empty()) {

return;

}

// Now we'll open the .cpp file

printer.open(

sourcefile.substr(0, std::ssize(sourcefile) - 1),

tokens.get_comments()

);

// 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()) {

if (!flag_clean_cpp1) {

printer.print_extra( "// ----- Cpp2 support -----\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" );

}

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

}

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

// First, echo the non-Cpp2 parts

//

auto cpp2_found = false;

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)

{

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) {

errors.emplace_back(

source_position(curr_lineno, 1),

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

);

}

else {

errors.emplace_back(

source_position(curr_lineno, 1),

"pure-cpp2 switch disables Cpp1 syntax"

);

}

return;

}

printer.print_cpp1( line.text, curr_lineno );

}

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

else {

cpp2_found = true;

// 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

// that we didn't misidentify anything as Cpp2 (even in the

// presence of nonstandard vendor extensions)

//

if (!cpp2_found) {

return;

}

// If there is Cpp2 code, we have more to do...

// Next, bring in the Cpp2 helpers

//

if (!flag_clean_cpp1) {

printer.print_extra( "\n//=== Cpp2 definitions ==========================================================\n\n" );

}

// Next, emit the Cpp2 definitions

//

printer.enable_definitions();

for (auto& section : tokens.get_map())

{

assert (!section.second.empty());

// Tell the printer that we're starting a Cpp2 section

// This time, we use the actual first start line of the section which includes

// the blank/comment lines at the beginning if any (whereas in the first pass

// we used the line of the first Cpp2 token in the section to skip blanks/comments)

printer.start_cpp2( section.first /*lineno*/);

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

auto decls = parser.get_parse_tree(section.second);

for (auto& decl : decls) {

assert(decl);

emit(*decl);

}

}

if (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

printer.print_extra("\n");

}

}

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

//

// emit() functions - each emits a kind of node

//

// The body often mirrors the node's visit() function, unless customization

// is needed where Cpp1 and Cpp2 have different grammar orders

//

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

// try_emit

//

// Helper to emit whatever is in a variant where each

// alternative is a smart pointer

//

template <int I>

auto try_emit(auto& v, auto... more) -> void {

if (v.index() == I) {

auto const& alt = std::get<I>(v);

assert (alt);

emit (*alt, more...);

}

}

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

//

// A StringLiteral could include captures

//

auto expand_string_literal(token const& n) -> std::string

{

assert(n.type() == lexeme::StringLiteral);

auto text = std::string_view(n);

auto length = n.length();

assert (std::ssize(text) == length);

assert(length >= 2);

assert(text.back() == '"');

auto pos = 0;

auto ret = std::string{}; // the return string we're going to build

auto current_start = 0; // the current offset before which the string has been into ret

// Skip prefix to first non-" character

while (pos < length && text[pos] != '"') {

++pos;

}

assert(pos < length && text[pos] == '"');

++pos;

// Now we're on the first character of the string itself

for ( ; pos < length && (text[pos] != '"' || text[pos-1] == '\\'); ++pos)

{

// Find the next )$

if (text[pos] == '$' && text[pos-1] == ')')

{

// Scan back to find the matching (

auto paren_depth = 1;

auto open = pos - 2;

// "next" in the string is the "last" one encountered in the backwards scan

auto last_nonwhitespace = '\0';

for( ; text[open] != '"' || text[open-1] != '\\'; --open)

{

if (text[open] == ')') {

++paren_depth;

}

else if (text[open] == '(') {

--paren_depth;

if (paren_depth == 0) {

break;

}

}

else if (

(text[open] == '+' && text[open - 1] == '+') ||

(text[open] == '-' && text[open - 1] == '-')

)

{

errors.emplace_back(

source_position( n.position().lineno, n.position().colno + pos ),

"a string interpolation expression may not contain ++ or --"

);

return "";

}

else if (

(text[open] == '*' || text[open] == '&' || text[open] == '~') &&

!isspace(text[open - 1]) &&

!isalnum(last_nonwhitespace) && last_nonwhitespace != '('

)

{

errors.emplace_back(

source_position( n.position().lineno, n.position().colno + pos ),

"a string interpolation expression may not contain unary & * or ~"

);

return "";

}

if (!std::isspace(text[open])) {

last_nonwhitespace = text[open];

}

}

if (text[open] == '"')

{

errors.emplace_back(

source_position( n.position().lineno, n.position().colno + pos ),

"no matching ( for string interpolation ending in )$"

);

return "";

}

assert (text[open] == '(');

// 'open' is now at the matching (

// Put the next non-interpolated chunk straight into ret

if (current_start > 0) {

ret += '"';

}

ret += text.substr(current_start, open - current_start);

ret += '"';

// Then put interpolated chunk into ret

ret += " + cpp2::to_string";

ret += text.substr(open, pos - open);

ret += " + ";

current_start = pos+1;

}

}

// Now we should be on the the final " closing the string

assert(pos == length-1 && text[pos] == '"');

// Put the final non-interpolated chunk straight into ret

if (current_start > 0) {

ret += '"';

}

ret += text.substr(current_start);

return ret;

}

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

//

auto emit(token const& n) -> void

{

if (n == "new") {

printer.print_cpp2("cpp2_new", n.position());

}

else if (n.type() == lexeme::StringLiteral) {

printer.print_cpp2( expand_string_literal(n), n.position() );

}

else {