#include "mpc.h"

Classes
struct	mpc_mem_t

struct	mpc_input_t

struct	mpc_pdata_fail_t

struct	mpc_pdata_lift_t

struct	mpc_pdata_expect_t

struct	mpc_pdata_anchor_t

struct	mpc_pdata_single_t

struct	mpc_pdata_range_t

struct	mpc_pdata_satisfy_t

struct	mpc_pdata_string_t

struct	mpc_pdata_apply_t

struct	mpc_pdata_apply_to_t

struct	mpc_pdata_check_t

struct	mpc_pdata_check_with_t

struct	mpc_pdata_predict_t

struct	mpc_pdata_not_t

struct	mpc_pdata_repeat_t

struct	mpc_pdata_or_t

struct	mpc_pdata_and_t

union	mpc_pdata_t

struct	mpc_parser_t

struct	mpca_grammar_st_t

struct	mpca_stmt_t

Macros
#define	MPC_SUCCESS(x) r->output = x; return 1

#define	MPC_FAILURE(x) r->error = x; return 0

#define	MPC_PRIMITIVE(x)

#define	MPC_MAX_RECURSION_DEPTH 1000

Enumerations
enum	{ MPC_INPUT_STRING = 0 , MPC_INPUT_FILE = 1 , MPC_INPUT_PIPE = 2 }

enum	{ MPC_INPUT_MARKS_MIN = 32 }

enum	{ MPC_INPUT_MEM_NUM = 512 }

enum	{ MPC_TYPE_UNDEFINED = 0 , MPC_TYPE_PASS = 1 , MPC_TYPE_FAIL = 2 , MPC_TYPE_LIFT = 3 , MPC_TYPE_LIFT_VAL = 4 , MPC_TYPE_EXPECT = 5 , MPC_TYPE_ANCHOR = 6 , MPC_TYPE_STATE = 7 , MPC_TYPE_ANY = 8 , MPC_TYPE_SINGLE = 9 , MPC_TYPE_ONEOF = 10 , MPC_TYPE_NONEOF = 11 , MPC_TYPE_RANGE = 12 , MPC_TYPE_SATISFY = 13 , MPC_TYPE_STRING = 14 , MPC_TYPE_APPLY = 15 , MPC_TYPE_APPLY_TO = 16 , MPC_TYPE_PREDICT = 17 , MPC_TYPE_NOT = 18 , MPC_TYPE_MAYBE = 19 , MPC_TYPE_MANY = 20 , MPC_TYPE_MANY1 = 21 , MPC_TYPE_COUNT = 22 , MPC_TYPE_OR = 23 , MPC_TYPE_AND = 24 , MPC_TYPE_CHECK = 25 , MPC_TYPE_CHECK_WITH = 26 , MPC_TYPE_SOI = 27 , MPC_TYPE_EOI = 28 }

enum	{ MPC_PARSE_STACK_MIN = 4 }

Functions
static mpc_state_t	mpc_state_invalid (void)

static mpc_state_t	mpc_state_new (void)

static mpc_input_t *	mpc_input_new_string (const char filename, const char string)

static mpc_input_t *	mpc_input_new_nstring (const char filename, const char string, size_t length)

static mpc_input_t *	mpc_input_new_pipe (const char filename, FILE pipe)

static mpc_input_t *	mpc_input_new_file (const char filename, FILE file)

static void	mpc_input_delete (mpc_input_t *i)

static int	mpc_mem_ptr (mpc_input_t i, void p)

static void *	mpc_malloc (mpc_input_t *i, size_t n)

static void *	mpc_calloc (mpc_input_t *i, size_t n, size_t m)

static void	mpc_free (mpc_input_t i, void p)

static void *	mpc_realloc (mpc_input_t i, void p, size_t n)

static void *	mpc_export (mpc_input_t i, void p)

static void	mpc_input_backtrack_disable (mpc_input_t *i)

static void	mpc_input_backtrack_enable (mpc_input_t *i)

static void	mpc_input_suppress_disable (mpc_input_t *i)

static void	mpc_input_suppress_enable (mpc_input_t *i)

static void	mpc_input_mark (mpc_input_t *i)

static void	mpc_input_unmark (mpc_input_t *i)

static void	mpc_input_rewind (mpc_input_t *i)

static int	mpc_input_buffer_in_range (mpc_input_t *i)

static char	mpc_input_buffer_get (mpc_input_t *i)

static char	mpc_input_getc (mpc_input_t *i)

static char	mpc_input_peekc (mpc_input_t *i)

static int	mpc_input_terminated (mpc_input_t *i)

static int	mpc_input_failure (mpc_input_t *i, char c)

static int	mpc_input_success (mpc_input_t i, char c, char *o)

static int	mpc_input_any (mpc_input_t i, char *o)

static int	mpc_input_char (mpc_input_t i, char c, char *o)

static int	mpc_input_range (mpc_input_t i, char c, char d, char *o)

static int	mpc_input_oneof (mpc_input_t i, const char c, char **o)

static int	mpc_input_noneof (mpc_input_t i, const char c, char **o)

static int	mpc_input_satisfy (mpc_input_t i, int(cond)(char), char **o)

static int	mpc_input_string (mpc_input_t i, const char c, char **o)

static int	mpc_input_anchor (mpc_input_t i, int(f)(char, char), char **o)

static int	mpc_input_soi (mpc_input_t i, char *o)

static int	mpc_input_eoi (mpc_input_t i, char *o)

static mpc_state_t *	mpc_input_state_copy (mpc_input_t *i)

void	mpc_err_delete (mpc_err_t *x)

void	mpc_err_print (mpc_err_t *x)

void	mpc_err_print_to (mpc_err_t x, FILE f)

static void	mpc_err_string_cat (char buffer, int pos, int max, char const fmt,...)

static const char *	mpc_err_char_unescape (char c)

char *	mpc_err_string (mpc_err_t *x)

static mpc_err_t *	mpc_err_new (mpc_input_t i, const char expected)

static mpc_err_t *	mpc_err_fail (mpc_input_t i, const char failure)

static mpc_err_t *	mpc_err_file (const char filename, const char failure)

static void	mpc_err_delete_internal (mpc_input_t i, mpc_err_t x)

static mpc_err_t *	mpc_err_export (mpc_input_t i, mpc_err_t x)

static int	mpc_err_contains_expected (mpc_input_t i, mpc_err_t x, char *expected)

static void	mpc_err_add_expected (mpc_input_t i, mpc_err_t x, char *expected)

static mpc_err_t *	mpc_err_or (mpc_input_t i, mpc_err_t *x, int n)

static mpc_err_t *	mpc_err_repeat (mpc_input_t i, mpc_err_t x, const char *prefix)

static mpc_err_t *	mpc_err_many1 (mpc_input_t i, mpc_err_t x)

static mpc_err_t *	mpc_err_count (mpc_input_t i, mpc_err_t x, int n)

static mpc_err_t *	mpc_err_merge (mpc_input_t i, mpc_err_t x, mpc_err_t *y)

static mpc_val_t *	mpcf_input_nth_free (mpc_input_t i, int n, mpc_val_t *xs, int x)

static mpc_val_t *	mpcf_input_fst_free (mpc_input_t i, int n, mpc_val_t *xs)

static mpc_val_t *	mpcf_input_snd_free (mpc_input_t i, int n, mpc_val_t *xs)

static mpc_val_t *	mpcf_input_trd_free (mpc_input_t i, int n, mpc_val_t *xs)

static mpc_val_t *	mpcf_input_strfold (mpc_input_t i, int n, mpc_val_t *xs)

static mpc_val_t *	mpcf_input_state_ast (mpc_input_t i, int n, mpc_val_t *xs)

static mpc_val_t *	mpc_parse_fold (mpc_input_t i, mpc_fold_t f, int n, mpc_val_t *xs)

static mpc_val_t *	mpcf_input_free (mpc_input_t i, mpc_val_t x)

static mpc_val_t *	mpcf_input_str_ast (mpc_input_t i, mpc_val_t c)

static mpc_val_t *	mpc_parse_apply (mpc_input_t i, mpc_apply_t f, mpc_val_t x)

static mpc_val_t *	mpc_parse_apply_to (mpc_input_t i, mpc_apply_to_t f, mpc_val_t x, mpc_val_t *d)

static void	mpc_parse_dtor (mpc_input_t i, mpc_dtor_t d, mpc_val_t x)

static int	mpc_parse_run (mpc_input_t i, mpc_parser_t p, mpc_result_t r, mpc_err_t *e, int depth)

int	mpc_parse_input (mpc_input_t i, mpc_parser_t p, mpc_result_t *r)

int	mpc_parse (const char filename, const char string, mpc_parser_t p, mpc_result_t r)

int	mpc_nparse (const char filename, const char string, size_t length, mpc_parser_t p, mpc_result_t r)

int	mpc_parse_file (const char filename, FILE file, mpc_parser_t p, mpc_result_t r)

int	mpc_parse_pipe (const char filename, FILE pipe, mpc_parser_t p, mpc_result_t r)

int	mpc_parse_contents (const char filename, mpc_parser_t p, mpc_result_t *r)

static void	mpc_undefine_unretained (mpc_parser_t *p, int force)

static void	mpc_undefine_or (mpc_parser_t *p)

static void	mpc_undefine_and (mpc_parser_t *p)

void	mpc_delete (mpc_parser_t *p)

static void	mpc_soft_delete (mpc_val_t *x)

static mpc_parser_t *	mpc_undefined (void)

mpc_parser_t *	mpc_new (const char *name)

mpc_parser_t *	mpc_copy (mpc_parser_t *a)

mpc_parser_t *	mpc_undefine (mpc_parser_t *p)

mpc_parser_t *	mpc_define (mpc_parser_t p, mpc_parser_t a)

void	mpc_cleanup (int n,...)

mpc_parser_t *	mpc_pass (void)

mpc_parser_t *	mpc_fail (const char *m)

mpc_parser_t *	mpc_failf (const char *fmt,...)

mpc_parser_t *	mpc_lift_val (mpc_val_t *x)

mpc_parser_t *	mpc_lift (mpc_ctor_t lf)

mpc_parser_t *	mpc_anchor (int(*f)(char, char))

mpc_parser_t *	mpc_state (void)

mpc_parser_t *	mpc_expect (mpc_parser_t a, const char expected)

mpc_parser_t *	mpc_expectf (mpc_parser_t a, const char fmt,...)

mpc_parser_t *	mpc_any (void)

mpc_parser_t *	mpc_char (char c)

mpc_parser_t *	mpc_range (char s, char e)

mpc_parser_t *	mpc_oneof (const char *s)

mpc_parser_t *	mpc_noneof (const char *s)

mpc_parser_t *	mpc_satisfy (int(*f)(char))

mpc_parser_t *	mpc_string (const char *s)

mpc_parser_t *	mpc_apply (mpc_parser_t *a, mpc_apply_t f)

mpc_parser_t *	mpc_apply_to (mpc_parser_t a, mpc_apply_to_t f, void x)

mpc_parser_t *	mpc_check (mpc_parser_t a, mpc_dtor_t da, mpc_check_t f, const char e)

mpc_parser_t *	mpc_check_with (mpc_parser_t a, mpc_dtor_t da, mpc_check_with_t f, void x, const char *e)

mpc_parser_t *	mpc_checkf (mpc_parser_t a, mpc_dtor_t da, mpc_check_t f, const char fmt,...)

mpc_parser_t *	mpc_check_withf (mpc_parser_t a, mpc_dtor_t da, mpc_check_with_t f, void x, const char *fmt,...)

mpc_parser_t *	mpc_predictive (mpc_parser_t *a)

mpc_parser_t *	mpc_not_lift (mpc_parser_t *a, mpc_dtor_t da, mpc_ctor_t lf)

mpc_parser_t *	mpc_not (mpc_parser_t *a, mpc_dtor_t da)

mpc_parser_t *	mpc_maybe_lift (mpc_parser_t *a, mpc_ctor_t lf)

mpc_parser_t *	mpc_maybe (mpc_parser_t *a)

mpc_parser_t *	mpc_many (mpc_fold_t f, mpc_parser_t *a)

mpc_parser_t *	mpc_many1 (mpc_fold_t f, mpc_parser_t *a)

mpc_parser_t *	mpc_count (int n, mpc_fold_t f, mpc_parser_t *a, mpc_dtor_t da)

mpc_parser_t *	mpc_or (int n,...)

mpc_parser_t *	mpc_and (int n, mpc_fold_t f,...)

mpc_parser_t *	mpc_soi (void)

mpc_parser_t *	mpc_eoi (void)

static int	mpc_boundary_anchor (char prev, char next)

static int	mpc_boundary_newline_anchor (char prev, char next)

mpc_parser_t *	mpc_boundary (void)

mpc_parser_t *	mpc_boundary_newline (void)

mpc_parser_t *	mpc_whitespace (void)

mpc_parser_t *	mpc_whitespaces (void)

mpc_parser_t *	mpc_blank (void)

mpc_parser_t *	mpc_newline (void)

mpc_parser_t *	mpc_tab (void)

mpc_parser_t *	mpc_escape (void)

mpc_parser_t *	mpc_digit (void)

mpc_parser_t *	mpc_hexdigit (void)

mpc_parser_t *	mpc_octdigit (void)

mpc_parser_t *	mpc_digits (void)

mpc_parser_t *	mpc_hexdigits (void)

mpc_parser_t *	mpc_octdigits (void)

mpc_parser_t *	mpc_lower (void)

mpc_parser_t *	mpc_upper (void)

mpc_parser_t *	mpc_alpha (void)

mpc_parser_t *	mpc_underscore (void)

mpc_parser_t *	mpc_alphanum (void)

mpc_parser_t *	mpc_int (void)

mpc_parser_t *	mpc_hex (void)

mpc_parser_t *	mpc_oct (void)

mpc_parser_t *	mpc_number (void)

mpc_parser_t *	mpc_real (void)

mpc_parser_t *	mpc_float (void)

mpc_parser_t *	mpc_char_lit (void)

mpc_parser_t *	mpc_string_lit (void)

mpc_parser_t *	mpc_regex_lit (void)

mpc_parser_t *	mpc_ident (void)

mpc_parser_t *	mpc_startwith (mpc_parser_t *a)

mpc_parser_t *	mpc_endwith (mpc_parser_t *a, mpc_dtor_t da)

mpc_parser_t *	mpc_whole (mpc_parser_t *a, mpc_dtor_t da)

mpc_parser_t *	mpc_stripl (mpc_parser_t *a)

mpc_parser_t *	mpc_stripr (mpc_parser_t *a)

mpc_parser_t *	mpc_strip (mpc_parser_t *a)

mpc_parser_t *	mpc_tok (mpc_parser_t *a)

mpc_parser_t *	mpc_sym (const char *s)

mpc_parser_t *	mpc_total (mpc_parser_t *a, mpc_dtor_t da)

mpc_parser_t *	mpc_between (mpc_parser_t a, mpc_dtor_t ad, const char o, const char *c)

mpc_parser_t *	mpc_parens (mpc_parser_t *a, mpc_dtor_t ad)

mpc_parser_t *	mpc_braces (mpc_parser_t *a, mpc_dtor_t ad)

mpc_parser_t *	mpc_brackets (mpc_parser_t *a, mpc_dtor_t ad)

mpc_parser_t *	mpc_squares (mpc_parser_t *a, mpc_dtor_t ad)

mpc_parser_t *	mpc_tok_between (mpc_parser_t a, mpc_dtor_t ad, const char o, const char *c)

mpc_parser_t *	mpc_tok_parens (mpc_parser_t *a, mpc_dtor_t ad)

mpc_parser_t *	mpc_tok_braces (mpc_parser_t *a, mpc_dtor_t ad)

mpc_parser_t *	mpc_tok_brackets (mpc_parser_t *a, mpc_dtor_t ad)

mpc_parser_t *	mpc_tok_squares (mpc_parser_t *a, mpc_dtor_t ad)

static mpc_val_t *	mpcf_re_or (int n, mpc_val_t **xs)

static mpc_val_t *	mpcf_re_and (int n, mpc_val_t **xs)

static mpc_val_t *	mpcf_re_repeat (int n, mpc_val_t **xs)

static mpc_parser_t *	mpc_re_escape_char (char c)

static mpc_val_t *	mpcf_re_escape (mpc_val_t x, void data)

static const char *	mpc_re_range_escape_char (char c)

static mpc_val_t *	mpcf_re_range (mpc_val_t *x)

mpc_parser_t *	mpc_re (const char *re)

mpc_parser_t *	mpc_re_mode (const char *re, int mode)

void	mpcf_dtor_null (mpc_val_t *x)

mpc_val_t *	mpcf_ctor_null (void)

mpc_val_t *	mpcf_ctor_str (void)

mpc_val_t *	mpcf_free (mpc_val_t *x)

mpc_val_t *	mpcf_int (mpc_val_t *x)

mpc_val_t *	mpcf_hex (mpc_val_t *x)

mpc_val_t *	mpcf_oct (mpc_val_t *x)

mpc_val_t *	mpcf_float (mpc_val_t *x)

mpc_val_t *	mpcf_strtriml (mpc_val_t *x)

mpc_val_t *	mpcf_strtrimr (mpc_val_t *x)

mpc_val_t *	mpcf_strtrim (mpc_val_t *x)

static mpc_val_t *	mpcf_escape_new (mpc_val_t x, const char input, const char **output)

static mpc_val_t *	mpcf_unescape_new (mpc_val_t x, const char input, const char **output)

mpc_val_t *	mpcf_escape (mpc_val_t *x)

mpc_val_t *	mpcf_unescape (mpc_val_t *x)

mpc_val_t *	mpcf_escape_regex (mpc_val_t *x)

mpc_val_t *	mpcf_unescape_regex (mpc_val_t *x)

mpc_val_t *	mpcf_escape_string_raw (mpc_val_t *x)

mpc_val_t *	mpcf_unescape_string_raw (mpc_val_t *x)

mpc_val_t *	mpcf_escape_char_raw (mpc_val_t *x)

mpc_val_t *	mpcf_unescape_char_raw (mpc_val_t *x)

mpc_val_t *	mpcf_null (int n, mpc_val_t **xs)

mpc_val_t *	mpcf_fst (int n, mpc_val_t **xs)

mpc_val_t *	mpcf_snd (int n, mpc_val_t **xs)

mpc_val_t *	mpcf_trd (int n, mpc_val_t **xs)

static mpc_val_t *	mpcf_nth_free (int n, mpc_val_t **xs, int x)

mpc_val_t *	mpcf_fst_free (int n, mpc_val_t **xs)

mpc_val_t *	mpcf_snd_free (int n, mpc_val_t **xs)

mpc_val_t *	mpcf_trd_free (int n, mpc_val_t **xs)

mpc_val_t *	mpcf_all_free (int n, mpc_val_t **xs)

mpc_val_t *	mpcf_strfold (int n, mpc_val_t **xs)

mpc_val_t *	mpcf_maths (int n, mpc_val_t **xs)

static void	mpc_print_unretained (mpc_parser_t *p, int force)

void	mpc_print (mpc_parser_t *p)

int	mpc_test_fail (mpc_parser_t p, const char s, const void d, int(tester)(const void , const void ), mpc_dtor_t destructor, void(printer)(const void ))

int	mpc_test_pass (mpc_parser_t p, const char s, const void d, int(tester)(const void , const void ), mpc_dtor_t destructor, void(printer)(const void ))

void	mpc_ast_delete (mpc_ast_t *a)

static void	mpc_ast_delete_no_children (mpc_ast_t *a)

mpc_ast_t *	mpc_ast_new (const char tag, const char contents)

mpc_ast_t *	mpc_ast_build (int n, const char *tag,...)

mpc_ast_t *	mpc_ast_add_root (mpc_ast_t *a)

int	mpc_ast_eq (mpc_ast_t a, mpc_ast_t b)

mpc_ast_t *	mpc_ast_add_child (mpc_ast_t r, mpc_ast_t a)

mpc_ast_t *	mpc_ast_add_tag (mpc_ast_t a, const char t)

mpc_ast_t *	mpc_ast_add_root_tag (mpc_ast_t a, const char t)

mpc_ast_t *	mpc_ast_tag (mpc_ast_t a, const char t)

mpc_ast_t *	mpc_ast_state (mpc_ast_t *a, mpc_state_t s)

static void	mpc_ast_print_depth (mpc_ast_t a, int d, FILE fp)

void	mpc_ast_print (mpc_ast_t *a)

void	mpc_ast_print_to (mpc_ast_t a, FILE fp)

int	mpc_ast_get_index (mpc_ast_t ast, const char tag)

int	mpc_ast_get_index_lb (mpc_ast_t ast, const char tag, int lb)

mpc_ast_t *	mpc_ast_get_child (mpc_ast_t ast, const char tag)

mpc_ast_t *	mpc_ast_get_child_lb (mpc_ast_t ast, const char tag, int lb)

mpc_ast_trav_t *	mpc_ast_traverse_start (mpc_ast_t *ast, mpc_ast_trav_order_t order)

mpc_ast_t *	mpc_ast_traverse_next (mpc_ast_trav_t **trav)

void	mpc_ast_traverse_free (mpc_ast_trav_t **trav)

mpc_val_t *	mpcf_fold_ast (int n, mpc_val_t **xs)

mpc_val_t *	mpcf_str_ast (mpc_val_t *c)

mpc_val_t *	mpcf_state_ast (int n, mpc_val_t **xs)

mpc_parser_t *	mpca_state (mpc_parser_t *a)

mpc_parser_t *	mpca_tag (mpc_parser_t a, const char t)

mpc_parser_t *	mpca_add_tag (mpc_parser_t a, const char t)

mpc_parser_t *	mpca_root (mpc_parser_t *a)

mpc_parser_t *	mpca_not (mpc_parser_t *a)

mpc_parser_t *	mpca_maybe (mpc_parser_t *a)

mpc_parser_t *	mpca_many (mpc_parser_t *a)

mpc_parser_t *	mpca_many1 (mpc_parser_t *a)

mpc_parser_t *	mpca_count (int n, mpc_parser_t *a)

mpc_parser_t *	mpca_or (int n,...)

mpc_parser_t *	mpca_and (int n,...)

mpc_parser_t *	mpca_total (mpc_parser_t *a)

static mpc_val_t *	mpcaf_grammar_or (int n, mpc_val_t **xs)

static mpc_val_t *	mpcaf_grammar_and (int n, mpc_val_t **xs)

static mpc_val_t *	mpcaf_grammar_repeat (int n, mpc_val_t **xs)

static mpc_val_t *	mpcaf_grammar_string (mpc_val_t x, void s)

static mpc_val_t *	mpcaf_grammar_char (mpc_val_t x, void s)

static mpc_val_t *	mpcaf_fold_regex (int n, mpc_val_t **xs)

static int	is_number (const char *s)

static mpc_parser_t *	mpca_grammar_find_parser (char x, mpca_grammar_st_t st)

static mpc_val_t *	mpcaf_grammar_id (mpc_val_t x, void s)

mpc_parser_t *	mpca_grammar_st (const char grammar, mpca_grammar_st_t st)

mpc_parser_t *	mpca_grammar (int flags, const char *grammar,...)

static mpc_val_t *	mpca_stmt_afold (int n, mpc_val_t **xs)

static mpc_val_t *	mpca_stmt_fold (int n, mpc_val_t **xs)

static void	mpca_stmt_list_delete (mpc_val_t *x)

static mpc_val_t *	mpca_stmt_list_apply_to (mpc_val_t x, void s)

static mpc_err_t *	mpca_lang_st (mpc_input_t i, mpca_grammar_st_t st)

mpc_err_t *	mpca_lang_file (int flags, FILE *f,...)

mpc_err_t *	mpca_lang_pipe (int flags, FILE *p,...)

mpc_err_t *	mpca_lang (int flags, const char *language,...)

mpc_err_t *	mpca_lang_contents (int flags, const char *filename,...)

static int	mpc_nodecount_unretained (mpc_parser_t *p, int force)

void	mpc_stats (mpc_parser_t *p)

static void	mpc_optimise_unretained (mpc_parser_t *p, int force)

void	mpc_optimise (mpc_parser_t *p)

Variables
static char	char_unescape_buffer [4]

static const char	mpc_escape_input_c []

static const char *	mpc_escape_output_c []

static const char	mpc_escape_input_raw_re [] = { '/' }

static const char *	mpc_escape_output_raw_re [] = { "\\/", NULL }

static const char	mpc_escape_input_raw_cstr [] = { '"' }

static const char *	mpc_escape_output_raw_cstr [] = { "\\\"", NULL }

static const char	mpc_escape_input_raw_cchar [] = { '\'' }

static const char *	mpc_escape_output_raw_cchar [] = { "\\'", NULL }

Macro Definition Documentation

◆ MPC_FAILURE

#define MPC_FAILURE ( x ) r->error = x; return 0

Definition at line 1040 of file mpc.c.

◆ MPC_MAX_RECURSION_DEPTH

#define MPC_MAX_RECURSION_DEPTH 1000

Definition at line 1045 of file mpc.c.

◆ MPC_PRIMITIVE

#define MPC_PRIMITIVE ( x )

Value:

if (x) { MPC_SUCCESS(r->output); } \

else { MPC_FAILURE(NULL); }

NULL

#define NULL

Definition: cris-opc.c:27

r

#define r

Definition: crypto_rc6.c:12

x

int x

Definition: mipsasm.c:20

MPC_SUCCESS

#define MPC_SUCCESS(x)

Definition: mpc.c:1039

MPC_FAILURE

#define MPC_FAILURE(x)

Definition: mpc.c:1040

Definition at line 1041 of file mpc.c.

◆ MPC_SUCCESS

#define MPC_SUCCESS ( x ) r->output = x; return 1

Definition at line 1039 of file mpc.c.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
MPC_INPUT_STRING
MPC_INPUT_FILE
MPC_INPUT_PIPE

Definition at line 60 of file mpc.c.

      {
   MPC_INPUT_STRING = 0,
   MPC_INPUT_FILE   = 1,
   MPC_INPUT_PIPE   = 2
 };

◆ anonymous enum

anonymous enum

Enumerator
MPC_INPUT_MARKS_MIN

Definition at line 66 of file mpc.c.

      {
   MPC_INPUT_MARKS_MIN = 32
 };

◆ anonymous enum

anonymous enum

Enumerator
MPC_INPUT_MEM_NUM

Definition at line 70 of file mpc.c.

      {
   MPC_INPUT_MEM_NUM = 512
 };

◆ anonymous enum

anonymous enum

Enumerator
MPC_TYPE_UNDEFINED
MPC_TYPE_PASS
MPC_TYPE_FAIL
MPC_TYPE_LIFT
MPC_TYPE_LIFT_VAL
MPC_TYPE_EXPECT
MPC_TYPE_ANCHOR
MPC_TYPE_STATE
MPC_TYPE_ANY
MPC_TYPE_SINGLE
MPC_TYPE_ONEOF
MPC_TYPE_NONEOF
MPC_TYPE_RANGE
MPC_TYPE_SATISFY
MPC_TYPE_STRING
MPC_TYPE_APPLY
MPC_TYPE_APPLY_TO
MPC_TYPE_PREDICT
MPC_TYPE_NOT
MPC_TYPE_MAYBE
MPC_TYPE_MANY
MPC_TYPE_MANY1
MPC_TYPE_COUNT
MPC_TYPE_OR
MPC_TYPE_AND
MPC_TYPE_CHECK
MPC_TYPE_CHECK_WITH
MPC_TYPE_SOI
MPC_TYPE_EOI

Definition at line 883 of file mpc.c.

      {
   MPC_TYPE_UNDEFINED  = 0,
   MPC_TYPE_PASS       = 1,
   MPC_TYPE_FAIL       = 2,
   MPC_TYPE_LIFT       = 3,
   MPC_TYPE_LIFT_VAL   = 4,
   MPC_TYPE_EXPECT     = 5,
   MPC_TYPE_ANCHOR     = 6,
   MPC_TYPE_STATE      = 7,
  
   MPC_TYPE_ANY        = 8,
   MPC_TYPE_SINGLE     = 9,
   MPC_TYPE_ONEOF      = 10,
   MPC_TYPE_NONEOF     = 11,
   MPC_TYPE_RANGE      = 12,
   MPC_TYPE_SATISFY    = 13,
   MPC_TYPE_STRING     = 14,
  
   MPC_TYPE_APPLY      = 15,
   MPC_TYPE_APPLY_TO   = 16,
   MPC_TYPE_PREDICT    = 17,
   MPC_TYPE_NOT        = 18,
   MPC_TYPE_MAYBE      = 19,
   MPC_TYPE_MANY       = 20,
   MPC_TYPE_MANY1      = 21,
   MPC_TYPE_COUNT      = 22,
  
   MPC_TYPE_OR         = 23,
   MPC_TYPE_AND        = 24,
  
   MPC_TYPE_CHECK      = 25,
   MPC_TYPE_CHECK_WITH = 26,
  
   MPC_TYPE_SOI        = 27,
   MPC_TYPE_EOI        = 28
 };

◆ anonymous enum

anonymous enum

Enumerator
MPC_PARSE_STACK_MIN

Definition at line 1035 of file mpc.c.

      {
   MPC_PARSE_STACK_MIN = 4
 };

Function Documentation

◆ is_number()

static int is_number ( const char * s )

static

Definition at line 3453 of file mpc.c.

                                     {
   size_t i;
   for (i = 0; i < strlen(s); i++) { if (!strchr("0123456789", s[i])) { return 0; } }
   return 1;
 }

References i, and s.

Referenced by mpca_grammar_find_parser().

◆ mpc_alpha()

mpc_parser_t* mpc_alpha ( void )

Definition at line 2025 of file mpc.c.

2025 { return mpc_expect(mpc_oneof("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"), "letter"); }

mpc_oneof

mpc_parser_t * mpc_oneof(const char *s)

Definition: mpc.c:1762

mpc_expect

mpc_parser_t * mpc_expect(mpc_parser_t *a, const char *expected)

Definition: mpc.c:1690

References mpc_expect(), and mpc_oneof().

Referenced by mpc_alphanum(), and mpc_ident().

◆ mpc_alphanum()

mpc_parser_t* mpc_alphanum ( void )

Definition at line 2027 of file mpc.c.

2027 { return mpc_expect(mpc_or(3, mpc_alpha(), mpc_digit(), mpc_underscore()), "alphanumeric"); }

mpc_digit

mpc_parser_t * mpc_digit(void)

Definition: mpc.c:2016

mpc_alpha

mpc_parser_t * mpc_alpha(void)

Definition: mpc.c:2025

mpc_underscore

mpc_parser_t * mpc_underscore(void)

Definition: mpc.c:2026

mpc_or

mpc_parser_t * mpc_or(int n,...)

Definition: mpc.c:1928

References mpc_alpha(), mpc_digit(), mpc_expect(), mpc_or(), and mpc_underscore().

Referenced by mpc_ident(), and mpc_re_escape_char().

◆ mpc_anchor()

mpc_parser_t* mpc_anchor ( int(*)(char, char) f )

Definition at line 1677 of file mpc.c.

                                              {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_ANCHOR;
   p->data.anchor.f = f;
   return mpc_expect(p, "anchor");
 }

