From 32043a11c3843b2aa3a936d1e27f7df68bfbadeb Mon Sep 17 00:00:00 2001
From: Jeff Garzik <jeff@bloq.com>
Date: Thu, 28 Jul 2016 18:34:21 -0400
Subject: [PATCH] Pass parser state ptr to each parser executor callback.

---
 Makefile     |   2 +
 README       |   4 +
 exec.c       | 156 +++++++++++-----------
 sql-parser.h | 156 +++++++++++-----------
 sql.y        | 368 +++++++++++++++++++++++++--------------------------
 5 files changed, 346 insertions(+), 340 deletions(-)

diff --git a/Makefile b/Makefile
index 9420761..47eba10 100644
--- a/Makefile
+++ b/Makefile
@@ -35,4 +35,6 @@ clean:
 .SUFFIXES:	.l .y .c
 
 exec.o:	exec.c sql-parser.h
+sql.o: sql-parser.h
+sql.tab.o: sql-parser.h
 
diff --git a/README b/README
index c49f3c7..4eb1531 100644
--- a/README
+++ b/README
@@ -4,3 +4,7 @@ An SQL parser, generated from Bison (Yacc) and Flex (Lex).
 Original version - most of the work - comes from John Levine's
 Flex & Bison book published by O'Reilley.
 
+Example usage:
+
+	$ echo "SELECT a.name,b.address FROM people ORDER BY name;" | ./sql
+
diff --git a/exec.c b/exec.c
index f275da1..7fb02d0 100644
--- a/exec.c
+++ b/exec.c
@@ -56,12 +56,12 @@ static const char *interval_names[] = {
 	[SDI_HOUR_SECOND]	= "SDI_HOUR_SECOND",
 };
 
-void sqlp_alias(const char *alias)
+void sqlp_alias(struct psql_state *pstate, const char *alias)
 {
 	printf("exec ALIAS %s\n", alias);
 }
 
-void sqlp_assign(const char *db_name, const char *name)
+void sqlp_assign(struct psql_state *pstate, const char *db_name, const char *name)
 {
 	printf("exec ASSIGN %s%s%s\n",
 	       db_name ? db_name : "",
@@ -69,119 +69,119 @@ void sqlp_assign(const char *db_name, const char *name)
 	       name);
 }
 
-void sqlp_assign_at(const char *name)
+void sqlp_assign_at(struct psql_state *pstate, const char *name)
 {
 	printf("exec ASSIGN-AT %s\n", name);
 }
 
-void sqlp_bool(int val)
+void sqlp_bool(struct psql_state *pstate, int val)
 {
 	printf("exec BOOL %d\n", val);
 }
 
-void sqlp_call(int n_args, const char *name)
+void sqlp_call(struct psql_state *pstate, int n_args, const char *name)
 {
 	printf("exec CALL %d %s\n", n_args, name);
 }
 
-void sqlp_call_date(int n_args, enum sqlp_expr_ops op)
+void sqlp_call_date(struct psql_state *pstate, int n_args, enum sqlp_expr_ops op)
 {
 	printf("exec CALL %d DATE %s\n",
 	       n_args,
 	       op == SEO_ADD ? "ADD" : "SUB");
 }
 
-void sqlp_call_trim_opts(int trim_opts)
+void sqlp_call_trim_opts(struct psql_state *pstate, int trim_opts)
 {
 	printf("exec CALL TRIM OPTS %d\n", trim_opts);
 }
 
-void sqlp_case(int n_list, int have_else)
+void sqlp_case(struct psql_state *pstate, int n_list, int have_else)
 {
 	printf("exec CASE %d %d\n", n_list, have_else);
 }
 
-void sqlp_caseval(int n_list, int have_else)
+void sqlp_caseval(struct psql_state *pstate, int n_list, int have_else)
 {
 	printf("exec CASEVAL %d %d\n", n_list, have_else);
 }
 
-void sqlp_col_attr(enum sqlp_col_attribs attr)
+void sqlp_col_attr(struct psql_state *pstate, enum sqlp_col_attribs attr)
 {
 	printf("exec ATTR %s\n", attr_names[attr]);
 }
 
-void sqlp_col_attr_uniq(int n_cols)
+void sqlp_col_attr_uniq(struct psql_state *pstate, int n_cols)
 {
 	printf("exec ATTR UNIQUE-KEY %d\n", n_cols);
 }
 
-void sqlp_col_attr_comm(const char *comm)
+void sqlp_col_attr_comm(struct psql_state *pstate, const char *comm)
 {
 	printf("exec ATTR COMMENT %s\n", comm);
 }
 
-void sqlp_col_charset(const char *charset)
+void sqlp_col_charset(struct psql_state *pstate, const char *charset)
 {
 	printf("exec ATTR CHARSET %s\n", charset);
 }
 
-void sqlp_col_collate(const char *collate)
+void sqlp_col_collate(struct psql_state *pstate, const char *collate)
 {
 	printf("exec ATTR COLLATE %s\n", collate);
 }
 
-void sqlp_col_def_str(const char *str)
+void sqlp_col_def_str(struct psql_state *pstate, const char *str)
 {
 	printf("exec ATTR DEFAULT-STR %s\n", str);
 }
 
-void sqlp_col_def_num(int num)
+void sqlp_col_def_num(struct psql_state *pstate, int num)
 {
 	printf("exec ATTR DEFAULT-NUM %d\n", num);
 }
 
-void sqlp_col_def_float(float num)
+void sqlp_col_def_float(struct psql_state *pstate, float num)
 {
 	printf("exec ATTR DEFAULT-FLOAT %g\n", num);
 }
 
-void sqlp_col_def_bool(int bool)
+void sqlp_col_def_bool(struct psql_state *pstate, int bool)
 {
 	printf("exec ATTR DEFAULT-BOOL %d\n", bool);
 }
 
-void sqlp_col_key_pri(int n_cols)
+void sqlp_col_key_pri(struct psql_state *pstate, int n_cols)
 {
 	printf("exec KEY-PRI %d\n", n_cols);
 }
 
-void sqlp_col_key(int n_cols)
+void sqlp_col_key(struct psql_state *pstate, int n_cols)
 {
 	printf("exec KEY %d\n", n_cols);
 }
 
-void sqlp_col_key_textidx(int n_cols)
+void sqlp_col_key_textidx(struct psql_state *pstate, int n_cols)
 {
 	printf("exec KEY-TEXTIDX %d\n", n_cols);
 }
 
-void sqlp_column(const char *name)
+void sqlp_column(struct psql_state *pstate, const char *name)
 {
 	printf("exec COLUMN %s\n", name);
 }
 
-void sqlp_create_db(int if_ne, const char *name)
+void sqlp_create_db(struct psql_state *pstate, int if_ne, const char *name)
 {
 	printf("exec CREATE-DB %d %s\n", if_ne, name);
 }
 
-void sqlp_create_sel(int ignore_replace)
+void sqlp_create_sel(struct psql_state *pstate, int ignore_replace)
 {
 	printf("exec CREATE-SELECT %d\n", ignore_replace);
 }
 
