bpp Namespace Reference

Classes
class	bash_case
	A case statement in Bash++. More...
class	bash_case_pattern
	A pattern for a case statement in Bash++. More...
class	bash_for
	A for loop in Bash++. More...
class	bash_function
class	bash_if
	An if statement in Bash++. More...
class	bash_if_branch
	A branch of an if statement in Bash++. More...
class	bash_while_condition
	The condition for a while loop in Bash++. More...
class	bash_while_loop
	A while loop in Bash++. More...
class	BashppServer
	The main server class for handling LSP requests and notifications. More...
class	bpp_class
	A class in Bash++. More...
class	bpp_code_entity
	An entity which can contain code. More...
class	bpp_datamember
	A data member in a class. More...
class	bpp_delete_statement
	A delete statement in Bash++. More...
class	bpp_dynamic_cast_statement
	A dynamic_cast statement in Bash++. More...
class	bpp_entity
	The base class for all entities in the Bash++ compiler. More...
class	bpp_method
	A method in a class. More...
class	bpp_method_parameter
	A parameter in a method. More...
class	bpp_object
	An object in Bash++. More...
class	bpp_object_address
	A statement which takes the address of an object in Bash++. More...
class	bpp_object_assignment
	An object assignment statement in Bash++. More...
class	bpp_object_reference
	An object reference in Bash++. More...
class	bpp_pointer_dereference
	A pointer dereference in Bash++. More...
class	bpp_program
	The main program. More...
class	bpp_string
	The practical difference between bpp_code_entity and bpp_string is how we handle the code buffers. More...
class	bpp_value_assignment
	A value assignment statement in Bash++. More...
struct	code_segment
	A struct to hold (compiled) code segments. More...
struct	diagnostic
struct	entity_reference
struct	SymbolPosition

Typedefs
using	json = nlohmann::json

Enumerations
enum	bpp_scope { SCOPE_PUBLIC , SCOPE_PROTECTED , SCOPE_PRIVATE , SCOPE_INACCESSIBLE }
enum	reference_type { ref_primitive , ref_method , ref_object }
enum	diagnostic_type { DIAGNOSTIC_ERROR , DIAGNOSTIC_WARNING , DIAGNOSTIC_INFO , DIAGNOSTIC_HINT }

Functions
bool	is_protected_keyword (const std::string &keyword)
	Check if a string matches any of our protected keywords.
bool	is_valid_identifier (const std::string &identifier)
	Check if a string is a valid identifier in Bash++.
code_segment	generate_supershell_code (const std::string &code_to_run, bool in_while_condition, std::shared_ptr< bash_while_condition > current_while_condition, std::shared_ptr< bpp::bpp_program > program)
	Generates a supershell code segment for executing a bash command.
code_segment	generate_delete_code (std::shared_ptr< bpp::bpp_object > object, const std::string &object_ref, std::shared_ptr< bpp::bpp_program > program)
	Generates a code segment for deleting an object.
code_segment	generate_method_call_code (const std::string &reference_code, const std::string &method_name, std::shared_ptr< bpp::bpp_class > assumed_class, bool force_static_reference, std::shared_ptr< bpp::bpp_program > program)
	Generates a code segment for calling a method.
code_segment	generate_dynamic_cast_code (const std::string &reference_code, const std::string &class_name, std::shared_ptr< bpp::bpp_program > program)
	Generates a code segment for performing a dynamic cast.
code_segment	generate_typeof_code (const std::string &reference_code, std::shared_ptr< bpp::bpp_program > program)
code_segment	inline_new (const std::string &new_address, std::shared_ptr< bpp::bpp_class > new_class)
	Generates a code segment to INLINE class's "new" function within a method.
entity_reference	resolve_reference_impl (const std::string &file, std::shared_ptr< bpp::bpp_entity > context, std::deque< antlr4::tree::TerminalNode * > *nodes, std::deque< std::string > *identifiers, bool declare_local, std::shared_ptr< bpp::bpp_program > program)
	Resolves a reference to an entity in a particular context.
code_segment	generate_delete_code (std::shared_ptr< bpp_object > object, const std::string &object_ref, std::shared_ptr< bpp::bpp_program > program)
code_segment	generate_method_call_code (const std::string &reference_code, const std::string &method_name, std::shared_ptr< bpp_class > assumed_class, bool force_static_reference, std::shared_ptr< bpp::bpp_program > program)
entity_reference	resolve_reference (const std::string &file, std::shared_ptr< bpp::bpp_entity > context, std::deque< std::string > *identifiers, bool declare_local, std::shared_ptr< bpp::bpp_program > program)
entity_reference	resolve_reference (const std::string &file, std::shared_ptr< bpp::bpp_entity > context, std::deque< antlr4::tree::TerminalNode * > *identifiers, bool declare_local, std::shared_ptr< bpp::bpp_program > program)
template<typename T >
void	printValue (std::ostream &os, const T &value)
template<typename... Ts>
void	printValue (std::ostream &os, const std::variant< Ts... > &v)