References f, mpc_expect(), MPC_TYPE_ANCHOR, mpc_undefined(), and p.

Referenced by mpc_boundary(), and mpc_boundary_newline().

◆ mpc_and()

mpc_parser_t* mpc_and	(	int	n,
		mpc_fold_t	f,
			...
	)

Definition at line 1948 of file mpc.c.

                                                 {
  
   int i;
   va_list va;
  
   mpc_parser_t *p = mpc_undefined();
  
   p->type = MPC_TYPE_AND;
   p->data.and.n = n;
   p->data.and.f = f;
   p->data.and.xs = malloc(sizeof(mpc_parser_t*) * n);
   p->data.and.dxs = malloc(sizeof(mpc_dtor_t) * (n-1));
  
   va_start(va, f);
   for (i = 0; i < n; i++) {
     p->data.and.xs[i] = va_arg(va, mpc_parser_t*);
   }
   for (i = 0; i < (n-1); i++) {
     p->data.and.dxs[i] = va_arg(va, mpc_dtor_t);
   }
   va_end(va);
  
   return p;
 }

References f, i, malloc(), MPC_TYPE_AND, mpc_undefined(), n, and p.

Referenced by mpc_between(), mpc_endwith(), mpc_escape(), mpc_ident(), mpc_re_escape_char(), mpc_re_mode(), mpc_real(), mpc_startwith(), mpc_strip(), mpc_stripl(), mpc_stripr(), mpc_tok(), mpc_tok_between(), mpc_whole(), mpca_grammar_st(), mpca_lang_st(), mpca_state(), mpcf_re_and(), and mpcf_re_escape().

◆ mpc_any()

mpc_parser_t* mpc_any ( void )

Definition at line 1741 of file mpc.c.

                             {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_ANY;
   return mpc_expect(p, "any character");
 }

References mpc_expect(), MPC_TYPE_ANY, mpc_undefined(), and p.

Referenced by mpc_char_lit(), mpc_escape(), and mpcf_re_escape().

◆ mpc_apply()

mpc_parser_t* mpc_apply	(	mpc_parser_t *	a,
		mpc_apply_t	f
	)

Definition at line 1798 of file mpc.c.

                                                         {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_APPLY;
   p->data.apply.x = a;
   p->data.apply.f = f;
   return p;
 }

References a, f, MPC_TYPE_APPLY, mpc_undefined(), and p.

Referenced by mpc_blank(), mpc_float(), mpc_hex(), mpc_int(), mpc_oct(), mpc_re_mode(), mpca_root(), mpcaf_fold_regex(), mpcaf_grammar_char(), and mpcaf_grammar_string().

◆ mpc_apply_to()

mpc_parser_t* mpc_apply_to	(	mpc_parser_t *	a,
		mpc_apply_to_t	f,
		void *	x
	)

Definition at line 1806 of file mpc.c.

                                                                        {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_APPLY_TO;
   p->data.apply_to.x = a;
   p->data.apply_to.f = f;
   p->data.apply_to.d = x;
   return p;
 }

References a, f, MPC_TYPE_APPLY_TO, mpc_undefined(), p, and x.

Referenced by mpc_re_mode(), mpca_add_tag(), mpca_grammar_st(), mpca_lang_st(), and mpca_tag().

◆ mpc_ast_add_child()

mpc_ast_t* mpc_ast_add_child	(	mpc_ast_t *	r,
		mpc_ast_t *	a
	)

Definition at line 2974 of file mpc.c.

                                                          {
   r->children_num++;
   r->children = realloc(r->children, sizeof(mpc_ast_t*) * r->children_num);
   r->children[r->children_num-1] = a;
   return r;
 }

References a, r, and realloc().

Referenced by mpc_ast_add_root(), mpc_ast_build(), and mpcf_fold_ast().

◆ mpc_ast_add_root()

mpc_ast_t* mpc_ast_add_root ( mpc_ast_t * a )

Definition at line 2946 of file mpc.c.

                                           {
  
   mpc_ast_t *r;
  
   if (a == NULL) { return a; }
   if (a->children_num == 0) { return a; }
   if (a->children_num == 1) { return a; }
  
   r = mpc_ast_new(">", "");
   mpc_ast_add_child(r, a);
   return r;
 }

References a, mpc_ast_add_child(), mpc_ast_new(), NULL, and r.

Referenced by mpca_root().

◆ mpc_ast_add_root_tag()

mpc_ast_t* mpc_ast_add_root_tag	(	mpc_ast_t *	a,
		const char *	t
	)

Definition at line 2990 of file mpc.c.

                                                              {
   if (a == NULL) { return a; }
   a->tag = realloc(a->tag, (strlen(t)-1) + strlen(a->tag) + 1);
   memmove(a->tag + (strlen(t)-1), a->tag, strlen(a->tag)+1);
   memmove(a->tag, t, (strlen(t)-1));
   return a;
 }

References a, NULL, and realloc().

Referenced by mpcf_fold_ast().

◆ mpc_ast_add_tag()

mpc_ast_t* mpc_ast_add_tag	(	mpc_ast_t *	a,
		const char *	t
	)

Definition at line 2981 of file mpc.c.

                                                         {
   if (a == NULL) { return a; }
   a->tag = realloc(a->tag, strlen(t) + 1 + strlen(a->tag) + 1);
   memmove(a->tag + strlen(t) + 1, a->tag, strlen(a->tag)+1);
   memmove(a->tag, t, strlen(t));
   memmove(a->tag + strlen(t), "|", 1);
   return a;
 }

References a, NULL, and realloc().

Referenced by mpca_add_tag().

◆ mpc_ast_build()

mpc_ast_t* mpc_ast_build	(	int	n,
		const char *	tag,
			...
	)

Definition at line 2928 of file mpc.c.

                                                       {
  
   mpc_ast_t *a = mpc_ast_new(tag, "");
  
   int i;
   va_list va;
   va_start(va, tag);
  
   for (i = 0; i < n; i++) {
     mpc_ast_add_child(a, va_arg(va, mpc_ast_t*));
   }
  
   va_end(va);
  
   return a;
  
 }

References a, i, mpc_ast_add_child(), mpc_ast_new(), n, and test-lz4-versions::tag.

◆ mpc_ast_delete()

void mpc_ast_delete ( mpc_ast_t * a )

Definition at line 2886 of file mpc.c.

                                   {
  
   int i;
  
   if (a == NULL) { return; }
  
   for (i = 0; i < a->children_num; i++) {
     mpc_ast_delete(a->children[i]);
   }
  
   free(a->children);
   free(a->tag);
   free(a->contents);
   free(a);
  
 }

References a, free(), i, and NULL.

Referenced by main(), mpc_optimise_unretained(), mpca_and(), mpca_count(), mpca_not(), and mpca_total().

◆ mpc_ast_delete_no_children()

static void mpc_ast_delete_no_children ( mpc_ast_t * a )

static

Definition at line 2903 of file mpc.c.

                                                      {
   free(a->children);
   free(a->tag);
   free(a->contents);
   free(a);
 }

References a, and free().

Referenced by mpcf_fold_ast().

◆ mpc_ast_eq()

int mpc_ast_eq	(	mpc_ast_t *	a,
		mpc_ast_t *	b
	)

Definition at line 2959 of file mpc.c.

                                            {
  
   int i;
  
   if (strcmp(a->tag, b->tag) != 0) { return 0; }
   if (strcmp(a->contents, b->contents) != 0) { return 0; }
   if (a->children_num != b->children_num) { return 0; }
  
   for (i = 0; i < a->children_num; i++) {
     if (!mpc_ast_eq(a->children[i], b->children[i])) { return 0; }
   }
  
   return 1;
 }

References a, b, and i.

◆ mpc_ast_get_child()

mpc_ast_t* mpc_ast_get_child	(	mpc_ast_t *	ast,
		const char *	tag
	)

Definition at line 3060 of file mpc.c.

                                                               {
   return mpc_ast_get_child_lb(ast, tag, 0);
 }

References mpc_ast_get_child_lb(), and test-lz4-versions::tag.

◆ mpc_ast_get_child_lb()

mpc_ast_t* mpc_ast_get_child_lb	(	mpc_ast_t *	ast,
		const char *	tag,
		int	lb
	)

Definition at line 3064 of file mpc.c.

                                                                          {
   int i;
  
   for(i=lb; i<ast->children_num; i++) {
     if(strcmp(ast->children[i]->tag, tag) == 0) {
       return ast->children[i];
     }
   }
  
   return NULL;
 }

References mpc_ast_t::children, mpc_ast_t::children_num, i, NULL, test-lz4-versions::tag, and mpc_ast_t::tag.

Referenced by mpc_ast_get_child().

◆ mpc_ast_get_index()

int mpc_ast_get_index	(	mpc_ast_t *	ast,
		const char *	tag
	)

Definition at line 3044 of file mpc.c.

                                                        {
   return mpc_ast_get_index_lb(ast, tag, 0);
 }

References mpc_ast_get_index_lb(), and test-lz4-versions::tag.

◆ mpc_ast_get_index_lb()

int mpc_ast_get_index_lb	(	mpc_ast_t *	ast,
		const char *	tag,
		int	lb
	)

Definition at line 3048 of file mpc.c.

                                                                   {
   int i;
  
   for(i=lb; i<ast->children_num; i++) {
     if(strcmp(ast->children[i]->tag, tag) == 0) {
       return i;
     }
   }
  
   return -1;
 }

References mpc_ast_t::children, mpc_ast_t::children_num, i, test-lz4-versions::tag, and mpc_ast_t::tag.

Referenced by mpc_ast_get_index().

◆ mpc_ast_new()

mpc_ast_t* mpc_ast_new	(	const char *	tag,
		const char *	contents
	)

Definition at line 2910 of file mpc.c.

                                                               {
  
   mpc_ast_t *a = malloc(sizeof(mpc_ast_t));
  
   a->tag = malloc(strlen(tag) + 1);
   strcpy(a->tag, tag);
  
   a->contents = malloc(strlen(contents) + 1);
   strcpy(a->contents, contents);
  
   a->state = mpc_state_new();
  
   a->children_num = 0;
   a->children = NULL;
   return a;
  
 }

References a, malloc(), mpc_state_new(), NULL, and test-lz4-versions::tag.

Referenced by mpc_ast_add_root(), mpc_ast_build(), mpcf_fold_ast(), mpcf_input_str_ast(), and mpcf_str_ast().

◆ mpc_ast_print()

void mpc_ast_print ( mpc_ast_t * a )

Definition at line 3036 of file mpc.c.

                                  {
   mpc_ast_print_depth(a, 0, stdout);
 }

References a, and mpc_ast_print_depth().

Referenced by main().

◆ mpc_ast_print_depth()

static void mpc_ast_print_depth	(	mpc_ast_t *	a,
		int	d,
		FILE *	fp
	)

static

Definition at line 3010 of file mpc.c.

                                                                {
  
   int i;
  
   if (a == NULL) {
     fprintf(fp, "NULL\n");
     return;
   }
  
   for (i = 0; i < d; i++) { fprintf(fp, "  "); }
  
   if (strlen(a->contents)) {
     fprintf(fp, "%s:%lu:%lu '%s'\n", a->tag,
       (long unsigned int)(a->state.row+1),
       (long unsigned int)(a->state.col+1),
       a->contents);
   } else {
     fprintf(fp, "%s \n", a->tag);
   }
  
   for (i = 0; i < a->children_num; i++) {
     mpc_ast_print_depth(a->children[i], d+1, fp);
   }
  
 }

References a, d, i, and NULL.

Referenced by mpc_ast_print(), and mpc_ast_print_to().

◆ mpc_ast_print_to()

void mpc_ast_print_to	(	mpc_ast_t *	a,
		FILE *	fp
	)

Definition at line 3040 of file mpc.c.

                                               {
   mpc_ast_print_depth(a, 0, fp);
 }

References a, and mpc_ast_print_depth().

Referenced by main().

◆ mpc_ast_state()

mpc_ast_t* mpc_ast_state	(	mpc_ast_t *	a,
		mpc_state_t	s
	)

Definition at line 3004 of file mpc.c.

                                                       {
   if (a == NULL) { return a; }
   a->state = s;
   return a;
 }

References a, NULL, and s.

Referenced by mpcf_input_state_ast(), and mpcf_state_ast().

◆ mpc_ast_tag()

mpc_ast_t* mpc_ast_tag	(	mpc_ast_t *	a,
		const char *	t
	)

Definition at line 2998 of file mpc.c.

                                                     {
   a->tag = realloc(a->tag, strlen(t) + 1);
   strcpy(a->tag, t);
   return a;
 }

References a, and realloc().

Referenced by mpca_tag().

◆ mpc_ast_traverse_free()

void mpc_ast_traverse_free ( mpc_ast_trav_t ** trav )

Definition at line 3201 of file mpc.c.

                                                   {
   mpc_ast_trav_t *n_trav;
  
   /* Go through parents until all are free */
   while(*trav != NULL) {
       n_trav = (*trav)->parent;
       free(*trav);
       *trav = n_trav;
   }
 }

References free(), NULL, and mpc_ast_trav_t::parent.

◆ mpc_ast_traverse_next()

mpc_ast_t* mpc_ast_traverse_next ( mpc_ast_trav_t ** trav )

Definition at line 3118 of file mpc.c.

                                                         {
   mpc_ast_trav_t *n_trav, *to_free;
   mpc_ast_t *ret = NULL;
   int cchild;
  
   /* The end of traversal was reached */
   if(*trav == NULL) return NULL;
  
   switch((*trav)->order) {
     case mpc_ast_trav_order_pre:
       ret = (*trav)->curr_node;
  
       /* If there aren't any more children, go up */
       while(*trav != NULL &&
         (*trav)->curr_child >= (*trav)->curr_node->children_num)
       {
         to_free = *trav;
         *trav = (*trav)->parent;
         free(to_free);
       }
  
       /* If trav is NULL, the end was reached */
       if(*trav == NULL) {
         break;
       }
  
       /* Go to next child */
       n_trav = malloc(sizeof(mpc_ast_trav_t));
  
       cchild = (*trav)->curr_child;
       n_trav->curr_node = (*trav)->curr_node->children[cchild];
       n_trav->parent = *trav;
       n_trav->curr_child = 0;
       n_trav->order = (*trav)->order;
  
       (*trav)->curr_child++;
       *trav = n_trav;
  
       break;
  
     case mpc_ast_trav_order_post:
       ret = (*trav)->curr_node;
  
       /* Move up tree to the parent If the parent doesn't have any more nodes,
        * then this is the current node. If it does, move down to its left most
        * child. Also, free the previous traversal node */
       to_free = *trav;
       *trav = (*trav)->parent;
       free(to_free);
  
       if(*trav == NULL)
         break;
  
       /* Next child */
       (*trav)->curr_child++;
  
       /* If there aren't any more children, this is the next node */
       if((*trav)->curr_child >= (*trav)->curr_node->children_num) {
         break;
       }
  
       /* If there are still more children, find the leftmost child from this
        * node */
       while((*trav)->curr_node->children_num > 0) {
         n_trav = malloc(sizeof(mpc_ast_trav_t));
  
         cchild = (*trav)->curr_child;
         n_trav->curr_node = (*trav)->curr_node->children[cchild];
         n_trav->parent = *trav;
         n_trav->curr_child = 0;
         n_trav->order = (*trav)->order;
  
         *trav = n_trav;
       }
  
     default:
       /* Unreachable, but compiler complaints */
       break;
   }
  
   return ret;
 }

References mpc_ast_t::children, mpc_ast_trav_t::curr_child, mpc_ast_trav_t::curr_node, free(), malloc(), mpc_ast_trav_order_post, mpc_ast_trav_order_pre, NULL, mpc_ast_trav_t::order, and mpc_ast_trav_t::parent.

◆ mpc_ast_traverse_start()

mpc_ast_trav_t* mpc_ast_traverse_start	(	mpc_ast_t *	ast,
		mpc_ast_trav_order_t	order
	)

Definition at line 3076 of file mpc.c.

 {
   mpc_ast_trav_t *trav, *n_trav;
   mpc_ast_t *cnode = ast;
  
   /* Create the traversal structure */
   trav = malloc(sizeof(mpc_ast_trav_t));
   trav->curr_node = cnode;
   trav->parent = NULL;
   trav->curr_child = 0;
   trav->order = order;
  
   /* Get start node */
   switch(order) {
     case mpc_ast_trav_order_pre:
       /* Nothing else is needed for pre order start */
       break;
  
     case mpc_ast_trav_order_post:
       while(cnode->children_num > 0) {
         cnode = cnode->children[0];
  
         n_trav = malloc(sizeof(mpc_ast_trav_t));
         n_trav->curr_node = cnode;
         n_trav->parent = trav;
         n_trav->curr_child = 0;
         n_trav->order = order;
  
         trav = n_trav;
       }
  
       break;
  
     default:
       /* Unreachable, but compiler complaints */
       break;
   }
  
   return trav;
 }

References mpc_ast_t::children, mpc_ast_t::children_num, mpc_ast_trav_t::curr_child, mpc_ast_trav_t::curr_node, malloc(), mpc_ast_trav_order_post, mpc_ast_trav_order_pre, NULL, mpc_ast_trav_t::order, and mpc_ast_trav_t::parent.

◆ mpc_between()

mpc_parser_t* mpc_between	(	mpc_parser_t *	a,
		mpc_dtor_t	ad,
		const char *	o,
		const char *	c
	)

Definition at line 2093 of file mpc.c.

                                                                                         {
   return mpc_and(3, mpcf_snd_free,
     mpc_string(o), a, mpc_string(c),
     free, ad);
 }

References a, c, free(), mpc_and(), mpc_string(), and mpcf_snd_free().

Referenced by mpc_braces(), mpc_brackets(), mpc_char_lit(), mpc_parens(), mpc_regex_lit(), mpc_squares(), and mpc_string_lit().

◆ mpc_blank()

mpc_parser_t* mpc_blank ( void )

Definition at line 2010 of file mpc.c.

2010 { return mpc_expect(mpc_apply(mpc_whitespaces(), mpcf_free), "whitespace"); }

mpc_apply

mpc_parser_t * mpc_apply(mpc_parser_t *a, mpc_apply_t f)

Definition: mpc.c:1798

mpcf_free

mpc_val_t * mpcf_free(mpc_val_t *x)

Definition: mpc.c:2432

mpc_whitespaces

mpc_parser_t * mpc_whitespaces(void)

Definition: mpc.c:2009

References mpc_apply(), mpc_expect(), mpc_whitespaces(), and mpcf_free().

Referenced by mpc_strip(), mpc_stripl(), mpc_stripr(), and mpc_tok().

◆ mpc_boundary()

mpc_parser_t* mpc_boundary ( void )

Definition at line 2005 of file mpc.c.

2005 { return mpc_expect(mpc_anchor(mpc_boundary_anchor), "word boundary"); }

mpc_boundary_anchor

static int mpc_boundary_anchor(char prev, char next)

Definition: mpc.c:1989

mpc_anchor

mpc_parser_t * mpc_anchor(int(*f)(char, char))

Definition: mpc.c:1677

References mpc_anchor(), mpc_boundary_anchor(), and mpc_expect().

Referenced by mpc_re_escape_char().

◆ mpc_boundary_anchor()

static int mpc_boundary_anchor	(	char	prev,
		char	next
	)

static

Definition at line 1989 of file mpc.c.

                                                      {
   const char* word = "abcdefghijklmnopqrstuvwxyz"
                      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                      "0123456789_";
   if ( strchr(word, next) &&  prev == '\0') { return 1; }
   if ( strchr(word, prev) &&  next == '\0') { return 1; }
   if ( strchr(word, next) && !strchr(word, prev)) { return 1; }
   if (!strchr(word, next) &&  strchr(word, prev)) { return 1; }
   return 0;
 }

Referenced by mpc_boundary().

◆ mpc_boundary_newline()

mpc_parser_t* mpc_boundary_newline ( void )

Definition at line 2006 of file mpc.c.

2006 { return mpc_expect(mpc_anchor(mpc_boundary_newline_anchor), "start of newline"); }

mpc_boundary_newline_anchor

static int mpc_boundary_newline_anchor(char prev, char next)

Definition: mpc.c:2000

References mpc_anchor(), mpc_boundary_newline_anchor(), and mpc_expect().

Referenced by mpcf_re_escape().

◆ mpc_boundary_newline_anchor()

static int mpc_boundary_newline_anchor	(	char	prev,
		char	next
	)

static

Definition at line 2000 of file mpc.c.

                                                              {
   (void)next;
   return prev == '\n';
 }

Referenced by mpc_boundary_newline().

◆ mpc_braces()

mpc_parser_t* mpc_braces	(	mpc_parser_t *	a,
		mpc_dtor_t	ad
	)

Definition at line 2100 of file mpc.c.

2100 { return mpc_between(a, ad, "<", ">"); }

mpc_between

mpc_parser_t * mpc_between(mpc_parser_t *a, mpc_dtor_t ad, const char *o, const char *c)

Definition: mpc.c:2093

References a, and mpc_between().

◆ mpc_brackets()

mpc_parser_t* mpc_brackets	(	mpc_parser_t *	a,
		mpc_dtor_t	ad
	)

Definition at line 2101 of file mpc.c.

2101 { return mpc_between(a, ad, "{", "}"); }

References a, and mpc_between().

Referenced by mpc_re_mode().

◆ mpc_calloc()

static void* mpc_calloc	(	mpc_input_t *	i,
		size_t	n,
		size_t	m
	)

static

Definition at line 257 of file mpc.c.

                                                             {
   char *x = mpc_malloc(i, n * m);
   memset(x, 0, n * m);
   return x;
 }

References i, regress::m, memset(), mpc_malloc(), n, and x.

Referenced by mpc_err_repeat(), and mpcf_input_strfold().

◆ mpc_char()

mpc_parser_t* mpc_char ( char c )

Definition at line 1747 of file mpc.c.

                                {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_SINGLE;
   p->data.single.x = c;
   return mpc_expectf(p, "'%c'", c);
 }

References c, mpc_expectf(), MPC_TYPE_SINGLE, mpc_undefined(), and p.

Referenced by mpc_escape(), mpc_newline(), mpc_re_escape_char(), mpc_re_mode(), mpc_real(), mpc_tab(), mpc_underscore(), mpcaf_grammar_char(), and mpcf_re_escape().

◆ mpc_char_lit()

mpc_parser_t* mpc_char_lit ( void )

Definition at line 2056 of file mpc.c.

                                  {
   return mpc_expect(mpc_between(mpc_or(2, mpc_escape(), mpc_any()), free, "'", "'"), "char");
 }

References free(), mpc_any(), mpc_between(), mpc_escape(), mpc_expect(), and mpc_or().

Referenced by mpca_grammar_st(), and mpca_lang_st().

◆ mpc_check()

mpc_parser_t* mpc_check	(	mpc_parser_t *	a,
		mpc_dtor_t	da,
		mpc_check_t	f,
		const char *	e
	)

Definition at line 1815 of file mpc.c.

                                                                                       {
   mpc_parser_t  *p = mpc_undefined();
   p->type = MPC_TYPE_CHECK;
   p->data.check.x = a;
   p->data.check.dx = da;
   p->data.check.f = f;
   p->data.check.e = malloc(strlen(e) + 1);
   strcpy(p->data.check.e, e);
   return p;
 }

References a, e, f, malloc(), MPC_TYPE_CHECK, mpc_undefined(), and p.

Referenced by mpc_checkf().

◆ mpc_check_with()

mpc_parser_t* mpc_check_with	(	mpc_parser_t *	a,
		mpc_dtor_t	da,
		mpc_check_with_t	f,
		void *	x,
		const char *	e
	)

Definition at line 1826 of file mpc.c.

                                                                                                          {
   mpc_parser_t  *p = mpc_undefined();
   p->type = MPC_TYPE_CHECK_WITH;
   p->data.check_with.x = a;
   p->data.check_with.dx = da;
   p->data.check_with.f = f;
   p->data.check_with.d = x;
   p->data.check_with.e = malloc(strlen(e) + 1);
   strcpy(p->data.check_with.e, e);
   return p;
 }

References a, e, f, malloc(), MPC_TYPE_CHECK_WITH, mpc_undefined(), p, and x.

Referenced by mpc_check_withf().

◆ mpc_check_withf()

mpc_parser_t* mpc_check_withf	(	mpc_parser_t *	a,
		mpc_dtor_t	da,
		mpc_check_with_t	f,
		void *	x,
		const char *	fmt,
			...
	)

Definition at line 1854 of file mpc.c.

                                                                                                                  {
   va_list va;
   char *buffer;
   mpc_parser_t *p;
  
   va_start(va, fmt);
   buffer = malloc(2048);
   vsprintf(buffer, fmt, va);
   va_end(va);
  
   p = mpc_check_with(a, da, f, x, buffer);
   free(buffer);
  
   return p;
 }

References a, f, free(), malloc(), mpc_check_with(), p, vsprintf, and x.

◆ mpc_checkf()

mpc_parser_t* mpc_checkf	(	mpc_parser_t *	a,
		mpc_dtor_t	da,
		mpc_check_t	f,
		const char *	fmt,
			...
	)

Definition at line 1838 of file mpc.c.

                                                                                               {
   va_list va;
   char *buffer;
   mpc_parser_t *p;
  
   va_start(va, fmt);
   buffer = malloc(2048);
   vsprintf(buffer, fmt, va);
   va_end(va);
  
   p = mpc_check(a, da, f, buffer);
   free(buffer);
  
   return p;
 }

References a, f, free(), malloc(), mpc_check(), p, and vsprintf.

◆ mpc_cleanup()

void mpc_cleanup	(	int	n,
			...
	)

Definition at line 1596 of file mpc.c.

                              {
   int i;
   mpc_parser_t **list = malloc(sizeof(mpc_parser_t*) * n);
  
   va_list va;
   va_start(va, n);
   for (i = 0; i < n; i++) { list[i] = va_arg(va, mpc_parser_t*); }
   for (i = 0; i < n; i++) { mpc_undefine(list[i]); }
   for (i = 0; i < n; i++) { mpc_delete(list[i]); }
   va_end(va);
  
   free(list);
 }

References free(), i, list(), malloc(), mpc_delete(), mpc_undefine(), and n.

Referenced by main(), mpc_re_mode(), mpca_grammar_st(), and mpca_lang_st().

◆ mpc_copy()

mpc_parser_t* mpc_copy ( mpc_parser_t * a )

Definition at line 1488 of file mpc.c.

                                         {
   int i = 0;
   mpc_parser_t *p;
  
   if (a->retained) { return a; }
  
   p = mpc_undefined();
   p->retained = a->retained;
   p->type = a->type;
   p->data = a->data;
  
   if (a->name) {
     p->name = malloc(strlen(a->name)+1);
     strcpy(p->name, a->name);
   }
  
   switch (a->type) {
  
     case MPC_TYPE_FAIL:
       p->data.fail.m = malloc(strlen(a->data.fail.m)+1);
       strcpy(p->data.fail.m, a->data.fail.m);
     break;
  
     case MPC_TYPE_ONEOF:
     case MPC_TYPE_NONEOF:
     case MPC_TYPE_STRING:
       p->data.string.x = malloc(strlen(a->data.string.x)+1);
       strcpy(p->data.string.x, a->data.string.x);
       break;
  
     case MPC_TYPE_APPLY:    p->data.apply.x    = mpc_copy(a->data.apply.x);    break;
     case MPC_TYPE_APPLY_TO: p->data.apply_to.x = mpc_copy(a->data.apply_to.x); break;
     case MPC_TYPE_PREDICT:  p->data.predict.x  = mpc_copy(a->data.predict.x);  break;
  
     case MPC_TYPE_MAYBE:
     case MPC_TYPE_NOT:
       p->data.not.x = mpc_copy(a->data.not.x);
       break;
  
     case MPC_TYPE_EXPECT:
       p->data.expect.x = mpc_copy(a->data.expect.x);
       p->data.expect.m = malloc(strlen(a->data.expect.m)+1);
       strcpy(p->data.expect.m, a->data.expect.m);
       break;
  
     case MPC_TYPE_MANY:
     case MPC_TYPE_MANY1:
     case MPC_TYPE_COUNT:
       p->data.repeat.x = mpc_copy(a->data.repeat.x);
       break;
  
     case MPC_TYPE_OR:
       p->data.or.xs = malloc(a->data.or.n * sizeof(mpc_parser_t*));
       for (i = 0; i < a->data.or.n; i++) {
         p->data.or.xs[i] = mpc_copy(a->data.or.xs[i]);
       }
     break;
     case MPC_TYPE_AND:
       p->data.and.xs = malloc(a->data.and.n * sizeof(mpc_parser_t*));
       for (i = 0; i < a->data.and.n; i++) {
         p->data.and.xs[i] = mpc_copy(a->data.and.xs[i]);
       }
       p->data.and.dxs = malloc((a->data.and.n-1) * sizeof(mpc_dtor_t));
       for (i = 0; i < a->data.and.n-1; i++) {
         p->data.and.dxs[i] = a->data.and.dxs[i];
       }
     break;
  
     case MPC_TYPE_CHECK:
       p->data.check.x      = mpc_copy(a->data.check.x);
       p->data.check.e      = malloc(strlen(a->data.check.e)+1);
       strcpy(p->data.check.e, a->data.check.e);
       break;
     case MPC_TYPE_CHECK_WITH:
       p->data.check_with.x = mpc_copy(a->data.check_with.x);
       p->data.check_with.e = malloc(strlen(a->data.check_with.e)+1);
       strcpy(p->data.check_with.e, a->data.check_with.e);
       break;
  
     default: break;
   }
  
  
   return p;
 }

References a, i, malloc(), MPC_TYPE_AND, MPC_TYPE_APPLY, MPC_TYPE_APPLY_TO, MPC_TYPE_CHECK, MPC_TYPE_CHECK_WITH, MPC_TYPE_COUNT, MPC_TYPE_EXPECT, MPC_TYPE_FAIL, MPC_TYPE_MANY, MPC_TYPE_MANY1, MPC_TYPE_MAYBE, MPC_TYPE_NONEOF, MPC_TYPE_NOT, MPC_TYPE_ONEOF, MPC_TYPE_OR, MPC_TYPE_PREDICT, MPC_TYPE_STRING, mpc_undefined(), and p.

◆ mpc_count()

mpc_parser_t* mpc_count	(	int	n,
		mpc_fold_t	f,
		mpc_parser_t *	a,
		mpc_dtor_t	da
	)

Definition at line 1918 of file mpc.c.

                                                                              {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_COUNT;
   p->data.repeat.n = n;
   p->data.repeat.f = f;
   p->data.repeat.x = a;
   p->data.repeat.dx = da;
   return p;
 }

References a, f, MPC_TYPE_COUNT, mpc_undefined(), n, and p.

Referenced by mpca_count(), and mpcf_re_repeat().

◆ mpc_define()

mpc_parser_t* mpc_define	(	mpc_parser_t *	p,
		mpc_parser_t *	a
	)

Definition at line 1580 of file mpc.c.

                                                            {
  
   if (p->retained) {
     p->type = a->type;
     p->data = a->data;
   } else {
     mpc_parser_t *a2 = mpc_failf("Attempt to assign to Unretained Parser!");
     p->type = a2->type;
     p->data = a2->data;
     free(a2);
   }
  
   free(a);
   return p;
 }