-void sqlp_create_tbl(int temp, int if_n_exists, int n_cols,
+void sqlp_create_tbl(struct psql_state *pstate, int temp, int if_n_exists, int n_cols,
 		     const char *db_name, const char *name)
 {
 	printf("exec CREATE-TABLE %d %d %d %s%s%s\n",
@@ -191,7 +191,7 @@ void sqlp_create_tbl(int temp, int if_n_exists, int n_cols,
 	       name);
 }
 
-void sqlp_create_tbl_sel(int temp, int if_n_exists, int n_cols,
+void sqlp_create_tbl_sel(struct psql_state *pstate, int temp, int if_n_exists, int n_cols,
 		     const char *db_name, const char *name)
 {
 	printf("exec CREATE-TABLE-SELECT %d %d %d %s%s%s\n",
@@ -201,237 +201,237 @@ void sqlp_create_tbl_sel(int temp, int if_n_exists, int n_cols,
 	       name);
 }
 
-void sqlp_date_interval(enum sqlp_date_intervals interval)
+void sqlp_date_interval(struct psql_state *pstate, enum sqlp_date_intervals interval)
 {
 	printf("exec DATE-INTERVAL %s\n", interval_names[interval]);
 }
 
-void sqlp_def_col(int flags, const char *name)
+void sqlp_def_col(struct psql_state *pstate, int flags, const char *name)
 {
 	printf("exec DEFINE-COL %d %s\n", flags, name);
 }
 
-void sqlp_delete(int opts, const char *name)
+void sqlp_delete(struct psql_state *pstate, int opts, const char *name)
 {
 	printf("exec DELETE %d %s\n", opts, name);
 }
 
-void sqlp_delete_multi(int opts, int n_del, int n_tbl_ref)
+void sqlp_delete_multi(struct psql_state *pstate, int opts, int n_del, int n_tbl_ref)
 {
 	printf("exec DELETE-MULTI %d %d %d\n", opts, n_del, n_tbl_ref);
 }
 
-void sqlp_drop_db(int if_exists, const char *name)
+void sqlp_drop_db(struct psql_state *pstate, int if_exists, const char *name)
 {
 	printf("exec DROP-DB %d %s\n", if_exists, name);
 }
 
-void sqlp_drop_table(int temp, int if_exists, int n_tables)
+void sqlp_drop_table(struct psql_state *pstate, int temp, int if_exists, int n_tables)
 {
 	printf("exec DROP-TABLE %d %d %d\n", temp, if_exists, n_tables);
 }
 
-void sqlp_enum_val(const char *val)
+void sqlp_enum_val(struct psql_state *pstate, const char *val)
 {
 	printf("exec ENUM-VAL %s\n", val);
 }
 
-void sqlp_expr_cmp(int comp)
+void sqlp_expr_cmp(struct psql_state *pstate, int comp)
 {
 	printf("exec CMP %d\n", comp);
 }
 
-void sqlp_expr_is_bool(int val)
+void sqlp_expr_is_bool(struct psql_state *pstate, int val)
 {
 	printf("exec EXPR-IS-BOOL %d\n", val);
 }
 
-void sqlp_expr_is_in(int val)
+void sqlp_expr_is_in(struct psql_state *pstate, int val)
 {
 	printf("exec EXPR-IS-IN %d\n", val);
 }
 
-void sqlp_expr_op(enum sqlp_expr_ops op)
+void sqlp_expr_op(struct psql_state *pstate, enum sqlp_expr_ops op)
 {
 	printf("exec EXPR-OP %s\n", op_names[op]);
 }
 
-void sqlp_expr_cmp_sel(int sel_type, int comp)
+void sqlp_expr_cmp_sel(struct psql_state *pstate, int sel_type, int comp)
 {
 	printf("exec CMP-SELECT %d %d\n", sel_type, comp);
 }
 
-void sqlp_fieldname(const char *db_name, const char *name)
+void sqlp_fieldname(struct psql_state *pstate, const char *db_name, const char *name)
 {
 	printf("exec FIELD-NAME %s.%s\n", db_name, name);
 }
 
-void sqlp_float(float val)
+void sqlp_float(struct psql_state *pstate, float val)
 {
 	printf("exec FLOAT %g\n", val);
 }
 
-void sqlp_group_by_list(int n_list, int opts)
+void sqlp_group_by_list(struct psql_state *pstate, int n_list, int opts)
 {
 	printf("exec GROUPBY-LIST %d %d\n", n_list, opts);
 }
 
-void sqlp_group_by(int opts)
+void sqlp_group_by(struct psql_state *pstate, int opts)
 {
 	printf("exec GROUPBY %d\n", opts);
 }
 
-void sqlp_having(void)
+void sqlp_having(struct psql_state *pstate)
 {
 	printf("exec HAVING\n");
 }
 
-void sqlp_index(const char *name)
+void sqlp_index(struct psql_state *pstate, const char *name)
 {
 	printf("exec INDEX %s\n", name);
 }
 
-void sqlp_index_hint(int n_indexed, int opts)
+void sqlp_index_hint(struct psql_state *pstate, int n_indexed, int opts)
 {
 	printf("exec INDEX-HINT %d %d\n", n_indexed, opts);
 }
 
-void sqlp_ins_cols(int n_cols)
+void sqlp_ins_cols(struct psql_state *pstate, int n_cols)
 {
 	printf("exec INSERT-COLS %d\n", n_cols);
 }
 
-void sqlp_ins_default(void)
+void sqlp_ins_default(struct psql_state *pstate)
 {
 	printf("exec INSERT-DEFAULT\n");
 }
 
-void sqlp_ins_dup_update(int n_assn)
+void sqlp_ins_dup_update(struct psql_state *pstate, int n_assn)
 {
 	printf("exec INSERT DUP-ONUPDATE %d\n", n_assn);
 }
 
-void sqlp_insert(int opts, int n_vals, const char *tbl_name)
+void sqlp_insert(struct psql_state *pstate, int opts, int n_vals, const char *tbl_name)
 {
 	printf("exec INSERT %d %d %s\n", opts, n_vals, tbl_name);
 }
 
-void sqlp_insert_assn(int opts, int n_assn, const char *tbl_name)
+void sqlp_insert_assn(struct psql_state *pstate, int opts, int n_assn, const char *tbl_name)
 {
 	printf("exec INSERT-ASSN %d %d %s\n", opts, n_assn, tbl_name);
 }
 
-void sqlp_insert_sel(int opts, const char *tbl_name)
+void sqlp_insert_sel(struct psql_state *pstate, int opts, const char *tbl_name)
 {
 	printf("exec INSERT-SEL %d %s\n", opts, tbl_name);
 }
 
-void sqlp_into(int n_cols)
+void sqlp_into(struct psql_state *pstate, int n_cols)
 {
 	printf("exec INTO %d\n", n_cols);
 }
 
-void sqlp_join(int opts)
+void sqlp_join(struct psql_state *pstate, int opts)
 {
 	printf("exec JOIN %d\n", opts);
 }
 
-void sqlp_join_expr(void)
+void sqlp_join_expr(struct psql_state *pstate)
 {
 	printf("exec JOIN-ON EXPR\n");
 }
 
-void sqlp_join_using(int n_cols)
+void sqlp_join_using(struct psql_state *pstate, int n_cols)
 {
 	printf("exec JOIN-USING %d\n", n_cols);
 }
 
-void sqlp_limit(int two_expr)
+void sqlp_limit(struct psql_state *pstate, int two_expr)
 {
 	printf("exec LIMIT %d\n", two_expr);
 }
 
-void sqlp_name(const char *name)
+void sqlp_name(struct psql_state *pstate, const char *name)
 {
 	printf("exec NAME %s\n", name);
 }
 
-void sqlp_now(void)
+void sqlp_now(struct psql_state *pstate)
 {
 	printf("exec NOW\n");
 }
 
-void sqlp_number(int val)
+void sqlp_number(struct psql_state *pstate, int val)
 {
 	printf("exec INT/NUMBER %d\n", val);
 }
 
-void sqlp_order_by(int n_list)
+void sqlp_order_by(struct psql_state *pstate, int n_list)
 {
 	printf("exec ORDER-BY %d\n", n_list);
 }
 
-void sqlp_replace_assn(int opts, int n_assn, const char *name)
+void sqlp_replace_assn(struct psql_state *pstate, int opts, int n_assn, const char *name)
 {
 	printf("exec REPLACE-ASSN %d %d %s\n", opts, n_assn, name);
 }
 
-void sqlp_replace_vals(int opts, int n_vals, const char *name)
+void sqlp_replace_vals(struct psql_state *pstate, int opts, int n_vals, const char *name)
 {
 	printf("exec REPLACE-VALS %d %d %s\n", opts, n_vals, name);
 }
 
-void sqlp_replace_sel(int opts, const char *name)
+void sqlp_replace_sel(struct psql_state *pstate, int opts, const char *name)
 {
 	printf("exec REPLACE-SEL %d %s\n", opts, name);
 }
 
-void sqlp_select(int opts, int n_expr, int n_tbl_ref)
+void sqlp_select(struct psql_state *pstate, int opts, int n_expr, int n_tbl_ref)
 {
 	printf("exec SELECT %d %d %d\n", opts, n_expr, n_tbl_ref);
 }
 
-void sqlp_select_nodata(int opts, int n_expr)
+void sqlp_select_nodata(struct psql_state *pstate, int opts, int n_expr)
 {
 	printf("exec SELECT-NODATA %d %d\n", opts, n_expr);
 }
 
-void sqlp_select_all(void)
+void sqlp_select_all(struct psql_state *pstate)
 {
 	printf("exec SELECT-ALL\n");
 }
 
-void sqlp_set(const char *name)
+void sqlp_set(struct psql_state *pstate, const char *name)
 {
 	printf("exec SET %s\n", name);
 }
 
-void sqlp_start_col(void)
+void sqlp_start_col(struct psql_state *pstate)
 {
 	printf("exec START-COL\n");
 }
 
-void sqlp_stmt(void)
+void sqlp_stmt(struct psql_state *pstate)
 {
 	printf("exec STMT\n");
 }
 
-void sqlp_string(const char *str)
+void sqlp_string(struct psql_state *pstate, const char *str)
 {
 	printf("exec STRING %s\n", str);
 }
 
-void sqlp_subquery(void)
+void sqlp_subquery(struct psql_state *pstate)
 {
 	printf("exec SUBQUERY\n");
 }
 
-void sqlp_subquery_as(const char *name)
+void sqlp_subquery_as(struct psql_state *pstate, const char *name)
 {
 	printf("exec SUBQUERY-AS %s\n", name);
 }
 
-void sqlp_table(const char *db_name, const char *name)
+void sqlp_table(struct psql_state *pstate, const char *db_name, const char *name)
 {
 	printf("exec TABLE %s%s%s\n",
 	       db_name ? db_name : "",
@@ -439,27 +439,27 @@ void sqlp_table(const char *db_name, const char *name)
 	       name);
 }
 
-void sqlp_table_refs(int n_refs)
+void sqlp_table_refs(struct psql_state *pstate, int n_refs)
 {
 	printf("exec TABLE-REFERENCES %d\n", n_refs);
 }
 
-void sqlp_update(int opts, int n_tbl_ref, int n_assn)
+void sqlp_update(struct psql_state *pstate, int opts, int n_tbl_ref, int n_assn)
 {
 	printf("exec UPDATE %d %d %d\n", opts, n_tbl_ref, n_assn);
 }
 
-void sqlp_uservar(const char *str)
+void sqlp_uservar(struct psql_state *pstate, const char *str)
 {
 	printf("exec USER-VAR %s\n", str);
 }
 
-void sqlp_values(int n_vals)
+void sqlp_values(struct psql_state *pstate, int n_vals)
 {
 	printf("exec VALUES %d\n", n_vals);
 }
 
-void sqlp_where(void)
+void sqlp_where(struct psql_state *pstate)
 {
 	printf("exec WHERE\n");
 }
diff --git a/sql-parser.h b/sql-parser.h
index 684c2e3..a9bf0b3 100644
--- a/sql-parser.h
+++ b/sql-parser.h
@@ -56,85 +56,85 @@ struct psql_state {
 	yyscan_t	scanner;
 };
 
-extern void sqlp_alias(const char *alias);
-extern void sqlp_assign(const char *db_name, const char *name);
-extern void sqlp_assign_at(const char *name);
-extern void sqlp_bool(int val);
-extern void sqlp_call(int n_args, const char *name);
-extern void sqlp_call_date(int n_args, enum sqlp_expr_ops op);
-extern void sqlp_call_trim_opts(int trim_opts);
-extern void sqlp_case(int n_list, int have_else);
-extern void sqlp_caseval(int n_list, int have_else);
-extern void sqlp_col_attr(enum sqlp_col_attribs attr);
-extern void sqlp_col_attr_uniq(int n_cols);
-extern void sqlp_col_attr_comm(const char *comm);
-extern void sqlp_col_charset(const char *charset);
-extern void sqlp_col_collate(const char *collate);
-extern void sqlp_col_def_str(const char *str);
-extern void sqlp_col_def_num(int num);
-extern void sqlp_col_def_float(float num);
-extern void sqlp_col_def_bool(int bool);
-extern void sqlp_col_key_pri(int n_cols);
-extern void sqlp_col_key(int n_cols);
-extern void sqlp_col_key_textidx(int n_cols);
-extern void sqlp_column(const char *name);
-extern void sqlp_create_db(int if_n_exists, const char *name);
-extern void sqlp_create_tbl(int temp, int if_n_exists, int n_cols,
+extern void sqlp_alias(struct psql_state *pstate, const char *alias);
+extern void sqlp_assign(struct psql_state *pstate, const char *db_name, const char *name);
+extern void sqlp_assign_at(struct psql_state *pstate, const char *name);
+extern void sqlp_bool(struct psql_state *pstate, int val);
+extern void sqlp_call(struct psql_state *pstate, int n_args, const char *name);
+extern void sqlp_call_date(struct psql_state *pstate, int n_args, enum sqlp_expr_ops op);
+extern void sqlp_call_trim_opts(struct psql_state *pstate, int trim_opts);
+extern void sqlp_case(struct psql_state *pstate, int n_list, int have_else);
+extern void sqlp_caseval(struct psql_state *pstate, int n_list, int have_else);
+extern void sqlp_col_attr(struct psql_state *pstate, enum sqlp_col_attribs attr);
+extern void sqlp_col_attr_uniq(struct psql_state *pstate, int n_cols);
+extern void sqlp_col_attr_comm(struct psql_state *pstate, const char *comm);
+extern void sqlp_col_charset(struct psql_state *pstate, const char *charset);
+extern void sqlp_col_collate(struct psql_state *pstate, const char *collate);
+extern void sqlp_col_def_str(struct psql_state *pstate, const char *str);
+extern void sqlp_col_def_num(struct psql_state *pstate, int num);
+extern void sqlp_col_def_float(struct psql_state *pstate, float num);
+extern void sqlp_col_def_bool(struct psql_state *pstate, int bool);
+extern void sqlp_col_key_pri(struct psql_state *pstate, int n_cols);
+extern void sqlp_col_key(struct psql_state *pstate, int n_cols);
+extern void sqlp_col_key_textidx(struct psql_state *pstate, int n_cols);
+extern void sqlp_column(struct psql_state *pstate, const char *name);
+extern void sqlp_create_db(struct psql_state *pstate, int if_n_exists, const char *name);
+extern void sqlp_create_tbl(struct psql_state *pstate, int temp, int if_n_exists, int n_cols,
 			    const char *db_name, const char *name);
-extern void sqlp_create_tbl_sel(int temp, int if_n_exists, int n_cols,
+extern void sqlp_create_tbl_sel(struct psql_state *pstate, int temp, int if_n_exists, int n_cols,
 			    const char *db_name, const char *name);
-extern void sqlp_create_sel(int ignore_replace);
-extern void sqlp_date_interval(enum sqlp_date_intervals interval);
-extern void sqlp_def_col(int flags, const char *name);
-extern void sqlp_delete(int opts, const char *name);
-extern void sqlp_delete_multi(int opts, int n_del, int n_tbl_ref);
-extern void sqlp_drop_db(int if_exists, const char *name);
-extern void sqlp_drop_table(int temp, int if_exists, int n_tables);
-extern void sqlp_enum_val(const char *val);
-extern void sqlp_expr_op(enum sqlp_expr_ops op);
-extern void sqlp_expr_cmp(int comp);
-extern void sqlp_expr_cmp_sel(int sel_type, int comp);
-extern void sqlp_expr_is_bool(int val);
-extern void sqlp_expr_is_in(int val);
-extern void sqlp_fieldname(const char *db_name, const char *name);
-extern void sqlp_float(float val);
-extern void sqlp_group_by_list(int n_list, int opts);
-extern void sqlp_group_by(int opts);
-extern void sqlp_having(void);
-extern void sqlp_index(const char *name);
-extern void sqlp_index_hint(int n_indexed, int opts);
-extern void sqlp_ins_cols(int n_cols);
-extern void sqlp_ins_default(void);
-extern void sqlp_ins_dup_update(int n_assn);
-extern void sqlp_insert(int opts, int n_vals, const char *tbl_name);
-extern void sqlp_insert_assn(int opts, int n_assn, const char *tbl_name);
-extern void sqlp_insert_sel(int opts, const char *tbl_name);
-extern void sqlp_into(int n_cols);
-extern void sqlp_join(int opts);
-extern void sqlp_join_expr(void);
-extern void sqlp_join_using(int n_cols);
-extern void sqlp_limit(int two_expr);
-extern void sqlp_name(const char *name);
-extern void sqlp_now(void);
-extern void sqlp_number(int val);
-extern void sqlp_order_by(int n_list);
-extern void sqlp_replace_assn(int opts, int n_assn, const char *name);
-extern void sqlp_replace_vals(int opts, int n_vals, const char *name);
-extern void sqlp_replace_sel(int opts, const char *name);
-extern void sqlp_select(int opts, int n_expr, int n_tbl_ref);
-extern void sqlp_select_nodata(int opts, int n_expr);
-extern void sqlp_select_all(void);
-extern void sqlp_set(const char *name);
-extern void sqlp_start_col(void);
-extern void sqlp_string(const char *str);
-extern void sqlp_stmt(void);
-extern void sqlp_subquery(void);
-extern void sqlp_subquery_as(const char *name);
-extern void sqlp_table(const char *db_name, const char *name);
-extern void sqlp_table_refs(int n_refs);
-extern void sqlp_update(int opts, int n_tbl_ref, int n_assn);
-extern void sqlp_uservar(const char *str);
-extern void sqlp_values(int n_vals);
-extern void sqlp_where(void);
+extern void sqlp_create_sel(struct psql_state *pstate, int ignore_replace);
+extern void sqlp_date_interval(struct psql_state *pstate, enum sqlp_date_intervals interval);
+extern void sqlp_def_col(struct psql_state *pstate, int flags, const char *name);
+extern void sqlp_delete(struct psql_state *pstate, int opts, const char *name);
+extern void sqlp_delete_multi(struct psql_state *pstate, int opts, int n_del, int n_tbl_ref);
+extern void sqlp_drop_db(struct psql_state *pstate, int if_exists, const char *name);
+extern void sqlp_drop_table(struct psql_state *pstate, int temp, int if_exists, int n_tables);
+extern void sqlp_enum_val(struct psql_state *pstate, const char *val);
+extern void sqlp_expr_op(struct psql_state *pstate, enum sqlp_expr_ops op);
+extern void sqlp_expr_cmp(struct psql_state *pstate, int comp);
+extern void sqlp_expr_cmp_sel(struct psql_state *pstate, int sel_type, int comp);
+extern void sqlp_expr_is_bool(struct psql_state *pstate, int val);
+extern void sqlp_expr_is_in(struct psql_state *pstate, int val);
+extern void sqlp_fieldname(struct psql_state *pstate, const char *db_name, const char *name);
+extern void sqlp_float(struct psql_state *pstate, float val);
+extern void sqlp_group_by_list(struct psql_state *pstate, int n_list, int opts);
+extern void sqlp_group_by(struct psql_state *pstate, int opts);
+extern void sqlp_having(struct psql_state *pstate);
+extern void sqlp_index(struct psql_state *pstate, const char *name);
+extern void sqlp_index_hint(struct psql_state *pstate, int n_indexed, int opts);
+extern void sqlp_ins_cols(struct psql_state *pstate, int n_cols);
+extern void sqlp_ins_default(struct psql_state *pstate);
+extern void sqlp_ins_dup_update(struct psql_state *pstate, int n_assn);
+extern void sqlp_insert(struct psql_state *pstate, int opts, int n_vals, const char *tbl_name);
+extern void sqlp_insert_assn(struct psql_state *pstate, int opts, int n_assn, const char *tbl_name);
+extern void sqlp_insert_sel(struct psql_state *pstate, int opts, const char *tbl_name);
+extern void sqlp_into(struct psql_state *pstate, int n_cols);
+extern void sqlp_join(struct psql_state *pstate, int opts);
+extern void sqlp_join_expr(struct psql_state *pstate);
+extern void sqlp_join_using(struct psql_state *pstate, int n_cols);
+extern void sqlp_limit(struct psql_state *pstate, int two_expr);
+extern void sqlp_name(struct psql_state *pstate, const char *name);
+extern void sqlp_now(struct psql_state *pstate);
+extern void sqlp_number(struct psql_state *pstate, int val);
+extern void sqlp_order_by(struct psql_state *pstate, int n_list);
+extern void sqlp_replace_assn(struct psql_state *pstate, int opts, int n_assn, const char *name);
+extern void sqlp_replace_vals(struct psql_state *pstate, int opts, int n_vals, const char *name);
+extern void sqlp_replace_sel(struct psql_state *pstate, int opts, const char *name);
+extern void sqlp_select(struct psql_state *pstate, int opts, int n_expr, int n_tbl_ref);
+extern void sqlp_select_nodata(struct psql_state *pstate, int opts, int n_expr);
+extern void sqlp_select_all(struct psql_state *pstate);
+extern void sqlp_set(struct psql_state *pstate, const char *name);
+extern void sqlp_start_col(struct psql_state *pstate);
+extern void sqlp_string(struct psql_state *pstate, const char *str);
+extern void sqlp_stmt(struct psql_state *pstate);
+extern void sqlp_subquery(struct psql_state *pstate);
+extern void sqlp_subquery_as(struct psql_state *pstate, const char *name);
+extern void sqlp_table(struct psql_state *pstate, const char *db_name, const char *name);
+extern void sqlp_table_refs(struct psql_state *pstate, int n_refs);
+extern void sqlp_update(struct psql_state *pstate, int opts, int n_tbl_ref, int n_assn);
+extern void sqlp_uservar(struct psql_state *pstate, const char *str);
+extern void sqlp_values(struct psql_state *pstate, int n_vals);
+extern void sqlp_where(struct psql_state *pstate);
 
 #endif /* __SQL_PARSER_H__ */
diff --git a/sql.y b/sql.y
index f9e29a4..a2c9f05 100644
--- a/sql.y
+++ b/sql.y
@@ -369,29 +369,29 @@ stmt_list: error ';'
 
    /* statements: select statement */
 
-stmt: select_stmt { sqlp_stmt(); }
+stmt: select_stmt { sqlp_stmt(pstate); }
    ;
 
 select_stmt: SELECT select_opts select_expr_list
-                        { sqlp_select_nodata($2, $3); } ;
+                        { sqlp_select_nodata(pstate, $2, $3); } ;
     | SELECT select_opts select_expr_list
      FROM table_references
      opt_where opt_groupby opt_having opt_orderby opt_limit
-     opt_into_list { sqlp_select($2, $3, $5); } ;
+     opt_into_list { sqlp_select(pstate, $2, $3, $5); } ;
 ;
 
 opt_where: /* nil */ 
-   | WHERE expr { sqlp_where(); };
+   | WHERE expr { sqlp_where(pstate); };
 
 opt_groupby: /* nil */ 
    | GROUP BY groupby_list opt_with_rollup
-                             { sqlp_group_by_list($3, $4); }
+                             { sqlp_group_by_list(pstate, $3, $4); }
 ;
 
 groupby_list: expr opt_asc_desc
-                             { sqlp_group_by($2); $$ = 1; }
+                             { sqlp_group_by(pstate, $2); $$ = 1; }
    | groupby_list ',' expr opt_asc_desc
-                             { sqlp_group_by($4); $$ = $1 + 1; }
+                             { sqlp_group_by(pstate, $4); $$ = $1 + 1; }
    ;
 
 opt_asc_desc: /* nil */ { $$ = 0; }
@@ -403,25 +403,25 @@ opt_with_rollup: /* nil */  { $$ = 0; }
    | WITH ROLLUP  { $$ = 1; }
    ;
 
-opt_having: /* nil */ | HAVING expr { sqlp_having(); };
+opt_having: /* nil */ | HAVING expr { sqlp_having(pstate); };
 
-opt_orderby: /* nil */ | ORDER BY groupby_list { sqlp_order_by($3); }
+opt_orderby: /* nil */ | ORDER BY groupby_list { sqlp_order_by(pstate, $3); }
    ;
 
-opt_limit: /* nil */ | LIMIT expr { sqlp_limit(0); }
-  | LIMIT expr ',' expr             { sqlp_limit(1); }
+opt_limit: /* nil */ | LIMIT expr { sqlp_limit(pstate, 0); }
+  | LIMIT expr ',' expr             { sqlp_limit(pstate, 1); }
   ; 
 
 opt_into_list: /* nil */ 
-   | INTO column_list { sqlp_into($2); }
+   | INTO column_list { sqlp_into(pstate, $2); }
    ;
 
-column_list: NAME          { sqlp_column($1); free($1); $$ = 1; }
+column_list: NAME          { sqlp_column(pstate, $1); free($1); $$ = 1; }
   | STRING                 { lyyerror(@1, "string %s found where name required", $1);
-                              sqlp_column($1); free($1); $$ = 1; }
-  | column_list ',' NAME   { sqlp_column($3); free($3); $$ = $1 + 1; }
+                              sqlp_column(pstate, $1); free($1); $$ = 1; }
+  | column_list ',' NAME   { sqlp_column(pstate, $3); free($3); $$ = $1 + 1; }
   | column_list ',' STRING { lyyerror(@3, "string %s found where name required", $1);
-                            sqlp_column($3); free($3); $$ = $1 + 1; }
+                            sqlp_column(pstate, $3); free($3); $$ = $1 + 1; }
   ;
 
 select_opts:                          { $$ = 0; }
@@ -437,7 +437,7 @@ select_opts:                          { $$ = 0; }
 
 select_expr_list: select_expr { $$ = 1; }
     | select_expr_list ',' select_expr {$$ = $1 + 1; }
-    | '*' { sqlp_select_all(); $$ = 1; }
+    | '*' { sqlp_select_all(pstate); $$ = 1; }
     ;
 
 select_expr: expr opt_as_alias ;
@@ -451,33 +451,33 @@ table_reference:  table_factor
 ;
 
 table_factor:
-    NAME opt_as_alias index_hint { sqlp_table(NULL, $1); free($1); }
-  | NAME '.' NAME opt_as_alias index_hint { sqlp_table($1, $3);
+    NAME opt_as_alias index_hint { sqlp_table(pstate, NULL, $1); free($1); }
+  | NAME '.' NAME opt_as_alias index_hint { sqlp_table(pstate, $1, $3);
                                free($1); free($3); }
-  | table_subquery opt_as NAME { sqlp_subquery_as($3); free($3); }
-  | '(' table_references ')' { sqlp_table_refs($2); }
+  | table_subquery opt_as NAME { sqlp_subquery_as(pstate, $3); free($3); }
+  | '(' table_references ')' { sqlp_table_refs(pstate, $2); }
   ;
 
 opt_as: AS 
   | /* nil */
   ;
 
-opt_as_alias: AS NAME { sqlp_alias($2); free($2); }
-  | NAME              { sqlp_alias($1); free($1); }
+opt_as_alias: AS NAME { sqlp_alias(pstate, $2); free($2); }
+  | NAME              { sqlp_alias(pstate, $1); free($1); }
   | /* nil */
   ;
 
 join_table:
     table_reference opt_inner_cross JOIN table_factor opt_join_condition
-                  { sqlp_join(0100+$2); }
+                  { sqlp_join(pstate, 0100+$2); }
   | table_reference STRAIGHT_JOIN table_factor
-                  { sqlp_join(0200); }
+                  { sqlp_join(pstate, 0200); }
   | table_reference STRAIGHT_JOIN table_factor ON expr
-                  { sqlp_join(0200); }
+                  { sqlp_join(pstate, 0200); }
   | table_reference left_or_right opt_outer JOIN table_factor join_condition
-                  { sqlp_join(0300+$2+$3); }
+                  { sqlp_join(pstate, 0300+$2+$3); }
   | table_reference NATURAL opt_left_or_right_outer JOIN table_factor
-                  { sqlp_join(0400+$3); }
+                  { sqlp_join(pstate, 0400+$3); }
   ;
 
 opt_inner_cross: /* nil */ { $$ = 0; }
@@ -501,17 +501,17 @@ opt_left_or_right_outer: LEFT opt_outer { $$ = 1 + $2; }
 opt_join_condition: join_condition | /* nil */ ;
 
 join_condition:
-    ON expr { sqlp_join_expr(); }
-    | USING '(' column_list ')' { sqlp_join_using($3); }
+    ON expr { sqlp_join_expr(pstate); }
+    | USING '(' column_list ')' { sqlp_join_using(pstate, $3); }
     ;
 
 index_hint:
      USE KEY opt_for_join '(' index_list ')'
-                  { sqlp_index_hint($5, 010+$3); }
+                  { sqlp_index_hint(pstate, $5, 010+$3); }
    | IGNORE KEY opt_for_join '(' index_list ')'
-                  { sqlp_index_hint($5, 020+$3); }
+                  { sqlp_index_hint(pstate, $5, 020+$3); }
    | FORCE KEY opt_for_join '(' index_list ')'
-                  { sqlp_index_hint($5, 030+$3); }
+                  { sqlp_index_hint(pstate, $5, 030+$3); }
    | /* nil */
    ;
 
@@ -519,21 +519,21 @@ opt_for_join: FOR JOIN { $$ = 1; }
    | /* nil */ { $$ = 0; }
    ;
 
-index_list: NAME  { sqlp_index($1); free($1); $$ = 1; }
-   | index_list ',' NAME { sqlp_index($3); free($3); $$ = $1 + 1; }
+index_list: NAME  { sqlp_index(pstate, $1); free($1); $$ = 1; }
+   | index_list ',' NAME { sqlp_index(pstate, $3); free($3); $$ = $1 + 1; }
    ;
 
-table_subquery: '(' select_stmt ')' { sqlp_subquery(); }
+table_subquery: '(' select_stmt ')' { sqlp_subquery(pstate); }
    ;
 
    /* statements: delete statement */
 
-stmt: delete_stmt { sqlp_stmt(); }
+stmt: delete_stmt { sqlp_stmt(pstate); }
    ;
 
 delete_stmt: DELETE delete_opts FROM NAME
     opt_where opt_orderby opt_limit
-                  { sqlp_delete($2, $4); free($4); }
+                  { sqlp_delete(pstate, $2, $4); free($4); }
 ;
 
 delete_opts: delete_opts LOW_PRIORITY { $$ = $1 + 01; }
@@ -545,11 +545,11 @@ delete_opts: delete_opts LOW_PRIORITY { $$ = $1 + 01; }
 delete_stmt: DELETE delete_opts
     delete_list
     FROM table_references opt_where
-            { sqlp_delete_multi($2, $3, $5); }
+            { sqlp_delete_multi(pstate, $2, $3, $5); }
 
-delete_list: NAME opt_dot_star { sqlp_table(NULL, $1); free($1); $$ = 1; }
+delete_list: NAME opt_dot_star { sqlp_table(pstate, NULL, $1); free($1); $$ = 1; }
    | delete_list ',' NAME opt_dot_star
-            { sqlp_table(NULL, $3); free($3); $$ = $1 + 1; }
+            { sqlp_table(pstate, NULL, $3); free($3); $$ = $1 + 1; }
    ;
 
 opt_dot_star: /* nil */ | '.' '*' ;
@@ -557,22 +557,22 @@ opt_dot_star: /* nil */ | '.' '*' ;
 delete_stmt: DELETE delete_opts
     FROM delete_list
     USING table_references opt_where
-            { sqlp_delete_multi($2, $4, $6); }
+            { sqlp_delete_multi(pstate, $2, $4, $6); }
 ;
 
    /* statements: insert statement */
 
-stmt: insert_stmt { sqlp_stmt(); }
+stmt: insert_stmt { sqlp_stmt(pstate); }
    ;
 
 insert_stmt: INSERT insert_opts opt_into NAME
      opt_col_names
      VALUES insert_vals_list
-     opt_ondupupdate { sqlp_insert($2, $7, $4); free($4); }
+     opt_ondupupdate { sqlp_insert(pstate, $2, $7, $4); free($4); }
    ;
 
 opt_ondupupdate: /* nil */
-   | ONDUPLICATE KEY UPDATE insert_asgn_list { sqlp_ins_dup_update($4); }
+   | ONDUPLICATE KEY UPDATE insert_asgn_list { sqlp_ins_dup_update(pstate, $4); }
    ;
 
 insert_opts: /* nil */ { $$ = 0; }
@@ -586,75 +586,75 @@ opt_into: INTO | /* nil */
    ;
 
 opt_col_names: /* nil */
-   | '(' column_list ')' { sqlp_ins_cols($2); }
+   | '(' column_list ')' { sqlp_ins_cols(pstate, $2); }
    ;
 
-insert_vals_list: '(' insert_vals ')' { sqlp_values($2); $$ = 1; }
-   | insert_vals_list ',' '(' insert_vals ')' { sqlp_values($4); $$ = $1 + 1; }
+insert_vals_list: '(' insert_vals ')' { sqlp_values(pstate, $2); $$ = 1; }
+   | insert_vals_list ',' '(' insert_vals ')' { sqlp_values(pstate, $4); $$ = $1 + 1; }
 
 insert_vals:
      expr { $$ = 1; }
-   | DEFAULT { sqlp_ins_default(); $$ = 1; }
+   | DEFAULT { sqlp_ins_default(pstate); $$ = 1; }
    | insert_vals ',' expr { $$ = $1 + 1; }
-   | insert_vals ',' DEFAULT { sqlp_ins_default(); $$ = $1 + 1; }
+   | insert_vals ',' DEFAULT { sqlp_ins_default(pstate); $$ = $1 + 1; }
    ;
 
 insert_stmt: INSERT insert_opts opt_into NAME
     SET insert_asgn_list
     opt_ondupupdate
-     { sqlp_insert_assn($2, $6, $4); free($4); }
+     { sqlp_insert_assn(pstate, $2, $6, $4); free($4); }
    ;
 
 insert_stmt: INSERT insert_opts opt_into NAME opt_col_names
     select_stmt
-    opt_ondupupdate { sqlp_insert_sel($2, $4); free($4); }
+    opt_ondupupdate { sqlp_insert_sel(pstate, $2, $4); free($4); }
   ;
 
 insert_asgn_list:
      NAME COMPARISON expr 
        { if ($2 != 4) { lyyerror(@2,"bad insert assignment to %s", $1); YYERROR; }
-       sqlp_assign(NULL, $1); free($1); $$ = 1; }
+       sqlp_assign(pstate, NULL, $1); free($1); $$ = 1; }
    | NAME COMPARISON DEFAULT
        { if ($2 != 4) { lyyerror(@2,"bad insert assignment to %s", $1); YYERROR; }
-                 sqlp_ins_default(); sqlp_assign(NULL, $1); free($1); $$ = 1; }
+                 sqlp_ins_default(pstate); sqlp_assign(pstate, NULL, $1); free($1); $$ = 1; }
    | insert_asgn_list ',' NAME COMPARISON expr
        { if ($4 != 4) { lyyerror(@4,"bad insert assignment to %s", $1); YYERROR; }
-                 sqlp_assign(NULL, $3); free($3); $$ = $1 + 1; }
+                 sqlp_assign(pstate, NULL, $3); free($3); $$ = $1 + 1; }
    | insert_asgn_list ',' NAME COMPARISON DEFAULT
        { if ($4 != 4) { lyyerror(@4,"bad insert assignment to %s", $1); YYERROR; }
-                 sqlp_ins_default(); sqlp_assign(NULL, $3); free($3); $$ = $1 + 1; }
+                 sqlp_ins_default(pstate); sqlp_assign(pstate, NULL, $3); free($3); $$ = $1 + 1; }
    ;
 
    /** replace just like insert **/
-stmt: replace_stmt { sqlp_stmt(); }
+stmt: replace_stmt { sqlp_stmt(pstate); }
    ;
 
 replace_stmt: REPLACE insert_opts opt_into NAME
      opt_col_names
      VALUES insert_vals_list
-     opt_ondupupdate { sqlp_replace_vals($2, $7, $4); free($4); }
+     opt_ondupupdate { sqlp_replace_vals(pstate, $2, $7, $4); free($4); }
    ;
 
 replace_stmt: REPLACE insert_opts opt_into NAME
     SET insert_asgn_list
     opt_ondupupdate
-     { sqlp_replace_assn($2, $6, $4); free($4); }
+     { sqlp_replace_assn(pstate, $2, $6, $4); free($4); }
    ;
 
 replace_stmt: REPLACE insert_opts opt_into NAME opt_col_names
     select_stmt
-    opt_ondupupdate { sqlp_replace_sel($2, $4); free($4); }
+    opt_ondupupdate { sqlp_replace_sel(pstate, $2, $4); free($4); }
   ;
 
 /** update **/
-stmt: update_stmt { sqlp_stmt(); }
+stmt: update_stmt { sqlp_stmt(pstate); }
    ;
 
 update_stmt: UPDATE update_opts table_references
     SET update_asgn_list
     opt_where
     opt_orderby
-opt_limit { sqlp_update($2, $3, $5); }
+opt_limit { sqlp_update(pstate, $2, $3, $5); }
 ;
 
 update_opts: /* nil */ { $$ = 0; }
@@ -665,27 +665,27 @@ update_opts: /* nil */ { $$ = 0; }
 update_asgn_list:
      NAME COMPARISON expr 
      { if ($2 != 4) { lyyerror(@2,"bad update assignment to %s", $1); YYERROR; }
-	 sqlp_assign(NULL, $1); free($1); $$ = 1; }
+	 sqlp_assign(pstate, NULL, $1); free($1); $$ = 1; }
    | NAME '.' NAME COMPARISON expr 
    { if ($4 != 4) { lyyerror(@4,"bad update assignment to %s", $1); YYERROR; }
-	 sqlp_assign($1, $3); free($1); free($3); $$ = 1; }
+	 sqlp_assign(pstate, $1, $3); free($1); free($3); $$ = 1; }
    | update_asgn_list ',' NAME COMPARISON expr
    { if ($4 != 4) { lyyerror(@4,"bad update assignment to %s", $3); YYERROR; }
-	 sqlp_assign(NULL, $3); free($3); $$ = $1 + 1; }
+	 sqlp_assign(pstate, NULL, $3); free($3); $$ = $1 + 1; }
    | update_asgn_list ',' NAME '.' NAME COMPARISON expr
    { if ($6 != 4) { lyyerror(@6,"bad update  assignment to %s.$s", $3, $5); YYERROR; }
-	 sqlp_assign($3, $5); free($3); free($5); $$ = 1; }
+	 sqlp_assign(pstate, $3, $5); free($3); free($5); $$ = 1; }
    ;
 
 
    /** create database **/
 