Variables
const std::shared_ptr< bpp_entity >	inaccessible_entity = std::make_shared<bpp_entity>()
	A placeholder for an inaccessible entity (scope handling)
const std::shared_ptr< bpp_datamember >	inaccessible_datamember = std::make_shared<bpp_datamember>()
	A placeholder for an inaccessible data member of a class (scope handling)
const std::shared_ptr< bpp_method >	inaccessible_method = std::make_shared<bpp_method>()
	A placeholder for an inaccessible method of a class (scope handling)
static const char	bpp_nullptr [] = "0"
	The secret internal value of '@nullptr' in Bash++.
constexpr const char *	protected_keywords []
	A list of keywords that are reserved and cannot be used as identifiers in Bash++.

Detailed Description

Copyright (C) 2025 rail5 Bash++: Bash with classes

Copyright (C) 2025 Andrew S. Rightenburg Bash++: Bash with classes

Typedef Documentation

json

using bpp::json = typedef nlohmann::json

Enumeration Type Documentation

bpp_scope

enum bpp::bpp_scope

Enumerator
SCOPE_PUBLIC
SCOPE_PROTECTED
SCOPE_PRIVATE
SCOPE_INACCESSIBLE

diagnostic_type

enum bpp::diagnostic_type

Enumerator
DIAGNOSTIC_ERROR
DIAGNOSTIC_WARNING
DIAGNOSTIC_INFO
DIAGNOSTIC_HINT

reference_type

enum bpp::reference_type

Enumerator
ref_primitive
ref_method
ref_object

Function Documentation

generate_delete_code() [1/2]

code_segment bpp::generate_delete_code	(	std::shared_ptr< bpp::bpp_object >	object,
		const std::string &	object_ref,
		std::shared_ptr< bpp::bpp_program >	program
	)

Generates a code segment for deleting an object.

This function constructs a code segment to delete an object. The generated code includes:

• A call to the object's destructor if it has one.
• A call to the object's delete function.

Parameters

object	The object to be deleted.
object_ref	The string representing the object's reference in the compiled code.

Returns

A code_segment structure containing the complete deletion code:

• pre_code: The setup code including the destructor call.
• post_code: Empty
• code: Empty

generate_delete_code() [2/2]

code_segment bpp::generate_delete_code	(	std::shared_ptr< bpp_object >	object,
		const std::string &	object_ref,
		std::shared_ptr< bpp::bpp_program >	program
	)

generate_dynamic_cast_code()

code_segment bpp::generate_dynamic_cast_code	(	const std::string &	reference_code,
		const std::string &	class_name,
		std::shared_ptr< bpp::bpp_program >	program
	)

Generates a code segment for performing a dynamic cast.

This function constructs a code segment to perform a dynamic cast on an object. The generated code includes:

• A runtime check to verify the cast is valid.
• A substitution of either the address of the cast object or the nullptr value.

Parameters

reference_code	The code representing the object reference
class_name	The type to which we want to cast

Returns

A code segment structure containing the complete dynamic cast code:

• pre_code: Call to the runtime dynamic cast function
• post_code: Code for cleaning up the dynamic cast's temporary variable
• code: The temporary variable containing the result of the dynamic cast (either the address or the @nullptr value)

generate_method_call_code() [1/2]

code_segment bpp::generate_method_call_code	(	const std::string &	reference_code,
		const std::string &	method_name,
		std::shared_ptr< bpp::bpp_class >	assumed_class,
		bool	force_static_reference,
		std::shared_ptr< bpp::bpp_program >	program
	)

Generates a code segment for calling a method.

This function constructs a code segment to call a method on an object. The generated code includes:

• A lookup in the object's vTable if the method is virtual.
• A call to the method.

Parameters

reference_code	The code representing the object reference.
method_name	The name of the method to be called.
assumed_class	The class to which the object is assumed to belong at compile-time.

Returns

A code_segment structure containing the complete method call code:

• pre_code: The setup code including the vTable lookup.
• post_code: The code for cleaning up the vTable lookup.
• code: The expression to call the method.

generate_method_call_code() [2/2]

code_segment bpp::generate_method_call_code	(	const std::string &	reference_code,
		const std::string &	method_name,
		std::shared_ptr< bpp_class >	assumed_class,
		bool	force_static_reference,
		std::shared_ptr< bpp::bpp_program >	program
	)

generate_supershell_code()

code_segment bpp::generate_supershell_code	(	const std::string &	code_to_run,
		bool	in_while_condition,
		std::shared_ptr< bash_while_condition >	current_while_condition,
		std::shared_ptr< bpp::bpp_program >	program
	)

Generates a supershell code segment for executing a bash command.

This function constructs a code segment to run a specified command in a supershell. It creates a unique function name and output variable using a global counter. The generated code includes:

• A bash function definition wrapping the given command.
• A command to invoke the function and store its output, either appended to a while condition or added to the precode.
• Cleanup commands that unset the dynamically created function and output variable.

Parameters

code_to_run

The bash command to be executed within the supershell.

Returns

A code_segment structure containing the complete supershell execution code:

