cpp_parsing Namespace Reference

Classes
class	AnyOfParser
class	CharParser
class	CommaSeparatedTupleParser
class	DecimalLiteralParser
class	DeferredParser
class	IdentifierParser
class	IfThenParser
class	LiteralParser
class	MatchingPairParser
class	MatchingStringPairParser
class	NestedStringPairParser
class	OptionalParser
class	OptionalWhitespaceParser
struct	ParseResult
class	RepeatingParser
class	SequenceParser
class	TransformParser
class	TypeParser
class	TypeQualifierSequenceParser
class	UntilCharParser
class	VariableParser

Typedefs
using	CharParserPtr = std::shared_ptr<CharParser>

Functions
ParseResult	clean_parse_result (const ParseResult &r)
const cpp_parsing::ParseResult *	find_first_by_name (const cpp_parsing::ParseResult *root, const std::string &target)
const cpp_parsing::ParseResult *	find_first_name_contains (const cpp_parsing::ParseResult *root, const std::string &substr)
void	collect_by_name (const cpp_parsing::ParseResult *root, const std::string &target, std::vector< const cpp_parsing::ParseResult * > &out)
std::vector< std::pair< std::string, std::string > >	bfs_collect_matches (const cpp_parsing::ParseResult *root, const std::vector< std::string > &names)
std::string	node_text (const cpp_parsing::ParseResult *node)
std::ostream &	print_parse_result (std::ostream &os, const ParseResult &result, int indent)
std::ostream &	operator<< (std::ostream &os, const ParseResult &result)
CharParserPtr	optional_whitespace ()
CharParserPtr	identifier ()
CharParserPtr	variable ()
CharParserPtr	base_type ()
CharParserPtr	type_qualifier_sequence ()
CharParserPtr	until_char (std::vector< char > target_chars, bool inclusive, bool ignore_in_strings_and_chars, const std::string &name)
CharParserPtr	literal (const std::string &s)
CharParserPtr	matching_string_pair (const std::string &name, std::string left, std::string right)
CharParserPtr	matching_pair (CharParserPtr left_parser, CharParserPtr right_parser, const std::string &name)
CharParserPtr	nested_string_pair (CharParserPtr parser, const std::string &name, std::string left, std::string right)
CharParserPtr	repeating (CharParserPtr parser, const std::string &name)
CharParserPtr	optional (CharParserPtr parser, const std::string &name)
CharParserPtr	deferred ()
CharParserPtr	if_then (std::shared_ptr< CharParser > condition_parser, std::shared_ptr< CharParser > then_parser, const std::string &name)
CharParserPtr	any_of (std::vector< CharParserPtr > parsers, const std::string &name)
CharParserPtr	sequence (std::vector< CharParserPtr > parsers, const std::string &name)
CharParserPtr	not_any_of (std::shared_ptr< CharParser > inner, std::unordered_set< std::string > forbidden, std::string name)
std::string	remove_macros (const std::string &code)
std::string	remove_comments_from_file (const std::string &filename)
std::unordered_map< std::string, std::vector< std::string > >	collect_matches_by_parser_name (const ParseResult &result, const std::vector< std::string > &target_names)
ParseResult	parse_source_or_header_file (const std::string &source_code_path)
std::unordered_map< std::string, std::vector< std::string > >	get_parser_name_to_matches_for_source_file (const std::string &source_code_path)
std::vector< std::string >	extract_all_matches_for_a_particular_parser (const std::string &source_code_path, const std::string &parser_name)
std::vector< std::string >	extract_top_level_functions (const std::string &source_code_path)
std::vector< std::string >	extract_top_level_function_declarations (const std::string &header_code_path)
std::vector< std::string >	extract_top_level_classes (const std::string &source_code_path)
std::vector< std::string >	extract_top_level_enum_classes (const std::string &source_code_path)
CharParserPtr	get_templated_type_parser ()
std::string	truncate (const std::string &s, int cutoff=50)
std::string	get_next_part_of_string (const std::string &input, int start, int lookahead=50)
std::vector< CharParserPtr >	create_literal_parsers (std::vector< std::string > literals)
void	log_start_of_parser (const std::string &name, const std::string &input, size_t start)
void	test_parser (const std::string &input, const CharParserPtr &parser)
std::vector< CharParserPtr >	whitespace_between (const std::vector< CharParserPtr > &base_parsers)
CharParserPtr	comma_separated_sequence_parser (CharParserPtr element_parser)
CharParserPtr	optionally_namespaced_identifier ()
CharParserPtr	optional_reference_or_pointer ()
CharParserPtr	add_optional_type_surroundings (CharParserPtr base_parser)
CharParserPtr	lambda_type_parser ()
std::vector< CharParserPtr >	make_operator_literals ()
void	test ()