References a, mpc_parser_t::data, free(), mpc_failf(), p, and mpc_parser_t::type.

Referenced by mpc_re_mode(), mpca_grammar_st(), mpca_lang_st(), and mpca_stmt_list_apply_to().

◆ mpc_delete()

void mpc_delete ( mpc_parser_t * p )

Definition at line 1453 of file mpc.c.

                                  {
   if (p->retained) {
  
     if (p->type != MPC_TYPE_UNDEFINED) {
       mpc_undefine_unretained(p, 0);
     }
  
     free(p->name);
     free(p);
  
   } else {
     mpc_undefine_unretained(p, 0);
   }
 }

References free(), MPC_TYPE_UNDEFINED, mpc_undefine_unretained(), and p.

Referenced by mpc_cleanup(), mpc_optimise_unretained(), and mpc_re_mode().

◆ mpc_digit()

mpc_parser_t* mpc_digit ( void )

Definition at line 2016 of file mpc.c.

2016 { return mpc_expect(mpc_oneof("0123456789"), "digit"); }

References mpc_expect(), and mpc_oneof().

Referenced by mpc_alphanum(), mpc_digits(), and mpc_re_escape_char().

◆ mpc_digits()

mpc_parser_t* mpc_digits ( void )

Definition at line 2019 of file mpc.c.

2019 { return mpc_expect(mpc_many1(mpcf_strfold, mpc_digit()), "digits"); }

mpcf_strfold

mpc_val_t * mpcf_strfold(int n, mpc_val_t **xs)

Definition: mpc.c:2648

mpc_many1

mpc_parser_t * mpc_many1(mpc_fold_t f, mpc_parser_t *a)

Definition: mpc.c:1910

References mpc_digit(), mpc_expect(), mpc_many1(), and mpcf_strfold().

Referenced by mpc_int(), mpc_real(), mpca_grammar_st(), and mpca_lang_st().

◆ mpc_endwith()

mpc_parser_t* mpc_endwith	(	mpc_parser_t *	a,
		mpc_dtor_t	da
	)

Definition at line 2082 of file mpc.c.

2082 { return mpc_and(2, mpcf_fst, a, mpc_eoi(), da); }

mpc_eoi

mpc_parser_t * mpc_eoi(void)

Definition: mpc.c:1983

mpcf_fst

mpc_val_t * mpcf_fst(int n, mpc_val_t **xs)

Definition: mpc.c:2625

References a, mpc_and(), mpc_eoi(), and mpcf_fst().

◆ mpc_eoi()

mpc_parser_t* mpc_eoi ( void )

Definition at line 1983 of file mpc.c.

                             {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_EOI;
   return mpc_expect(p, "end of input");
 }

References mpc_expect(), MPC_TYPE_EOI, mpc_undefined(), and p.

Referenced by mpc_endwith(), mpc_re_escape_char(), mpc_whole(), and mpcf_re_escape().

◆ mpc_err_add_expected()

static void mpc_err_add_expected	(	mpc_input_t *	i,
		mpc_err_t *	x,
		char *	expected
	)

static

Definition at line 741 of file mpc.c.

                                                                                {
   (void)i;
   x->expected_num++;
   x->expected = mpc_realloc(i, x->expected, sizeof(char*) * x->expected_num);
   x->expected[x->expected_num-1] = mpc_malloc(i, strlen(expected) + 1);
   strcpy(x->expected[x->expected_num-1], expected);
 }

References i, mpc_malloc(), mpc_realloc(), and x.

Referenced by mpc_err_or().

◆ mpc_err_char_unescape()

static const char* mpc_err_char_unescape ( char c )

static

Definition at line 606 of file mpc.c.

                                                  {
  
   char_unescape_buffer[0] = '\'';
   char_unescape_buffer[1] = ' ';
   char_unescape_buffer[2] = '\'';
   char_unescape_buffer[3] = '\0';
  
   switch (c) {
     case '\a': return "bell";
     case '\b': return "backspace";
     case '\f': return "formfeed";
     case '\r': return "carriage return";
     case '\v': return "vertical tab";
     case '\0': return "end of input";
     case '\n': return "newline";
     case '\t': return "tab";
     case ' ' : return "space";
     default:
       char_unescape_buffer[1] = c;
       return char_unescape_buffer;
   }
  
 }

References c, and char_unescape_buffer.

Referenced by mpc_err_string().

◆ mpc_err_contains_expected()

static int mpc_err_contains_expected	(	mpc_input_t *	i,
		mpc_err_t *	x,
		char *	expected
	)

static

Definition at line 732 of file mpc.c.

                                                                                    {
   int j;
   (void)i;
   for (j = 0; j < x->expected_num; j++) {
     if (strcmp(x->expected[j], expected) == 0) { return 1; }
   }
   return 0;
 }

References i, and x.

Referenced by mpc_err_or().

◆ mpc_err_count()

static mpc_err_t* mpc_err_count	(	mpc_input_t *	i,
		mpc_err_t *	x,
		int	n
	)

static

Definition at line 861 of file mpc.c.

                                                                      {
   mpc_err_t *y;
   int digits = n/10 + 1;
   char *prefix;
   prefix = mpc_malloc(i, digits + strlen(" of ") + 1);
   sprintf(prefix, "%i of ", n);
   y = mpc_err_repeat(i, x, prefix);
   mpc_free(i, prefix);
   return y;
 }

References i, mpc_err_repeat(), mpc_free(), mpc_malloc(), n, prefix, sprintf, and x.

Referenced by mpc_parse_run().

◆ mpc_err_delete()

void mpc_err_delete ( mpc_err_t * x )

Definition at line 575 of file mpc.c.

                                   {
   int i;
   for (i = 0; i < x->expected_num; i++) { free(x->expected[i]); }
   free(x->expected);
   free(x->filename);
   free(x->failure);
   free(x);
 }

References free(), i, and x.

Referenced by main(), mpc_re_mode(), mpc_test_fail(), mpc_test_pass(), and mpca_grammar_st().

◆ mpc_err_delete_internal()

static void mpc_err_delete_internal	(	mpc_input_t *	i,
		mpc_err_t *	x
	)

static

Definition at line 711 of file mpc.c.

                                                                   {
   int j;
   if (x == NULL) { return; }
   for (j = 0; j < x->expected_num; j++) { mpc_free(i, x->expected[j]); }
   mpc_free(i, x->expected);
   mpc_free(i, x->filename);
   mpc_free(i, x->failure);
   mpc_free(i, x);
 }

References i, mpc_free(), NULL, and x.

Referenced by mpc_err_or(), and mpc_parse_input().

◆ mpc_err_export()

static mpc_err_t* mpc_err_export	(	mpc_input_t *	i,
		mpc_err_t *	x
	)

static

Definition at line 721 of file mpc.c.

                                                                {
   int j;
   for (j = 0; j < x->expected_num; j++) {
     x->expected[j] = mpc_export(i, x->expected[j]);
   }
   x->expected = mpc_export(i, x->expected);
   x->filename = mpc_export(i, x->filename);
   x->failure = mpc_export(i, x->failure);
   return mpc_export(i, x);
 }

References i, mpc_export(), and x.

Referenced by mpc_parse_input().

◆ mpc_err_fail()

static mpc_err_t* mpc_err_fail	(	mpc_input_t *	i,
		const char *	failure
	)

static

Definition at line 682 of file mpc.c.

                                                                     {
   mpc_err_t *x;
   if (i->suppress) { return NULL; }
   x = mpc_malloc(i, sizeof(mpc_err_t));
   x->filename = mpc_malloc(i, strlen(i->filename) + 1);
   strcpy(x->filename, i->filename);
   x->state = i->state;
   x->expected_num = 0;
   x->expected = NULL;
   x->failure = mpc_malloc(i, strlen(failure) + 1);
   strcpy(x->failure, failure);
   x->received = ' ';
   return x;
 }

References i, mpc_malloc(), NULL, and x.

Referenced by mpc_parse_input(), and mpc_parse_run().

◆ mpc_err_file()

static mpc_err_t* mpc_err_file	(	const char *	filename,
		const char *	failure
	)

static

Definition at line 697 of file mpc.c.

                                                                           {
   mpc_err_t *x;
   x = malloc(sizeof(mpc_err_t));
   x->filename = malloc(strlen(filename) + 1);
   strcpy(x->filename, filename);
   x->state = mpc_state_new();
   x->expected_num = 0;
   x->expected = NULL;
   x->failure = malloc(strlen(failure) + 1);
   strcpy(x->failure, failure);
   x->received = ' ';
   return x;
 }

References malloc(), mpc_state_new(), NULL, and x.

Referenced by mpc_parse_contents(), and mpca_lang_contents().

◆ mpc_err_many1()

static mpc_err_t* mpc_err_many1	(	mpc_input_t *	i,
		mpc_err_t *	x
	)

static

Definition at line 857 of file mpc.c.

                                                               {
   return mpc_err_repeat(i, x, "one or more of ");
 }

References i, mpc_err_repeat(), and x.

Referenced by mpc_parse_run().

◆ mpc_err_merge()

static mpc_err_t* mpc_err_merge	(	mpc_input_t *	i,
		mpc_err_t *	x,
		mpc_err_t *	y
	)

static

Definition at line 872 of file mpc.c.

                                                                             {
   mpc_err_t *errs[2];
   errs[0] = x;
   errs[1] = y;
   return mpc_err_or(i, errs, 2);
 }

References i, mpc_err_or(), and x.

Referenced by mpc_parse_input(), and mpc_parse_run().

◆ mpc_err_new()

static mpc_err_t* mpc_err_new	(	mpc_input_t *	i,
		const char *	expected
	)

static

Definition at line 666 of file mpc.c.

                                                                     {
   mpc_err_t *x;
   if (i->suppress) { return NULL; }
   x = mpc_malloc(i, sizeof(mpc_err_t));
   x->filename = mpc_malloc(i, strlen(i->filename) + 1);
   strcpy(x->filename, i->filename);
   x->state = i->state;
   x->expected_num = 1;
   x->expected = mpc_malloc(i, sizeof(char*));
   x->expected[0] = mpc_malloc(i, strlen(expected) + 1);
   strcpy(x->expected[0], expected);
   x->failure = NULL;
   x->received = mpc_input_peekc(i);
   return x;
 }

References i, mpc_input_peekc(), mpc_malloc(), NULL, and x.

Referenced by mpc_parse_run().

◆ mpc_err_or()

static mpc_err_t* mpc_err_or	(	mpc_input_t *	i,
		mpc_err_t **	x,
		int	n
	)

static

Definition at line 749 of file mpc.c.

                                                                    {
  
   int j, k, fst;
   mpc_err_t *e;
  
   fst = -1;
   for (j = 0; j < n; j++) {
     if (x[j] != NULL) { fst = j; }
   }
  
   if (fst == -1) { return NULL; }
  
   e = mpc_malloc(i, sizeof(mpc_err_t));
   e->state = mpc_state_invalid();
   e->expected_num = 0;
   e->expected = NULL;
   e->failure = NULL;
   e->filename = mpc_malloc(i, strlen(x[fst]->filename)+1);
   strcpy(e->filename, x[fst]->filename);
  
   for (j = 0; j < n; j++) {
     if (x[j] == NULL) { continue; }
     if (x[j]->state.pos > e->state.pos) { e->state = x[j]->state; }
   }
  
   for (j = 0; j < n; j++) {
     if (x[j] == NULL) { continue; }
     if (x[j]->state.pos < e->state.pos) { continue; }
  
     if (x[j]->failure) {
       e->failure = mpc_malloc(i, strlen(x[j]->failure)+1);
       strcpy(e->failure, x[j]->failure);
       break;
     }
  
     e->received = x[j]->received;
  
     for (k = 0; k < x[j]->expected_num; k++) {
       if (!mpc_err_contains_expected(i, e, x[j]->expected[k])) {
         mpc_err_add_expected(i, e, x[j]->expected[k]);
       }
     }
   }
  
   for (j = 0; j < n; j++) {
     if (x[j] == NULL) { continue; }
     mpc_err_delete_internal(i, x[j]);
   }
  
   return e;
 }

References e, i, k, mpc_err_add_expected(), mpc_err_contains_expected(), mpc_err_delete_internal(), mpc_malloc(), mpc_state_invalid(), n, NULL, and x.

Referenced by mpc_err_merge().

◆ mpc_err_print()

void mpc_err_print ( mpc_err_t * x )

Definition at line 584 of file mpc.c.

                                  {
   mpc_err_print_to(x, stdout);
 }

References mpc_err_print_to(), and x.

Referenced by main(), and mpc_test_pass().

◆ mpc_err_print_to()

void mpc_err_print_to	(	mpc_err_t *	x,
		FILE *	f
	)

Definition at line 588 of file mpc.c.

                                              {
   char *str = mpc_err_string(x);
   fprintf(f, "%s", str);
   free(str);
 }

References f, free(), mpc_err_string(), cmd_descs_generate::str, and x.

Referenced by mpc_err_print().

◆ mpc_err_repeat()

static mpc_err_t* mpc_err_repeat	(	mpc_input_t *	i,
		mpc_err_t *	x,
		const char *	prefix
	)

static

Definition at line 801 of file mpc.c.

                                                                                    {
  
   int j = 0;
   size_t l = 0;
   char *expect = NULL;
  
   if (x == NULL) { return NULL; }
  
   if (x->expected_num == 0) {
     expect = mpc_calloc(i, 1, 1);
     x->expected_num = 1;
     x->expected = mpc_realloc(i, x->expected, sizeof(char*) * x->expected_num);
     x->expected[0] = expect;
     return x;
   }
  
   else if (x->expected_num == 1) {
     expect = mpc_malloc(i, strlen(prefix) + strlen(x->expected[0]) + 1);
     strcpy(expect, prefix);
     strcat(expect, x->expected[0]);
     mpc_free(i, x->expected[0]);
     x->expected[0] = expect;
     return x;
   }
  
   else if (x->expected_num > 1) {
  
     l += strlen(prefix);
     for (j = 0; j < x->expected_num-2; j++) {
       l += strlen(x->expected[j]) + strlen(", ");
     }
     l += strlen(x->expected[x->expected_num-2]);
     l += strlen(" or ");
     l += strlen(x->expected[x->expected_num-1]);
  
     expect = mpc_malloc(i, l + 1);
  
     strcpy(expect, prefix);
     for (j = 0; j < x->expected_num-2; j++) {
       strcat(expect, x->expected[j]); strcat(expect, ", ");
     }
     strcat(expect, x->expected[x->expected_num-2]);
     strcat(expect, " or ");
     strcat(expect, x->expected[x->expected_num-1]);
  
     for (j = 0; j < x->expected_num; j++) { mpc_free(i, x->expected[j]); }
  
     x->expected_num = 1;
     x->expected = mpc_realloc(i, x->expected, sizeof(char*) * x->expected_num);
     x->expected[0] = expect;
     return x;
   }
  
   return NULL;
 }

References expect, i, mpc_calloc(), mpc_free(), mpc_malloc(), mpc_realloc(), NULL, prefix, and x.

Referenced by mpc_err_count(), and mpc_err_many1().

◆ mpc_err_string()

char* mpc_err_string ( mpc_err_t * x )

Definition at line 630 of file mpc.c.

                                    {
  
   int i;
   int pos = 0;
   int max = 1023;
   char *buffer = calloc(1, 1024);
  
   if (x->failure) {
     mpc_err_string_cat(buffer, &pos, &max,
     "%s: error: %s\n", x->filename, x->failure);
     return buffer;
   }
  
   mpc_err_string_cat(buffer, &pos, &max,
     "%s:%li:%li: error: expected ", x->filename, x->state.row+1, x->state.col+1);
  
   if (x->expected_num == 0) { mpc_err_string_cat(buffer, &pos, &max, "ERROR: NOTHING EXPECTED"); }
   if (x->expected_num == 1) { mpc_err_string_cat(buffer, &pos, &max, "%s", x->expected[0]); }
   if (x->expected_num >= 2) {
  
     for (i = 0; i < x->expected_num-2; i++) {
       mpc_err_string_cat(buffer, &pos, &max, "%s, ", x->expected[i]);
     }
  
     mpc_err_string_cat(buffer, &pos, &max, "%s or %s",
       x->expected[x->expected_num-2],
       x->expected[x->expected_num-1]);
   }
  
   mpc_err_string_cat(buffer, &pos, &max, " at ");
   mpc_err_string_cat(buffer, &pos, &max, mpc_err_char_unescape(x->received));
   mpc_err_string_cat(buffer, &pos, &max, "\n");
  
   return realloc(buffer, strlen(buffer) + 1);
 }

References calloc(), i, max, mpc_err_char_unescape(), mpc_err_string_cat(), pos, realloc(), and x.

Referenced by mpc_err_print_to(), mpc_re_mode(), and mpca_grammar_st().

◆ mpc_err_string_cat()

static void mpc_err_string_cat	(	char *	buffer,
		int *	pos,
		int *	max,
		char const *	fmt,
			...
	)

static

Definition at line 594 of file mpc.c.

                                                                                        {
   /* TODO: Error Checking on Length */
   int left = ((*max) - (*pos));
   va_list va;
   va_start(va, fmt);
   if (left < 0) { left = 0;}
   (*pos) += vsprintf(buffer + (*pos), fmt, va);
   va_end(va);
 }

References pos, and vsprintf.

Referenced by mpc_err_string().

◆ mpc_escape()

mpc_parser_t* mpc_escape ( void )

Definition at line 2014 of file mpc.c.

2014 { return mpc_and(2, mpcf_strfold, mpc_char('\\'), mpc_any(), free); }

mpc_char

mpc_parser_t * mpc_char(char c)

Definition: mpc.c:1747

References free(), mpc_and(), mpc_any(), mpc_char(), and mpcf_strfold().

Referenced by mpc_char_lit(), mpc_re_mode(), mpc_regex_lit(), and mpc_string_lit().

◆ mpc_expect()

mpc_parser_t* mpc_expect	(	mpc_parser_t *	a,
		const char *	expected
	)

Definition at line 1690 of file mpc.c.

                                                                 {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_EXPECT;
   p->data.expect.x = a;
   p->data.expect.m = malloc(strlen(expected) + 1);
   strcpy(p->data.expect.m, expected);
   return p;
 }

References a, malloc(), MPC_TYPE_EXPECT, mpc_undefined(), and p.

Referenced by mpc_alpha(), mpc_alphanum(), mpc_anchor(), mpc_any(), mpc_blank(), mpc_boundary(), mpc_boundary_newline(), mpc_char_lit(), mpc_digit(), mpc_digits(), mpc_eoi(), mpc_float(), mpc_hex(), mpc_hexdigit(), mpc_hexdigits(), mpc_int(), mpc_lower(), mpc_newline(), mpc_number(), mpc_oct(), mpc_octdigit(), mpc_octdigits(), mpc_real(), mpc_regex_lit(), mpc_soi(), mpc_string_lit(), mpc_tab(), mpc_underscore(), mpc_upper(), mpc_whitespace(), mpc_whitespaces(), mpca_stmt_list_apply_to(), and mpcf_re_escape().

◆ mpc_expectf()

mpc_parser_t* mpc_expectf	(	mpc_parser_t *	a,
		const char *	fmt,
			...
	)

Definition at line 1719 of file mpc.c.

                                                                  {
   va_list va;
   char *buffer;
  
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_EXPECT;
  
   va_start(va, fmt);
   buffer = malloc(2048);
   vsprintf(buffer, fmt, va);
   va_end(va);
  
   buffer = realloc(buffer, strlen(buffer) + 1);
   p->data.expect.x = a;
   p->data.expect.m = buffer;
   return p;
 }

References a, malloc(), MPC_TYPE_EXPECT, mpc_undefined(), p, realloc(), and vsprintf.

Referenced by mpc_char(), mpc_noneof(), mpc_oneof(), mpc_range(), mpc_satisfy(), and mpc_string().

◆ mpc_export()

static void* mpc_export	(	mpc_input_t *	i,
		void *	p
	)

static

Definition at line 286 of file mpc.c.

                                                  {
   char *q = NULL;
   if (!mpc_mem_ptr(i, p)) { return p; }
   q = malloc(sizeof(mpc_mem_t));
   memcpy(q, p, sizeof(mpc_mem_t));
   mpc_free(i, p);
   return q;
 }

References i, malloc(), memcpy(), mpc_free(), mpc_mem_ptr(), NULL, and p.

Referenced by mpc_err_export(), mpc_parse_apply(), mpc_parse_apply_to(), mpc_parse_dtor(), mpc_parse_fold(), and mpc_parse_input().

◆ mpc_fail()

mpc_parser_t* mpc_fail ( const char * m )

Definition at line 1616 of file mpc.c.

                                       {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_FAIL;
   p->data.fail.m = malloc(strlen(m) + 1);
   strcpy(p->data.fail.m, m);
   return p;
 }

References regress::m, malloc(), MPC_TYPE_FAIL, mpc_undefined(), and p.

Referenced by mpcf_re_range().

◆ mpc_failf()

mpc_parser_t* mpc_failf	(	const char *	fmt,
			...
	)

Definition at line 1644 of file mpc.c.

                                               {
  
   va_list va;
   char *buffer;
  
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_FAIL;
  
   va_start(va, fmt);
   buffer = malloc(2048);
   vsprintf(buffer, fmt, va);
   va_end(va);
  
   buffer = realloc(buffer, strlen(buffer) + 1);
   p->data.fail.m = buffer;
   return p;
  
 }

References malloc(), MPC_TYPE_FAIL, mpc_undefined(), p, realloc(), and vsprintf.

Referenced by mpc_define(), mpc_re_mode(), mpca_grammar_find_parser(), and mpca_grammar_st().

◆ mpc_float()

mpc_parser_t* mpc_float ( void )

Definition at line 2052 of file mpc.c.

                               {
   return mpc_expect(mpc_apply(mpc_real(), mpcf_float), "float");
 }

References mpc_apply(), mpc_expect(), mpc_real(), and mpcf_float().

◆ mpc_free()

static void mpc_free	(	mpc_input_t *	i,
		void *	p
	)

static

Definition at line 263 of file mpc.c.

                                               {
   size_t j;
   if (!mpc_mem_ptr(i, p)) { free(p); return; }
   j = ((size_t)(((char*)p) - ((char*)i->mem))) / sizeof(mpc_mem_t);
   i->mem_full[j] = 0;
 }

References free(), i, mpc_mem_ptr(), and p.

Referenced by mpc_err_count(), mpc_err_delete_internal(), mpc_err_repeat(), mpc_export(), mpc_parse_dtor(), mpc_parse_run(), mpc_realloc(), mpcf_input_free(), mpcf_input_nth_free(), mpcf_input_state_ast(), mpcf_input_str_ast(), and mpcf_input_strfold().

◆ mpc_hex()

mpc_parser_t* mpc_hex ( void )

Definition at line 2030 of file mpc.c.

2030 { return mpc_expect(mpc_apply(mpc_hexdigits(), mpcf_hex), "hexadecimal"); }

mpcf_hex

mpc_val_t * mpcf_hex(mpc_val_t *x)

Definition: mpc.c:2441

mpc_hexdigits

mpc_parser_t * mpc_hexdigits(void)

Definition: mpc.c:2020

References mpc_apply(), mpc_expect(), mpc_hexdigits(), and mpcf_hex().

Referenced by mpc_number().

◆ mpc_hexdigit()

mpc_parser_t* mpc_hexdigit ( void )

Definition at line 2017 of file mpc.c.

2017 { return mpc_expect(mpc_oneof("0123456789ABCDEFabcdef"), "hex digit"); }

References mpc_expect(), and mpc_oneof().

Referenced by mpc_hexdigits().

◆ mpc_hexdigits()

mpc_parser_t* mpc_hexdigits ( void )

Definition at line 2020 of file mpc.c.

2020 { return mpc_expect(mpc_many1(mpcf_strfold, mpc_hexdigit()), "hex digits"); }

mpc_hexdigit

mpc_parser_t * mpc_hexdigit(void)

Definition: mpc.c:2017

References mpc_expect(), mpc_hexdigit(), mpc_many1(), and mpcf_strfold().

Referenced by mpc_hex().

◆ mpc_ident()

mpc_parser_t* mpc_ident ( void )

Definition at line 2070 of file mpc.c.

                               {
   mpc_parser_t *p0, *p1;
   p0 = mpc_or(2, mpc_alpha(), mpc_underscore());
   p1 = mpc_many(mpcf_strfold, mpc_alphanum());
   return mpc_and(2, mpcf_strfold, p0, p1, free);
 }

References free(), mpc_alpha(), mpc_alphanum(), mpc_and(), mpc_many(), mpc_or(), mpc_underscore(), and mpcf_strfold().

Referenced by mpca_grammar_st(), and mpca_lang_st().

◆ mpc_input_anchor()

static int mpc_input_anchor	(	mpc_input_t *	i,
		int(*)(char, char)	f,
		char **	o
	)

static

Definition at line 543 of file mpc.c.

                                                                           {
   *o = NULL;
   return f(i->last, mpc_input_peekc(i));
 }

References f, i, mpc_input_peekc(), and NULL.

Referenced by mpc_parse_run().

◆ mpc_input_any()

static int mpc_input_any	(	mpc_input_t *	i,
		char **	o
	)

static

Definition at line 482 of file mpc.c.

                                                    {
   char x;
   if (mpc_input_terminated(i)) { return 0; }
   x = mpc_input_getc(i);
   return mpc_input_success(i, x, o);
 }

References i, mpc_input_getc(), mpc_input_success(), mpc_input_terminated(), and x.

Referenced by mpc_parse_run().

◆ mpc_input_backtrack_disable()

static void mpc_input_backtrack_disable ( mpc_input_t * i )

static

Definition at line 295 of file mpc.c.

295 { i->backtrack--; }

References i.

Referenced by mpc_parse_run().

◆ mpc_input_backtrack_enable()

static void mpc_input_backtrack_enable ( mpc_input_t * i )

static

Definition at line 296 of file mpc.c.

296 { i->backtrack++; }

References i.

Referenced by mpc_parse_run().

◆ mpc_input_buffer_get()

static char mpc_input_buffer_get ( mpc_input_t * i )

static

Definition at line 366 of file mpc.c.

                                                  {
   return i->buffer[i->state.pos - i->marks[0].pos];
 }

References i.

Referenced by mpc_input_getc(), and mpc_input_peekc().

◆ mpc_input_buffer_in_range()

static int mpc_input_buffer_in_range ( mpc_input_t * i )

static

Definition at line 362 of file mpc.c.

                                                      {
   return i->state.pos < (long)(strlen(i->buffer) + i->marks[0].pos);
 }

References i, and long.

Referenced by mpc_input_failure(), mpc_input_getc(), mpc_input_peekc(), and mpc_input_success().

◆ mpc_input_char()

static int mpc_input_char	(	mpc_input_t *	i,
		char	c,
		char **	o
	)

static

Definition at line 489 of file mpc.c.

                                                             {
   char x;
   if (mpc_input_terminated(i)) { return 0; }
   x = mpc_input_getc(i);
   return x == c ? mpc_input_success(i, x, o) : mpc_input_failure(i, x);
 }

References c, i, mpc_input_failure(), mpc_input_getc(), mpc_input_success(), mpc_input_terminated(), and x.

Referenced by mpc_input_string(), and mpc_parse_run().

◆ mpc_input_delete()

static void mpc_input_delete ( mpc_input_t * i )

static

Definition at line 219 of file mpc.c.

                                              {
  
   free(i->filename);
  
   if (i->type == MPC_INPUT_STRING) { free(i->string); }
   if (i->type == MPC_INPUT_PIPE) { free(i->buffer); }
  
   free(i->marks);
   free(i->lasts);
   free(i);
 }

References free(), i, MPC_INPUT_PIPE, and MPC_INPUT_STRING.

Referenced by mpc_nparse(), mpc_parse(), mpc_parse_file(), mpc_parse_pipe(), mpca_lang(), mpca_lang_contents(), mpca_lang_file(), and mpca_lang_pipe().

◆ mpc_input_eoi()

static int mpc_input_eoi	(	mpc_input_t *	i,
		char **	o
	)

static

Definition at line 553 of file mpc.c.

                                                    {
   *o = NULL;
   if (i->state.term) {
     return 0;
   } else if (mpc_input_terminated(i)) {
     i->state.term = 1;
     return 1;
   } else {
     return 0;
   }
 }

References i, mpc_input_terminated(), and NULL.

Referenced by mpc_parse_run().

◆ mpc_input_failure()

static int mpc_input_failure	(	mpc_input_t *	i,
		char	c
	)

static

Definition at line 435 of file mpc.c.

                                                      {
  
   switch (i->type) {
     case MPC_INPUT_STRING: { break; }
     case MPC_INPUT_FILE: fseek(i->file, -1, SEEK_CUR); { break; }
     case MPC_INPUT_PIPE: {
  
       if (!i->buffer) { ungetc(c, i->file); break; }
  
       if (i->buffer && mpc_input_buffer_in_range(i)) {
         break;
       } else {
         ungetc(c, i->file);
       }
     }
     default: { break; }
   }
   return 0;
 }

References c, i, mpc_input_buffer_in_range(), MPC_INPUT_FILE, MPC_INPUT_PIPE, MPC_INPUT_STRING, and SEEK_CUR.

Referenced by mpc_input_char(), mpc_input_noneof(), mpc_input_oneof(), mpc_input_range(), and mpc_input_satisfy().

◆ mpc_input_getc()

static char mpc_input_getc ( mpc_input_t * i )

static

Definition at line 370 of file mpc.c.

                                            {
  
   char c = '\0';
  
   switch (i->type) {
  
     case MPC_INPUT_STRING: return i->string[i->state.pos];
     case MPC_INPUT_FILE: c = fgetc(i->file); return c;
     case MPC_INPUT_PIPE:
  
       if (!i->buffer) { c = getc(i->file); return c; }
  
       if (i->buffer && mpc_input_buffer_in_range(i)) {
         c = mpc_input_buffer_get(i);
         return c;
       } else {
         c = getc(i->file);
         return c;
       }
  
     default: return c;
   }
 }

References c, i, mpc_input_buffer_get(), mpc_input_buffer_in_range(), MPC_INPUT_FILE, MPC_INPUT_PIPE, and MPC_INPUT_STRING.

Referenced by mpc_input_any(), mpc_input_char(), mpc_input_noneof(), mpc_input_oneof(), mpc_input_range(), and mpc_input_satisfy().

◆ mpc_input_mark()

static void mpc_input_mark ( mpc_input_t * i )

static

Definition at line 301 of file mpc.c.

                                            {
  
   if (i->backtrack < 1) { return; }
  
   i->marks_num++;
  
   if (i->marks_num > i->marks_slots) {
     i->marks_slots = i->marks_num + i->marks_num / 2;
     i->marks = realloc(i->marks, sizeof(mpc_state_t) * i->marks_slots);
     i->lasts = realloc(i->lasts, sizeof(char) * i->marks_slots);
   }
  
   i->marks[i->marks_num-1] = i->state;
   i->lasts[i->marks_num-1] = i->last;
  
   if (i->type == MPC_INPUT_PIPE && i->marks_num == 1) {
     i->buffer = calloc(1, 1);
   }
  
 }

