mpc.h File Reference

#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <math.h>
#include <errno.h>
#include <ctype.h>

Go to the source code of this file.

Classes
struct	mpc_state_t
struct	mpc_err_t
union	mpc_result_t
struct	mpc_ast_t
struct	mpc_ast_trav_t

Typedefs
typedef void	mpc_val_t
typedef struct mpc_parser_t	mpc_parser_t
typedef void(*	mpc_dtor_t) (mpc_val_t *)
typedef mpc_val_t *(*	mpc_ctor_t) (void)
typedef mpc_val_t *(*	mpc_apply_t) (mpc_val_t *)
typedef mpc_val_t *(*	mpc_apply_to_t) (mpc_val_t *, void *)
typedef mpc_val_t *(*	mpc_fold_t) (int, mpc_val_t **)
typedef int(*	mpc_check_t) (mpc_val_t **)
typedef int(*	mpc_check_with_t) (mpc_val_t **, void *)
typedef struct mpc_ast_t	mpc_ast_t
typedef struct mpc_ast_trav_t	mpc_ast_trav_t

Enumerations
enum	{   MPC_RE_DEFAULT = 0 , MPC_RE_M = 1 , MPC_RE_S = 2 , MPC_RE_MULTILINE = 1 ,   MPC_RE_DOTALL = 2 }
enum	mpc_ast_trav_order_t { mpc_ast_trav_order_pre , mpc_ast_trav_order_post }
enum	{ MPCA_LANG_DEFAULT = 0 , MPCA_LANG_PREDICTIVE = 1 , MPCA_LANG_WHITESPACE_SENSITIVE = 2 }

Functions
void	mpc_err_delete (mpc_err_t *e)
char *	mpc_err_string (mpc_err_t *e)
void	mpc_err_print (mpc_err_t *e)
void	mpc_err_print_to (mpc_err_t *e, FILE *f)
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)
mpc_parser_t *	mpc_new (const char *name)
mpc_parser_t *	mpc_copy (mpc_parser_t *a)
mpc_parser_t *	mpc_define (mpc_parser_t *p, mpc_parser_t *a)
mpc_parser_t *	mpc_undefine (mpc_parser_t *p)
void	mpc_delete (mpc_parser_t *p)
void	mpc_cleanup (int n,...)
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_pass (void)
mpc_parser_t *	mpc_fail (const char *m)
mpc_parser_t *	mpc_failf (const char *fmt,...)
mpc_parser_t *	mpc_lift (mpc_ctor_t f)
mpc_parser_t *	mpc_lift_val (mpc_val_t *x)
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 *e)
mpc_parser_t *	mpc_expectf (mpc_parser_t *a, const char *fmt,...)
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_not (mpc_parser_t *a, mpc_dtor_t da)
mpc_parser_t *	mpc_not_lift (mpc_parser_t *a, mpc_dtor_t da, mpc_ctor_t lf)
mpc_parser_t *	mpc_maybe (mpc_parser_t *a)
mpc_parser_t *	mpc_maybe_lift (mpc_parser_t *a, mpc_ctor_t lf)
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_predictive (mpc_parser_t *a)
mpc_parser_t *	mpc_eoi (void)
mpc_parser_t *	mpc_soi (void)
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)
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)
mpc_val_t *	mpcf_escape (mpc_val_t *x)
mpc_val_t *	mpcf_escape_regex (mpc_val_t *x)
mpc_val_t *	mpcf_escape_string_raw (mpc_val_t *x)
mpc_val_t *	mpcf_escape_char_raw (mpc_val_t *x)
mpc_val_t *	mpcf_unescape (mpc_val_t *x)
mpc_val_t *	mpcf_unescape_regex (mpc_val_t *x)
mpc_val_t *	mpcf_unescape_string_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)
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_freefold (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)
mpc_parser_t *	mpc_re (const char *re)
mpc_parser_t *	mpc_re_mode (const char *re, int mode)
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)
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)
void	mpc_ast_delete (mpc_ast_t *a)
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)
int	mpc_ast_eq (mpc_ast_t *a, mpc_ast_t *b)
mpc_val_t *	mpcf_fold_ast (int n, mpc_val_t **as)
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_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_state (mpc_parser_t *a)
mpc_parser_t *	mpca_total (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_grammar (int flags, const char *grammar,...)
mpc_err_t *	mpca_lang (int flags, const char *language,...)
mpc_err_t *	mpca_lang_file (int flags, FILE *f,...)
mpc_err_t *	mpca_lang_pipe (int flags, FILE *f,...)
mpc_err_t *	mpca_lang_contents (int flags, const char *filename,...)
void	mpc_print (mpc_parser_t *p)
void	mpc_optimise (mpc_parser_t *p)
void	mpc_stats (mpc_parser_t *p)
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 *))
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 *))

Typedef Documentation

mpc_apply_t

typedef mpc_val_t*(* mpc_apply_t) (mpc_val_t *)

Definition at line 81 of file mpc.h.

mpc_apply_to_t