-stmt: create_database_stmt { sqlp_stmt(); }
+stmt: create_database_stmt { sqlp_stmt(pstate); }
    ;
 
 create_database_stmt: 
-     CREATE DATABASE opt_if_not_exists NAME { sqlp_create_db($3, $4); free($4); }
-   | CREATE SCHEMA opt_if_not_exists NAME { sqlp_create_db($3, $4); free($4); }
+     CREATE DATABASE opt_if_not_exists NAME { sqlp_create_db(pstate, $3, $4); free($4); }
+   | CREATE SCHEMA opt_if_not_exists NAME { sqlp_create_db(pstate, $3, $4); free($4); }
    ;
 
 opt_if_not_exists:  /* nil */ { $$ = 0; }
@@ -695,12 +695,12 @@ opt_if_not_exists:  /* nil */ { $$ = 0; }
 
    /** drop database **/
 
-stmt: drop_database_stmt { sqlp_stmt(); }
+stmt: drop_database_stmt { sqlp_stmt(pstate); }
    ;
 
 drop_database_stmt: 
-     DROP DATABASE opt_if_exists NAME { sqlp_drop_db($3, $4); free($4); }
-   | DROP SCHEMA opt_if_exists NAME { sqlp_drop_db($3, $4); free($4); }
+     DROP DATABASE opt_if_exists NAME { sqlp_drop_db(pstate, $3, $4); free($4); }
+   | DROP SCHEMA opt_if_exists NAME { sqlp_drop_db(pstate, $3, $4); free($4); }
    ;
 
 opt_if_exists:  /* nil */ { $$ = 0; }