References calloc(), i, MPC_INPUT_PIPE, and realloc().

Referenced by mpc_input_string(), and mpc_parse_run().

◆ mpc_input_new_file()

static mpc_input_t* mpc_input_new_file	(	const char *	filename,
		FILE *	file
	)

static

Definition at line 192 of file mpc.c.

                                                                          {
  
   mpc_input_t *i = malloc(sizeof(mpc_input_t));
  
   i->filename = malloc(strlen(filename) + 1);
   strcpy(i->filename, filename);
   i->type = MPC_INPUT_FILE;
   i->state = mpc_state_new();
  
   i->string = NULL;
   i->buffer = NULL;
   i->file = file;
  
   i->suppress = 0;
   i->backtrack = 1;
   i->marks_num = 0;
   i->marks_slots = MPC_INPUT_MARKS_MIN;
   i->marks = malloc(sizeof(mpc_state_t) * i->marks_slots);
   i->lasts = malloc(sizeof(char) * i->marks_slots);
   i->last = '\0';
  
   i->mem_index = 0;
   memset(i->mem_full, 0, sizeof(char) * MPC_INPUT_MEM_NUM);
  
   return i;
 }

References file, i, malloc(), memset(), MPC_INPUT_FILE, MPC_INPUT_MARKS_MIN, MPC_INPUT_MEM_NUM, mpc_state_new(), and NULL.

Referenced by mpc_parse_file(), mpca_lang_contents(), and mpca_lang_file().

◆ mpc_input_new_nstring()

static mpc_input_t* mpc_input_new_nstring	(	const char *	filename,
		const char *	string,
		size_t	length
	)

static

Definition at line 132 of file mpc.c.

                                                                                                    {
  
   mpc_input_t *i = malloc(sizeof(mpc_input_t));
  
   i->filename = malloc(strlen(filename) + 1);
   strcpy(i->filename, filename);
   i->type = MPC_INPUT_STRING;
  
   i->state = mpc_state_new();
  
   i->string = malloc(length + 1);
   strncpy(i->string, string, length);
   i->string[length] = '\0';
   i->buffer = NULL;
   i->file = NULL;
  
   i->suppress = 0;
   i->backtrack = 1;
   i->marks_num = 0;
   i->marks_slots = MPC_INPUT_MARKS_MIN;
   i->marks = malloc(sizeof(mpc_state_t) * i->marks_slots);
   i->lasts = malloc(sizeof(char) * i->marks_slots);
   i->last = '\0';
  
   i->mem_index = 0;
   memset(i->mem_full, 0, sizeof(char) * MPC_INPUT_MEM_NUM);
  
   return i;
  
 }

References i, length, malloc(), memset(), MPC_INPUT_MARKS_MIN, MPC_INPUT_MEM_NUM, MPC_INPUT_STRING, mpc_state_new(), and NULL.

Referenced by mpc_nparse().

◆ mpc_input_new_pipe()

static mpc_input_t* mpc_input_new_pipe	(	const char *	filename,
		FILE *	pipe
	)

static

Definition at line 163 of file mpc.c.

                                                                          {
  
   mpc_input_t *i = malloc(sizeof(mpc_input_t));
  
   i->filename = malloc(strlen(filename) + 1);
   strcpy(i->filename, filename);
  
   i->type = MPC_INPUT_PIPE;
   i->state = mpc_state_new();
  
   i->string = NULL;
   i->buffer = NULL;
   i->file = pipe;
  
   i->suppress = 0;
   i->backtrack = 1;
   i->marks_num = 0;
   i->marks_slots = MPC_INPUT_MARKS_MIN;
   i->marks = malloc(sizeof(mpc_state_t) * i->marks_slots);
   i->lasts = malloc(sizeof(char) * i->marks_slots);
   i->last = '\0';
  
   i->mem_index = 0;
   memset(i->mem_full, 0, sizeof(char) * MPC_INPUT_MEM_NUM);
  
   return i;
  
 }

References i, malloc(), memset(), MPC_INPUT_MARKS_MIN, MPC_INPUT_MEM_NUM, MPC_INPUT_PIPE, mpc_state_new(), NULL, and pipe.

Referenced by mpc_parse_pipe(), and mpca_lang_pipe().

◆ mpc_input_new_string()

static mpc_input_t* mpc_input_new_string	(	const char *	filename,
		const char *	string
	)

static

Definition at line 103 of file mpc.c.

                                                                                    {
  
   mpc_input_t *i = malloc(sizeof(mpc_input_t));
  
   i->filename = malloc(strlen(filename) + 1);
   strcpy(i->filename, filename);
   i->type = MPC_INPUT_STRING;
  
   i->state = mpc_state_new();
  
   i->string = malloc(strlen(string) + 1);
   strcpy(i->string, string);
   i->buffer = NULL;
   i->file = NULL;
  
   i->suppress = 0;
   i->backtrack = 1;
   i->marks_num = 0;
   i->marks_slots = MPC_INPUT_MARKS_MIN;
   i->marks = malloc(sizeof(mpc_state_t) * i->marks_slots);
   i->lasts = malloc(sizeof(char) * i->marks_slots);
   i->last = '\0';
  
   i->mem_index = 0;
   memset(i->mem_full, 0, sizeof(char) * MPC_INPUT_MEM_NUM);
  
   return i;
 }

References i, malloc(), memset(), MPC_INPUT_MARKS_MIN, MPC_INPUT_MEM_NUM, MPC_INPUT_STRING, mpc_state_new(), and NULL.

Referenced by mpc_parse(), and mpca_lang().

◆ mpc_input_noneof()

static int mpc_input_noneof	(	mpc_input_t *	i,
		const char *	c,
		char **	o
	)

static

Definition at line 510 of file mpc.c.

                                                                      {
   char x;
   if (mpc_input_terminated(i)) { return 0; }
   x = mpc_input_getc(i);
   return strchr(c, x) == 0 ? mpc_input_success(i, x, o) : mpc_input_failure(i, x);
 }

References c, i, mpc_input_failure(), mpc_input_getc(), mpc_input_success(), mpc_input_terminated(), and x.

Referenced by mpc_parse_run().

◆ mpc_input_oneof()

static int mpc_input_oneof	(	mpc_input_t *	i,
		const char *	c,
		char **	o
	)

static

Definition at line 503 of file mpc.c.

                                                                     {
   char x;
   if (mpc_input_terminated(i)) { return 0; }
   x = mpc_input_getc(i);
   return strchr(c, x) != 0 ? mpc_input_success(i, x, o) : mpc_input_failure(i, x);
 }

References c, i, mpc_input_failure(), mpc_input_getc(), mpc_input_success(), mpc_input_terminated(), and x.

Referenced by mpc_parse_run().

◆ mpc_input_peekc()

static char mpc_input_peekc ( mpc_input_t * i )

static

Definition at line 394 of file mpc.c.

                                             {
  
   char c = '\0';
  
   switch (i->type) {
     case MPC_INPUT_STRING: return i->string[i->state.pos];
     case MPC_INPUT_FILE:
  
       c = fgetc(i->file);
       if (feof(i->file)) { return '\0'; }
  
       fseek(i->file, -1, SEEK_CUR);
       return c;
  
     case MPC_INPUT_PIPE:
  
       if (!i->buffer) {
         c = getc(i->file);
         if (feof(i->file)) { return '\0'; }
         ungetc(c, i->file);
         return c;
       }
  
       if (i->buffer && mpc_input_buffer_in_range(i)) {
         return mpc_input_buffer_get(i);
       } else {
         c = getc(i->file);
         if (feof(i->file)) { return '\0'; }
         ungetc(c, i->file);
         return c;
       }
  
     default: return c;
   }
  
 }

References c, i, mpc_input_buffer_get(), mpc_input_buffer_in_range(), MPC_INPUT_FILE, MPC_INPUT_PIPE, MPC_INPUT_STRING, and SEEK_CUR.

Referenced by mpc_err_new(), mpc_input_anchor(), and mpc_input_terminated().

◆ mpc_input_range()

static int mpc_input_range	(	mpc_input_t *	i,
		char	c,
		char	d,
		char **	o
	)

static

Definition at line 496 of file mpc.c.

                                                                      {
   char x;
   if (mpc_input_terminated(i)) { return 0; }
   x = mpc_input_getc(i);
   return x >= c && x <= d ? mpc_input_success(i, x, o) : mpc_input_failure(i, x);
 }

References c, d, i, mpc_input_failure(), mpc_input_getc(), mpc_input_success(), mpc_input_terminated(), and x.

Referenced by mpc_parse_run().

◆ mpc_input_rewind()

static void mpc_input_rewind ( mpc_input_t * i )

static

Definition at line 348 of file mpc.c.

                                              {
  
   if (i->backtrack < 1) { return; }
  
   i->state = i->marks[i->marks_num-1];
   i->last  = i->lasts[i->marks_num-1];
  
   if (i->type == MPC_INPUT_FILE) {
     fseek(i->file, i->state.pos, SEEK_SET);
   }
  
   mpc_input_unmark(i);
 }

References i, MPC_INPUT_FILE, mpc_input_unmark(), and SEEK_SET.

Referenced by mpc_input_string(), and mpc_parse_run().

◆ mpc_input_satisfy()

static int mpc_input_satisfy	(	mpc_input_t *	i,
		int(*)(char)	cond,
		char **	o
	)

static

Definition at line 517 of file mpc.c.

                                                                          {
   char x;
   if (mpc_input_terminated(i)) { return 0; }
   x = mpc_input_getc(i);
   return cond(x) ? mpc_input_success(i, x, o) : mpc_input_failure(i, x);
 }

References cond, i, mpc_input_failure(), mpc_input_getc(), mpc_input_success(), mpc_input_terminated(), and x.

Referenced by mpc_parse_run().

◆ mpc_input_soi()

static int mpc_input_soi	(	mpc_input_t *	i,
		char **	o
	)

static

Definition at line 548 of file mpc.c.

                                                    {
   *o = NULL;
   return i->last == '\0';
 }

References i, and NULL.

Referenced by mpc_parse_run().

◆ mpc_input_state_copy()

static mpc_state_t* mpc_input_state_copy ( mpc_input_t * i )

static

Definition at line 565 of file mpc.c.

                                                          {
   mpc_state_t *r = mpc_malloc(i, sizeof(mpc_state_t));
   memcpy(r, &i->state, sizeof(mpc_state_t));
   return r;
 }

References i, memcpy(), mpc_malloc(), and r.

Referenced by mpc_parse_run().

◆ mpc_input_string()

static int mpc_input_string	(	mpc_input_t *	i,
		const char *	c,
		char **	o
	)

static

Definition at line 524 of file mpc.c.

                                                                      {
  
   const char *x = c;
  
   mpc_input_mark(i);
   while (*x) {
     if (!mpc_input_char(i, *x, NULL)) {
       mpc_input_rewind(i);
       return 0;
     }
     x++;
   }
   mpc_input_unmark(i);
  
   *o = mpc_malloc(i, strlen(c) + 1);
   strcpy(*o, c);
   return 1;
 }

References c, i, mpc_input_char(), mpc_input_mark(), mpc_input_rewind(), mpc_input_unmark(), mpc_malloc(), NULL, and x.

Referenced by mpc_parse_run().

◆ mpc_input_success()

static int mpc_input_success	(	mpc_input_t *	i,
		char	c,
		char **	o
	)

static

Definition at line 455 of file mpc.c.

                                                                {
  
   if (i->type == MPC_INPUT_PIPE
   &&  i->buffer && !mpc_input_buffer_in_range(i)) {
     i->buffer = realloc(i->buffer, strlen(i->buffer) + 2);
     i->buffer[strlen(i->buffer) + 1] = '\0';
     i->buffer[strlen(i->buffer) + 0] = c;
   }
  
   i->last = c;
   i->state.pos++;
   i->state.col++;
  
   if (c == '\n') {
     i->state.col = 0;
     i->state.row++;
   }
  
   if (o) {
     (*o) = mpc_malloc(i, 2);
     (*o)[0] = c;
     (*o)[1] = '\0';
   }
  
   return 1;
 }

References c, i, mpc_input_buffer_in_range(), MPC_INPUT_PIPE, mpc_malloc(), and realloc().

Referenced by mpc_input_any(), mpc_input_char(), mpc_input_noneof(), mpc_input_oneof(), mpc_input_range(), and mpc_input_satisfy().

◆ mpc_input_suppress_disable()

static void mpc_input_suppress_disable ( mpc_input_t * i )

static

Definition at line 298 of file mpc.c.

298 { i->suppress--; }

References i.

Referenced by mpc_parse_run().

◆ mpc_input_suppress_enable()

static void mpc_input_suppress_enable ( mpc_input_t * i )

static

Definition at line 299 of file mpc.c.

299 { i->suppress++; }

References i.

Referenced by mpc_parse_run().

◆ mpc_input_terminated()

static int mpc_input_terminated ( mpc_input_t * i )

static

Definition at line 431 of file mpc.c.

                                                 {
   return mpc_input_peekc(i) == '\0';
 }

References i, and mpc_input_peekc().

Referenced by mpc_input_any(), mpc_input_char(), mpc_input_eoi(), mpc_input_noneof(), mpc_input_oneof(), mpc_input_range(), and mpc_input_satisfy().

◆ mpc_input_unmark()

static void mpc_input_unmark ( mpc_input_t * i )

static

Definition at line 322 of file mpc.c.

                                              {
   int j;
  
   if (i->backtrack < 1) { return; }
  
   i->marks_num--;
  
   if (i->marks_slots > i->marks_num + i->marks_num / 2
   &&  i->marks_slots > MPC_INPUT_MARKS_MIN) {
     i->marks_slots =
       i->marks_num > MPC_INPUT_MARKS_MIN ?
       i->marks_num : MPC_INPUT_MARKS_MIN;
     i->marks = realloc(i->marks, sizeof(mpc_state_t) * i->marks_slots);
     i->lasts = realloc(i->lasts, sizeof(char) * i->marks_slots);
   }
  
   if (i->type == MPC_INPUT_PIPE && i->marks_num == 0) {
     for (j = strlen(i->buffer) - 1; j >= 0; j--)
       ungetc(i->buffer[j], i->file);
  
     free(i->buffer);
     i->buffer = NULL;
   }
  
 }

References free(), i, MPC_INPUT_MARKS_MIN, MPC_INPUT_PIPE, NULL, and realloc().

Referenced by mpc_input_rewind(), mpc_input_string(), and mpc_parse_run().

◆ mpc_int()

mpc_parser_t* mpc_int ( void )

Definition at line 2029 of file mpc.c.

2029 { return mpc_expect(mpc_apply(mpc_digits(), mpcf_int), "integer"); }

mpc_digits

mpc_parser_t * mpc_digits(void)

Definition: mpc.c:2019

mpcf_int

mpc_val_t * mpcf_int(mpc_val_t *x)

Definition: mpc.c:2434

References mpc_apply(), mpc_digits(), mpc_expect(), and mpcf_int().

Referenced by mpc_number(), mpc_re_mode(), mpca_grammar_st(), and mpca_lang_st().

◆ mpc_lift()

mpc_parser_t* mpc_lift ( mpc_ctor_t lf )

Definition at line 1670 of file mpc.c.

                                       {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_LIFT;
   p->data.lift.lf = lf;
   return p;
 }

References MPC_TYPE_LIFT, mpc_undefined(), and p.

Referenced by mpc_re_escape_char(), mpcf_re_and(), and mpcf_re_escape().

◆ mpc_lift_val()

mpc_parser_t* mpc_lift_val ( mpc_val_t * x )

Definition at line 1663 of file mpc.c.

                                          {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_LIFT_VAL;
   p->data.lift.x = x;
   return p;
 }

References MPC_TYPE_LIFT_VAL, mpc_undefined(), p, and x.

Referenced by mpca_grammar_st(), and mpca_lang_st().

◆ mpc_lower()

mpc_parser_t* mpc_lower ( void )

Definition at line 2023 of file mpc.c.

2023 { return mpc_expect(mpc_oneof("abcdefghijklmnopqrstuvwxyz"), "lowercase letter"); }

References mpc_expect(), and mpc_oneof().

◆ mpc_malloc()

static void* mpc_malloc	(	mpc_input_t *	i,
		size_t	n
	)

static

Definition at line 237 of file mpc.c.

                                                   {
   size_t j;
   char *p;
  
   if (n > sizeof(mpc_mem_t)) { return malloc(n); }
  
   j = i->mem_index;
   do {
     if (!i->mem_full[i->mem_index]) {
       p = (void*)(i->mem + i->mem_index);
       i->mem_full[i->mem_index] = 1;
       i->mem_index = (i->mem_index+1) % MPC_INPUT_MEM_NUM;
       return p;
     }
     i->mem_index = (i->mem_index+1) % MPC_INPUT_MEM_NUM;
   } while (j != i->mem_index);
  
   return malloc(n);
 }

References i, malloc(), MPC_INPUT_MEM_NUM, n, and p.

Referenced by mpc_calloc(), mpc_err_add_expected(), mpc_err_count(), mpc_err_fail(), mpc_err_new(), mpc_err_or(), mpc_err_repeat(), mpc_input_state_copy(), mpc_input_string(), mpc_input_success(), and mpc_parse_run().

◆ mpc_many()

mpc_parser_t* mpc_many	(	mpc_fold_t	f,
		mpc_parser_t *	a
	)

Definition at line 1902 of file mpc.c.

                                                       {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_MANY;
   p->data.repeat.x = a;
   p->data.repeat.f = f;
   return p;
 }

References a, f, MPC_TYPE_MANY, mpc_undefined(), and p.

Referenced by mpc_ident(), mpc_re_mode(), mpc_regex_lit(), mpc_string_lit(), mpc_whitespaces(), mpca_grammar_st(), mpca_lang_st(), mpca_many(), and mpcf_re_repeat().

◆ mpc_many1()

mpc_parser_t* mpc_many1	(	mpc_fold_t	f,
		mpc_parser_t *	a
	)

Definition at line 1910 of file mpc.c.

                                                        {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_MANY1;
   p->data.repeat.x = a;
   p->data.repeat.f = f;
   return p;
 }

References a, f, MPC_TYPE_MANY1, mpc_undefined(), and p.

Referenced by mpc_digits(), mpc_hexdigits(), mpc_octdigits(), mpca_grammar_st(), mpca_lang_st(), mpca_many1(), and mpcf_re_repeat().

◆ mpc_maybe()

mpc_parser_t* mpc_maybe ( mpc_parser_t * a )

Definition at line 1898 of file mpc.c.

                                          {
   return mpc_maybe_lift(a, mpcf_ctor_null);
 }

References a, mpc_maybe_lift(), and mpcf_ctor_null().

Referenced by mpc_re_mode(), mpca_grammar_st(), mpca_lang_st(), and mpca_maybe().

◆ mpc_maybe_lift()

mpc_parser_t* mpc_maybe_lift	(	mpc_parser_t *	a,
		mpc_ctor_t	lf
	)

Definition at line 1890 of file mpc.c.

                                                              {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_MAYBE;
   p->data.not.x = a;
   p->data.not.lf = lf;
   return p;
 }

References a, MPC_TYPE_MAYBE, mpc_undefined(), and p.

Referenced by mpc_maybe(), mpc_real(), and mpcf_re_repeat().

◆ mpc_mem_ptr()

static int mpc_mem_ptr	(	mpc_input_t *	i,
		void *	p
	)

static

Definition at line 231 of file mpc.c.

                                                 {
   return
     (char*)p >= (char*)(i->mem) &&
     (char*)p <  (char*)(i->mem) + (MPC_INPUT_MEM_NUM * sizeof(mpc_mem_t));
 }

References i, MPC_INPUT_MEM_NUM, and p.

Referenced by mpc_export(), mpc_free(), and mpc_realloc().

◆ mpc_new()

mpc_parser_t* mpc_new ( const char * name )

Definition at line 1480 of file mpc.c.

                                         {
   mpc_parser_t *p = mpc_undefined();
   p->retained = 1;
   p->name = realloc(p->name, strlen(name) + 1);
   strcpy(p->name, name);
   return p;
 }

References mpc_undefined(), p, and realloc().

Referenced by main(), mpc_re_mode(), mpca_grammar_st(), and mpca_lang_st().

◆ mpc_newline()

mpc_parser_t* mpc_newline ( void )

Definition at line 2012 of file mpc.c.

2012 { return mpc_expect(mpc_char('\n'), "newline"); }

References mpc_char(), and mpc_expect().

Referenced by mpcf_re_escape().

◆ mpc_nodecount_unretained()

static int mpc_nodecount_unretained	(	mpc_parser_t *	p,
		int	force
	)

static

Definition at line 3847 of file mpc.c.

                                                                 {
  
   int i, total;
  
   if (p->retained && !force) { return 0; }
  
   if (p->type == MPC_TYPE_EXPECT) { return 1 + mpc_nodecount_unretained(p->data.expect.x, 0); }
  
   if (p->type == MPC_TYPE_APPLY)    { return 1 + mpc_nodecount_unretained(p->data.apply.x, 0); }
   if (p->type == MPC_TYPE_APPLY_TO) { return 1 + mpc_nodecount_unretained(p->data.apply_to.x, 0); }
   if (p->type == MPC_TYPE_PREDICT)  { return 1 + mpc_nodecount_unretained(p->data.predict.x, 0); }
  
   if (p->type == MPC_TYPE_CHECK)    { return 1 + mpc_nodecount_unretained(p->data.check.x, 0); }
   if (p->type == MPC_TYPE_CHECK_WITH) { return 1 + mpc_nodecount_unretained(p->data.check_with.x, 0); }
  
   if (p->type == MPC_TYPE_NOT)   { return 1 + mpc_nodecount_unretained(p->data.not.x, 0); }
   if (p->type == MPC_TYPE_MAYBE) { return 1 + mpc_nodecount_unretained(p->data.not.x, 0); }
  
   if (p->type == MPC_TYPE_MANY)  { return 1 + mpc_nodecount_unretained(p->data.repeat.x, 0); }
   if (p->type == MPC_TYPE_MANY1) { return 1 + mpc_nodecount_unretained(p->data.repeat.x, 0); }
   if (p->type == MPC_TYPE_COUNT) { return 1 + mpc_nodecount_unretained(p->data.repeat.x, 0); }
  
   if (p->type == MPC_TYPE_OR) {
     total = 1;
     for(i = 0; i < p->data.or.n; i++) {
       total += mpc_nodecount_unretained(p->data.or.xs[i], 0);
     }
     return total;
   }
  
   if (p->type == MPC_TYPE_AND) {
     total = 1;
     for(i = 0; i < p->data.and.n; i++) {
       total += mpc_nodecount_unretained(p->data.and.xs[i], 0);
     }
     return total;
   }
  
   return 1;
  
 }

References i, MPC_TYPE_AND, MPC_TYPE_APPLY, MPC_TYPE_APPLY_TO, MPC_TYPE_CHECK, MPC_TYPE_CHECK_WITH, MPC_TYPE_COUNT, MPC_TYPE_EXPECT, MPC_TYPE_MANY, MPC_TYPE_MANY1, MPC_TYPE_MAYBE, MPC_TYPE_NOT, MPC_TYPE_OR, MPC_TYPE_PREDICT, and p.

Referenced by mpc_stats().

◆ mpc_noneof()

mpc_parser_t* mpc_noneof ( const char * s )

Definition at line 1770 of file mpc.c.

                                         {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_NONEOF;
   p->data.string.x = malloc(strlen(s) + 1);
   strcpy(p->data.string.x, s);
   return mpc_expectf(p, "none of '%s'", s);
  
 }

References malloc(), mpc_expectf(), MPC_TYPE_NONEOF, mpc_undefined(), p, and s.

Referenced by mpc_re_mode(), mpc_regex_lit(), mpc_string_lit(), mpcf_re_escape(), and mpcf_re_range().

◆ mpc_not()

mpc_parser_t* mpc_not	(	mpc_parser_t *	a,
		mpc_dtor_t	da
	)

Definition at line 1886 of file mpc.c.

                                                       {
   return mpc_not_lift(a, da, mpcf_ctor_null);
 }

References a, mpc_not_lift(), and mpcf_ctor_null().

Referenced by mpca_not().

◆ mpc_not_lift()

mpc_parser_t* mpc_not_lift	(	mpc_parser_t *	a,
		mpc_dtor_t	da,
		mpc_ctor_t	lf
	)

Definition at line 1877 of file mpc.c.

                                                                           {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_NOT;
   p->data.not.x = a;
   p->data.not.dx = da;
   p->data.not.lf = lf;
   return p;
 }

References a, MPC_TYPE_NOT, mpc_undefined(), and p.

Referenced by mpc_not(), and mpc_re_escape_char().

◆ mpc_nparse()

int mpc_nparse	(	const char *	filename,
		const char *	string,
		size_t	length,
		mpc_parser_t *	p,
		mpc_result_t *	r
	)

Definition at line 1329 of file mpc.c.

                                                                                                           {
   int x;
   mpc_input_t *i = mpc_input_new_nstring(filename, string, length);
   x = mpc_parse_input(i, p, r);
   mpc_input_delete(i);
   return x;
 }

References i, length, mpc_input_delete(), mpc_input_new_nstring(), mpc_parse_input(), p, r, and x.

◆ mpc_number()

mpc_parser_t* mpc_number ( void )

Definition at line 2032 of file mpc.c.

2032 { return mpc_expect(mpc_or(3, mpc_int(), mpc_hex(), mpc_oct()), "number"); }

mpc_hex

mpc_parser_t * mpc_hex(void)

Definition: mpc.c:2030

mpc_int

mpc_parser_t * mpc_int(void)

Definition: mpc.c:2029

mpc_oct

mpc_parser_t * mpc_oct(void)

Definition: mpc.c:2031

References mpc_expect(), mpc_hex(), mpc_int(), mpc_oct(), and mpc_or().

◆ mpc_oct()

mpc_parser_t* mpc_oct ( void )

Definition at line 2031 of file mpc.c.

2031 { return mpc_expect(mpc_apply(mpc_octdigits(), mpcf_oct), "octadecimal"); }

mpcf_oct

mpc_val_t * mpcf_oct(mpc_val_t *x)

Definition: mpc.c:2448

mpc_octdigits

mpc_parser_t * mpc_octdigits(void)

Definition: mpc.c:2021

References mpc_apply(), mpc_expect(), mpc_octdigits(), and mpcf_oct().

Referenced by mpc_number().

◆ mpc_octdigit()

mpc_parser_t* mpc_octdigit ( void )

Definition at line 2018 of file mpc.c.

2018 { return mpc_expect(mpc_oneof("01234567"), "oct digit"); }

References mpc_expect(), and mpc_oneof().

Referenced by mpc_octdigits().

◆ mpc_octdigits()

mpc_parser_t* mpc_octdigits ( void )

Definition at line 2021 of file mpc.c.

2021 { return mpc_expect(mpc_many1(mpcf_strfold, mpc_octdigit()), "oct digits"); }

mpc_octdigit

mpc_parser_t * mpc_octdigit(void)

Definition: mpc.c:2018

References mpc_expect(), mpc_many1(), mpc_octdigit(), and mpcf_strfold().

Referenced by mpc_oct().

◆ mpc_oneof()

mpc_parser_t* mpc_oneof ( const char * s )

Definition at line 1762 of file mpc.c.

                                        {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_ONEOF;
   p->data.string.x = malloc(strlen(s) + 1);
   strcpy(p->data.string.x, s);
   return mpc_expectf(p, "one of '%s'", s);
 }

References malloc(), mpc_expectf(), MPC_TYPE_ONEOF, mpc_undefined(), p, and s.

Referenced by mpc_alpha(), mpc_digit(), mpc_hexdigit(), mpc_lower(), mpc_octdigit(), mpc_real(), mpc_upper(), mpc_whitespace(), mpca_grammar_st(), mpca_lang_st(), and mpcf_re_range().

◆ mpc_optimise()

void mpc_optimise ( mpc_parser_t * p )

Definition at line 4064 of file mpc.c.

                                    {
   mpc_optimise_unretained(p, 1);
 }

References mpc_optimise_unretained(), and p.

Referenced by mpc_re_mode(), mpca_grammar_st(), mpca_lang_st(), and mpca_stmt_list_apply_to().

◆ mpc_optimise_unretained()

static void mpc_optimise_unretained	(	mpc_parser_t *	p,
		int	force
	)

static