Variables
Logger	logger ("cpp_parsing")
const std::unordered_set< std::string >	cpp_built_in_types
const std::vector< std::string >	cpp_sign_specifier = {"unsigned", "signed"}
const std::vector< std::string >	cpp_size_specifier = {"short", "long", "long long"}
const std::unordered_set< std::string >	access_specifiers = {"public", "protected", "private"}
const std::vector< std::string >	overloadable_operators
const std::unordered_set< std::string >	cpp_keywords
CharParserPtr	macro_if_statement = sequence({})
CharParserPtr	system_include_parser
CharParserPtr	local_include_parser
CharParserPtr	default_value_for_parameter_suffix_parser
CharParserPtr	full_non_recursive_type = add_optional_type_surroundings(optionally_namespaced_identifier())
CharParserPtr	type = not_any_of(add_optional_type_surroundings(get_templated_type_parser()), cpp_keywords)
CharParserPtr	assignment_parser
CharParserPtr	declaration_parser
CharParserPtr	parameter_parser
CharParserPtr	optional_parameter_sequence
CharParserPtr	optional_parameters
CharParserPtr	parameter_tuple_parser
std::vector< CharParserPtr >	operator_literals = make_operator_literals()
CharParserPtr	optionally_namespaced_variable_parser
CharParserPtr	function_invocation
CharParserPtr	initializer_list_parser
CharParserPtr	constructor_def_parser
CharParserPtr	base_function_signature_parser
CharParserPtr	function_signature_parser
CharParserPtr	function_def_parser
CharParserPtr	function_decl_parser
const std::vector< CharParserPtr >	access_specifier_parsers
const CharParserPtr	access_specifier_parser = any_of(access_specifier_parsers, "access_specifier")
const CharParserPtr	class_inheritance_parser
CharParserPtr	class_def_parser
CharParserPtr	class_def_parser_good
CharParserPtr	struct_def_parser_good
CharParserPtr	enum_class_def_parser
CharParserPtr	using_statement_parser
CharParserPtr	struct_def_parser
CharParserPtr	source_file_body_parser
CharParserPtr	source_file_namespace_body_parser
CharParserPtr	local_or_system_includes_parser
CharParserPtr	source_file_parser
CharParserPtr	header_file_parser

Typedef Documentation

CharParserPtr

using cpp_parsing::CharParserPtr = std::shared_ptr<CharParser>

Function Documentation

add_optional_type_surroundings()

CharParserPtr cpp_parsing::add_optional_type_surroundings ( CharParserPtr base_parser )

inline

any_of()

CharParserPtr cpp_parsing::any_of	(	std::vector< CharParserPtr >	parsers,
		const std::string &	name )

base_type()

CharParserPtr cpp_parsing::base_type

(

)

bfs_collect_matches()

std::vector< std::pair< std::string, std::string > > cpp_parsing::bfs_collect_matches	(	const cpp_parsing::ParseResult *	root,
		const std::vector< std::string > &	names )

clean_parse_result()

ParseResult cpp_parsing::clean_parse_result

(

const ParseResult &

r

)

collect_by_name()

void cpp_parsing::collect_by_name	(	const cpp_parsing::ParseResult *	root,
		const std::string &	target,
		std::vector< const cpp_parsing::ParseResult * > &	out )

collect_matches_by_parser_name()