@@ -709,35 +709,35 @@ opt_if_exists:  /* nil */ { $$ = 0; }
 
 
    /** create table **/
-stmt: create_table_stmt { sqlp_stmt(); }
+stmt: create_table_stmt { sqlp_stmt(pstate); }
    ;
 
 create_table_stmt: CREATE opt_temporary TABLE opt_if_not_exists NAME
-   '(' create_col_list ')' { sqlp_create_tbl($2, $4, $7, NULL, $5); free($5); }
+   '(' create_col_list ')' { sqlp_create_tbl(pstate, $2, $4, $7, NULL, $5); free($5); }
    ;
 
 create_table_stmt: CREATE opt_temporary TABLE opt_if_not_exists NAME '.' NAME
-   '(' create_col_list ')' { sqlp_create_tbl($2, $4, $9, $5, $7);
+   '(' create_col_list ')' { sqlp_create_tbl(pstate, $2, $4, $9, $5, $7);
                           free($5); free($7); }
    ;
 
 create_table_stmt: CREATE opt_temporary TABLE opt_if_not_exists NAME
    '(' create_col_list ')'
-create_select_statement { sqlp_create_tbl_sel($2, $4, $7, NULL, $5); free($5); }
+create_select_statement { sqlp_create_tbl_sel(pstate, $2, $4, $7, NULL, $5); free($5); }
     ;
 
 create_table_stmt: CREATE opt_temporary TABLE opt_if_not_exists NAME
-   create_select_statement { sqlp_create_tbl_sel($2, $4, 0, NULL, $5); free($5); }
+   create_select_statement { sqlp_create_tbl_sel(pstate, $2, $4, 0, NULL, $5); free($5); }
     ;
 
 create_table_stmt: CREATE opt_temporary TABLE opt_if_not_exists NAME '.' NAME
    '(' create_col_list ')'
-   create_select_statement  { sqlp_create_tbl_sel($2, $4, 0, $5, $7);
+   create_select_statement  { sqlp_create_tbl_sel(pstate, $2, $4, 0, $5, $7);
                               free($5); free($7); }
     ;
 
 create_table_stmt: CREATE opt_temporary TABLE opt_if_not_exists NAME '.' NAME
-   create_select_statement { sqlp_create_tbl_sel($2, $4, 0, $5, $7);
+   create_select_statement { sqlp_create_tbl_sel(pstate, $2, $4, 0, $5, $7);
                           free($5); free($7); }
     ;
 
@@ -745,29 +745,29 @@ create_col_list: create_definition { $$ = 1; }
     | create_col_list ',' create_definition { $$ = $1 + 1; }
     ;
 
-create_definition: { sqlp_start_col(); } NAME data_type column_atts
-                   { sqlp_def_col($3, $2); free($2); }
+create_definition: { sqlp_start_col(pstate); } NAME data_type column_atts
+                   { sqlp_def_col(pstate, $3, $2); free($2); }
 
-    | PRIMARY KEY '(' column_list ')'    { sqlp_col_key_pri($4); }
-    | KEY '(' column_list ')'            { sqlp_col_key($3); }
-    | INDEX '(' column_list ')'          { sqlp_col_key($3); }
-    | FULLTEXT INDEX '(' column_list ')' { sqlp_col_key_textidx($4); }
-    | FULLTEXT KEY '(' column_list ')'   { sqlp_col_key_textidx($4); }
+    | PRIMARY KEY '(' column_list ')'    { sqlp_col_key_pri(pstate, $4); }
+    | KEY '(' column_list ')'            { sqlp_col_key(pstate, $3); }
+    | INDEX '(' column_list ')'          { sqlp_col_key(pstate, $3); }
+    | FULLTEXT INDEX '(' column_list ')' { sqlp_col_key_textidx(pstate, $4); }
+    | FULLTEXT KEY '(' column_list ')'   { sqlp_col_key_textidx(pstate, $4); }
     ;
 
 column_atts: /* nil */ { $$ = 0; }
-    | column_atts NOT NULLX             { sqlp_col_attr(SCA_NOTNULL); $$ = $1 + 1; }
+    | column_atts NOT NULLX             { sqlp_col_attr(pstate, SCA_NOTNULL); $$ = $1 + 1; }
     | column_atts NULLX
-    | column_atts DEFAULT STRING        { sqlp_col_def_str($3); free($3); $$ = $1 + 1; }
-    | column_atts DEFAULT INTNUM        { sqlp_col_def_num($3); $$ = $1 + 1; }
-    | column_atts DEFAULT APPROXNUM     { sqlp_col_def_float($3); $$ = $1 + 1; }
-    | column_atts DEFAULT BOOL          { sqlp_col_def_bool($3); $$ = $1 + 1; }
-    | column_atts AUTO_INCREMENT        { sqlp_col_attr(SCA_AUTOINC); $$ = $1 + 1; }
-    | column_atts UNIQUE '(' column_list ')' { sqlp_col_attr_uniq($4); $$ = $1 + 1; }
-    | column_atts UNIQUE KEY { sqlp_col_attr_uniq(0); $$ = $1 + 1; }
-    | column_atts PRIMARY KEY { sqlp_col_attr(SCA_PRIMARY_KEY); $$ = $1 + 1; }
-    | column_atts KEY { sqlp_col_attr(SCA_PRIMARY_KEY); $$ = $1 + 1; }
-    | column_atts COMMENT STRING { sqlp_col_attr_comm($3); free($3); $$ = $1 + 1; }
+    | column_atts DEFAULT STRING        { sqlp_col_def_str(pstate, $3); free($3); $$ = $1 + 1; }
+    | column_atts DEFAULT INTNUM        { sqlp_col_def_num(pstate, $3); $$ = $1 + 1; }
+    | column_atts DEFAULT APPROXNUM     { sqlp_col_def_float(pstate, $3); $$ = $1 + 1; }
+    | column_atts DEFAULT BOOL          { sqlp_col_def_bool(pstate, $3); $$ = $1 + 1; }
+    | column_atts AUTO_INCREMENT        { sqlp_col_attr(pstate, SCA_AUTOINC); $$ = $1 + 1; }
+    | column_atts UNIQUE '(' column_list ')' { sqlp_col_attr_uniq(pstate, $4); $$ = $1 + 1; }
+    | column_atts UNIQUE KEY { sqlp_col_attr_uniq(pstate, 0); $$ = $1 + 1; }
+    | column_atts PRIMARY KEY { sqlp_col_attr(pstate, SCA_PRIMARY_KEY); $$ = $1 + 1; }
+    | column_atts KEY { sqlp_col_attr(pstate, SCA_PRIMARY_KEY); $$ = $1 + 1; }
+    | column_atts COMMENT STRING { sqlp_col_attr_comm(pstate, $3); free($3); $$ = $1 + 1; }
     ;
 
 opt_length: /* nil */ { $$ = 0; }
@@ -785,8 +785,8 @@ opt_uz: /* nil */ { $$ = 0; }
    ;
 
 opt_csc: /* nil */
-   | opt_csc CHAR SET STRING { sqlp_col_charset($4); free($4); }
-   | opt_csc COLLATE STRING { sqlp_col_collate($3); free($3); }
+   | opt_csc CHAR SET STRING { sqlp_col_charset(pstate, $4); free($4); }
+   | opt_csc COLLATE STRING { sqlp_col_collate(pstate, $3); free($3); }
    ;
 
 data_type:
@@ -822,11 +822,11 @@ data_type:
    | SET '(' enum_list ')' opt_csc { $$ = 210000 + $3; }
    ;
 
-enum_list: STRING { sqlp_enum_val($1); free($1); $$ = 1; }
-   | enum_list ',' STRING { sqlp_enum_val($3); free($3); $$ = $1 + 1; }
+enum_list: STRING { sqlp_enum_val(pstate, $1); free($1); $$ = 1; }
+   | enum_list ',' STRING { sqlp_enum_val(pstate, $3); free($3); $$ = $1 + 1; }
    ;
 
-create_select_statement: opt_ignore_replace opt_as select_stmt { sqlp_create_sel($1); }
+create_select_statement: opt_ignore_replace opt_as select_stmt { sqlp_create_sel(pstate, $1); }
    ;
 
 opt_ignore_replace: /* nil */ { $$ = 0; }
@@ -840,24 +840,24 @@ opt_temporary:   /* nil */ { $$ = 0; }
 
    /** drop table **/
 
-stmt: drop_table_stmt { sqlp_stmt(); }
+stmt: drop_table_stmt { sqlp_stmt(pstate); }
    ;
 
 drop_table_stmt: 
-   DROP opt_temporary TABLE opt_if_exists table_list { sqlp_drop_table($2, $4, $5); }
+   DROP opt_temporary TABLE opt_if_exists table_list { sqlp_drop_table(pstate, $2, $4, $5); }
    ;
 
-table_list: NAME          { sqlp_table(NULL, $1); free($1); $$ = 1; }
+table_list: NAME          { sqlp_table(pstate, NULL, $1); free($1); $$ = 1; }
   | STRING                 { lyyerror(@1, "string %s found where name required", $1);
-                              sqlp_table(NULL, $1); free($1); $$ = 1; }
-  | table_list ',' NAME   { sqlp_table(NULL, $3); free($3); $$ = $1 + 1; }
+                              sqlp_table(pstate, NULL, $1); free($1); $$ = 1; }
+  | table_list ',' NAME   { sqlp_table(pstate, NULL, $3); free($3); $$ = $1 + 1; }
   | table_list ',' STRING { lyyerror(@3, "string %s found where name required", $1);
-                            sqlp_table(NULL, $3); free($3); $$ = $1 + 1; }
+                            sqlp_table(pstate, NULL, $3); free($3); $$ = $1 + 1; }
   ;
 
    /**** set user variables ****/
 
-stmt: set_stmt { sqlp_stmt(); }
+stmt: set_stmt { sqlp_stmt(pstate); }
    ;
 
 set_stmt: SET set_list ;
@@ -866,52 +866,52 @@ set_list: set_expr | set_list ',' set_expr ;
 
 set_expr:
 USERVAR COMPARISON expr { if ($2 != 4) { lyyerror(@2,"bad set to @%s", $1); YYERROR; }
-		 sqlp_set($1); free($1); }
-    | USERVAR ASSIGN expr { sqlp_set($1); free($1); }
+		 sqlp_set(pstate, $1); free($1); }
+    | USERVAR ASSIGN expr { sqlp_set(pstate, $1); free($1); }
     ;
 
    /**** expressions ****/
 