Definition at line 3895 of file mpc.c.

                                                                 {
  
   int i, n, m;
   mpc_parser_t *t;
  
   if (p->retained && !force) { return; }
  
   /* Optimise Subexpressions */
  
   if (p->type == MPC_TYPE_EXPECT)     { mpc_optimise_unretained(p->data.expect.x, 0); }
   if (p->type == MPC_TYPE_APPLY)      { mpc_optimise_unretained(p->data.apply.x, 0); }
   if (p->type == MPC_TYPE_APPLY_TO)   { mpc_optimise_unretained(p->data.apply_to.x, 0); }
   if (p->type == MPC_TYPE_CHECK)      { mpc_optimise_unretained(p->data.check.x, 0); }
   if (p->type == MPC_TYPE_CHECK_WITH) { mpc_optimise_unretained(p->data.check_with.x, 0); }
   if (p->type == MPC_TYPE_PREDICT)    { mpc_optimise_unretained(p->data.predict.x, 0); }
   if (p->type == MPC_TYPE_NOT)        { mpc_optimise_unretained(p->data.not.x, 0); }
   if (p->type == MPC_TYPE_MAYBE)      { mpc_optimise_unretained(p->data.not.x, 0); }
   if (p->type == MPC_TYPE_MANY)       { mpc_optimise_unretained(p->data.repeat.x, 0); }
   if (p->type == MPC_TYPE_MANY1)      { mpc_optimise_unretained(p->data.repeat.x, 0); }
   if (p->type == MPC_TYPE_COUNT)      { mpc_optimise_unretained(p->data.repeat.x, 0); }
  
   if (p->type == MPC_TYPE_OR) {
     for(i = 0; i < p->data.or.n; i++) {
       mpc_optimise_unretained(p->data.or.xs[i], 0);
     }
   }
  
   if (p->type == MPC_TYPE_AND) {
     for(i = 0; i < p->data.and.n; i++) {
       mpc_optimise_unretained(p->data.and.xs[i], 0);
     }
   }
  
   /* Perform optimisations */
  
   while (1) {
  
     /* Merge rhs `or` */
     if (p->type == MPC_TYPE_OR
     &&  p->data.or.xs[p->data.or.n-1]->type == MPC_TYPE_OR
     && !p->data.or.xs[p->data.or.n-1]->retained) {
       t = p->data.or.xs[p->data.or.n-1];
       n = p->data.or.n; m = t->data.or.n;
       p->data.or.n = n + m - 1;
       p->data.or.xs = realloc(p->data.or.xs, sizeof(mpc_parser_t*) * (n + m -1));
       memmove(p->data.or.xs + n - 1, t->data.or.xs, m * sizeof(mpc_parser_t*));
       free(t->data.or.xs); free(t->name); free(t);
       continue;
     }
  
     /* Merge lhs `or` */
     if (p->type == MPC_TYPE_OR
     &&  p->data.or.xs[0]->type == MPC_TYPE_OR
     && !p->data.or.xs[0]->retained) {
       t = p->data.or.xs[0];
       n = p->data.or.n; m = t->data.or.n;
       p->data.or.n = n + m - 1;
       p->data.or.xs = realloc(p->data.or.xs, sizeof(mpc_parser_t*) * (n + m -1));
       memmove(p->data.or.xs + m, p->data.or.xs + 1, (n - 1) * sizeof(mpc_parser_t*));
       memmove(p->data.or.xs, t->data.or.xs, m * sizeof(mpc_parser_t*));
       free(t->data.or.xs); free(t->name); free(t);
       continue;
     }
  
     /* Remove ast `pass` */
     if (p->type == MPC_TYPE_AND
     &&  p->data.and.n == 2
     &&  p->data.and.xs[0]->type == MPC_TYPE_PASS
     && !p->data.and.xs[0]->retained
     &&  p->data.and.f == mpcf_fold_ast) {
       t = p->data.and.xs[1];
       mpc_delete(p->data.and.xs[0]);
       free(p->data.and.xs); free(p->data.and.dxs); free(p->name);
       memcpy(p, t, sizeof(mpc_parser_t));
       free(t);
       continue;
     }
  
     /* Merge ast lhs `and` */
     if (p->type == MPC_TYPE_AND
     &&  p->data.and.f == mpcf_fold_ast
     &&  p->data.and.xs[0]->type == MPC_TYPE_AND
     && !p->data.and.xs[0]->retained
     &&  p->data.and.xs[0]->data.and.f == mpcf_fold_ast) {
       t = p->data.and.xs[0];
       n = p->data.and.n; m = t->data.and.n;
       p->data.and.n = n + m - 1;
       p->data.and.xs = realloc(p->data.and.xs, sizeof(mpc_parser_t*) * (n + m - 1));
       p->data.and.dxs = realloc(p->data.and.dxs, sizeof(mpc_dtor_t) * (n + m - 1 - 1));
       memmove(p->data.and.xs + m, p->data.and.xs + 1, (n - 1) * sizeof(mpc_parser_t*));
       memmove(p->data.and.xs, t->data.and.xs, m * sizeof(mpc_parser_t*));
       for (i = 0; i < p->data.and.n-1; i++) { p->data.and.dxs[i] = (mpc_dtor_t)mpc_ast_delete; }
       free(t->data.and.xs); free(t->data.and.dxs); free(t->name); free(t);
       continue;
     }
  
     /* Merge ast rhs `and` */
     if (p->type == MPC_TYPE_AND
     &&  p->data.and.f == mpcf_fold_ast
     &&  p->data.and.xs[p->data.and.n-1]->type == MPC_TYPE_AND
     && !p->data.and.xs[p->data.and.n-1]->retained
     &&  p->data.and.xs[p->data.and.n-1]->data.and.f == mpcf_fold_ast) {
       t = p->data.and.xs[p->data.and.n-1];
       n = p->data.and.n; m = t->data.and.n;
       p->data.and.n = n + m - 1;
       p->data.and.xs = realloc(p->data.and.xs, sizeof(mpc_parser_t*) * (n + m -1));
       p->data.and.dxs = realloc(p->data.and.dxs, sizeof(mpc_dtor_t) * (n + m - 1 - 1));
       memmove(p->data.and.xs + n - 1, t->data.and.xs, m * sizeof(mpc_parser_t*));
       for (i = 0; i < p->data.and.n-1; i++) { p->data.and.dxs[i] = (mpc_dtor_t)mpc_ast_delete; }
       free(t->data.and.xs); free(t->data.and.dxs); free(t->name); free(t);
       continue;
     }
  
     /* Remove re `lift` */
     if (p->type == MPC_TYPE_AND
     &&  p->data.and.n == 2
     &&  p->data.and.xs[0]->type == MPC_TYPE_LIFT
     &&  p->data.and.xs[0]->data.lift.lf == mpcf_ctor_str
     && !p->data.and.xs[0]->retained
     &&  p->data.and.f == mpcf_strfold) {
       t = p->data.and.xs[1];
       mpc_delete(p->data.and.xs[0]);
       free(p->data.and.xs); free(p->data.and.dxs); free(p->name);
       memcpy(p, t, sizeof(mpc_parser_t));
       free(t);
       continue;
     }
  
     /* Merge re lhs `and` */
     if (p->type == MPC_TYPE_AND
     &&  p->data.and.f == mpcf_strfold
     &&  p->data.and.xs[0]->type == MPC_TYPE_AND
     && !p->data.and.xs[0]->retained
     &&  p->data.and.xs[0]->data.and.f == mpcf_strfold) {
       t = p->data.and.xs[0];
       n = p->data.and.n; m = t->data.and.n;
       p->data.and.n = n + m - 1;
       p->data.and.xs = realloc(p->data.and.xs, sizeof(mpc_parser_t*) * (n + m - 1));
       p->data.and.dxs = realloc(p->data.and.dxs, sizeof(mpc_dtor_t) * (n + m - 1 - 1));
       memmove(p->data.and.xs + m, p->data.and.xs + 1, (n - 1) * sizeof(mpc_parser_t*));
       memmove(p->data.and.xs, t->data.and.xs, m * sizeof(mpc_parser_t*));
       for (i = 0; i < p->data.and.n-1; i++) { p->data.and.dxs[i] = free; }
       free(t->data.and.xs); free(t->data.and.dxs); free(t->name); free(t);
       continue;
     }
  
     /* Merge re rhs `and` */
     if (p->type == MPC_TYPE_AND
     &&  p->data.and.f == mpcf_strfold
     &&  p->data.and.xs[p->data.and.n-1]->type == MPC_TYPE_AND
     && !p->data.and.xs[p->data.and.n-1]->retained
     &&  p->data.and.xs[p->data.and.n-1]->data.and.f == mpcf_strfold) {
       t = p->data.and.xs[p->data.and.n-1];
       n = p->data.and.n; m = t->data.and.n;
       p->data.and.n = n + m - 1;
       p->data.and.xs = realloc(p->data.and.xs, sizeof(mpc_parser_t*) * (n + m -1));
       p->data.and.dxs = realloc(p->data.and.dxs, sizeof(mpc_dtor_t) * (n + m - 1 - 1));
       memmove(p->data.and.xs + n - 1, t->data.and.xs, m * sizeof(mpc_parser_t*));
       for (i = 0; i < p->data.and.n-1; i++) { p->data.and.dxs[i] = free; }
       free(t->data.and.xs); free(t->data.and.dxs); free(t->name); free(t);
       continue;
     }
  
     return;
  
   }
  
 }

References mpc_pdata_t::and, mpc_parser_t::data, mpc_pdata_and_t::dxs, free(), i, regress::m, memcpy(), mpc_ast_delete(), mpc_delete(), MPC_TYPE_AND, MPC_TYPE_APPLY, MPC_TYPE_APPLY_TO, MPC_TYPE_CHECK, MPC_TYPE_CHECK_WITH, MPC_TYPE_COUNT, MPC_TYPE_EXPECT, MPC_TYPE_LIFT, MPC_TYPE_MANY, MPC_TYPE_MANY1, MPC_TYPE_MAYBE, MPC_TYPE_NOT, MPC_TYPE_OR, MPC_TYPE_PASS, MPC_TYPE_PREDICT, mpcf_ctor_str(), mpcf_fold_ast(), mpcf_strfold(), n, mpc_pdata_or_t::n, mpc_pdata_and_t::n, mpc_parser_t::name, mpc_pdata_t::or, p, realloc(), mpc_pdata_or_t::xs, and mpc_pdata_and_t::xs.

Referenced by mpc_optimise().

◆ mpc_or()

mpc_parser_t* mpc_or	(	int	n,
			...
	)

Definition at line 1928 of file mpc.c.

                                  {
  
   int i;
   va_list va;
  
   mpc_parser_t *p = mpc_undefined();
  
   p->type = MPC_TYPE_OR;
   p->data.or.n = n;
   p->data.or.xs = malloc(sizeof(mpc_parser_t*) * n);
  
   va_start(va, n);
   for (i = 0; i < n; i++) {
     p->data.or.xs[i] = va_arg(va, mpc_parser_t*);
   }
   va_end(va);
  
   return p;
 }

References i, malloc(), MPC_TYPE_OR, mpc_undefined(), n, and p.

Referenced by mpc_alphanum(), mpc_char_lit(), mpc_ident(), mpc_number(), mpc_re_mode(), mpc_regex_lit(), mpc_string_lit(), mpca_grammar_st(), mpca_lang_st(), mpcf_re_escape(), and mpcf_re_or().

◆ mpc_parens()

mpc_parser_t* mpc_parens	(	mpc_parser_t *	a,
		mpc_dtor_t	ad
	)

Definition at line 2099 of file mpc.c.

2099 { return mpc_between(a, ad, "(", ")"); }

References a, and mpc_between().

Referenced by mpc_re_mode().

◆ mpc_parse()

int mpc_parse	(	const char *	filename,
		const char *	string,
		mpc_parser_t *	p,
		mpc_result_t *	r
	)

Definition at line 1321 of file mpc.c.

                                                                                           {
   int x;
   mpc_input_t *i = mpc_input_new_string(filename, string);
   x = mpc_parse_input(i, p, r);
   mpc_input_delete(i);
   return x;
 }

References i, mpc_input_delete(), mpc_input_new_string(), mpc_parse_input(), p, r, and x.

Referenced by mpc_re_mode(), mpc_test_fail(), mpc_test_pass(), and mpca_grammar_st().

◆ mpc_parse_apply()

static mpc_val_t* mpc_parse_apply	(	mpc_input_t *	i,
		mpc_apply_t	f,
		mpc_val_t *	x
	)

static

Definition at line 1020 of file mpc.c.

                                                                                {
   if (f == mpcf_free)     { return mpcf_input_free(i, x); }
   if (f == mpcf_str_ast)  { return mpcf_input_str_ast(i, x); }
   return f(mpc_export(i, x));
 }

References f, i, mpc_export(), mpcf_free(), mpcf_input_free(), mpcf_input_str_ast(), mpcf_str_ast(), and x.

Referenced by mpc_parse_run().

◆ mpc_parse_apply_to()

static mpc_val_t* mpc_parse_apply_to	(	mpc_input_t *	i,
		mpc_apply_to_t	f,
		mpc_val_t *	x,
		mpc_val_t *	d
	)

static

Definition at line 1026 of file mpc.c.

                                                                                                    {
   return f(mpc_export(i, x), d);
 }

References d, f, i, mpc_export(), and x.

Referenced by mpc_parse_run().

◆ mpc_parse_contents()

int mpc_parse_contents	(	const char *	filename,
		mpc_parser_t *	p,
		mpc_result_t *	r
	)

Definition at line 1353 of file mpc.c.

                                                                                {
  
   FILE *f = fopen(filename, "rb");
   int res;
  
   if (f == NULL) {
     r->output = NULL;
     r->error = mpc_err_file(filename, "Unable to open file!");
     return 0;
   }
  
   res = mpc_parse_file(filename, f, p, r);
   fclose(f);
   return res;
 }

References f, benchmark::FILE, mpc_err_file(), mpc_parse_file(), NULL, p, and r.

Referenced by main().

◆ mpc_parse_dtor()

static void mpc_parse_dtor	(	mpc_input_t *	i,
		mpc_dtor_t	d,
		mpc_val_t *	x
	)

static

Definition at line 1030 of file mpc.c.

                                                                        {
   if (d == free) { mpc_free(i, x); return; }
   d(mpc_export(i, x));
 }

References d, free(), i, mpc_export(), mpc_free(), and x.

Referenced by mpc_parse_run().

◆ mpc_parse_file()

int mpc_parse_file	(	const char *	filename,
		FILE *	file,
		mpc_parser_t *	p,
		mpc_result_t *	r
	)

Definition at line 1337 of file mpc.c.

                                                                                        {
   int x;
   mpc_input_t *i = mpc_input_new_file(filename, file);
   x = mpc_parse_input(i, p, r);
   mpc_input_delete(i);
   return x;
 }

References i, mpc_input_delete(), mpc_input_new_file(), mpc_parse_input(), p, r, and x.

Referenced by mpc_parse_contents().

◆ mpc_parse_fold()

static mpc_val_t* mpc_parse_fold	(	mpc_input_t *	i,
		mpc_fold_t	f,
		int	n,
		mpc_val_t **	xs
	)

static

Definition at line 994 of file mpc.c.

                                                                                       {
   int j;
   if (f == mpcf_null)      { return mpcf_null(n, xs); }
   if (f == mpcf_fst)       { return mpcf_fst(n, xs); }
   if (f == mpcf_snd)       { return mpcf_snd(n, xs); }
   if (f == mpcf_trd)       { return mpcf_trd(n, xs); }
   if (f == mpcf_fst_free)  { return mpcf_input_fst_free(i, n, xs); }
   if (f == mpcf_snd_free)  { return mpcf_input_snd_free(i, n, xs); }
   if (f == mpcf_trd_free)  { return mpcf_input_trd_free(i, n, xs); }
   if (f == mpcf_strfold)   { return mpcf_input_strfold(i, n, xs); }
   if (f == mpcf_state_ast) { return mpcf_input_state_ast(i, n, xs); }
   for (j = 0; j < n; j++) { xs[j] = mpc_export(i, xs[j]); }
   return f(j, xs);
 }

References f, i, mpc_export(), mpcf_fst(), mpcf_fst_free(), mpcf_input_fst_free(), mpcf_input_snd_free(), mpcf_input_state_ast(), mpcf_input_strfold(), mpcf_input_trd_free(), mpcf_null(), mpcf_snd(), mpcf_snd_free(), mpcf_state_ast(), mpcf_strfold(), mpcf_trd(), mpcf_trd_free(), and n.

Referenced by mpc_parse_run().

◆ mpc_parse_input()

int mpc_parse_input	(	mpc_input_t *	i,
		mpc_parser_t *	p,
		mpc_result_t *	r
	)

Definition at line 1307 of file mpc.c.

                                                                       {
   int x;
   mpc_err_t *e = mpc_err_fail(i, "Unknown Error");
   e->state = mpc_state_invalid();
   x = mpc_parse_run(i, p, r, &e, 0);
   if (x) {
     mpc_err_delete_internal(i, e);
     r->output = mpc_export(i, r->output);
   } else {
     r->error = mpc_err_export(i, mpc_err_merge(i, e, r->error));
   }
   return x;
 }

References e, i, mpc_err_delete_internal(), mpc_err_export(), mpc_err_fail(), mpc_err_merge(), mpc_export(), mpc_parse_run(), mpc_state_invalid(), p, r, and x.

Referenced by mpc_nparse(), mpc_parse(), mpc_parse_file(), mpc_parse_pipe(), and mpca_lang_st().

◆ mpc_parse_pipe()

int mpc_parse_pipe	(	const char *	filename,
		FILE *	pipe,
		mpc_parser_t *	p,
		mpc_result_t *	r
	)

Definition at line 1345 of file mpc.c.

                                                                                        {
   int x;
   mpc_input_t *i = mpc_input_new_pipe(filename, pipe);
   x = mpc_parse_input(i, p, r);
   mpc_input_delete(i);
   return x;
 }

References i, mpc_input_delete(), mpc_input_new_pipe(), mpc_parse_input(), p, pipe, r, and x.

Referenced by main().

◆ mpc_parse_run()

static int mpc_parse_run	(	mpc_input_t *	i,
		mpc_parser_t *	p,
		mpc_result_t *	r,
		mpc_err_t **	e,
		int	depth
	)

static

Definition at line 1047 of file mpc.c.

                                                                                                      {
  
   int j = 0, k = 0;
   mpc_result_t results_stk[MPC_PARSE_STACK_MIN];
   mpc_result_t *results;
   int results_slots = MPC_PARSE_STACK_MIN;
  
   if (depth == MPC_MAX_RECURSION_DEPTH)
   {
     MPC_FAILURE(mpc_err_fail(i, "Maximum recursion depth exceeded!"));
   }
  
   switch (p->type) {
  
     /* Basic Parsers */
  
     case MPC_TYPE_ANY:     MPC_PRIMITIVE(mpc_input_any(i, (char**)&r->output));
     case MPC_TYPE_SINGLE:  MPC_PRIMITIVE(mpc_input_char(i, p->data.single.x, (char**)&r->output));
     case MPC_TYPE_RANGE:   MPC_PRIMITIVE(mpc_input_range(i, p->data.range.x, p->data.range.y, (char**)&r->output));
     case MPC_TYPE_ONEOF:   MPC_PRIMITIVE(mpc_input_oneof(i, p->data.string.x, (char**)&r->output));
     case MPC_TYPE_NONEOF:  MPC_PRIMITIVE(mpc_input_noneof(i, p->data.string.x, (char**)&r->output));
     case MPC_TYPE_SATISFY: MPC_PRIMITIVE(mpc_input_satisfy(i, p->data.satisfy.f, (char**)&r->output));
     case MPC_TYPE_STRING:  MPC_PRIMITIVE(mpc_input_string(i, p->data.string.x, (char**)&r->output));
     case MPC_TYPE_ANCHOR:  MPC_PRIMITIVE(mpc_input_anchor(i, p->data.anchor.f, (char**)&r->output));
     case MPC_TYPE_SOI:     MPC_PRIMITIVE(mpc_input_soi(i, (char**)&r->output));
     case MPC_TYPE_EOI:     MPC_PRIMITIVE(mpc_input_eoi(i, (char**)&r->output));
  
     /* Other parsers */
  
     case MPC_TYPE_UNDEFINED: MPC_FAILURE(mpc_err_fail(i, "Parser Undefined!"));
     case MPC_TYPE_PASS:      MPC_SUCCESS(NULL);
     case MPC_TYPE_FAIL:      MPC_FAILURE(mpc_err_fail(i, p->data.fail.m));
     case MPC_TYPE_LIFT:      MPC_SUCCESS(p->data.lift.lf());
     case MPC_TYPE_LIFT_VAL:  MPC_SUCCESS(p->data.lift.x);
     case MPC_TYPE_STATE:     MPC_SUCCESS(mpc_input_state_copy(i));
  
     /* Application Parsers */
  
     case MPC_TYPE_APPLY:
       if (mpc_parse_run(i, p->data.apply.x, r, e, depth+1)) {
         MPC_SUCCESS(mpc_parse_apply(i, p->data.apply.f, r->output));
       } else {
         MPC_FAILURE(r->output);
       }
  
     case MPC_TYPE_APPLY_TO:
       if (mpc_parse_run(i, p->data.apply_to.x, r, e, depth+1)) {
         MPC_SUCCESS(mpc_parse_apply_to(i, p->data.apply_to.f, r->output, p->data.apply_to.d));
       } else {
         MPC_FAILURE(r->error);
       }
  
     case MPC_TYPE_CHECK:
       if (mpc_parse_run(i, p->data.check.x, r, e, depth+1)) {
         if (p->data.check.f(&r->output)) {
           MPC_SUCCESS(r->output);
         } else {
           mpc_parse_dtor(i, p->data.check.dx, r->output);
           MPC_FAILURE(mpc_err_fail(i, p->data.check.e));
         }
       } else {
         MPC_FAILURE(r->error);
       }
  
     case MPC_TYPE_CHECK_WITH:
       if (mpc_parse_run(i, p->data.check_with.x, r, e, depth+1)) {
         if (p->data.check_with.f(&r->output, p->data.check_with.d)) {
           MPC_SUCCESS(r->output);
         } else {
           mpc_parse_dtor(i, p->data.check.dx, r->output);
           MPC_FAILURE(mpc_err_fail(i, p->data.check_with.e));
         }
       } else {
         MPC_FAILURE(r->error);
       }
  
     case MPC_TYPE_EXPECT:
       mpc_input_suppress_enable(i);
       if (mpc_parse_run(i, p->data.expect.x, r, e, depth+1)) {
         mpc_input_suppress_disable(i);
         MPC_SUCCESS(r->output);
       } else {
         mpc_input_suppress_disable(i);
         MPC_FAILURE(mpc_err_new(i, p->data.expect.m));
       }
  
     case MPC_TYPE_PREDICT:
       mpc_input_backtrack_disable(i);
       if (mpc_parse_run(i, p->data.predict.x, r, e, depth+1)) {
         mpc_input_backtrack_enable(i);
         MPC_SUCCESS(r->output);
       } else {
         mpc_input_backtrack_enable(i);
         MPC_FAILURE(r->error);
       }
  
     /* Optional Parsers */
  
     /* TODO: Update Not Error Message */
  
     case MPC_TYPE_NOT:
       mpc_input_mark(i);
       mpc_input_suppress_enable(i);
       if (mpc_parse_run(i, p->data.not.x, r, e, depth+1)) {
         mpc_input_rewind(i);
         mpc_input_suppress_disable(i);
         mpc_parse_dtor(i, p->data.not.dx, r->output);
         MPC_FAILURE(mpc_err_new(i, "opposite"));
       } else {
         mpc_input_unmark(i);
         mpc_input_suppress_disable(i);
         MPC_SUCCESS(p->data.not.lf());
       }
  
     case MPC_TYPE_MAYBE:
       if (mpc_parse_run(i, p->data.not.x, r, e, depth+1)) {
         MPC_SUCCESS(r->output);
       } else {
         *e = mpc_err_merge(i, *e, r->error);
         MPC_SUCCESS(p->data.not.lf());
       }
  
     /* Repeat Parsers */
  
     case MPC_TYPE_MANY:
  
       results = results_stk;
  
       while (mpc_parse_run(i, p->data.repeat.x, &results[j], e, depth+1)) {
         j++;
         if (j == MPC_PARSE_STACK_MIN) {
           results_slots = j + j / 2;
           results = mpc_malloc(i, sizeof(mpc_result_t) * results_slots);
           memcpy(results, results_stk, sizeof(mpc_result_t) * MPC_PARSE_STACK_MIN);
         } else if (j >= results_slots) {
           results_slots = j + j / 2;
           results = mpc_realloc(i, results, sizeof(mpc_result_t) * results_slots);
         }
       }
  
       *e = mpc_err_merge(i, *e, results[j].error);
  
       MPC_SUCCESS(
         mpc_parse_fold(i, p->data.repeat.f, j, (mpc_val_t**)results);
         if (j >= MPC_PARSE_STACK_MIN) { mpc_free(i, results); });
  
     case MPC_TYPE_MANY1:
  
       results = results_stk;
  
       while (mpc_parse_run(i, p->data.repeat.x, &results[j], e, depth+1)) {
         j++;
         if (j == MPC_PARSE_STACK_MIN) {
           results_slots = j + j / 2;
           results = mpc_malloc(i, sizeof(mpc_result_t) * results_slots);
           memcpy(results, results_stk, sizeof(mpc_result_t) * MPC_PARSE_STACK_MIN);
         } else if (j >= results_slots) {
           results_slots = j + j / 2;
           results = mpc_realloc(i, results, sizeof(mpc_result_t) * results_slots);
         }
       }
  
       if (j == 0) {
         MPC_FAILURE(
           mpc_err_many1(i, results[j].error);
           if (j >= MPC_PARSE_STACK_MIN) { mpc_free(i, results); });
       } else {
  
         *e = mpc_err_merge(i, *e, results[j].error);
  
         MPC_SUCCESS(
           mpc_parse_fold(i, p->data.repeat.f, j, (mpc_val_t**)results);
           if (j >= MPC_PARSE_STACK_MIN) { mpc_free(i, results); });
       }
  
     case MPC_TYPE_COUNT:
  
       results = p->data.repeat.n > MPC_PARSE_STACK_MIN
         ? mpc_malloc(i, sizeof(mpc_result_t) * p->data.repeat.n)
         : results_stk;
  
       while (mpc_parse_run(i, p->data.repeat.x, &results[j], e, depth+1)) {
         j++;
         if (j == p->data.repeat.n) { break; }
       }
  
       if (j == p->data.repeat.n) {
         MPC_SUCCESS(
           mpc_parse_fold(i, p->data.repeat.f, j, (mpc_val_t**)results);
           if (p->data.repeat.n > MPC_PARSE_STACK_MIN) { mpc_free(i, results); });
       } else {
         for (k = 0; k < j; k++) {
           mpc_parse_dtor(i, p->data.repeat.dx, results[k].output);
         }
         MPC_FAILURE(
           mpc_err_count(i, results[j].error, p->data.repeat.n);
           if (p->data.repeat.n > MPC_PARSE_STACK_MIN) { mpc_free(i, results); });
       }
  
     /* Combinatory Parsers */
  
     case MPC_TYPE_OR:
  
       if (p->data.or.n == 0) { MPC_SUCCESS(NULL); }
  
       results = p->data.or.n > MPC_PARSE_STACK_MIN
         ? mpc_malloc(i, sizeof(mpc_result_t) * p->data.or.n)
         : results_stk;
  
       for (j = 0; j < p->data.or.n; j++) {
         if (mpc_parse_run(i, p->data.or.xs[j], &results[j], e, depth+1)) {
           MPC_SUCCESS(results[j].output;
             if (p->data.or.n > MPC_PARSE_STACK_MIN) { mpc_free(i, results); });
         } else {
           *e = mpc_err_merge(i, *e, results[j].error);
         }
       }
  
       MPC_FAILURE(NULL;
         if (p->data.or.n > MPC_PARSE_STACK_MIN) { mpc_free(i, results); });
  
     case MPC_TYPE_AND:
  
       if (p->data.and.n == 0) { MPC_SUCCESS(NULL); }
  
       results = p->data.or.n > MPC_PARSE_STACK_MIN
         ? mpc_malloc(i, sizeof(mpc_result_t) * p->data.or.n)
         : results_stk;
  
       mpc_input_mark(i);
       for (j = 0; j < p->data.and.n; j++) {
         if (!mpc_parse_run(i, p->data.and.xs[j], &results[j], e, depth+1)) {
           mpc_input_rewind(i);
           for (k = 0; k < j; k++) {
             mpc_parse_dtor(i, p->data.and.dxs[k], results[k].output);
           }
           MPC_FAILURE(results[j].error;
             if (p->data.or.n > MPC_PARSE_STACK_MIN) { mpc_free(i, results); });
         }
       }
       mpc_input_unmark(i);
       MPC_SUCCESS(
         mpc_parse_fold(i, p->data.and.f, j, (mpc_val_t**)results);
         if (p->data.or.n > MPC_PARSE_STACK_MIN) { mpc_free(i, results); });
  
     /* End */
  
     default:
  
       MPC_FAILURE(mpc_err_fail(i, "Unknown Parser Type Id!"));
   }
  
   return 0;
  
 }

References e, error(), i, if(), k, memcpy(), mpc_err_count(), mpc_err_fail(), mpc_err_many1(), mpc_err_merge(), mpc_err_new(), MPC_FAILURE, mpc_free(), mpc_input_anchor(), mpc_input_any(), mpc_input_backtrack_disable(), mpc_input_backtrack_enable(), mpc_input_char(), mpc_input_eoi(), mpc_input_mark(), mpc_input_noneof(), mpc_input_oneof(), mpc_input_range(), mpc_input_rewind(), mpc_input_satisfy(), mpc_input_soi(), mpc_input_state_copy(), mpc_input_string(), mpc_input_suppress_disable(), mpc_input_suppress_enable(), mpc_input_unmark(), mpc_malloc(), MPC_MAX_RECURSION_DEPTH, mpc_parse_apply(), mpc_parse_apply_to(), mpc_parse_dtor(), mpc_parse_fold(), MPC_PARSE_STACK_MIN, MPC_PRIMITIVE, mpc_realloc(), MPC_SUCCESS, MPC_TYPE_ANCHOR, MPC_TYPE_AND, MPC_TYPE_ANY, MPC_TYPE_APPLY, MPC_TYPE_APPLY_TO, MPC_TYPE_CHECK, MPC_TYPE_CHECK_WITH, MPC_TYPE_COUNT, MPC_TYPE_EOI, MPC_TYPE_EXPECT, MPC_TYPE_FAIL, MPC_TYPE_LIFT, MPC_TYPE_LIFT_VAL, MPC_TYPE_MANY, MPC_TYPE_MANY1, MPC_TYPE_MAYBE, MPC_TYPE_NONEOF, MPC_TYPE_NOT, MPC_TYPE_ONEOF, MPC_TYPE_OR, MPC_TYPE_PASS, MPC_TYPE_PREDICT, MPC_TYPE_RANGE, MPC_TYPE_SATISFY, MPC_TYPE_SINGLE, MPC_TYPE_SOI, MPC_TYPE_STATE, MPC_TYPE_STRING, MPC_TYPE_UNDEFINED, NULL, output, p, and r.

Referenced by mpc_parse_input().

◆ mpc_pass()

mpc_parser_t* mpc_pass ( void )

Definition at line 1610 of file mpc.c.

                              {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_PASS;
   return p;
 }

References MPC_TYPE_PASS, mpc_undefined(), and p.

Referenced by mpc_re_mode(), mpca_grammar_st(), mpca_lang_st(), and mpcaf_grammar_and().

◆ mpc_predictive()

mpc_parser_t* mpc_predictive ( mpc_parser_t * a )

Definition at line 1870 of file mpc.c.

                                               {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_PREDICT;
   p->data.predict.x = a;
   return p;
 }

References a, MPC_TYPE_PREDICT, mpc_undefined(), and p.

Referenced by mpc_re_mode(), mpca_grammar_st(), mpca_lang_st(), and mpca_stmt_list_apply_to().

◆ mpc_print()

void mpc_print ( mpc_parser_t * p )

Definition at line 2811 of file mpc.c.

                                 {
   mpc_print_unretained(p, 1);
   printf("\n");
 }

References mpc_print_unretained(), p, and printf().

◆ mpc_print_unretained()

static void mpc_print_unretained	(	mpc_parser_t *	p,
		int	force
	)

static