typedef mpc_val_t*(* mpc_apply_to_t) (mpc_val_t *, void *)

Definition at line 82 of file mpc.h.

mpc_ast_t

typedef struct mpc_ast_t mpc_ast_t

mpc_ast_trav_t

typedef struct mpc_ast_trav_t mpc_ast_trav_t

mpc_check_t

typedef int(* mpc_check_t) (mpc_val_t **)

Definition at line 85 of file mpc.h.

mpc_check_with_t

typedef int(* mpc_check_with_t) (mpc_val_t **, void *)

Definition at line 86 of file mpc.h.

mpc_ctor_t

typedef mpc_val_t*(* mpc_ctor_t) (void)

Definition at line 79 of file mpc.h.

mpc_dtor_t

typedef void(* mpc_dtor_t) (mpc_val_t *)

Definition at line 78 of file mpc.h.

mpc_fold_t

typedef mpc_val_t*(* mpc_fold_t) (int, mpc_val_t **)

Definition at line 83 of file mpc.h.

mpc_parser_t

typedef struct mpc_parser_t mpc_parser_t

Definition at line 58 of file mpc.h.

mpc_val_t

typedef void mpc_val_t

Definition at line 58 of file mpc.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
MPC_RE_DEFAULT
MPC_RE_M
MPC_RE_S
MPC_RE_MULTILINE
MPC_RE_DOTALL

Definition at line 269 of file mpc.h.

     {
  MPC_RE_DEFAULT   = 0,
  MPC_RE_M         = 1,
  MPC_RE_S         = 2,
  MPC_RE_MULTILINE = 1,
  MPC_RE_DOTALL    = 2
};

anonymous enum

anonymous enum

Enumerator
MPCA_LANG_DEFAULT
MPCA_LANG_PREDICTIVE
MPCA_LANG_WHITESPACE_SENSITIVE

Definition at line 354 of file mpc.h.

     {
  MPCA_LANG_DEFAULT              = 0,
  MPCA_LANG_PREDICTIVE           = 1,
  MPCA_LANG_WHITESPACE_SENSITIVE = 2
};

mpc_ast_trav_order_t

enum mpc_ast_trav_order_t

Enumerator
mpc_ast_trav_order_pre
mpc_ast_trav_order_post

Definition at line 310 of file mpc.h.

             {
  mpc_ast_trav_order_pre,
  mpc_ast_trav_order_post
} mpc_ast_trav_order_t;

Function Documentation

mpc_alpha()

mpc_parser_t* mpc_alpha

(

void

)

Definition at line 2025 of file mpc.c.

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

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.

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

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

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

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.

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

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

Referenced by mpc_re_escape_char().

mpc_boundary_newline()

mpc_parser_t* mpc_boundary_newline

(

void

)

Definition at line 2006 of file mpc.c.

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

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

Referenced by mpcf_re_escape().

mpc_braces()

mpc_parser_t* mpc_braces	(	mpc_parser_t *	a,
		mpc_dtor_t	ad
	)

Definition at line 2100 of file mpc.c.

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

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.

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

References a, and mpc_between().

Referenced by mpc_re_mode().

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.

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

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

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.

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

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_delete()

void mpc_err_delete

(

mpc_err_t *

e

)

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_print()

void mpc_err_print

(

mpc_err_t *

e

)

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 *	e,
		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_string()

char* mpc_err_string

(

mpc_err_t *

e

)

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_escape()

mpc_parser_t* mpc_escape

(

void

)

Definition at line 2014 of file mpc.c.

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

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 *	e
	)

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_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_hex()

mpc_parser_t* mpc_hex

(

void

)

Definition at line 2030 of file mpc.c.

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

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.

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

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

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_int()

mpc_parser_t* mpc_int

(

void

)

Definition at line 2029 of file mpc.c.

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

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

f

)

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.

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

References mpc_expect(), and mpc_oneof().

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

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

References mpc_char(), and mpc_expect().

Referenced by mpcf_re_escape().

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.

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

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.

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

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.

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

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

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

{ 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_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_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_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_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_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_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_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_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_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.

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

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

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

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

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.

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

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

{ return mpc_tok(mpc_string(s)); }

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.

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

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

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

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.

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

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

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

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

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_underscore()

mpc_parser_t* mpc_underscore

(

void

)

Definition at line 2026 of file mpc.c.

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

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

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

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

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

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

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_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 *	f,
			...
	)

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_many()

mpc_parser_t* mpca_many

(

mpc_parser_t *

a

)

Definition at line 3283 of file mpc.c.

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

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

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

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

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

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

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

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.

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

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

{ (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_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 **	as
	)

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.

{ free(x); return NULL; }

References free(), NULL, and x.

Referenced by mpc_blank(), and mpc_parse_apply().

mpcf_freefold()

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

mpcf_fst()

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

Definition at line 2625 of file mpc.c.

{ (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.

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

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_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_null()

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

Definition at line 2624 of file mpc.c.

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

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

Definition at line 2626 of file mpc.c.

{ (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.

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

{ (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.

{ 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_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.