-expr: NAME          { sqlp_name($1); free($1); }
-   | USERVAR         { sqlp_uservar($1); free($1); }
-   | NAME '.' NAME { sqlp_fieldname($1, $3); free($1); free($3); }
-   | STRING        { sqlp_string($1); free($1); }
-   | INTNUM        { sqlp_number($1); }
-   | APPROXNUM     { sqlp_float($1); }
-   | BOOL          { sqlp_bool($1); }
+expr: NAME          { sqlp_name(pstate, $1); free($1); }
+   | USERVAR         { sqlp_uservar(pstate, $1); free($1); }
+   | NAME '.' NAME { sqlp_fieldname(pstate, $1, $3); free($1); free($3); }
+   | STRING        { sqlp_string(pstate, $1); free($1); }
+   | INTNUM        { sqlp_number(pstate, $1); }
+   | APPROXNUM     { sqlp_float(pstate, $1); }
+   | BOOL          { sqlp_bool(pstate, $1); }
    ;
 
-expr: expr '+' expr { sqlp_expr_op(SEO_ADD); }
-   | expr '-' expr { sqlp_expr_op(SEO_SUB); }
-   | expr '*' expr { sqlp_expr_op(SEO_MUL); }
-   | expr '/' expr { sqlp_expr_op(SEO_DIV); }
-   | expr '%' expr { sqlp_expr_op(SEO_MOD); }
-   | expr MOD expr { sqlp_expr_op(SEO_MOD); }
-   | '-' expr %prec UMINUS { sqlp_expr_op(SEO_NEG); }
-   | expr ANDOP expr { sqlp_expr_op(SEO_AND); }
-   | expr OR expr { sqlp_expr_op(SEO_OR); }
-   | expr XOR expr { sqlp_expr_op(SEO_XOR); }
-   | expr COMPARISON expr { sqlp_expr_cmp($2); }
-   | expr COMPARISON '(' select_stmt ')' { sqlp_expr_cmp_sel(0, $2); }
-   | expr COMPARISON ANY '(' select_stmt ')' { sqlp_expr_cmp_sel(1, $2); }
-   | expr COMPARISON SOME '(' select_stmt ')' { sqlp_expr_cmp_sel(2, $2); }
-   | expr COMPARISON ALL '(' select_stmt ')' { sqlp_expr_cmp_sel(3, $2); }
-   | expr '|' expr { sqlp_expr_op(SEO_BITOR); }
-   | expr '&' expr { sqlp_expr_op(SEO_BITAND); }
-   | expr '^' expr { sqlp_expr_op(SEO_BITXOR); }
-   | expr SHIFT expr { sqlp_expr_op($2 == 1 ? SEO_SHL : SEO_SHR); }
-   | NOT expr { sqlp_expr_op(SEO_NOT); }
-   | '!' expr { sqlp_expr_op(SEO_NOT); }
-   | USERVAR ASSIGN expr { sqlp_assign_at($1); free($1); }
+expr: expr '+' expr { sqlp_expr_op(pstate, SEO_ADD); }
+   | expr '-' expr { sqlp_expr_op(pstate, SEO_SUB); }
+   | expr '*' expr { sqlp_expr_op(pstate, SEO_MUL); }
+   | expr '/' expr { sqlp_expr_op(pstate, SEO_DIV); }
+   | expr '%' expr { sqlp_expr_op(pstate, SEO_MOD); }
+   | expr MOD expr { sqlp_expr_op(pstate, SEO_MOD); }
+   | '-' expr %prec UMINUS { sqlp_expr_op(pstate, SEO_NEG); }
+   | expr ANDOP expr { sqlp_expr_op(pstate, SEO_AND); }
+   | expr OR expr { sqlp_expr_op(pstate, SEO_OR); }
+   | expr XOR expr { sqlp_expr_op(pstate, SEO_XOR); }
+   | expr COMPARISON expr { sqlp_expr_cmp(pstate, $2); }
+   | expr COMPARISON '(' select_stmt ')' { sqlp_expr_cmp_sel(pstate, 0, $2); }
+   | expr COMPARISON ANY '(' select_stmt ')' { sqlp_expr_cmp_sel(pstate, 1, $2); }
+   | expr COMPARISON SOME '(' select_stmt ')' { sqlp_expr_cmp_sel(pstate, 2, $2); }
+   | expr COMPARISON ALL '(' select_stmt ')' { sqlp_expr_cmp_sel(pstate, 3, $2); }
+   | expr '|' expr { sqlp_expr_op(pstate, SEO_BITOR); }
+   | expr '&' expr { sqlp_expr_op(pstate, SEO_BITAND); }
+   | expr '^' expr { sqlp_expr_op(pstate, SEO_BITXOR); }
+   | expr SHIFT expr { sqlp_expr_op(pstate, $2 == 1 ? SEO_SHL : SEO_SHR); }
+   | NOT expr { sqlp_expr_op(pstate, SEO_NOT); }
+   | '!' expr { sqlp_expr_op(pstate, SEO_NOT); }
+   | USERVAR ASSIGN expr { sqlp_assign_at(pstate, $1); free($1); }
    ;    
 