Definition at line 2688 of file mpc.c.

                                                              {
  
   /* TODO: Print Everything Escaped */
  
   int i;
   char *s, *e;
   char buff[2];
  
   if (p->retained && !force) {;
     if (p->name) { printf("<%s>", p->name); }
     else { printf("<anon>"); }
     return;
   }
  
   if (p->type == MPC_TYPE_UNDEFINED) { printf("<?>"); }
   if (p->type == MPC_TYPE_PASS)   { printf("<:>"); }
   if (p->type == MPC_TYPE_FAIL)   { printf("<!>"); }
   if (p->type == MPC_TYPE_LIFT)   { printf("<#>"); }
   if (p->type == MPC_TYPE_STATE)  { printf("<S>"); }
   if (p->type == MPC_TYPE_ANCHOR) { printf("<@>"); }
   if (p->type == MPC_TYPE_EXPECT) {
     printf("%s", p->data.expect.m);
     /*mpc_print_unretained(p->data.expect.x, 0);*/
   }
  
   if (p->type == MPC_TYPE_ANY) { printf("<.>"); }
   if (p->type == MPC_TYPE_SATISFY) { printf("<f>"); }
  
   if (p->type == MPC_TYPE_SINGLE) {
     buff[0] = p->data.single.x; buff[1] = '\0';
     s = mpcf_escape_new(
       buff,
       mpc_escape_input_c,
       mpc_escape_output_c);
     printf("'%s'", s);
     free(s);
   }
  
   if (p->type == MPC_TYPE_RANGE) {
     buff[0] = p->data.range.x; buff[1] = '\0';
     s = mpcf_escape_new(
       buff,
       mpc_escape_input_c,
       mpc_escape_output_c);
     buff[0] = p->data.range.y; buff[1] = '\0';
     e = mpcf_escape_new(
       buff,
       mpc_escape_input_c,
       mpc_escape_output_c);
     printf("[%s-%s]", s, e);
     free(s);
     free(e);
   }
  
   if (p->type == MPC_TYPE_ONEOF) {
     s = mpcf_escape_new(
       p->data.string.x,
       mpc_escape_input_c,
       mpc_escape_output_c);
     printf("[%s]", s);
     free(s);
   }
  
   if (p->type == MPC_TYPE_NONEOF) {
     s = mpcf_escape_new(
       p->data.string.x,
       mpc_escape_input_c,
       mpc_escape_output_c);
     printf("[^%s]", s);
     free(s);
   }
  
   if (p->type == MPC_TYPE_STRING) {
     s = mpcf_escape_new(
       p->data.string.x,
       mpc_escape_input_c,
       mpc_escape_output_c);
     printf("\"%s\"", s);
     free(s);
   }
  
   if (p->type == MPC_TYPE_APPLY)    { mpc_print_unretained(p->data.apply.x, 0); }
   if (p->type == MPC_TYPE_APPLY_TO) { mpc_print_unretained(p->data.apply_to.x, 0); }
   if (p->type == MPC_TYPE_PREDICT)  { mpc_print_unretained(p->data.predict.x, 0); }
  
   if (p->type == MPC_TYPE_NOT)   { mpc_print_unretained(p->data.not.x, 0); printf("!"); }
   if (p->type == MPC_TYPE_MAYBE) { mpc_print_unretained(p->data.not.x, 0); printf("?"); }
  
   if (p->type == MPC_TYPE_MANY)  { mpc_print_unretained(p->data.repeat.x, 0); printf("*"); }
   if (p->type == MPC_TYPE_MANY1) { mpc_print_unretained(p->data.repeat.x, 0); printf("+"); }
   if (p->type == MPC_TYPE_COUNT) { mpc_print_unretained(p->data.repeat.x, 0); printf("{%i}", p->data.repeat.n); }
  
   if (p->type == MPC_TYPE_OR) {
     printf("(");
     for(i = 0; i < p->data.or.n-1; i++) {
       mpc_print_unretained(p->data.or.xs[i], 0);
       printf(" | ");
     }
     mpc_print_unretained(p->data.or.xs[p->data.or.n-1], 0);
     printf(")");
   }
  
   if (p->type == MPC_TYPE_AND) {
     printf("(");
     for(i = 0; i < p->data.and.n-1; i++) {
       mpc_print_unretained(p->data.and.xs[i], 0);
       printf(" ");
     }
     mpc_print_unretained(p->data.and.xs[p->data.and.n-1], 0);
     printf(")");
   }
  
   if (p->type == MPC_TYPE_CHECK) {
     mpc_print_unretained(p->data.check.x, 0);
     printf("->?");
   }
   if (p->type == MPC_TYPE_CHECK_WITH) {
     mpc_print_unretained(p->data.check_with.x, 0);
     printf("->?");
   }
  
 }

References e, free(), i, mpc_escape_input_c, mpc_escape_output_c, MPC_TYPE_ANCHOR, MPC_TYPE_AND, MPC_TYPE_ANY, MPC_TYPE_APPLY, MPC_TYPE_APPLY_TO, MPC_TYPE_CHECK, MPC_TYPE_CHECK_WITH, MPC_TYPE_COUNT, MPC_TYPE_EXPECT, MPC_TYPE_FAIL, MPC_TYPE_LIFT, MPC_TYPE_MANY, MPC_TYPE_MANY1, MPC_TYPE_MAYBE, MPC_TYPE_NONEOF, MPC_TYPE_NOT, MPC_TYPE_ONEOF, MPC_TYPE_OR, MPC_TYPE_PASS, MPC_TYPE_PREDICT, MPC_TYPE_RANGE, MPC_TYPE_SATISFY, MPC_TYPE_SINGLE, MPC_TYPE_STATE, MPC_TYPE_STRING, MPC_TYPE_UNDEFINED, mpcf_escape_new(), p, printf(), and s.

Referenced by mpc_print().

◆ mpc_range()

mpc_parser_t* mpc_range	(	char	s,
		char	e
	)

Definition at line 1754 of file mpc.c.

                                         {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_RANGE;
   p->data.range.x = s;
   p->data.range.y = e;
   return mpc_expectf(p, "character between '%c' and '%c'", s, e);
 }

References e, mpc_expectf(), MPC_TYPE_RANGE, mpc_undefined(), p, and s.

◆ mpc_re()

mpc_parser_t* mpc_re ( const char * re )

Definition at line 2353 of file mpc.c.

                                      {
   return mpc_re_mode(re, MPC_RE_DEFAULT);
 }

References MPC_RE_DEFAULT, and mpc_re_mode().

◆ mpc_re_escape_char()

static mpc_parser_t* mpc_re_escape_char ( char c )

static

Definition at line 2197 of file mpc.c.

                                                 {
   switch (c) {
     case 'a': return mpc_char('\a');
     case 'f': return mpc_char('\f');
     case 'n': return mpc_char('\n');
     case 'r': return mpc_char('\r');
     case 't': return mpc_char('\t');
     case 'v': return mpc_char('\v');
     case 'b': return mpc_and(2, mpcf_snd, mpc_boundary(), mpc_lift(mpcf_ctor_str), free);
     case 'B': return mpc_not_lift(mpc_boundary(), free, mpcf_ctor_str);
     case 'A': return mpc_and(2, mpcf_snd, mpc_soi(), mpc_lift(mpcf_ctor_str), free);
     case 'Z': return mpc_and(2, mpcf_snd, mpc_eoi(), mpc_lift(mpcf_ctor_str), free);
     case 'd': return mpc_digit();
     case 'D': return mpc_not_lift(mpc_digit(), free, mpcf_ctor_str);
     case 's': return mpc_whitespace();
     case 'S': return mpc_not_lift(mpc_whitespace(), free, mpcf_ctor_str);
     case 'w': return mpc_alphanum();
     case 'W': return mpc_not_lift(mpc_alphanum(), free, mpcf_ctor_str);
     default: return NULL;
   }
 }

References c, free(), mpc_alphanum(), mpc_and(), mpc_boundary(), mpc_char(), mpc_digit(), mpc_eoi(), mpc_lift(), mpc_not_lift(), mpc_soi(), mpc_whitespace(), mpcf_ctor_str(), mpcf_snd(), and NULL.

Referenced by mpcf_re_escape().

◆ mpc_re_mode()

mpc_parser_t* mpc_re_mode	(	const char *	re,
		int	mode
	)

Definition at line 2357 of file mpc.c.

                                                     {
  
   char *err_msg;
   mpc_parser_t *err_out;
   mpc_result_t r;
   mpc_parser_t *Regex, *Term, *Factor, *Base, *Range, *RegexEnclose;
  
   Regex  = mpc_new("regex");
   Term   = mpc_new("term");
   Factor = mpc_new("factor");
   Base   = mpc_new("base");
   Range  = mpc_new("range");
  
   mpc_define(Regex, mpc_and(2, mpcf_re_or,
     Term,
     mpc_maybe(mpc_and(2, mpcf_snd_free, mpc_char('|'), Regex, free)),
     (mpc_dtor_t)mpc_delete
   ));
  
   mpc_define(Term, mpc_many(mpcf_re_and, Factor));
  
   mpc_define(Factor, mpc_and(2, mpcf_re_repeat,
     Base,
     mpc_or(5,
       mpc_char('*'), mpc_char('+'), mpc_char('?'),
       mpc_brackets(mpc_int(), free),
       mpc_pass()),
     (mpc_dtor_t)mpc_delete
   ));
  
   mpc_define(Base, mpc_or(4,
     mpc_parens(Regex, (mpc_dtor_t)mpc_delete),
     mpc_squares(Range, (mpc_dtor_t)mpc_delete),
     mpc_apply_to(mpc_escape(), mpcf_re_escape, &mode),
     mpc_apply_to(mpc_noneof(")|"), mpcf_re_escape, &mode)
   ));
  
   mpc_define(Range, mpc_apply(
     mpc_many(mpcf_strfold, mpc_or(2, mpc_escape(), mpc_noneof("]"))),
     mpcf_re_range
   ));
  
   RegexEnclose = mpc_whole(mpc_predictive(Regex), (mpc_dtor_t)mpc_delete);
  
   mpc_optimise(RegexEnclose);
   mpc_optimise(Regex);
   mpc_optimise(Term);
   mpc_optimise(Factor);
   mpc_optimise(Base);
   mpc_optimise(Range);
  
   if(!mpc_parse("<mpc_re_compiler>", re, RegexEnclose, &r)) {
     err_msg = mpc_err_string(r.error);
     err_out = mpc_failf("Invalid Regex: %s", err_msg);
     mpc_err_delete(r.error);
     free(err_msg);
     r.output = err_out;
   }
  
   mpc_cleanup(6, RegexEnclose, Regex, Term, Factor, Base, Range);
  
   mpc_optimise(r.output);
  
   return r.output;
  
 }

References free(), mpc_and(), mpc_apply(), mpc_apply_to(), mpc_brackets(), mpc_char(), mpc_cleanup(), mpc_define(), mpc_delete(), mpc_err_delete(), mpc_err_string(), mpc_escape(), mpc_failf(), mpc_int(), mpc_many(), mpc_maybe(), mpc_new(), mpc_noneof(), mpc_optimise(), mpc_or(), mpc_parens(), mpc_parse(), mpc_pass(), mpc_predictive(), mpc_squares(), mpc_whole(), mpcf_re_and(), mpcf_re_escape(), mpcf_re_or(), mpcf_re_range(), mpcf_re_repeat(), mpcf_snd_free(), mpcf_strfold(), and r.

Referenced by mpc_re(), and mpcaf_fold_regex().

◆ mpc_re_range_escape_char()

static const char* mpc_re_range_escape_char ( char c )

static

Definition at line 2273 of file mpc.c.

                                                     {
   switch (c) {
     case '-': return "-";
     case 'a': return "\a";
     case 'f': return "\f";
     case 'n': return "\n";
     case 'r': return "\r";
     case 't': return "\t";
     case 'v': return "\v";
     case 'b': return "\b";
     case 'd': return "0123456789";
     case 's': return " \f\n\r\t\v";
     case 'w': return "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
     default: return NULL;
   }
 }

References c, and NULL.

Referenced by mpcf_re_range().

◆ mpc_real()

mpc_parser_t* mpc_real ( void )

Definition at line 2034 of file mpc.c.

                              {
  
   /* [+-]?\d+(\.\d+)?([eE][+-]?[0-9]+)? */
  
   mpc_parser_t *p0, *p1, *p2, *p30, *p31, *p32, *p3;
  
   p0 = mpc_maybe_lift(mpc_oneof("+-"), mpcf_ctor_str);
   p1 = mpc_digits();
   p2 = mpc_maybe_lift(mpc_and(2, mpcf_strfold, mpc_char('.'), mpc_digits(), free), mpcf_ctor_str);
   p30 = mpc_oneof("eE");
   p31 = mpc_maybe_lift(mpc_oneof("+-"), mpcf_ctor_str);
   p32 = mpc_digits();
   p3 = mpc_maybe_lift(mpc_and(3, mpcf_strfold, p30, p31, p32, free, free), mpcf_ctor_str);
  
   return mpc_expect(mpc_and(4, mpcf_strfold, p0, p1, p2, p3, free, free, free), "real");
  
 }

References free(), mpc_and(), mpc_char(), mpc_digits(), mpc_expect(), mpc_maybe_lift(), mpc_oneof(), mpcf_ctor_str(), and mpcf_strfold().

Referenced by mpc_float().

◆ mpc_realloc()

static void* mpc_realloc	(	mpc_input_t *	i,
		void *	p,
		size_t	n
	)

static

Definition at line 270 of file mpc.c.

                                                             {
  
   char *q = NULL;
  
   if (!mpc_mem_ptr(i, p)) { return realloc(p, n); }
  
   if (n > sizeof(mpc_mem_t)) {
     q = malloc(n);
     memcpy(q, p, sizeof(mpc_mem_t));
     mpc_free(i, p);
     return q;
   }
  
   return p;
 }

References i, malloc(), memcpy(), mpc_free(), mpc_mem_ptr(), n, NULL, p, and realloc().

Referenced by mpc_err_add_expected(), mpc_err_repeat(), mpc_parse_run(), and mpcf_input_strfold().

◆ mpc_regex_lit()

mpc_parser_t* mpc_regex_lit ( void )

Definition at line 2065 of file mpc.c.

                                   {
   mpc_parser_t *regexchar = mpc_or(2, mpc_escape(), mpc_noneof("/"));
   return mpc_expect(mpc_between(mpc_many(mpcf_strfold, regexchar), free, "/", "/"), "regex");
 }

References free(), mpc_between(), mpc_escape(), mpc_expect(), mpc_many(), mpc_noneof(), mpc_or(), and mpcf_strfold().

Referenced by mpca_grammar_st(), and mpca_lang_st().

◆ mpc_satisfy()

mpc_parser_t* mpc_satisfy ( int(*)(char) f )

Definition at line 1779 of file mpc.c.

                                          {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_SATISFY;
   p->data.satisfy.f = f;
   return mpc_expectf(p, "character satisfying function %p", f);
 }

References f, mpc_expectf(), MPC_TYPE_SATISFY, mpc_undefined(), and p.

◆ mpc_soft_delete()

static void mpc_soft_delete ( mpc_val_t * x )

static

Definition at line 1468 of file mpc.c.

                                           {
   mpc_undefine_unretained(x, 0);
 }

References mpc_undefine_unretained(), and x.

Referenced by mpca_grammar_st(), mpca_lang_st(), and mpca_stmt_list_delete().

◆ mpc_soi()

mpc_parser_t* mpc_soi ( void )

Definition at line 1977 of file mpc.c.

                             {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_SOI;
   return mpc_expect(p, "start of input");
 }

References mpc_expect(), MPC_TYPE_SOI, mpc_undefined(), and p.

Referenced by mpc_re_escape_char(), mpc_startwith(), mpc_whole(), and mpcf_re_escape().

◆ mpc_squares()

mpc_parser_t* mpc_squares	(	mpc_parser_t *	a,
		mpc_dtor_t	ad
	)

Definition at line 2102 of file mpc.c.

2102 { return mpc_between(a, ad, "[", "]"); }

References a, and mpc_between().

Referenced by mpc_re_mode().

◆ mpc_startwith()

mpc_parser_t* mpc_startwith ( mpc_parser_t * a )

Definition at line 2081 of file mpc.c.

2081 { return mpc_and(2, mpcf_snd, mpc_soi(), a, mpcf_dtor_null); }

mpcf_dtor_null

void mpcf_dtor_null(mpc_val_t *x)

Definition: mpc.c:2428

References a, mpc_and(), mpc_soi(), mpcf_dtor_null(), and mpcf_snd().

◆ mpc_state()

mpc_parser_t* mpc_state ( void )

Definition at line 1684 of file mpc.c.

                               {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_STATE;
   return p;
 }

References MPC_TYPE_STATE, mpc_undefined(), and p.

Referenced by mpca_state().

◆ mpc_state_invalid()

static mpc_state_t mpc_state_invalid ( void )

static

Definition at line 7 of file mpc.c.

                                            {
   mpc_state_t s;
   s.pos = -1;
   s.row = -1;
   s.col = -1;
   s.term = 0;
   return s;
 }

References s.

Referenced by mpc_err_or(), and mpc_parse_input().

◆ mpc_state_new()

static mpc_state_t mpc_state_new ( void )

static

Definition at line 16 of file mpc.c.

                                        {
   mpc_state_t s;
   s.pos = 0;
   s.row = 0;
   s.col = 0;
   s.term = 0;
   return s;
 }

References s.

Referenced by mpc_ast_new(), mpc_err_file(), mpc_input_new_file(), mpc_input_new_nstring(), mpc_input_new_pipe(), and mpc_input_new_string().

◆ mpc_stats()

void mpc_stats ( mpc_parser_t * p )

Definition at line 3889 of file mpc.c.

                                 {
   printf("Stats\n");
   printf("=====\n");
   printf("Node Count: %i\n", mpc_nodecount_unretained(p, 1));
 }

References mpc_nodecount_unretained(), p, and printf().

◆ mpc_string()

mpc_parser_t* mpc_string ( const char * s )

Definition at line 1786 of file mpc.c.

                                         {
   mpc_parser_t *p = mpc_undefined();
   p->type = MPC_TYPE_STRING;
   p->data.string.x = malloc(strlen(s) + 1);
   strcpy(p->data.string.x, s);
   return mpc_expectf(p, "\"%s\"", s);
 }

References malloc(), mpc_expectf(), MPC_TYPE_STRING, mpc_undefined(), p, and s.

Referenced by mpc_between(), mpc_sym(), and mpcaf_grammar_string().

◆ mpc_string_lit()

mpc_parser_t* mpc_string_lit ( void )

Definition at line 2060 of file mpc.c.

                                    {
   mpc_parser_t *strchar = mpc_or(2, mpc_escape(), mpc_noneof("\""));
   return mpc_expect(mpc_between(mpc_many(mpcf_strfold, strchar), free, "\"", "\""), "string");
 }

References free(), mpc_between(), mpc_escape(), mpc_expect(), mpc_many(), mpc_noneof(), mpc_or(), and mpcf_strfold().

Referenced by mpca_grammar_st(), and mpca_lang_st().

◆ mpc_strip()

mpc_parser_t* mpc_strip ( mpc_parser_t * a )

Definition at line 2087 of file mpc.c.

2087 { return mpc_and(3, mpcf_snd, mpc_blank(), a, mpc_blank(), mpcf_dtor_null, mpcf_dtor_null); }

mpc_blank

mpc_parser_t * mpc_blank(void)

Definition: mpc.c:2010

References a, mpc_and(), mpc_blank(), mpcf_dtor_null(), and mpcf_snd().

Referenced by mpc_total().

◆ mpc_stripl()

mpc_parser_t* mpc_stripl ( mpc_parser_t * a )

Definition at line 2085 of file mpc.c.

2085 { return mpc_and(2, mpcf_snd, mpc_blank(), a, mpcf_dtor_null); }

References a, mpc_and(), mpc_blank(), mpcf_dtor_null(), and mpcf_snd().

◆ mpc_stripr()

mpc_parser_t* mpc_stripr ( mpc_parser_t * a )

Definition at line 2086 of file mpc.c.

2086 { return mpc_and(2, mpcf_fst, a, mpc_blank(), mpcf_dtor_null); }

References a, mpc_and(), mpc_blank(), mpcf_dtor_null(), and mpcf_fst().

◆ mpc_sym()

mpc_parser_t* mpc_sym ( const char * s )

Definition at line 2089 of file mpc.c.

2089 { return mpc_tok(mpc_string(s)); }

mpc_tok

mpc_parser_t * mpc_tok(mpc_parser_t *a)

Definition: mpc.c:2088

References mpc_string(), mpc_tok(), and s.

Referenced by mpc_tok_between(), mpca_grammar_st(), and mpca_lang_st().

◆ mpc_tab()

mpc_parser_t* mpc_tab ( void )

Definition at line 2013 of file mpc.c.

2013 { return mpc_expect(mpc_char('\t'), "tab"); }

References mpc_char(), and mpc_expect().

◆ mpc_test_fail()

int mpc_test_fail	(	mpc_parser_t *	p,
		const char *	s,
		const void *	d,
		int()(const void , const void *)	tester,
		mpc_dtor_t	destructor,
		void()(const void )	printer
	)

Definition at line 2831 of file mpc.c.

                                {
   mpc_result_t r;
   (void) printer;
   if (mpc_parse("<test>", s, p, &r)) {
  
     if (tester(r.output, d)) {
       destructor(r.output);
       return 0;
     } else {
       destructor(r.output);
       return 1;
     }
  
   } else {
     mpc_err_delete(r.error);
     return 1;
   }
  
 }

References d, mpc_err_delete(), mpc_parse(), p, r, and s.

◆ mpc_test_pass()

int mpc_test_pass	(	mpc_parser_t *	p,
		const char *	s,
		const void *	d,
		int()(const void , const void *)	tester,
		mpc_dtor_t	destructor,
		void()(const void )	printer
	)

Definition at line 2854 of file mpc.c.

                                {
  
   mpc_result_t r;
   if (mpc_parse("<test>", s, p, &r)) {
  
     if (tester(r.output, d)) {
       destructor(r.output);
       return 1;
     } else {
       printf("Got "); printer(r.output); printf("\n");
       printf("Expected "); printer(d); printf("\n");
       destructor(r.output);
       return 0;
     }
  
   } else {
     mpc_err_print(r.error);
     mpc_err_delete(r.error);
     return 0;
  
   }
  
 }

References d, mpc_err_delete(), mpc_err_print(), mpc_parse(), p, printf(), r, and s.

◆ mpc_tok()

mpc_parser_t* mpc_tok ( mpc_parser_t * a )

Definition at line 2088 of file mpc.c.

2088 { return mpc_and(2, mpcf_fst, a, mpc_blank(), mpcf_dtor_null); }

References a, mpc_and(), mpc_blank(), mpcf_dtor_null(), and mpcf_fst().

Referenced by mpc_sym(), mpc_tok_between(), mpca_grammar_st(), mpca_lang_st(), mpcaf_fold_regex(), mpcaf_grammar_char(), and mpcaf_grammar_string().

◆ mpc_tok_between()

mpc_parser_t* mpc_tok_between	(	mpc_parser_t *	a,
		mpc_dtor_t	ad,
		const char *	o,
		const char *	c
	)

Definition at line 2104 of file mpc.c.

                                                                                             {
   return mpc_and(3, mpcf_snd_free,
     mpc_sym(o), mpc_tok(a), mpc_sym(c),
     free, ad);
 }

References a, c, free(), mpc_and(), mpc_sym(), mpc_tok(), and mpcf_snd_free().

Referenced by mpc_tok_braces(), mpc_tok_brackets(), mpc_tok_parens(), and mpc_tok_squares().

◆ mpc_tok_braces()

mpc_parser_t* mpc_tok_braces	(	mpc_parser_t *	a,
		mpc_dtor_t	ad
	)

Definition at line 2111 of file mpc.c.

2111 { return mpc_tok_between(a, ad, "<", ">"); }

mpc_tok_between

mpc_parser_t * mpc_tok_between(mpc_parser_t *a, mpc_dtor_t ad, const char *o, const char *c)

Definition: mpc.c:2104

References a, and mpc_tok_between().

Referenced by mpca_grammar_st(), and mpca_lang_st().

◆ mpc_tok_brackets()

mpc_parser_t* mpc_tok_brackets	(	mpc_parser_t *	a,
		mpc_dtor_t	ad
	)

Definition at line 2112 of file mpc.c.

2112 { return mpc_tok_between(a, ad, "{", "}"); }

References a, and mpc_tok_between().

Referenced by mpca_grammar_st(), and mpca_lang_st().

◆ mpc_tok_parens()

mpc_parser_t* mpc_tok_parens	(	mpc_parser_t *	a,
		mpc_dtor_t	ad
	)

Definition at line 2110 of file mpc.c.

2110 { return mpc_tok_between(a, ad, "(", ")"); }

References a, and mpc_tok_between().

Referenced by mpca_grammar_st(), and mpca_lang_st().

◆ mpc_tok_squares()

mpc_parser_t* mpc_tok_squares	(	mpc_parser_t *	a,
		mpc_dtor_t	ad
	)

Definition at line 2113 of file mpc.c.

2113 { return mpc_tok_between(a, ad, "[", "]"); }

References a, and mpc_tok_between().

◆ mpc_total()

mpc_parser_t* mpc_total	(	mpc_parser_t *	a,
		mpc_dtor_t	da
	)

Definition at line 2091 of file mpc.c.

2091 { return mpc_whole(mpc_strip(a), da); }

mpc_strip

mpc_parser_t * mpc_strip(mpc_parser_t *a)

Definition: mpc.c:2087

References a, mpc_strip(), and mpc_whole().

Referenced by mpca_grammar_st(), mpca_lang_st(), and mpca_total().

◆ mpc_undefine()

mpc_parser_t* mpc_undefine ( mpc_parser_t * p )

Definition at line 1574 of file mpc.c.

                                             {
   mpc_undefine_unretained(p, 1);
   p->type = MPC_TYPE_UNDEFINED;
   return p;
 }

References MPC_TYPE_UNDEFINED, mpc_undefine_unretained(), and p.

Referenced by mpc_cleanup().

◆ mpc_undefine_and()

static void mpc_undefine_and ( mpc_parser_t * p )

static

Definition at line 1385 of file mpc.c.

                                               {
  
   int i;
   for (i = 0; i < p->data.and.n; i++) {
     mpc_undefine_unretained(p->data.and.xs[i], 0);
   }
   free(p->data.and.xs);
   free(p->data.and.dxs);
  
 }

References free(), i, mpc_undefine_unretained(), and p.

Referenced by mpc_undefine_unretained().

◆ mpc_undefine_or()

static void mpc_undefine_or ( mpc_parser_t * p )

static

Definition at line 1375 of file mpc.c.

                                              {
  
   int i;
   for (i = 0; i < p->data.or.n; i++) {
     mpc_undefine_unretained(p->data.or.xs[i], 0);
   }
   free(p->data.or.xs);
  
 }

References free(), i, mpc_undefine_unretained(), and p.

Referenced by mpc_undefine_unretained().

◆ mpc_undefine_unretained()

static void mpc_undefine_unretained	(	mpc_parser_t *	p,
		int	force
	)

static

Definition at line 1396 of file mpc.c.

                                                                 {
  
   if (p->retained && !force) { return; }
  
   switch (p->type) {
  
     case MPC_TYPE_FAIL: free(p->data.fail.m); break;
  
     case MPC_TYPE_ONEOF:
     case MPC_TYPE_NONEOF:
     case MPC_TYPE_STRING:
       free(p->data.string.x);
       break;
  
     case MPC_TYPE_APPLY:    mpc_undefine_unretained(p->data.apply.x, 0);    break;
     case MPC_TYPE_APPLY_TO: mpc_undefine_unretained(p->data.apply_to.x, 0); break;
     case MPC_TYPE_PREDICT:  mpc_undefine_unretained(p->data.predict.x, 0);  break;
  
     case MPC_TYPE_MAYBE:
     case MPC_TYPE_NOT:
       mpc_undefine_unretained(p->data.not.x, 0);
       break;
  
     case MPC_TYPE_EXPECT:
       mpc_undefine_unretained(p->data.expect.x, 0);
       free(p->data.expect.m);
       break;
  
     case MPC_TYPE_MANY:
     case MPC_TYPE_MANY1:
     case MPC_TYPE_COUNT:
       mpc_undefine_unretained(p->data.repeat.x, 0);
       break;
  
     case MPC_TYPE_OR:  mpc_undefine_or(p);  break;
     case MPC_TYPE_AND: mpc_undefine_and(p); break;
  
     case MPC_TYPE_CHECK:
       mpc_undefine_unretained(p->data.check.x, 0);
       free(p->data.check.e);
       break;
  
     case MPC_TYPE_CHECK_WITH:
       mpc_undefine_unretained(p->data.check_with.x, 0);
       free(p->data.check_with.e);
       break;
  
     default: break;
   }
  
   if (!force) {
     free(p->name);
     free(p);
   }
  
 }

References free(), MPC_TYPE_AND, MPC_TYPE_APPLY, MPC_TYPE_APPLY_TO, MPC_TYPE_CHECK, MPC_TYPE_CHECK_WITH, MPC_TYPE_COUNT, MPC_TYPE_EXPECT, MPC_TYPE_FAIL, MPC_TYPE_MANY, MPC_TYPE_MANY1, MPC_TYPE_MAYBE, MPC_TYPE_NONEOF, MPC_TYPE_NOT, MPC_TYPE_ONEOF, MPC_TYPE_OR, MPC_TYPE_PREDICT, MPC_TYPE_STRING, mpc_undefine_and(), mpc_undefine_or(), and p.

Referenced by mpc_delete(), mpc_soft_delete(), mpc_undefine(), mpc_undefine_and(), and mpc_undefine_or().

◆ mpc_undefined()

static mpc_parser_t* mpc_undefined ( void )

static

Definition at line 1472 of file mpc.c.

                                          {
   mpc_parser_t *p = calloc(1, sizeof(mpc_parser_t));
   p->retained = 0;
   p->type = MPC_TYPE_UNDEFINED;
   p->name = NULL;
   return p;
 }

References calloc(), MPC_TYPE_UNDEFINED, NULL, and p.

Referenced by mpc_anchor(), mpc_and(), mpc_any(), mpc_apply(), mpc_apply_to(), mpc_char(), mpc_check(), mpc_check_with(), mpc_copy(), mpc_count(), mpc_eoi(), mpc_expect(), mpc_expectf(), mpc_fail(), mpc_failf(), mpc_lift(), mpc_lift_val(), mpc_many(), mpc_many1(), mpc_maybe_lift(), mpc_new(), mpc_noneof(), mpc_not_lift(), mpc_oneof(), mpc_or(), mpc_pass(), mpc_predictive(), mpc_range(), mpc_satisfy(), mpc_soi(), mpc_state(), mpc_string(), mpca_and(), and mpca_or().

◆ mpc_underscore()

mpc_parser_t* mpc_underscore ( void )

Definition at line 2026 of file mpc.c.

2026 { return mpc_expect(mpc_char('_'), "underscore"); }

References mpc_char(), and mpc_expect().

Referenced by mpc_alphanum(), and mpc_ident().

◆ mpc_upper()

mpc_parser_t* mpc_upper ( void )

Definition at line 2024 of file mpc.c.

2024 { return mpc_expect(mpc_oneof("ABCDEFGHIJKLMNOPQRSTUVWXYZ"), "uppercase letter"); }

References mpc_expect(), and mpc_oneof().

◆ mpc_whitespace()

mpc_parser_t* mpc_whitespace ( void )

Definition at line 2008 of file mpc.c.

2008 { return mpc_expect(mpc_oneof(" \f\n\r\t\v"), "whitespace"); }

References mpc_expect(), and mpc_oneof().

Referenced by mpc_re_escape_char(), and mpc_whitespaces().

◆ mpc_whitespaces()

mpc_parser_t* mpc_whitespaces ( void )

Definition at line 2009 of file mpc.c.

2009 { return mpc_expect(mpc_many(mpcf_strfold, mpc_whitespace()), "spaces"); }

References mpc_expect(), mpc_many(), mpc_whitespace(), and mpcf_strfold().

Referenced by mpc_blank().

◆ mpc_whole()

mpc_parser_t* mpc_whole	(	mpc_parser_t *	a,
		mpc_dtor_t	da
	)

Definition at line 2083 of file mpc.c.

2083 { return mpc_and(3, mpcf_snd, mpc_soi(), a, mpc_eoi(), mpcf_dtor_null, da); }

References a, mpc_and(), mpc_eoi(), mpc_soi(), mpcf_dtor_null(), and mpcf_snd().

Referenced by mpc_re_mode(), and mpc_total().

