cppfront Documentation

You can use #!cpp using statements to bring names from a namespace into the current scope, avoiding the need for explicit qualification.

• Specific name: #!cpp using a_namespace::a_name; brings only a_name into the current scope.
• Wildcard (all names): #!cpp using a_namespace::_; brings all names from a_namespace into the current scope using the _ wildcard.

//  A namespace to put all the names provided by a widget library
widgetlib: namespace = {
    widget: type = { /*...*/ }
    // ... more things ...
}

main: () = {
    //  Explicit name qualification
    w: widgetlib::widget = /*...*/;

    {
        //  Using the specific name, no widgetlib:: qualification needed
        using widgetlib::widget;
        w2: widget = /*...*/;
        // ...
    }

    {
        //  Using the whole namespace, no widgetlib:: qualification needed
        using widgetlib::_;
        w3: widget = /*...*/;
        // ...
    }

    // ...
}

Cpp2 supports three types of contracts to ensure code correctness:

• Preconditions (pre): Evaluated before entering a function body. Use pre(condition, "message") to specify a requirement and an optional error message.
• Postconditions (post): Evaluated immediately before a normal return from a function body. If the function exits via an exception, postconditions are not evaluated. Use the $ syntax to capture values at the time of function entry (e.g., post(container.ssize() == container.ssize$ + 1)).
• Assertions (assert): Evaluated when control flow passes through them within a function body.

Contracts can be assigned to specific contract groups using angle brackets: pre<group_name>(condition) or assert<group_name>(condition). If no group is specified, the contract belongs to the default group (accessible as cpp2_default in Cpp1 code).

insert_at: (container, where: int, val: int)
    pre<bounds_safety>( 0 <= where <= container.ssize(), "position (where)$ is outside 'container'" )
    post              ( container.ssize() == container.ssize$ + 1 )
= {
    _ = container.insert( container.begin()+where, val );
}

Cpp2 uses a consistent, context-free syntax for declarations: _name_ : _kind_ = _statement_. This eliminates the 'vexing parse' problem found in standard C++.

Key features include:

• Order-independence: No forward declarations are required; functions can call each other regardless of definition order.
• String Interpolation: Use #!cpp "text (variable)$!" to embed variables directly into strings. This supports standard C++ format specifications.
• Default Safety: Subscript access (e.g., vector[0]) is bounds-checked by default.
• Parameter Passing: The default is in (read-only). Other modes include inout, copy, out, move, and forward.
• Standard Library: The full C++ standard library is available by default when using specific compiler flags.

main: () = {
    words: std::vector = ( "Alice", "Bob" );
    hello( words[0] );
    hello( words[1] );
}

hello: (msg: std::string_view) = {
    std::cout << "Hello, (msg)$!\n";
}

The main function serves as the program entry point. It can be defined in two ways:

1. No parameters: #!cpp main: ()
2. With args parameter: #!cpp main: (args)

When using (args), the parameter is of implicit type cpp2::args_t. This type behaves like a #!cpp const std::array<std::string_view> and performs zero heap allocations. You can access raw C/C++ parameters via args.argc and args.argv.

Return types:

• #!cpp void (default): The compiled Cpp1 code will return int automatically.
• #!cpp int: If no #!cpp return is present, it defaults to #!cpp return 0;.
• Other types supported by your Cpp1 compiler as nonstandard extensions.

// Print out command line arguments, then invoke
// a Qt event loop for a non-UI Qt application
main: (args) -> int
= {
    for args do (arg) {
        std::cout << arg << "\n";
    }

    app: QCoreApplication = (args.argc, args.argv);
    return app.exec();
}