-expr:  expr IS NULLX     { sqlp_expr_op(SEO_IS_NULL); }
-   |   expr IS NOT NULLX { sqlp_expr_op(SEO_IS_NULL); sqlp_expr_op(SEO_NOT); }
-   |   expr IS BOOL      { sqlp_expr_is_bool($3); }
-   |   expr IS NOT BOOL  { sqlp_expr_is_bool($4); sqlp_expr_op(SEO_NOT); }
+expr:  expr IS NULLX     { sqlp_expr_op(pstate, SEO_IS_NULL); }
+   |   expr IS NOT NULLX { sqlp_expr_op(pstate, SEO_IS_NULL); sqlp_expr_op(pstate, SEO_NOT); }
+   |   expr IS BOOL      { sqlp_expr_is_bool(pstate, $3); }
+   |   expr IS NOT BOOL  { sqlp_expr_is_bool(pstate, $4); sqlp_expr_op(pstate, SEO_NOT); }
    ;
 
-expr: expr BETWEEN expr AND expr %prec BETWEEN { sqlp_expr_op(SEO_BETWEEN); }
+expr: expr BETWEEN expr AND expr %prec BETWEEN { sqlp_expr_op(pstate, SEO_BETWEEN); }
    ;
 
 
@@ -923,71 +923,71 @@ opt_val_list: /* nil */ { $$ = 0; }
    | val_list
    ;
 