◆ mpca_add_tag()

mpc_parser_t* mpca_add_tag	(	mpc_parser_t *	a,
		const char *	t
	)

Definition at line 3273 of file mpc.c.

                                                            {
   return mpc_apply_to(a, (mpc_apply_to_t)mpc_ast_add_tag, (void*)t);
 }

References a, mpc_apply_to(), and mpc_ast_add_tag().

Referenced by mpcaf_grammar_id().

◆ mpca_and()

mpc_parser_t* mpca_and	(	int	n,
			...
	)

Definition at line 3308 of file mpc.c.

                                    {
  
   int i;
   va_list va;
  
   mpc_parser_t *p = mpc_undefined();
  
   p->type = MPC_TYPE_AND;
   p->data.and.n = n;
   p->data.and.f = mpcf_fold_ast;
   p->data.and.xs = malloc(sizeof(mpc_parser_t*) * n);
   p->data.and.dxs = malloc(sizeof(mpc_dtor_t) * (n-1));
  
   va_start(va, n);
   for (i = 0; i < n; i++) {
     p->data.and.xs[i] = va_arg(va, mpc_parser_t*);
   }
   for (i = 0; i < (n-1); i++) {
     p->data.and.dxs[i] = (mpc_dtor_t)mpc_ast_delete;
   }
   va_end(va);
  
   return p;
 }

References i, malloc(), mpc_ast_delete(), MPC_TYPE_AND, mpc_undefined(), mpcf_fold_ast(), n, and p.

Referenced by mpcaf_grammar_and().

◆ mpca_count()

mpc_parser_t* mpca_count	(	int	n,
		mpc_parser_t *	a
	)

Definition at line 3285 of file mpc.c.

3285 { return mpc_count(n, mpcf_fold_ast, a, (mpc_dtor_t)mpc_ast_delete); }

mpc_count

mpc_parser_t * mpc_count(int n, mpc_fold_t f, mpc_parser_t *a, mpc_dtor_t da)

Definition: mpc.c:1918

References a, mpc_ast_delete(), mpc_count(), mpcf_fold_ast(), and n.

Referenced by mpcaf_grammar_repeat().

◆ mpca_grammar()

mpc_parser_t* mpca_grammar	(	int	flags,
		const char *	grammar,
			...
	)

Definition at line 3588 of file mpc.c.

                                                                 {
   mpca_grammar_st_t st;
   mpc_parser_t *res;
   va_list va;
   va_start(va, grammar);
  
   st.va = &va;
   st.parsers_num = 0;
   st.parsers = NULL;
   st.flags = flags;
  
   res = mpca_grammar_st(grammar, &st);
   free(st.parsers);
   va_end(va);
   return res;
 }

References flags, mpca_grammar_st_t::flags, free(), mpca_grammar_st(), NULL, mpca_grammar_st_t::parsers, mpca_grammar_st_t::parsers_num, and mpca_grammar_st_t::va.

◆ mpca_grammar_find_parser()

static mpc_parser_t* mpca_grammar_find_parser	(	char *	x,
		mpca_grammar_st_t *	st
	)

static

Definition at line 3459 of file mpc.c.

                                                                               {
  
   int i;
   mpc_parser_t *p;
  
   /* Case of Number */
   if (is_number(x)) {
  
     i = strtol(x, NULL, 10);
  
     while (st->parsers_num <= i) {
       st->parsers_num++;
       st->parsers = realloc(st->parsers, sizeof(mpc_parser_t*) * st->parsers_num);
       st->parsers[st->parsers_num-1] = va_arg(*st->va, mpc_parser_t*);
       if (st->parsers[st->parsers_num-1] == NULL) {
         return mpc_failf("No Parser in position %i! Only supplied %i Parsers!", i, st->parsers_num);
       }
     }
  
     return st->parsers[st->parsers_num-1];
  
   /* Case of Identifier */
   } else {
  
     /* Search Existing Parsers */
     for (i = 0; i < st->parsers_num; i++) {
       mpc_parser_t *q = st->parsers[i];
       if (q == NULL) { return mpc_failf("Unknown Parser '%s'!", x); }
       if (q->name && strcmp(q->name, x) == 0) { return q; }
     }
  
     /* Search New Parsers */
     while (1) {
  
       p = va_arg(*st->va, mpc_parser_t*);
  
       st->parsers_num++;
       st->parsers = realloc(st->parsers, sizeof(mpc_parser_t*) * st->parsers_num);
       st->parsers[st->parsers_num-1] = p;
  
       if (p == NULL || p->name == NULL) { return mpc_failf("Unknown Parser '%s'!", x); }
       if (p->name && strcmp(p->name, x) == 0) { return p; }
  
     }
  
   }
  
 }

References i, is_number(), mpc_failf(), mpc_parser_t::name, NULL, p, mpca_grammar_st_t::parsers, mpca_grammar_st_t::parsers_num, realloc(), mpca_grammar_st_t::va, and x.

Referenced by mpca_stmt_list_apply_to(), and mpcaf_grammar_id().

◆ mpca_grammar_st()

mpc_parser_t* mpca_grammar_st	(	const char *	grammar,
		mpca_grammar_st_t *	st
	)

Definition at line 3521 of file mpc.c.

                                                                           {
  
   char *err_msg;
   mpc_parser_t *err_out;
   mpc_result_t r;
   mpc_parser_t *GrammarTotal, *Grammar, *Term, *Factor, *Base;
  
   GrammarTotal = mpc_new("grammar_total");
   Grammar = mpc_new("grammar");
   Term = mpc_new("term");
   Factor = mpc_new("factor");
   Base = mpc_new("base");
  
   mpc_define(GrammarTotal,
     mpc_predictive(mpc_total(Grammar, mpc_soft_delete))
   );
  
   mpc_define(Grammar, mpc_and(2, mpcaf_grammar_or,
     Term,
     mpc_maybe(mpc_and(2, mpcf_snd_free, mpc_sym("|"), Grammar, free)),
     mpc_soft_delete
   ));
  
   mpc_define(Term, mpc_many1(mpcaf_grammar_and, Factor));
  
   mpc_define(Factor, mpc_and(2, mpcaf_grammar_repeat,
     Base,
       mpc_or(6,
         mpc_sym("*"),
         mpc_sym("+"),
         mpc_sym("?"),
         mpc_sym("!"),
         mpc_tok_brackets(mpc_int(), free),
         mpc_pass()),
     mpc_soft_delete
   ));
  
   mpc_define(Base, mpc_or(5,
     mpc_apply_to(mpc_tok(mpc_string_lit()), mpcaf_grammar_string, st),
     mpc_apply_to(mpc_tok(mpc_char_lit()),   mpcaf_grammar_char, st),
     mpc_tok(mpc_and(3, mpcaf_fold_regex, mpc_regex_lit(), mpc_many(mpcf_strfold, mpc_oneof("ms")), mpc_lift_val(st), free, free)),
     mpc_apply_to(mpc_tok_braces(mpc_or(2, mpc_digits(), mpc_ident()), free), mpcaf_grammar_id, st),
     mpc_tok_parens(Grammar, mpc_soft_delete)
   ));
  
   mpc_optimise(GrammarTotal);
   mpc_optimise(Grammar);
   mpc_optimise(Factor);
   mpc_optimise(Term);
   mpc_optimise(Base);
  
   if(!mpc_parse("<mpc_grammar_compiler>", grammar, GrammarTotal, &r)) {
     err_msg = mpc_err_string(r.error);
     err_out = mpc_failf("Invalid Grammar: %s", err_msg);
     mpc_err_delete(r.error);
     free(err_msg);
     r.output = err_out;
   }
  
   mpc_cleanup(5, GrammarTotal, Grammar, Term, Factor, Base);
  
   mpc_optimise(r.output);
  
   return (st->flags & MPCA_LANG_PREDICTIVE) ? mpc_predictive(r.output) : r.output;
  
 }

References mpca_grammar_st_t::flags, free(), mpc_and(), mpc_apply_to(), mpc_char_lit(), mpc_cleanup(), mpc_define(), mpc_digits(), mpc_err_delete(), mpc_err_string(), mpc_failf(), mpc_ident(), mpc_int(), mpc_lift_val(), mpc_many(), mpc_many1(), mpc_maybe(), mpc_new(), mpc_oneof(), mpc_optimise(), mpc_or(), mpc_parse(), mpc_pass(), mpc_predictive(), mpc_regex_lit(), mpc_soft_delete(), mpc_string_lit(), mpc_sym(), mpc_tok(), mpc_tok_braces(), mpc_tok_brackets(), mpc_tok_parens(), mpc_total(), MPCA_LANG_PREDICTIVE, mpcaf_fold_regex(), mpcaf_grammar_and(), mpcaf_grammar_char(), mpcaf_grammar_id(), mpcaf_grammar_or(), mpcaf_grammar_repeat(), mpcaf_grammar_string(), mpcf_snd_free(), mpcf_strfold(), and r.

Referenced by mpca_grammar().

◆ mpca_lang()

mpc_err_t* mpca_lang	(	int	flags,
		const char *	language,
			...
	)

Definition at line 3790 of file mpc.c.

                                                            {
  
   mpca_grammar_st_t st;
   mpc_input_t *i;
   mpc_err_t *err;
  
   va_list va;
   va_start(va, language);
  
   st.va = &va;
   st.parsers_num = 0;
   st.parsers = NULL;
   st.flags = flags;
  
   i = mpc_input_new_string("<mpca_lang>", language);
   err = mpca_lang_st(i, &st);
   mpc_input_delete(i);
  
   free(st.parsers);
   va_end(va);
   return err;
 }

References err, flags, mpca_grammar_st_t::flags, free(), i, mpc_input_delete(), mpc_input_new_string(), mpca_lang_st(), NULL, mpca_grammar_st_t::parsers, mpca_grammar_st_t::parsers_num, and mpca_grammar_st_t::va.

Referenced by main().

◆ mpca_lang_contents()

mpc_err_t* mpca_lang_contents	(	int	flags,
		const char *	filename,
			...
	)

Definition at line 3813 of file mpc.c.

                                                                     {
  
   mpca_grammar_st_t st;
   mpc_input_t *i;
   mpc_err_t *err;
  
   va_list va;
  
   FILE *f = fopen(filename, "rb");
  
   if (f == NULL) {
     err = mpc_err_file(filename, "Unable to open file!");
     return err;
   }
  
   va_start(va, filename);
  
   st.va = &va;
   st.parsers_num = 0;
   st.parsers = NULL;
   st.flags = flags;
  
   i = mpc_input_new_file(filename, f);
   err = mpca_lang_st(i, &st);
   mpc_input_delete(i);
  
   free(st.parsers);
   va_end(va);
  
   fclose(f);
  
   return err;
 }

References err, f, benchmark::FILE, flags, mpca_grammar_st_t::flags, free(), i, mpc_err_file(), mpc_input_delete(), mpc_input_new_file(), mpca_lang_st(), NULL, mpca_grammar_st_t::parsers, mpca_grammar_st_t::parsers_num, and mpca_grammar_st_t::va.

◆ mpca_lang_file()

mpc_err_t* mpca_lang_file	(	int	flags,
		FILE *	f,
			...
	)

Definition at line 3746 of file mpc.c.

                                                    {
   mpca_grammar_st_t st;
   mpc_input_t *i;
   mpc_err_t *err;
  
   va_list va;
   va_start(va, f);
  
   st.va = &va;
   st.parsers_num = 0;
   st.parsers = NULL;
   st.flags = flags;
  
   i = mpc_input_new_file("<mpca_lang_file>", f);
   err = mpca_lang_st(i, &st);
   mpc_input_delete(i);
  
   free(st.parsers);
   va_end(va);
   return err;
 }

References err, f, flags, mpca_grammar_st_t::flags, free(), i, mpc_input_delete(), mpc_input_new_file(), mpca_lang_st(), NULL, mpca_grammar_st_t::parsers, mpca_grammar_st_t::parsers_num, and mpca_grammar_st_t::va.

◆ mpca_lang_pipe()

mpc_err_t* mpca_lang_pipe	(	int	flags,
		FILE *	p,
			...
	)

Definition at line 3768 of file mpc.c.

                                                    {
   mpca_grammar_st_t st;
   mpc_input_t *i;
   mpc_err_t *err;
  
   va_list va;
   va_start(va, p);
  
   st.va = &va;
   st.parsers_num = 0;
   st.parsers = NULL;
   st.flags = flags;
  
   i = mpc_input_new_pipe("<mpca_lang_pipe>", p);
   err = mpca_lang_st(i, &st);
   mpc_input_delete(i);
  
   free(st.parsers);
   va_end(va);
   return err;
 }

References err, flags, mpca_grammar_st_t::flags, free(), i, mpc_input_delete(), mpc_input_new_pipe(), mpca_lang_st(), NULL, p, mpca_grammar_st_t::parsers, mpca_grammar_st_t::parsers_num, and mpca_grammar_st_t::va.

◆ mpca_lang_st()

static mpc_err_t* mpca_lang_st	(	mpc_input_t *	i,
		mpca_grammar_st_t *	st
	)

static

Definition at line 3677 of file mpc.c.

                                                                       {
  
   mpc_result_t r;
   mpc_err_t *e;
   mpc_parser_t *Lang, *Stmt, *Grammar, *Term, *Factor, *Base;
  
   Lang    = mpc_new("lang");
   Stmt    = mpc_new("stmt");
   Grammar = mpc_new("grammar");
   Term    = mpc_new("term");
   Factor  = mpc_new("factor");
   Base    = mpc_new("base");
  
   mpc_define(Lang, mpc_apply_to(
     mpc_total(mpc_predictive(mpc_many(mpca_stmt_fold, Stmt)), mpca_stmt_list_delete),
     mpca_stmt_list_apply_to, st
   ));
  
   mpc_define(Stmt, mpc_and(5, mpca_stmt_afold,
     mpc_tok(mpc_ident()), mpc_maybe(mpc_tok(mpc_string_lit())), mpc_sym(":"), Grammar, mpc_sym(";"),
     free, free, free, mpc_soft_delete
   ));
  
   mpc_define(Grammar, mpc_and(2, mpcaf_grammar_or,
       Term,
       mpc_maybe(mpc_and(2, mpcf_snd_free, mpc_sym("|"), Grammar, free)),
       mpc_soft_delete
   ));
  
   mpc_define(Term, mpc_many1(mpcaf_grammar_and, Factor));
  
   mpc_define(Factor, mpc_and(2, mpcaf_grammar_repeat,
     Base,
       mpc_or(6,
         mpc_sym("*"),
         mpc_sym("+"),
         mpc_sym("?"),
         mpc_sym("!"),
         mpc_tok_brackets(mpc_int(), free),
         mpc_pass()),
     mpc_soft_delete
   ));
  
   mpc_define(Base, mpc_or(5,
     mpc_apply_to(mpc_tok(mpc_string_lit()), mpcaf_grammar_string, st),
     mpc_apply_to(mpc_tok(mpc_char_lit()),   mpcaf_grammar_char, st),
     mpc_tok(mpc_and(3, mpcaf_fold_regex, mpc_regex_lit(), mpc_many(mpcf_strfold, mpc_oneof("ms")), mpc_lift_val(st), free, free)),
     mpc_apply_to(mpc_tok_braces(mpc_or(2, mpc_digits(), mpc_ident()), free), mpcaf_grammar_id, st),
     mpc_tok_parens(Grammar, mpc_soft_delete)
   ));
  
   mpc_optimise(Lang);
   mpc_optimise(Stmt);
   mpc_optimise(Grammar);
   mpc_optimise(Term);
   mpc_optimise(Factor);
   mpc_optimise(Base);
  
   if (!mpc_parse_input(i, Lang, &r)) {
     e = r.error;
   } else {
     e = NULL;
   }
  
   mpc_cleanup(6, Lang, Stmt, Grammar, Term, Factor, Base);
  
   return e;
 }

References e, free(), i, mpc_and(), mpc_apply_to(), mpc_char_lit(), mpc_cleanup(), mpc_define(), mpc_digits(), mpc_ident(), mpc_int(), mpc_lift_val(), mpc_many(), mpc_many1(), mpc_maybe(), mpc_new(), mpc_oneof(), mpc_optimise(), mpc_or(), mpc_parse_input(), mpc_pass(), mpc_predictive(), mpc_regex_lit(), mpc_soft_delete(), mpc_string_lit(), mpc_sym(), mpc_tok(), mpc_tok_braces(), mpc_tok_brackets(), mpc_tok_parens(), mpc_total(), mpca_stmt_afold(), mpca_stmt_fold(), mpca_stmt_list_apply_to(), mpca_stmt_list_delete(), mpcaf_fold_regex(), mpcaf_grammar_and(), mpcaf_grammar_char(), mpcaf_grammar_id(), mpcaf_grammar_or(), mpcaf_grammar_repeat(), mpcaf_grammar_string(), mpcf_snd_free(), mpcf_strfold(), NULL, and r.

Referenced by mpca_lang(), mpca_lang_contents(), mpca_lang_file(), and mpca_lang_pipe().

◆ mpca_many()

mpc_parser_t* mpca_many ( mpc_parser_t * a )

Definition at line 3283 of file mpc.c.

3283 { return mpc_many(mpcf_fold_ast, a); }

References a, mpc_many(), and mpcf_fold_ast().

Referenced by mpcaf_grammar_repeat().

◆ mpca_many1()

mpc_parser_t* mpca_many1 ( mpc_parser_t * a )

Definition at line 3284 of file mpc.c.

3284 { return mpc_many1(mpcf_fold_ast, a); }

References a, mpc_many1(), and mpcf_fold_ast().

Referenced by mpcaf_grammar_repeat().

◆ mpca_maybe()

mpc_parser_t* mpca_maybe ( mpc_parser_t * a )

Definition at line 3282 of file mpc.c.

3282 { return mpc_maybe(a); }

References a, and mpc_maybe().

Referenced by mpcaf_grammar_repeat().

◆ mpca_not()

mpc_parser_t* mpca_not ( mpc_parser_t * a )

Definition at line 3281 of file mpc.c.

3281 { return mpc_not(a, (mpc_dtor_t)mpc_ast_delete); }

mpc_not

mpc_parser_t * mpc_not(mpc_parser_t *a, mpc_dtor_t da)

Definition: mpc.c:1886

References a, mpc_ast_delete(), and mpc_not().

Referenced by mpcaf_grammar_repeat().

◆ mpca_or()

mpc_parser_t* mpca_or	(	int	n,
			...
	)

Definition at line 3287 of file mpc.c.

                                   {
  
   int i;
   va_list va;
  
   mpc_parser_t *p = mpc_undefined();
  
   p->type = MPC_TYPE_OR;
   p->data.or.n = n;
   p->data.or.xs = malloc(sizeof(mpc_parser_t*) * n);
  
   va_start(va, n);
   for (i = 0; i < n; i++) {
     p->data.or.xs[i] = va_arg(va, mpc_parser_t*);
   }
   va_end(va);
  
   return p;
  
 }

References i, malloc(), MPC_TYPE_OR, mpc_undefined(), n, and p.

Referenced by mpcaf_grammar_or().

◆ mpca_root()

mpc_parser_t* mpca_root ( mpc_parser_t * a )

Definition at line 3277 of file mpc.c.

                                          {
   return mpc_apply(a, (mpc_apply_t)mpc_ast_add_root);
 }

References a, mpc_apply(), and mpc_ast_add_root().

Referenced by mpcaf_grammar_id().

◆ mpca_state()

mpc_parser_t* mpca_state ( mpc_parser_t * a )

Definition at line 3265 of file mpc.c.

                                           {
   return mpc_and(2, mpcf_state_ast, mpc_state(), a, free);
 }

References a, free(), mpc_and(), mpc_state(), and mpcf_state_ast().

Referenced by mpcaf_fold_regex(), mpcaf_grammar_char(), mpcaf_grammar_id(), and mpcaf_grammar_string().

◆ mpca_stmt_afold()

static mpc_val_t* mpca_stmt_afold	(	int	n,
		mpc_val_t **	xs
	)

static

Definition at line 3611 of file mpc.c.

                                                          {
   mpca_stmt_t *stmt = malloc(sizeof(mpca_stmt_t));
   stmt->ident = ((char**)xs)[0];
   stmt->name = ((char**)xs)[1];
   stmt->grammar = ((mpc_parser_t**)xs)[3];
   (void) n;
   free(((char**)xs)[2]);
   free(((char**)xs)[4]);
  
   return stmt;
 }

References free(), mpca_stmt_t::grammar, mpca_stmt_t::ident, malloc(), n, and mpca_stmt_t::name.

Referenced by mpca_lang_st().

◆ mpca_stmt_fold()

static mpc_val_t* mpca_stmt_fold	(	int	n,
		mpc_val_t **	xs
	)

static

Definition at line 3623 of file mpc.c.

                                                         {
  
   int i;
   mpca_stmt_t **stmts = malloc(sizeof(mpca_stmt_t*) * (n+1));
  
   for (i = 0; i < n; i++) {
     stmts[i] = xs[i];
   }
   stmts[n] = NULL;
  
   return stmts;
 }

References i, malloc(), n, and NULL.

Referenced by mpca_lang_st().

◆ mpca_stmt_list_apply_to()

static mpc_val_t* mpca_stmt_list_apply_to	(	mpc_val_t *	x,
		void *	s
	)

static

Definition at line 3652 of file mpc.c.

                                                                  {
  
   mpca_grammar_st_t *st = s;
   mpca_stmt_t *stmt;
   mpca_stmt_t **stmts = x;
   mpc_parser_t *left;
  
   while(*stmts) {
     stmt = *stmts;
     left = mpca_grammar_find_parser(stmt->ident, st);
     if (st->flags & MPCA_LANG_PREDICTIVE) { stmt->grammar = mpc_predictive(stmt->grammar); }
     if (stmt->name) { stmt->grammar = mpc_expect(stmt->grammar, stmt->name); }
     mpc_optimise(stmt->grammar);
     mpc_define(left, stmt->grammar);
     free(stmt->ident);
     free(stmt->name);
     free(stmt);
     stmts++;
   }
  
   free(x);
  
   return NULL;
 }

References mpca_grammar_st_t::flags, free(), mpca_stmt_t::grammar, mpca_stmt_t::ident, mpc_define(), mpc_expect(), mpc_optimise(), mpc_predictive(), mpca_grammar_find_parser(), MPCA_LANG_PREDICTIVE, mpca_stmt_t::name, NULL, s, and x.

Referenced by mpca_lang_st().

◆ mpca_stmt_list_delete()

static void mpca_stmt_list_delete ( mpc_val_t * x )

static

Definition at line 3636 of file mpc.c.

                                                 {
  
   mpca_stmt_t **stmts = x;
  
   while(*stmts) {
     mpca_stmt_t *stmt = *stmts;
     free(stmt->ident);
     free(stmt->name);
     mpc_soft_delete(stmt->grammar);
     free(stmt);
     stmts++;
   }
   free(x);
  
 }

References free(), mpca_stmt_t::grammar, mpca_stmt_t::ident, mpc_soft_delete(), mpca_stmt_t::name, and x.

Referenced by mpca_lang_st().

◆ mpca_tag()

mpc_parser_t* mpca_tag	(	mpc_parser_t *	a,
		const char *	t
	)

Definition at line 3269 of file mpc.c.

                                                        {
   return mpc_apply_to(a, (mpc_apply_to_t)mpc_ast_tag, (void*)t);
 }

References a, mpc_apply_to(), and mpc_ast_tag().

Referenced by mpcaf_fold_regex(), mpcaf_grammar_char(), and mpcaf_grammar_string().

◆ mpca_total()

mpc_parser_t* mpca_total ( mpc_parser_t * a )

Definition at line 3333 of file mpc.c.

3333 { return mpc_total(a, (mpc_dtor_t)mpc_ast_delete); }

References a, mpc_ast_delete(), and mpc_total().

◆ mpcaf_fold_regex()

static mpc_val_t* mpcaf_fold_regex	(	int	n,
		mpc_val_t **	xs
	)

static

Definition at line 3434 of file mpc.c.

                                                           {
   char *y = xs[0];
   char *m = xs[1];
   mpca_grammar_st_t *st = xs[2];
   mpc_parser_t *p;
   int mode = MPC_RE_DEFAULT;
  
   (void)n;
   if (strchr(m, 'm')) { mode |= MPC_RE_MULTILINE; }
   if (strchr(m, 's')) { mode |= MPC_RE_DOTALL; }
   y = mpcf_unescape_regex(y);
   p = (st->flags & MPCA_LANG_WHITESPACE_SENSITIVE) ? mpc_re_mode(y, mode) : mpc_tok(mpc_re_mode(y, mode));
   free(y);
   free(m);
  
   return mpca_state(mpca_tag(mpc_apply(p, mpcf_str_ast), "regex"));
 }

References mpca_grammar_st_t::flags, free(), regress::m, mpc_apply(), MPC_RE_DEFAULT, MPC_RE_DOTALL, mpc_re_mode(), MPC_RE_MULTILINE, mpc_tok(), MPCA_LANG_WHITESPACE_SENSITIVE, mpca_state(), mpca_tag(), mpcf_str_ast(), mpcf_unescape_regex(), n, and p.

Referenced by mpca_grammar_st(), and mpca_lang_st().

◆ mpcaf_grammar_and()

static mpc_val_t* mpcaf_grammar_and	(	int	n,
		mpc_val_t **	xs
	)

static

Definition at line 3392 of file mpc.c.

                                                            {
   int i;
   mpc_parser_t *p = mpc_pass();
   for (i = 0; i < n; i++) {
     if (xs[i] != NULL) { p = mpca_and(2, p, xs[i]); }
   }
   return p;
 }

References i, mpc_pass(), mpca_and(), n, NULL, and p.

Referenced by mpca_grammar_st(), and mpca_lang_st().

◆ mpcaf_grammar_char()

static mpc_val_t* mpcaf_grammar_char	(	mpc_val_t *	x,
		void *	s
	)

static

Definition at line 3426 of file mpc.c.

                                                             {
   mpca_grammar_st_t *st = s;
   char *y = mpcf_unescape(x);
   mpc_parser_t *p = (st->flags & MPCA_LANG_WHITESPACE_SENSITIVE) ? mpc_char(y[0]) : mpc_tok(mpc_char(y[0]));
   free(y);
   return mpca_state(mpca_tag(mpc_apply(p, mpcf_str_ast), "char"));
 }

References mpca_grammar_st_t::flags, free(), mpc_apply(), mpc_char(), mpc_tok(), MPCA_LANG_WHITESPACE_SENSITIVE, mpca_state(), mpca_tag(), mpcf_str_ast(), mpcf_unescape(), p, s, and x.

Referenced by mpca_grammar_st(), and mpca_lang_st().

◆ mpcaf_grammar_id()

static mpc_val_t* mpcaf_grammar_id	(	mpc_val_t *	x,
		void *	s
	)

static

Definition at line 3508 of file mpc.c.

                                                           {
  
   mpca_grammar_st_t *st = s;
   mpc_parser_t *p = mpca_grammar_find_parser(x, st);
   free(x);
  
   if (p->name) {
     return mpca_state(mpca_root(mpca_add_tag(p, p->name)));
   } else {
     return mpca_state(mpca_root(p));
   }
 }

References free(), mpca_add_tag(), mpca_grammar_find_parser(), mpca_root(), mpca_state(), p, s, and x.

Referenced by mpca_grammar_st(), and mpca_lang_st().

◆ mpcaf_grammar_or()

static mpc_val_t* mpcaf_grammar_or	(	int	n,
		mpc_val_t **	xs
	)

static

Definition at line 3386 of file mpc.c.

                                                           {
   (void) n;
   if (xs[1] == NULL) { return xs[0]; }
   else { return mpca_or(2, xs[0], xs[1]); }
 }

References mpca_or(), n, and NULL.

Referenced by mpca_grammar_st(), and mpca_lang_st().

◆ mpcaf_grammar_repeat()

static mpc_val_t* mpcaf_grammar_repeat	(	int	n,
		mpc_val_t **	xs
	)

static

Definition at line 3401 of file mpc.c.

                                                               {
   int num;
   (void) n;
   if (xs[1] == NULL) { return xs[0]; }
   switch(((char*)xs[1])[0])
   {
     case '*': { free(xs[1]); return mpca_many(xs[0]); }; break;
     case '+': { free(xs[1]); return mpca_many1(xs[0]); }; break;
     case '?': { free(xs[1]); return mpca_maybe(xs[0]); }; break;
     case '!': { free(xs[1]); return mpca_not(xs[0]); }; break;
     default:
       num = *((int*)xs[1]);
       free(xs[1]);
   }
   return mpca_count(num, xs[0]);
 }

References free(), mpca_count(), mpca_many(), mpca_many1(), mpca_maybe(), mpca_not(), n, NULL, and num.

Referenced by mpca_grammar_st(), and mpca_lang_st().

◆ mpcaf_grammar_string()

static mpc_val_t* mpcaf_grammar_string	(	mpc_val_t *	x,
		void *	s
	)

static

Definition at line 3418 of file mpc.c.

                                                               {
   mpca_grammar_st_t *st = s;
   char *y = mpcf_unescape(x);
   mpc_parser_t *p = (st->flags & MPCA_LANG_WHITESPACE_SENSITIVE) ? mpc_string(y) : mpc_tok(mpc_string(y));
   free(y);
   return mpca_state(mpca_tag(mpc_apply(p, mpcf_str_ast), "string"));
 }

References mpca_grammar_st_t::flags, free(), mpc_apply(), mpc_string(), mpc_tok(), MPCA_LANG_WHITESPACE_SENSITIVE, mpca_state(), mpca_tag(), mpcf_str_ast(), mpcf_unescape(), p, s, and x.

Referenced by mpca_grammar_st(), and mpca_lang_st().

◆ mpcf_all_free()

mpc_val_t* mpcf_all_free	(	int	n,
		mpc_val_t **	xs
	)

Definition at line 2640 of file mpc.c.

                                                 {
   int i;
   for (i = 0; i < n; i++) {
     free(xs[i]);
   }
   return NULL;
 }

References free(), i, n, and NULL.

◆ mpcf_ctor_null()

mpc_val_t* mpcf_ctor_null ( void )

Definition at line 2430 of file mpc.c.

2430 { return NULL; }

References NULL.

Referenced by mpc_maybe(), and mpc_not().

◆ mpcf_ctor_str()

mpc_val_t* mpcf_ctor_str ( void )

Definition at line 2431 of file mpc.c.

2431 { return calloc(1, 1); }

References calloc().

Referenced by mpc_optimise_unretained(), mpc_re_escape_char(), mpc_real(), mpcf_re_and(), mpcf_re_escape(), and mpcf_re_repeat().

◆ mpcf_dtor_null()

void mpcf_dtor_null ( mpc_val_t * x )

Definition at line 2428 of file mpc.c.

2428 { (void) x; return; }

References x.

Referenced by mpc_startwith(), mpc_strip(), mpc_stripl(), mpc_stripr(), mpc_tok(), and mpc_whole().

◆ mpcf_escape()

mpc_val_t* mpcf_escape ( mpc_val_t * x )

Definition at line 2576 of file mpc.c.

                                      {
   mpc_val_t *y = mpcf_escape_new(x, mpc_escape_input_c, mpc_escape_output_c);
   free(x);
   return y;
 }