std::unordered_map< std::string, std::vector< std::string > > cpp_parsing::collect_matches_by_parser_name	(	const ParseResult &	result,
		const std::vector< std::string > &	target_names )

comma_separated_sequence_parser()

CharParserPtr cpp_parsing::comma_separated_sequence_parser ( CharParserPtr element_parser )

inline

create_literal_parsers()

std::vector< CharParserPtr > cpp_parsing::create_literal_parsers ( std::vector< std::string > literals )

inline

deferred()

CharParserPtr cpp_parsing::deferred

(

)

extract_all_matches_for_a_particular_parser()

std::vector< std::string > cpp_parsing::extract_all_matches_for_a_particular_parser	(	const std::string &	source_code_path,
		const std::string &	parser_name )

extract_top_level_classes()

std::vector< std::string > cpp_parsing::extract_top_level_classes

(

const std::string &

source_code_path

)

extract_top_level_enum_classes()

std::vector< std::string > cpp_parsing::extract_top_level_enum_classes

(

const std::string &

source_code_path

)

extract_top_level_function_declarations()

std::vector< std::string > cpp_parsing::extract_top_level_function_declarations

(

const std::string &

header_code_path

)

extract_top_level_functions()

std::vector< std::string > cpp_parsing::extract_top_level_functions

(

const std::string &

source_code_path

)

find_first_by_name()

const cpp_parsing::ParseResult * cpp_parsing::find_first_by_name	(	const cpp_parsing::ParseResult *	root,
		const std::string &	target )

find_first_name_contains()

const cpp_parsing::ParseResult * cpp_parsing::find_first_name_contains	(	const cpp_parsing::ParseResult *	root,
		const std::string &	substr )

get_next_part_of_string()

std::string cpp_parsing::get_next_part_of_string ( const std::string & input, int start, int lookahead = 50 )

inline

get_parser_name_to_matches_for_source_file()

std::unordered_map< std::string, std::vector< std::string > > cpp_parsing::get_parser_name_to_matches_for_source_file

(

const std::string &

source_code_path

)

get_templated_type_parser()

CharParserPtr cpp_parsing::get_templated_type_parser

(

)

identifier()

CharParserPtr cpp_parsing::identifier

(

)

if_then()

CharParserPtr cpp_parsing::if_then	(	std::shared_ptr< CharParser >	condition_parser,
		std::shared_ptr< CharParser >	then_parser,
		const std::string &	name )

lambda_type_parser()

CharParserPtr cpp_parsing::lambda_type_parser ( )

inline

literal()

CharParserPtr cpp_parsing::literal

(

const std::string &

s

)

log_start_of_parser()

void cpp_parsing::log_start_of_parser ( const std::string & name, const std::string & input, size_t start )

inline

make_operator_literals()

std::vector< CharParserPtr > cpp_parsing::make_operator_literals ( )

inline

matching_pair()

CharParserPtr cpp_parsing::matching_pair	(	CharParserPtr	left_parser,
		CharParserPtr	right_parser,
		const std::string &	name )

matching_string_pair()

CharParserPtr cpp_parsing::matching_string_pair	(	const std::string &	name,
		std::string	left,
		std::string	right )

nested_string_pair()

CharParserPtr cpp_parsing::nested_string_pair	(	CharParserPtr	parser,
		const std::string &	name,
		std::string	left,
		std::string	right )

node_text()

std::string cpp_parsing::node_text

(

const cpp_parsing::ParseResult *

node

)

not_any_of()

CharParserPtr cpp_parsing::not_any_of	(	std::shared_ptr< CharParser >	inner,
		std::unordered_set< std::string >	forbidden,
		std::string	name )

operator<<()

std::ostream & cpp_parsing::operator<<	(	std::ostream &	os,
		const ParseResult &	result )

optional()

CharParserPtr cpp_parsing::optional	(	CharParserPtr	parser,
		const std::string &	name )

optional_reference_or_pointer()

CharParserPtr cpp_parsing::optional_reference_or_pointer ( )

inline

optional_whitespace()

CharParserPtr cpp_parsing::optional_whitespace

(

)

optionally_namespaced_identifier()

CharParserPtr cpp_parsing::optionally_namespaced_identifier ( )