-expr: expr IN '(' val_list ')'       { sqlp_expr_is_in($4); }
-   | expr NOT IN '(' val_list ')'    { sqlp_expr_is_in($5); sqlp_expr_op(SEO_NOT); }
-   | expr IN '(' select_stmt ')'     { sqlp_expr_op(SEO_IN_SELECT); }
-   | expr NOT IN '(' select_stmt ')' { sqlp_expr_op(SEO_IN_SELECT); sqlp_expr_op(SEO_NOT); }
-   | EXISTS '(' select_stmt ')'      { sqlp_expr_op(SEO_EXISTS); if($1)sqlp_expr_op(SEO_NOT); }
+expr: expr IN '(' val_list ')'       { sqlp_expr_is_in(pstate, $4); }
+   | expr NOT IN '(' val_list ')'    { sqlp_expr_is_in(pstate, $5); sqlp_expr_op(pstate, SEO_NOT); }
+   | expr IN '(' select_stmt ')'     { sqlp_expr_op(pstate, SEO_IN_SELECT); }
+   | expr NOT IN '(' select_stmt ')' { sqlp_expr_op(pstate, SEO_IN_SELECT); sqlp_expr_op(pstate, SEO_NOT); }
+   | EXISTS '(' select_stmt ')'      { sqlp_expr_op(pstate, SEO_EXISTS); if($1)sqlp_expr_op(pstate, SEO_NOT); }
    ;
 