References free(), mpc_escape_input_c, mpc_escape_output_c, mpcf_escape_new(), and x.

◆ mpcf_escape_char_raw()

mpc_val_t* mpcf_escape_char_raw ( mpc_val_t * x )

Definition at line 2612 of file mpc.c.

                                               {
   mpc_val_t *y = mpcf_escape_new(x, mpc_escape_input_raw_cchar, mpc_escape_output_raw_cchar);
   free(x);
   return y;
 }

References free(), mpc_escape_input_raw_cchar, mpc_escape_output_raw_cchar, mpcf_escape_new(), and x.

◆ mpcf_escape_new()

static mpc_val_t* mpcf_escape_new	(	mpc_val_t *	x,
		const char *	input,
		const char **	output
	)

static

Definition at line 2500 of file mpc.c.

                                                                                         {
  
   int i;
   int found;
   char buff[2];
   char *s = x;
   char *y = calloc(1, 1);
  
   while (*s) {
  
     i = 0;
     found = 0;
  
     while (output[i]) {
       if (*s == input[i]) {
         y = realloc(y, strlen(y) + strlen(output[i]) + 1);
         strcat(y, output[i]);
         found = 1;
         break;
       }
       i++;
     }
  
     if (!found) {
       y = realloc(y, strlen(y) + 2);
       buff[0] = *s; buff[1] = '\0';
       strcat(y, buff);
     }
  
     s++;
   }
  
  
   return y;
 }

References calloc(), found, i, input(), output, realloc(), s, and x.

Referenced by mpc_print_unretained(), mpcf_escape(), mpcf_escape_char_raw(), mpcf_escape_regex(), and mpcf_escape_string_raw().

◆ mpcf_escape_regex()

mpc_val_t* mpcf_escape_regex ( mpc_val_t * x )

Definition at line 2588 of file mpc.c.

                                            {
   mpc_val_t *y = mpcf_escape_new(x, mpc_escape_input_raw_re, mpc_escape_output_raw_re);
   free(x);
   return y;
 }

References free(), mpc_escape_input_raw_re, mpc_escape_output_raw_re, mpcf_escape_new(), and x.

◆ mpcf_escape_string_raw()

mpc_val_t* mpcf_escape_string_raw ( mpc_val_t * x )

Definition at line 2600 of file mpc.c.

                                                 {
   mpc_val_t *y = mpcf_escape_new(x, mpc_escape_input_raw_cstr, mpc_escape_output_raw_cstr);
   free(x);
   return y;
 }

References free(), mpc_escape_input_raw_cstr, mpc_escape_output_raw_cstr, mpcf_escape_new(), and x.

◆ mpcf_float()

mpc_val_t* mpcf_float ( mpc_val_t * x )

Definition at line 2455 of file mpc.c.

                                     {
   float *y = malloc(sizeof(float));
   *y = strtod(x, NULL);
   free(x);
   return y;
 }

References free(), malloc(), NULL, and x.

Referenced by mpc_float().

◆ mpcf_fold_ast()

mpc_val_t* mpcf_fold_ast	(	int	n,
		mpc_val_t **	xs
	)

Definition at line 3212 of file mpc.c.

                                                 {
  
   int i, j;
   mpc_ast_t** as = (mpc_ast_t**)xs;
   mpc_ast_t *r;
  
   if (n == 0) { return NULL; }
   if (n == 1) { return xs[0]; }
   if (n == 2 && xs[1] == NULL) { return xs[0]; }
   if (n == 2 && xs[0] == NULL) { return xs[1]; }
  
   r = mpc_ast_new(">", "");
  
   for (i = 0; i < n; i++) {
  
     if (as[i] == NULL) { continue; }
  
     if        (as[i] && as[i]->children_num == 0) {
       mpc_ast_add_child(r, as[i]);
     } else if (as[i] && as[i]->children_num == 1) {
       mpc_ast_add_child(r, mpc_ast_add_root_tag(as[i]->children[0], as[i]->tag));
       mpc_ast_delete_no_children(as[i]);
     } else if (as[i] && as[i]->children_num >= 2) {
       for (j = 0; j < as[i]->children_num; j++) {
         mpc_ast_add_child(r, as[i]->children[j]);
       }
       mpc_ast_delete_no_children(as[i]);
     }
  
   }
  
   if (r->children_num) {
     r->state = r->children[0]->state;
   }
  
   return r;
 }

References mpc_ast_t::children_num, i, mpc_ast_add_child(), mpc_ast_add_root_tag(), mpc_ast_delete_no_children(), mpc_ast_new(), n, NULL, r, and test-lz4-versions::tag.

Referenced by mpc_optimise_unretained(), mpca_and(), mpca_count(), mpca_many(), and mpca_many1().

◆ mpcf_free()

mpc_val_t* mpcf_free ( mpc_val_t * x )

Definition at line 2432 of file mpc.c.

2432 { free(x); return NULL; }

References free(), NULL, and x.

Referenced by mpc_blank(), and mpc_parse_apply().

◆ mpcf_fst()

mpc_val_t* mpcf_fst	(	int	n,
		mpc_val_t **	xs
	)

Definition at line 2625 of file mpc.c.

2625 { (void) n; return xs[0]; }

References n.

Referenced by mpc_endwith(), mpc_parse_fold(), mpc_stripr(), mpc_tok(), and mpcf_re_escape().

◆ mpcf_fst_free()

mpc_val_t* mpcf_fst_free	(	int	n,
		mpc_val_t **	xs
	)

Definition at line 2637 of file mpc.c.

2637 { return mpcf_nth_free(n, xs, 0); }

mpcf_nth_free

static mpc_val_t * mpcf_nth_free(int n, mpc_val_t **xs, int x)

Definition: mpc.c:2629

References mpcf_nth_free(), and n.

Referenced by mpc_parse_fold().

◆ mpcf_hex()

mpc_val_t* mpcf_hex ( mpc_val_t * x )

Definition at line 2441 of file mpc.c.

                                   {
   int *y = malloc(sizeof(int));
   *y = strtol(x, NULL, 16);
   free(x);
   return y;
 }

References free(), malloc(), NULL, and x.

Referenced by mpc_hex().

◆ mpcf_input_free()

static mpc_val_t* mpcf_input_free	(	mpc_input_t *	i,
		mpc_val_t *	x
	)

static

Definition at line 1009 of file mpc.c.

                                                                 {
   mpc_free(i, x);
   return NULL;
 }

References i, mpc_free(), NULL, and x.

Referenced by mpc_parse_apply().

◆ mpcf_input_fst_free()

static mpc_val_t* mpcf_input_fst_free	(	mpc_input_t *	i,
		int	n,
		mpc_val_t **	xs
	)

static

Definition at line 971 of file mpc.c.

971 { return mpcf_input_nth_free(i, n, xs, 0); }

mpcf_input_nth_free

static mpc_val_t * mpcf_input_nth_free(mpc_input_t *i, int n, mpc_val_t **xs, int x)

Definition: mpc.c:965

References i, mpcf_input_nth_free(), and n.

Referenced by mpc_parse_fold().

◆ mpcf_input_nth_free()

static mpc_val_t* mpcf_input_nth_free	(	mpc_input_t *	i,
		int	n,
		mpc_val_t **	xs,
		int	x
	)

static

Definition at line 965 of file mpc.c.

                                                                                     {
   int j;
   for (j = 0; j < n; j++) { if (j != x) { mpc_free(i, xs[j]); } }
   return xs[x];
 }

References i, mpc_free(), n, and x.

Referenced by mpcf_input_fst_free(), mpcf_input_snd_free(), and mpcf_input_trd_free().

◆ mpcf_input_snd_free()

static mpc_val_t* mpcf_input_snd_free	(	mpc_input_t *	i,
		int	n,
		mpc_val_t **	xs
	)

static

Definition at line 972 of file mpc.c.

972 { return mpcf_input_nth_free(i, n, xs, 1); }

References i, mpcf_input_nth_free(), and n.

Referenced by mpc_parse_fold().

◆ mpcf_input_state_ast()

static mpc_val_t* mpcf_input_state_ast	(	mpc_input_t *	i,
		int	n,
		mpc_val_t **	xs
	)

static

Definition at line 985 of file mpc.c.

                                                                               {
   mpc_state_t *s = ((mpc_state_t**)xs)[0];
   mpc_ast_t *a = ((mpc_ast_t**)xs)[1];
   a = mpc_ast_state(a, *s);
   mpc_free(i, s);
   (void) n;
   return a;
 }

References a, i, mpc_ast_state(), mpc_free(), n, and s.

Referenced by mpc_parse_fold().

◆ mpcf_input_str_ast()

static mpc_val_t* mpcf_input_str_ast	(	mpc_input_t *	i,
		mpc_val_t *	c
	)

static

Definition at line 1014 of file mpc.c.

                                                                    {
   mpc_ast_t *a = mpc_ast_new("", c);
   mpc_free(i, c);
   return a;
 }

References a, c, i, mpc_ast_new(), and mpc_free().

Referenced by mpc_parse_apply().

◆ mpcf_input_strfold()

static mpc_val_t* mpcf_input_strfold	(	mpc_input_t *	i,
		int	n,
		mpc_val_t **	xs
	)

static

Definition at line 975 of file mpc.c.

                                                                             {
   int j;
   size_t l = 0;
   if (n == 0) { return mpc_calloc(i, 1, 1); }
   for (j = 0; j < n; j++) { l += strlen(xs[j]); }
   xs[0] = mpc_realloc(i, xs[0], l + 1);
   for (j = 1; j < n; j++) { strcat(xs[0], xs[j]); mpc_free(i, xs[j]); }
   return xs[0];
 }

References i, mpc_calloc(), mpc_free(), mpc_realloc(), and n.

Referenced by mpc_parse_fold().

◆ mpcf_input_trd_free()

static mpc_val_t* mpcf_input_trd_free	(	mpc_input_t *	i,
		int	n,
		mpc_val_t **	xs
	)

static

Definition at line 973 of file mpc.c.

973 { return mpcf_input_nth_free(i, n, xs, 2); }

References i, mpcf_input_nth_free(), and n.

Referenced by mpc_parse_fold().

◆ mpcf_int()

mpc_val_t* mpcf_int ( mpc_val_t * x )

Definition at line 2434 of file mpc.c.

                                   {
   int *y = malloc(sizeof(int));
   *y = strtol(x, NULL, 10);
   free(x);
   return y;
 }

References free(), malloc(), NULL, and x.

Referenced by mpc_int().

◆ mpcf_maths()

mpc_val_t* mpcf_maths	(	int	n,
		mpc_val_t **	xs
	)

Definition at line 2665 of file mpc.c.

                                              {
   int **vs = (int**)xs;
   (void) n;
  
   switch(((char*)xs[1])[0])
   {
     case '*': { *vs[0] *= *vs[2]; }; break;
     case '/': { *vs[0] /= *vs[2]; }; break;
     case '%': { *vs[0] %= *vs[2]; }; break;
     case '+': { *vs[0] += *vs[2]; }; break;
     case '-': { *vs[0] -= *vs[2]; }; break;
     default: break;
   }
  
   free(xs[1]); free(xs[2]);
  
   return xs[0];
 }

References free(), and n.

◆ mpcf_nth_free()

static mpc_val_t* mpcf_nth_free	(	int	n,
		mpc_val_t **	xs,
		int	x
	)

static

Definition at line 2629 of file mpc.c.

                                                               {
   int i;
   for (i = 0; i < n; i++) {
     if (i != x) { free(xs[i]); }
   }
   return xs[x];
 }

References free(), i, n, and x.

Referenced by mpcf_fst_free(), mpcf_snd_free(), and mpcf_trd_free().

◆ mpcf_null()

mpc_val_t* mpcf_null	(	int	n,
		mpc_val_t **	xs
	)

Definition at line 2624 of file mpc.c.

2624 { (void) n; (void) xs; return NULL; }

References n, and NULL.

Referenced by mpc_parse_fold().

◆ mpcf_oct()

mpc_val_t* mpcf_oct ( mpc_val_t * x )

Definition at line 2448 of file mpc.c.

                                   {
   int *y = malloc(sizeof(int));
   *y = strtol(x, NULL, 8);
   free(x);
   return y;
 }

References free(), malloc(), NULL, and x.

Referenced by mpc_oct().

◆ mpcf_re_and()

static mpc_val_t* mpcf_re_and	(	int	n,
		mpc_val_t **	xs
	)

static

Definition at line 2171 of file mpc.c.

                                                      {
   int i;
   mpc_parser_t *p = mpc_lift(mpcf_ctor_str);
   for (i = 0; i < n; i++) {
     p = mpc_and(2, mpcf_strfold, p, xs[i], free);
   }
   return p;
 }

References free(), i, mpc_and(), mpc_lift(), mpcf_ctor_str(), mpcf_strfold(), n, and p.

Referenced by mpc_re_mode().

◆ mpcf_re_escape()

static mpc_val_t* mpcf_re_escape	(	mpc_val_t *	x,
		void *	data
	)

static

Definition at line 2219 of file mpc.c.

                                                            {
  
   int mode = *((int*)data);
   char *s = x;
   mpc_parser_t *p;
  
   /* Any Character */
   if (s[0] == '.') {
     free(s);
     if (mode & MPC_RE_DOTALL) {
       return mpc_any();
     } else {
       return mpc_expect(mpc_noneof("\n"), "any character except a newline");
     }
   }
  
   /* Start of Input */
   if (s[0] == '^') {
     free(s);
     if (mode & MPC_RE_MULTILINE) {
       return mpc_and(2, mpcf_snd, mpc_or(2, mpc_soi(), mpc_boundary_newline()), mpc_lift(mpcf_ctor_str), free);
     } else {
       return mpc_and(2, mpcf_snd, mpc_soi(), mpc_lift(mpcf_ctor_str), free);
     }
   }
  
   /* End of Input */
   if (s[0] == '$') {
     free(s);
     if (mode & MPC_RE_MULTILINE) {
       return mpc_or(2,
         mpc_newline(),
         mpc_and(2, mpcf_snd, mpc_eoi(), mpc_lift(mpcf_ctor_str), free));
     } else {
       return mpc_or(2,
         mpc_and(2, mpcf_fst, mpc_newline(), mpc_eoi(), free),
         mpc_and(2, mpcf_snd, mpc_eoi(), mpc_lift(mpcf_ctor_str), free));
     }
   }
  
   /* Regex Escape */
   if (s[0] == '\\') {
     p = mpc_re_escape_char(s[1]);
     p = (p == NULL) ? mpc_char(s[1]) : p;
     free(s);
     return p;
   }
  
   /* Regex Standard */
   p = mpc_char(s[0]);
   free(s);
   return p;
 }

References free(), mpc_and(), mpc_any(), mpc_boundary_newline(), mpc_char(), mpc_eoi(), mpc_expect(), mpc_lift(), mpc_newline(), mpc_noneof(), mpc_or(), MPC_RE_DOTALL, mpc_re_escape_char(), MPC_RE_MULTILINE, mpc_soi(), mpcf_ctor_str(), mpcf_fst(), mpcf_snd(), NULL, p, s, and x.

Referenced by mpc_re_mode().

◆ mpcf_re_or()

static mpc_val_t* mpcf_re_or	(	int	n,
		mpc_val_t **	xs
	)

static

Definition at line 2165 of file mpc.c.

                                                     {
   (void) n;
   if (xs[1] == NULL) { return xs[0]; }
   else { return mpc_or(2, xs[0], xs[1]); }
 }

References mpc_or(), n, and NULL.

Referenced by mpc_re_mode().

◆ mpcf_re_range()

static mpc_val_t* mpcf_re_range ( mpc_val_t * x )

static

Definition at line 2290 of file mpc.c.

                                               {
  
   mpc_parser_t *out;
   size_t i, j;
   size_t start, end;
   const char *tmp = NULL;
   const char *s = x;
   int comp = s[0] == '^' ? 1 : 0;
   char *range = calloc(1,1);
  
   if (s[0] == '\0') { free(range); free(x); return mpc_fail("Invalid Regex Range Expression"); }
   if (s[0] == '^' &&
       s[1] == '\0') { free(range); free(x); return mpc_fail("Invalid Regex Range Expression"); }
  
   for (i = comp; i < strlen(s); i++){
  
     /* Regex Range Escape */
     if (s[i] == '\\') {
       tmp = mpc_re_range_escape_char(s[i+1]);
       if (tmp != NULL) {
         range = realloc(range, strlen(range) + strlen(tmp) + 1);
         strcat(range, tmp);
       } else {
         range = realloc(range, strlen(range) + 1 + 1);
         range[strlen(range) + 1] = '\0';
         range[strlen(range) + 0] = s[i+1];
       }
       i++;
     }
  
     /* Regex Range...Range */
     else if (s[i] == '-') {
       if (s[i+1] == '\0' || i == 0) {
           range = realloc(range, strlen(range) + strlen("-") + 1);
           strcat(range, "-");
       } else {
         start = s[i-1]+1;
         end = s[i+1]-1;
         for (j = start; j <= end; j++) {
           range = realloc(range, strlen(range) + 1 + 1 + 1);
           range[strlen(range) + 1] = '\0';
           range[strlen(range) + 0] = (char)j;
         }
       }
     }
  
     /* Regex Range Normal */
     else {
       range = realloc(range, strlen(range) + 1 + 1);
       range[strlen(range) + 1] = '\0';
       range[strlen(range) + 0] = s[i];
     }
  
   }
  
   out = comp == 1 ? mpc_noneof(range) : mpc_oneof(range);
  
   free(x);
   free(range);
  
   return out;
 }

References calloc(), test_evm::end, free(), i, mpc_fail(), mpc_noneof(), mpc_oneof(), mpc_re_range_escape_char(), NULL, out, capstone::range, realloc(), s, start, autogen_x86imm::tmp, and x.

Referenced by mpc_re_mode().

◆ mpcf_re_repeat()

static mpc_val_t* mpcf_re_repeat	(	int	n,
		mpc_val_t **	xs
	)

static

Definition at line 2180 of file mpc.c.

                                                         {
   int num;
   (void) n;
   if (xs[1] == NULL) { return xs[0]; }
   switch(((char*)xs[1])[0])
   {
     case '*': { free(xs[1]); return mpc_many(mpcf_strfold, xs[0]); }; break;
     case '+': { free(xs[1]); return mpc_many1(mpcf_strfold, xs[0]); }; break;
     case '?': { free(xs[1]); return mpc_maybe_lift(xs[0], mpcf_ctor_str); }; break;
     default:
       num = *(int*)xs[1];
       free(xs[1]);
   }
  
   return mpc_count(num, mpcf_strfold, xs[0], free);
 }

References free(), mpc_count(), mpc_many(), mpc_many1(), mpc_maybe_lift(), mpcf_ctor_str(), mpcf_strfold(), n, NULL, and num.

Referenced by mpc_re_mode().

◆ mpcf_snd()

mpc_val_t* mpcf_snd	(	int	n,
		mpc_val_t **	xs
	)

Definition at line 2626 of file mpc.c.

2626 { (void) n; return xs[1]; }

References n.

Referenced by mpc_parse_fold(), mpc_re_escape_char(), mpc_startwith(), mpc_strip(), mpc_stripl(), mpc_whole(), and mpcf_re_escape().

◆ mpcf_snd_free()

mpc_val_t* mpcf_snd_free	(	int	n,
		mpc_val_t **	xs
	)

Definition at line 2638 of file mpc.c.

2638 { return mpcf_nth_free(n, xs, 1); }

References mpcf_nth_free(), and n.

Referenced by mpc_between(), mpc_parse_fold(), mpc_re_mode(), mpc_tok_between(), mpca_grammar_st(), and mpca_lang_st().

◆ mpcf_state_ast()

mpc_val_t* mpcf_state_ast	(	int	n,
		mpc_val_t **	xs
	)

Definition at line 3256 of file mpc.c.

                                                  {
   mpc_state_t *s = ((mpc_state_t**)xs)[0];
   mpc_ast_t *a = ((mpc_ast_t**)xs)[1];
   (void)n;
   a = mpc_ast_state(a, *s);
   free(s);
   return a;
 }

References a, free(), mpc_ast_state(), n, and s.

Referenced by mpc_parse_fold(), and mpca_state().

◆ mpcf_str_ast()

mpc_val_t* mpcf_str_ast ( mpc_val_t * c )

Definition at line 3250 of file mpc.c.

                                       {
   mpc_ast_t *a = mpc_ast_new("", c);
   free(c);
   return a;
 }

References a, c, free(), and mpc_ast_new().

Referenced by mpc_parse_apply(), mpcaf_fold_regex(), mpcaf_grammar_char(), and mpcaf_grammar_string().

◆ mpcf_strfold()

mpc_val_t* mpcf_strfold	(	int	n,
		mpc_val_t **	xs
	)

Definition at line 2648 of file mpc.c.

                                                {
   int i;
   size_t l = 0;
  
   if (n == 0) { return calloc(1, 1); }
  
   for (i = 0; i < n; i++) { l += strlen(xs[i]); }
  
   xs[0] = realloc(xs[0], l + 1);
  
   for (i = 1; i < n; i++) {
     strcat(xs[0], xs[i]); free(xs[i]);
   }
  
   return xs[0];
 }

References calloc(), free(), i, n, and realloc().

Referenced by mpc_digits(), mpc_escape(), mpc_hexdigits(), mpc_ident(), mpc_octdigits(), mpc_optimise_unretained(), mpc_parse_fold(), mpc_re_mode(), mpc_real(), mpc_regex_lit(), mpc_string_lit(), mpc_whitespaces(), mpca_grammar_st(), mpca_lang_st(), mpcf_re_and(), and mpcf_re_repeat().

◆ mpcf_strtrim()

mpc_val_t* mpcf_strtrim ( mpc_val_t * x )

Definition at line 2479 of file mpc.c.

                                       {
   return mpcf_strtriml(mpcf_strtrimr(x));
 }

References mpcf_strtriml(), mpcf_strtrimr(), and x.

◆ mpcf_strtriml()

mpc_val_t* mpcf_strtriml ( mpc_val_t * x )

Definition at line 2462 of file mpc.c.

                                        {
   char *s = x;
   while (isspace((unsigned char)*s)) {
     memmove(s, s+1, strlen(s));
   }
   return s;
 }

References isspace, s, and x.

Referenced by mpcf_strtrim().

◆ mpcf_strtrimr()

mpc_val_t* mpcf_strtrimr ( mpc_val_t * x )

Definition at line 2470 of file mpc.c.

                                        {
   char *s = x;
   size_t l = strlen(s);
   while (l > 0 && isspace((unsigned char)s[l-1])) {
     s[l-1] = '\0'; l--;
   }
   return s;
 }

References isspace, s, and x.

Referenced by mpcf_strtrim().

◆ mpcf_trd()

mpc_val_t* mpcf_trd	(	int	n,
		mpc_val_t **	xs
	)

Definition at line 2627 of file mpc.c.

2627 { (void) n; return xs[2]; }

References n.

Referenced by mpc_parse_fold().

◆ mpcf_trd_free()

mpc_val_t* mpcf_trd_free	(	int	n,
		mpc_val_t **	xs
	)

Definition at line 2639 of file mpc.c.

2639 { return mpcf_nth_free(n, xs, 2); }

References mpcf_nth_free(), and n.

Referenced by mpc_parse_fold().

◆ mpcf_unescape()

mpc_val_t* mpcf_unescape ( mpc_val_t * x )

Definition at line 2582 of file mpc.c.

                                        {
   mpc_val_t *y = mpcf_unescape_new(x, mpc_escape_input_c, mpc_escape_output_c);
   free(x);
   return y;
 }

References free(), mpc_escape_input_c, mpc_escape_output_c, mpcf_unescape_new(), and x.

Referenced by mpcaf_grammar_char(), and mpcaf_grammar_string().

◆ mpcf_unescape_char_raw()

mpc_val_t* mpcf_unescape_char_raw ( mpc_val_t * x )

Definition at line 2618 of file mpc.c.

                                                 {
   mpc_val_t *y = mpcf_unescape_new(x, mpc_escape_input_raw_cchar, mpc_escape_output_raw_cchar);
   free(x);
   return y;
 }

References free(), mpc_escape_input_raw_cchar, mpc_escape_output_raw_cchar, mpcf_unescape_new(), and x.

◆ mpcf_unescape_new()

static mpc_val_t* mpcf_unescape_new	(	mpc_val_t *	x,
		const char *	input,
		const char **	output
	)

static

Definition at line 2536 of file mpc.c.

                                                                                           {
  
   int i;
   int found = 0;
   char buff[2];
   char *s = x;
   char *y = calloc(1, 1);
  
   while (*s) {
  
     i = 0;
     found = 0;
  
     while (output[i]) {
       if ((*(s+0)) == output[i][0] &&
           (*(s+1)) == output[i][1]) {
         y = realloc(y, strlen(y) + 1 + 1);
         buff[0] = input[i]; buff[1] = '\0';
         strcat(y, buff);
         found = 1;
         s++;
         break;
       }
       i++;
     }
  
     if (!found) {
       y = realloc(y, strlen(y) + 1 + 1);
       buff[0] = *s; buff[1] = '\0';
       strcat(y, buff);
     }
  
     if (*s == '\0') { break; }
     else { s++; }
   }
  
   return y;
  
 }

References calloc(), found, i, input(), output, realloc(), s, and x.

Referenced by mpcf_unescape(), mpcf_unescape_char_raw(), mpcf_unescape_regex(), and mpcf_unescape_string_raw().

◆ mpcf_unescape_regex()

mpc_val_t* mpcf_unescape_regex ( mpc_val_t * x )

Definition at line 2594 of file mpc.c.

                                              {
   mpc_val_t *y = mpcf_unescape_new(x, mpc_escape_input_raw_re, mpc_escape_output_raw_re);
   free(x);
   return y;
 }

References free(), mpc_escape_input_raw_re, mpc_escape_output_raw_re, mpcf_unescape_new(), and x.

Referenced by mpcaf_fold_regex().

◆ mpcf_unescape_string_raw()

mpc_val_t* mpcf_unescape_string_raw ( mpc_val_t * x )

Definition at line 2606 of file mpc.c.

                                                   {
   mpc_val_t *y = mpcf_unescape_new(x, mpc_escape_input_raw_cstr, mpc_escape_output_raw_cstr);
   free(x);
   return y;
 }

References free(), mpc_escape_input_raw_cstr, mpc_escape_output_raw_cstr, mpcf_unescape_new(), and x.

Variable Documentation

◆ char_unescape_buffer

char char_unescape_buffer[4]

static

Definition at line 604 of file mpc.c.

Referenced by mpc_err_char_unescape().

◆ mpc_escape_input_c

const char mpc_escape_input_c[]

static

Initial value:

= {
  '\a', '\b', '\f', '\n', '\r',
  '\t', '\v', '\\', '\'', '\"', '\0'}

Definition at line 2483 of file mpc.c.

Referenced by mpc_print_unretained(), mpcf_escape(), and mpcf_unescape().

◆ mpc_escape_input_raw_cchar

const char mpc_escape_input_raw_cchar[] = { '\'' }

static

Definition at line 2497 of file mpc.c.

Referenced by mpcf_escape_char_raw(), and mpcf_unescape_char_raw().

◆ mpc_escape_input_raw_cstr

const char mpc_escape_input_raw_cstr[] = { '"' }

static

Definition at line 2494 of file mpc.c.

Referenced by mpcf_escape_string_raw(), and mpcf_unescape_string_raw().

◆ mpc_escape_input_raw_re

const char mpc_escape_input_raw_re[] = { '/' }

static

Definition at line 2491 of file mpc.c.

Referenced by mpcf_escape_regex(), and mpcf_unescape_regex().

◆ mpc_escape_output_c

const char* mpc_escape_output_c[]

static

Initial value:

= {
  "\\a", "\\b", "\\f", "\\n", "\\r", "\\t",
  "\\v", "\\\\", "\\'", "\\\"", "\\0", NULL}

Definition at line 2487 of file mpc.c.

Referenced by mpc_print_unretained(), mpcf_escape(), and mpcf_unescape().

◆ mpc_escape_output_raw_cchar

const char* mpc_escape_output_raw_cchar[] = { "\\'", NULL }

static

Definition at line 2498 of file mpc.c.

Referenced by mpcf_escape_char_raw(), and mpcf_unescape_char_raw().

◆ mpc_escape_output_raw_cstr

const char* mpc_escape_output_raw_cstr[] = { "\\\"", NULL }

static

Definition at line 2495 of file mpc.c.

Referenced by mpcf_escape_string_raw(), and mpcf_unescape_string_raw().

◆ mpc_escape_output_raw_re

const char* mpc_escape_output_raw_re[] = { "\\/", NULL }

static

Definition at line 2492 of file mpc.c.

Referenced by mpcf_escape_regex(), and mpcf_unescape_regex().

Classes

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

◆ MPC_FAILURE

◆ MPC_MAX_RECURSION_DEPTH

◆ MPC_PRIMITIVE

◆ MPC_SUCCESS

Enumeration Type Documentation

◆ anonymous enum

◆ anonymous enum

◆ anonymous enum

◆ anonymous enum

◆ anonymous enum

Function Documentation

◆ is_number()

◆ mpc_alpha()

◆ mpc_alphanum()

◆ mpc_anchor()

◆ mpc_and()

◆ mpc_any()

◆ mpc_apply()

◆ mpc_apply_to()

◆ mpc_ast_add_child()

◆ mpc_ast_add_root()

◆ mpc_ast_add_root_tag()

◆ mpc_ast_add_tag()

◆ mpc_ast_build()

◆ mpc_ast_delete()

◆ mpc_ast_delete_no_children()

◆ mpc_ast_eq()

◆ mpc_ast_get_child()

◆ mpc_ast_get_child_lb()

◆ mpc_ast_get_index()

◆ mpc_ast_get_index_lb()

◆ mpc_ast_new()

◆ mpc_ast_print()

◆ mpc_ast_print_depth()

◆ mpc_ast_print_to()

◆ mpc_ast_state()

◆ mpc_ast_tag()

◆ mpc_ast_traverse_free()

◆ mpc_ast_traverse_next()

◆ mpc_ast_traverse_start()

◆ mpc_between()

◆ mpc_blank()

◆ mpc_boundary()

◆ mpc_boundary_anchor()

◆ mpc_boundary_newline()

◆ mpc_boundary_newline_anchor()

◆ mpc_braces()

◆ mpc_brackets()

◆ mpc_calloc()

◆ mpc_char()

◆ mpc_char_lit()

◆ mpc_check()

◆ mpc_check_with()

◆ mpc_check_withf()

◆ mpc_checkf()

◆ mpc_cleanup()

◆ mpc_copy()

◆ mpc_count()

◆ mpc_define()

◆ mpc_delete()

◆ mpc_digit()

◆ mpc_digits()

◆ mpc_endwith()

◆ mpc_eoi()

◆ mpc_err_add_expected()

◆ mpc_err_char_unescape()

◆ mpc_err_contains_expected()

◆ mpc_err_count()

◆ mpc_err_delete()

◆ mpc_err_delete_internal()

◆ mpc_err_export()

◆ mpc_err_fail()

◆ mpc_err_file()

◆ mpc_err_many1()