• pre_code: The setup code including the function definition and invocation.
• post_code: The code for cleaning up the defined environment.
• code: An expression referencing the supershell output variable.

generate_typeof_code()

code_segment bpp::generate_typeof_code	(	const std::string &	reference_code,
		std::shared_ptr< bpp::bpp_program >	program
	)

inline_new()

code_segment bpp::inline_new	(	const std::string &	new_address,
		std::shared_ptr< bpp::bpp_class >	new_class
	)

Generates a code segment to INLINE class's "new" function within a method.

This is only to be used inside a method.

Rather than calling the class's "new" function, by inlining it, we can ensure that all instantiated objects are purely local to the method. This eliminates any issues with scope and recursion.

However, this change has resulted in some significant code duplication:

1. This function duplicates code in bpp_program::add_class, with the difference that the created variables are declared 'local'
2. bpp_method now has an override for add_object which is identical to that in its parent class bpp_code_entity, with the difference that rather than adding code which will call the class's "new" function at runtime, it adds the code generated by this function.

This will have to be handled soon.

Parameters

new_address	The address of the new object
new_class	The class of the new object

Returns

A code segment structure containing the complete new code:

• pre_code: All of the code necessary to create the object
• post_code: Empty
• code: Empty

is_protected_keyword()

bool bpp::is_protected_keyword ( const std::string &  keyword )

inline

Check if a string matches any of our protected keywords.

Parameters

keyword

The string to check

is_valid_identifier()

bool bpp::is_valid_identifier ( const std::string &  identifier )

inline

Check if a string is a valid identifier in Bash++.

Parameters

identifier

The string to check

Returns

true if the string is a valid identifier, false otherwise

printValue() [1/2]

template<typename... Ts>

void bpp::printValue	(	std::ostream &	os,
		const std::variant< Ts... > &	v
	)

printValue() [2/2]

template<typename T >

void bpp::printValue	(	std::ostream &	os,
		const T &	value
	)

resolve_reference() [1/2]

entity_reference bpp::resolve_reference ( const std::string &  file, std::shared_ptr< bpp::bpp_entity >  context, std::deque< antlr4::tree::TerminalNode * > *  identifiers, bool  declare_local, std::shared_ptr< bpp::bpp_program >  program  )

inline

resolve_reference() [2/2]

entity_reference bpp::resolve_reference ( const std::string &  file, std::shared_ptr< bpp::bpp_entity >  context, std::deque< std::string > *  identifiers, bool  declare_local, std::shared_ptr< bpp::bpp_program >  program  )

inline

resolve_reference_impl()

entity_reference bpp::resolve_reference_impl	(	const std::string &	file,
		std::shared_ptr< bpp::bpp_entity >	context,
		std::deque< antlr4::tree::TerminalNode * > *	nodes,
		std::deque< std::string > *	identifiers,
		bool	declare_local,
		std::shared_ptr< bpp::bpp_program >	program
	)

Resolves a reference to an entity in a particular context.

This function resolves a reference to an entity (object, method, or data member) based on a sequence of identifiers.

It does this by recursively scanning the current context for the requested identifier, and then setting a new context based on the resolution of that identifier. I.e., for {object, method}, it will first scan the current context for 'object', and then scan the 'object' context for 'method'.

If passing a self-reference (@this.... or @super....), The self-referential keyword should be the first node in the identifiers deque.

Parameters

file	The source file in which the reference is being resolved.
context	The context (code_entity) in which to resolve the reference.
nodes	A deque of TerminalNode pointers representing the identifiers in the reference.
identifiers	A deque of strings representing the identifiers in the reference.
program	The program in which the reference is being resolved.

Returns

An entity_reference structure containing:

• entity: A shared pointer to the resolved entity (object, method, or data member).
• reference_code: A code_segment containing the code to access the entity.
• created_first_temporary_variable: Whether a first temporary variable was necessary in the compiled code
• created_second_temporary_variable: Whether a second temporary variable was necessary in the compiled code
• class_containing_the_method: The class containing the method, if applicable.
• error: An optional reference_error structure containing an error message and relevant token if the reference could not be resolved.

Variable Documentation

bpp_nullptr

bpp::bpp_nullptr = "0"

static

The secret internal value of '@nullptr' in Bash++.

inaccessible_datamember

bpp::inaccessible_datamember = std::make_shared<bpp_datamember>()

inline

A placeholder for an inaccessible data member of a class (scope handling)

inaccessible_entity

bpp::inaccessible_entity = std::make_shared<bpp_entity>()

inline

A placeholder for an inaccessible entity (scope handling)

inaccessible_method

bpp::inaccessible_method = std::make_shared<bpp_method>()

inline

A placeholder for an inaccessible method of a class (scope handling)

protected_keywords

bpp::protected_keywords

inlineconstexpr

Initial value:

= {
            "class", "constructor", "delete", "destructor",
            "dynamic_cast", "include", "include_once", "method",
            "new", "nullptr", "primitive", "private",
            "protected", "public", "super", "this",
            "typeof", "virtual"
        }

A list of keywords that are reserved and cannot be used as identifiers in Bash++.