-expr: NAME '(' opt_val_list ')' {  sqlp_call($3, $1); free($1); }
+expr: NAME '(' opt_val_list ')' {  sqlp_call(pstate, $3, $1); free($1); }
    ;
 
   /* functions with special syntax */
-expr: FCOUNT '(' '*' ')' { sqlp_call(0, "COUNTALL"); }
-   | FCOUNT '(' expr ')' { sqlp_call(1, "COUNT"); } 
+expr: FCOUNT '(' '*' ')' { sqlp_call(pstate, 0, "COUNTALL"); }
+   | FCOUNT '(' expr ')' { sqlp_call(pstate, 1, "COUNT"); } 
 
-expr: FSUBSTRING '(' val_list ')' {  sqlp_call($3, "SUBSTR");}
-   | FSUBSTRING '(' expr FROM expr ')' {  sqlp_call(2, "SUBSTR"); }
-   | FSUBSTRING '(' expr FROM expr FOR expr ')' {  sqlp_call(3, "SUBSTR"); }
-| FTRIM '(' val_list ')' { sqlp_call($3, "TRIM"); }
-   | FTRIM '(' trim_ltb expr FROM val_list ')' { sqlp_call(3, "TRIM"); }
+expr: FSUBSTRING '(' val_list ')' {  sqlp_call(pstate, $3, "SUBSTR");}
+   | FSUBSTRING '(' expr FROM expr ')' {  sqlp_call(pstate, 2, "SUBSTR"); }
+   | FSUBSTRING '(' expr FROM expr FOR expr ')' {  sqlp_call(pstate, 3, "SUBSTR"); }
+| FTRIM '(' val_list ')' { sqlp_call(pstate, $3, "TRIM"); }
+   | FTRIM '(' trim_ltb expr FROM val_list ')' { sqlp_call(pstate, 3, "TRIM"); }
    ;
 
-trim_ltb: LEADING { sqlp_call_trim_opts(0); }
-   | TRAILING { sqlp_call_trim_opts(1); }
-   | BOTH { sqlp_call_trim_opts(2); }
+trim_ltb: LEADING { sqlp_call_trim_opts(pstate, 0); }
+   | TRAILING { sqlp_call_trim_opts(pstate, 1); }
+   | BOTH { sqlp_call_trim_opts(pstate, 2); }
    ;
 
-expr: FDATE_ADD '(' expr ',' interval_exp ')' { sqlp_call_date(3, SEO_ADD); }
-   |  FDATE_SUB '(' expr ',' interval_exp ')' { sqlp_call_date(3, SEO_SUB); }
+expr: FDATE_ADD '(' expr ',' interval_exp ')' { sqlp_call_date(pstate, 3, SEO_ADD); }
+   |  FDATE_SUB '(' expr ',' interval_exp ')' { sqlp_call_date(pstate, 3, SEO_SUB); }
    ;
 
-interval_exp: INTERVAL expr DAY_HOUR { sqlp_date_interval(SDI_DAY_HOUR); }
-   | INTERVAL expr DAY_MICROSECOND { sqlp_date_interval(SDI_DAY_MICROSECOND); }
-   | INTERVAL expr DAY_MINUTE { sqlp_date_interval(SDI_DAY_MINUTE); }
-   | INTERVAL expr DAY_SECOND { sqlp_date_interval(SDI_DAY_SECOND); }
-   | INTERVAL expr YEAR_MONTH { sqlp_date_interval(SDI_YEAR_MONTH); }
-   | INTERVAL expr YEAR       { sqlp_date_interval(SDI_YEAR); }
-   | INTERVAL expr HOUR_MICROSECOND { sqlp_date_interval(SDI_HOUR_MICROSECOND); }
-   | INTERVAL expr HOUR_MINUTE { sqlp_date_interval(SDI_HOUR_MINUTE); }
-   | INTERVAL expr HOUR_SECOND { sqlp_date_interval(SDI_HOUR_SECOND); }
+interval_exp: INTERVAL expr DAY_HOUR { sqlp_date_interval(pstate, SDI_DAY_HOUR); }
+   | INTERVAL expr DAY_MICROSECOND { sqlp_date_interval(pstate, SDI_DAY_MICROSECOND); }
+   | INTERVAL expr DAY_MINUTE { sqlp_date_interval(pstate, SDI_DAY_MINUTE); }
+   | INTERVAL expr DAY_SECOND { sqlp_date_interval(pstate, SDI_DAY_SECOND); }
+   | INTERVAL expr YEAR_MONTH { sqlp_date_interval(pstate, SDI_YEAR_MONTH); }
+   | INTERVAL expr YEAR       { sqlp_date_interval(pstate, SDI_YEAR); }
+   | INTERVAL expr HOUR_MICROSECOND { sqlp_date_interval(pstate, SDI_HOUR_MICROSECOND); }
+   | INTERVAL expr HOUR_MINUTE { sqlp_date_interval(pstate, SDI_HOUR_MINUTE); }
+   | INTERVAL expr HOUR_SECOND { sqlp_date_interval(pstate, SDI_HOUR_SECOND); }
    ;
 
-expr: CASE expr case_list END           { sqlp_caseval($3, 0); }
-   |  CASE expr case_list ELSE expr END { sqlp_caseval($3, 1); }
-   |  CASE case_list END                { sqlp_case($2, 0); }
-   |  CASE case_list ELSE expr END      { sqlp_case($2, 1); }
+expr: CASE expr case_list END           { sqlp_caseval(pstate, $3, 0); }
+   |  CASE expr case_list ELSE expr END { sqlp_caseval(pstate, $3, 1); }
+   |  CASE case_list END                { sqlp_case(pstate, $2, 0); }
+   |  CASE case_list ELSE expr END      { sqlp_case(pstate, $2, 1); }
    ;
 
 case_list: WHEN expr THEN expr     { $$ = 1; }
          | case_list WHEN expr THEN expr { $$ = $1+1; } 
    ;
 
-expr: expr LIKE expr { sqlp_expr_op(SEO_LIKE); }
-   | expr NOT LIKE expr { sqlp_expr_op(SEO_LIKE); sqlp_expr_op(SEO_NOT); }
+expr: expr LIKE expr { sqlp_expr_op(pstate, SEO_LIKE); }
+   | expr NOT LIKE expr { sqlp_expr_op(pstate, SEO_LIKE); sqlp_expr_op(pstate, SEO_NOT); }
    ;
 
-expr: expr REGEXP expr { sqlp_expr_op(SEO_REGEX); }
-   | expr NOT REGEXP expr { sqlp_expr_op(SEO_REGEX); sqlp_expr_op(SEO_NOT); }
+expr: expr REGEXP expr { sqlp_expr_op(pstate, SEO_REGEX); }
+   | expr NOT REGEXP expr { sqlp_expr_op(pstate, SEO_REGEX); sqlp_expr_op(pstate, SEO_NOT); }
    ;
 
-expr: CURRENT_TIMESTAMP { sqlp_now(); };
-   | CURRENT_DATE	{ sqlp_now(); };
-   | CURRENT_TIME	{ sqlp_now(); };
+expr: CURRENT_TIMESTAMP { sqlp_now(pstate); };
+   | CURRENT_DATE	{ sqlp_now(pstate); };
+   | CURRENT_TIME	{ sqlp_now(pstate); };
    ;
 
-expr: BINARY expr %prec UMINUS { sqlp_expr_op(SEO_STRTOBIN); }
+expr: BINARY expr %prec UMINUS { sqlp_expr_op(pstate, SEO_STRTOBIN); }
    ;
 
 %%