inline

parse_source_or_header_file()

ParseResult cpp_parsing::parse_source_or_header_file

(

const std::string &

source_code_path

)

print_parse_result()

std::ostream & cpp_parsing::print_parse_result	(	std::ostream &	os,
		const ParseResult &	result,
		int	indent )

remove_comments_from_file()

std::string cpp_parsing::remove_comments_from_file

(

const std::string &

filename

)

remove_macros()

std::string cpp_parsing::remove_macros

(

const std::string &

code

)

repeating()

CharParserPtr cpp_parsing::repeating	(	CharParserPtr	parser,
		const std::string &	name )

sequence()

CharParserPtr cpp_parsing::sequence	(	std::vector< CharParserPtr >	parsers,
		const std::string &	name )

test()

void cpp_parsing::test ( )

inline

test_parser()

void cpp_parsing::test_parser ( const std::string & input, const CharParserPtr & parser )

inline

truncate()

std::string cpp_parsing::truncate ( const std::string & s, int cutoff = 50 )

inline

type_qualifier_sequence()

CharParserPtr cpp_parsing::type_qualifier_sequence

(

)

until_char()

CharParserPtr cpp_parsing::until_char	(	std::vector< char >	target_chars,
		bool	inclusive,
		bool	ignore_in_strings_and_chars,
		const std::string &	name )

variable()

CharParserPtr cpp_parsing::variable

(

)

whitespace_between()

std::vector< CharParserPtr > cpp_parsing::whitespace_between ( const std::vector< CharParserPtr > & base_parsers )

inline

Variable Documentation

access_specifier_parser

const CharParserPtr cpp_parsing::access_specifier_parser = any_of(access_specifier_parsers, "access_specifier")

inline

access_specifier_parsers

const std::vector<CharParserPtr> cpp_parsing::access_specifier_parsers

inline

Initial value:

= [] {
    std::vector<CharParserPtr> result;
    result.reserve(access_specifiers.size());
    for (const auto &as : access_specifiers) {
        result.push_back(literal(as));
    }
    return result;
}()

access_specifiers

const std::unordered_set<std::string> cpp_parsing::access_specifiers = {"public", "protected", "private"}

assignment_parser

CharParserPtr cpp_parsing::assignment_parser

inline

Initial value:

=
    sequence(whitespace_between({type, variable(), literal("="), until_char({';'})}), "assignment")

base_function_signature_parser

CharParserPtr cpp_parsing::base_function_signature_parser

inline

Initial value:

=
    sequence(whitespace_between({
                 type,
                 any_of({optionally_namespaced_variable_parser, any_of(operator_literals)}),
             }),
             "base_function_signature")

class_def_parser

CharParserPtr cpp_parsing::class_def_parser

inline

Initial value:

=
    sequence(whitespace_between({literal("class"), variable(), optional(class_inheritance_parser),
                                 matching_string_pair(), literal(";")}),
             "class_def")

class_def_parser_good

CharParserPtr cpp_parsing::class_def_parser_good

inline

Initial value:

= sequence(
    whitespace_between(
        {literal("class"), variable(), optional(class_inheritance_parser),
         nested_string_pair(repeating(any_of({sequence(whitespace_between({literal("public:")})),
                                              sequence(whitespace_between({literal("private:")})), function_def_parser,
                                              function_decl_parser, assignment_parser, declaration_parser}))),
         literal(";")}),
    "class_def")

class_inheritance_parser

const CharParserPtr cpp_parsing::class_inheritance_parser

inline

Initial value:

=
    sequence(whitespace_between({literal(":"), optional(access_specifier_parser), variable()}), "class_inheritance")

constructor_def_parser

CharParserPtr cpp_parsing::constructor_def_parser

inline

Initial value:

= sequence({optionally_namespaced_variable_parser, parameter_tuple_parser,
                                                        optional(initializer_list_parser), matching_string_pair()},
                                                       "constructor_def_parser")

cpp_built_in_types

const std::unordered_set<std::string> cpp_parsing::cpp_built_in_types

Initial value:

= {
    "bool", "char", "double", "float", "long", "short", "int", "void",
}

cpp_keywords

const std::unordered_set<std::string> cpp_parsing::cpp_keywords

Initial value:

= {
    "alignas",      "alignof",   "and",        "and_eq",       "asm",
    "auto",         "bitand",    "bitor",      "break",        "case",
    "catch",        "char16_t",  "char32_t",   "class",        "compl",
    "const",        "constexpr", "const_cast", "continue",     "decltype",
    "default",      "delete",    "do",         "dynamic_cast", "else",
    "enum",         "explicit",  "export",     "extern",       "false",
    "for",          "friend",    "goto",       "if",           "inline",
    "mutable",      "namespace", "new",        "noexcept",     "not",
    "not_eq",       "nullptr",   "operator",   "or",           "or_eq",
    "private",      "protected", "public",     "register",     "reinterpret_cast",
    "return",       "signed",    "sizeof",     "static",       "static_assert",
    "static_cast",  "struct",    "switch",     "template",     "this",
    "thread_local", "throw",     "true",       "try",          "typedef",
    "typeid",       "typename",  "union",      "unsigned",     "using",
    "virtual",      "volatile",  "wchar_t",    "while",        "xor",
    "xor_eq"}

cpp_sign_specifier

const std::vector<std::string> cpp_parsing::cpp_sign_specifier = {"unsigned", "signed"}

cpp_size_specifier

const std::vector<std::string> cpp_parsing::cpp_size_specifier = {"short", "long", "long long"}

declaration_parser

CharParserPtr cpp_parsing::declaration_parser

inline

Initial value:

=
    sequence(whitespace_between({type, variable(), until_char({';'})}), "declaration")

default_value_for_parameter_suffix_parser

CharParserPtr cpp_parsing::default_value_for_parameter_suffix_parser

inline

Initial value:

=
    sequence(whitespace_between({literal("="), until_char({',', ')'}, false)}), "default_value_for_parameter_suffix")

enum_class_def_parser

CharParserPtr cpp_parsing::enum_class_def_parser

inline

Initial value:

=
    sequence(whitespace_between({literal("enum class"), variable(), optional(class_inheritance_parser),
                                 nested_string_pair(comma_separated_sequence_parser(variable())), literal(";")}),
             "enum_class_def")

full_non_recursive_type

CharParserPtr cpp_parsing::full_non_recursive_type = add_optional_type_surroundings(optionally_namespaced_identifier())

inline

function_decl_parser

CharParserPtr cpp_parsing::function_decl_parser

inline

Initial value:

=
    sequence(whitespace_between({function_signature_parser, literal(";")}), "function_decl")

function_def_parser

CharParserPtr cpp_parsing::function_def_parser

inline

Initial value:

=
    sequence(whitespace_between({function_signature_parser, matching_string_pair()}), "function_def")

function_invocation

CharParserPtr cpp_parsing::function_invocation

inline

Initial value:

=
    sequence(whitespace_between({optionally_namespaced_variable_parser, matching_string_pair("parens", "(", ")")}),
             "function_invocation")

function_signature_parser

CharParserPtr cpp_parsing::function_signature_parser

inline

Initial value:

=
    sequence(whitespace_between({base_function_signature_parser, parameter_tuple_parser, optional(literal("const"))}),
             "function_signature")

header_file_parser

CharParserPtr cpp_parsing::header_file_parser

inline

Initial value:

= sequence(
    {optional(local_or_system_includes_parser), any_of({source_file_namespace_body_parser, source_file_body_parser})},
    "source_file")

initializer_list_parser

CharParserPtr cpp_parsing::initializer_list_parser

inline

Initial value:

=
    sequence({literal(":"), comma_separated_sequence_parser(function_invocation)}, "initializer_list")

local_include_parser

CharParserPtr cpp_parsing::local_include_parser

inline

Initial value:

=
    sequence(whitespace_between({literal("#include"), sequence({literal("\""), until_char({'"'}, true, false)})}),
             "local_include")

local_or_system_includes_parser

CharParserPtr cpp_parsing::local_or_system_includes_parser

inline

Initial value:

=
    repeating(any_of({local_include_parser, system_include_parser}), "local_or_system_includes_parser")

logger

Logger cpp_parsing::logger("cpp_parsing") ( "cpp_parsing" )

inline

macro_if_statement

CharParserPtr cpp_parsing::macro_if_statement = sequence({})

inline

operator_literals

std::vector<CharParserPtr> cpp_parsing::operator_literals = make_operator_literals()

inline

optional_parameter_sequence

CharParserPtr cpp_parsing::optional_parameter_sequence

inline

Initial value:

=
    optional(repeating(sequence({literal(","), parameter_parser}, "comma_parameter"), "repeating_parameter_sequence"),
             "optional_parameter_sequence")

optional_parameters

CharParserPtr cpp_parsing::optional_parameters

inline

Initial value:

=
    optional(if_then(parameter_parser, optional_parameter_sequence, "one_or_more_parameter"), "optional_parameters")

optionally_namespaced_variable_parser

CharParserPtr cpp_parsing::optionally_namespaced_variable_parser

inline

Initial value:

=
    sequence({optional(sequence({variable(), literal("::")})), variable()}, "optionally_namespaced_variable")

overloadable_operators

const std::vector<std::string> cpp_parsing::overloadable_operators

parameter_parser

CharParserPtr cpp_parsing::parameter_parser

inline

Initial value:

=
    sequence(whitespace_between({optional(type_qualifier_sequence()), type, variable(),
                                 optional(default_value_for_parameter_suffix_parser)}),
             "parameter")

parameter_tuple_parser

CharParserPtr cpp_parsing::parameter_tuple_parser

inline

Initial value:

=
    sequence(whitespace_between({literal("("), optional_parameters, literal(")")}), "parameter_tuple")

source_file_body_parser

CharParserPtr cpp_parsing::source_file_body_parser

inline

Initial value:

= repeating(
    any_of({function_def_parser, constructor_def_parser, assignment_parser,
            
            class_def_parser, struct_def_parser, enum_class_def_parser, using_statement_parser, function_decl_parser}),
    "source_file_body")

source_file_namespace_body_parser

CharParserPtr cpp_parsing::source_file_namespace_body_parser

inline

Initial value:

=
    sequence(whitespace_between({literal("namespace"), variable(), nested_string_pair(source_file_body_parser)}),
             "source_file_namespace_body")

source_file_parser

CharParserPtr cpp_parsing::source_file_parser

inline

Initial value:

= sequence(
    {optional(local_or_system_includes_parser), any_of({source_file_namespace_body_parser, source_file_body_parser})},
    "source_file")

struct_def_parser

CharParserPtr cpp_parsing::struct_def_parser

inline

Initial value:

=
    sequence(whitespace_between({literal("struct"), variable(), matching_string_pair(), literal(";")}), "struct_def")

struct_def_parser_good

CharParserPtr cpp_parsing::struct_def_parser_good

inline

Initial value:

= sequence(
    whitespace_between(
        {literal("struct"), variable(), optional(class_inheritance_parser),
         nested_string_pair(repeating(any_of({sequence(whitespace_between({literal("public:")})),
                                              sequence(whitespace_between({literal("private:")})), function_def_parser,
                                              function_decl_parser, assignment_parser, declaration_parser}))),
         literal(";")}),
    "struct_def")

system_include_parser

CharParserPtr cpp_parsing::system_include_parser

inline

Initial value:

= sequence(whitespace_between({literal("#include"), sequence({
                                                                                                   literal("<"),
                                                                                                   until_char({'>'}),
                                                                                               })}),
                                                      "system_include")

type

CharParserPtr cpp_parsing::type = not_any_of(add_optional_type_surroundings(get_templated_type_parser()), cpp_keywords)

inline

using_statement_parser

CharParserPtr cpp_parsing::using_statement_parser

inline

Initial value:

= sequence(whitespace_between({
                                                           literal("using"),
                                                           variable(),
                                                           literal("="),
                                                           type,
                                                           literal(";"),
                                                       }),
                                                       "using_statement")