--- /dev/null
+%{
+#define YYPARSE_PARAM result /* need this to pass a pointer (void *) to yyparse */
+
+#include "postgres.h"
+
+#include "fmgr.h"
+#include "utils/builtins.h"
+#include "hstore.h"
+
+/*
+ * Bison doesn't allocate anything that needs to live across parser calls,
+ * so we can easily have it use palloc instead of malloc. This prevents
+ * memory leaks if we error out during parsing. Note this only works with
+ * bison >= 2.0. However, in bison 1.875 the default is to use alloca()
+ * if possible, so there's not really much problem anyhow, at least if
+ * you're building with gcc.
+ */
+#define YYMALLOC palloc
+#define YYFREE pfree
+
+/* Avoid exit() on fatal scanner errors (a bit ugly -- see yy_fatal_error) */
+#undef fprintf
+#define fprintf(file, fmt, msg) fprintf_to_ereport(fmt, msg)
+
+static void
+fprintf_to_ereport(const char *fmt, const char *msg)
+{
+ ereport(ERROR, (errmsg_internal("%s", msg)));
+}
+
+/* struct string is shared between scan and gram */
+typedef struct string {
+ char *val;
+ int len;
+ int total;
+} string;
+#include <hstore_gram.h>
+
+/* flex 2.5.4 doesn't bother with a decl for this */
+int hstore_yylex(YYSTYPE * yylval_param);
+int hstore_yyparse(void *result);
+void hstore_yyerror(const char *message);
+
+static HStoreValue*
+makeHStoreValueString(HStoreValue* v, string *s)
+{
+ if (v == NULL)
+ v = palloc(sizeof(*v));
+
+ if (s == NULL)
+ {
+ v->type = hsvNull;
+ v->size = sizeof(HEntry);
+ }
+ else if (s->len > HENTRY_POSMASK)
+ {
+ elog(ERROR, "string is too long");
+ }
+ else
+ {
+ v->type = hsvString;
+ v->string.val = s->val;
+ v->string.len = s->len;
+ v->size = sizeof(HEntry) + s->len;
+
+ }
+
+ return v;
+}
+
+static HStoreValue*
+makeHStoreValueNumeric(string *s)
+{
+ Numeric n = NULL;
+ HStoreValue *v;
+ MemoryContext ccxt = CurrentMemoryContext;
+
+ /*
+ * ignore ERRCODE_INVALID_TEXT_REPRESENTATION in parse: our
+ * test stringIsNumber could be not agree with numeric_in
+ */
+
+ PG_TRY();
+ {
+ n = DatumGetNumeric(DirectFunctionCall3(numeric_in, CStringGetDatum(s->val), 0, -1));
+ }
+ PG_CATCH();
+ {
+ ErrorData *errdata;
+ MemoryContext ecxt;
+
+ ecxt = MemoryContextSwitchTo(ccxt);
+ errdata = CopyErrorData();
+ if (errdata->sqlerrcode == ERRCODE_INVALID_TEXT_REPRESENTATION)
+ {
+ FlushErrorState();
+ n = NULL;
+ }
+ else
+ {
+ MemoryContextSwitchTo(ecxt);
+ PG_RE_THROW();
+ }
+ }
+ PG_END_TRY();
+
+ if (n != NULL)
+ {
+ v = palloc(sizeof(*v));
+ v->type = hsvNumeric;
+ v->numeric = n;
+ v->size = 2*sizeof(HEntry) + VARSIZE_ANY(n);
+ }
+ else
+ {
+ v = makeHStoreValueString(NULL, s);
+ }
+
+ return v;
+}
+
+static HStoreValue*
+makeHStoreValueBool(bool val) {
+ HStoreValue *v = palloc(sizeof(*v));
+
+ v->type = hsvBool;
+ v->boolean = val;
+ v->size = sizeof(HEntry);
+
+ return v;
+}
+
+static HStoreValue*
+makeHStoreValueArray(List *list)
+{
+ HStoreValue *v = palloc(sizeof(*v));
+
+ v->type = hsvArray;
+ v->array.scalar = false;
+ v->array.nelems = list_length(list);
+ v->size = sizeof(uint32) /* header */ + sizeof(HEntry) /* parent's entry */ + sizeof(HEntry) - 1 /*alignment*/;
+
+ if (v->array.nelems > 0)
+ {
+ ListCell *cell;
+ int i = 0;
+
+ v->array.elems = palloc(sizeof(HStoreValue) * v->array.nelems);
+
+ foreach(cell, list)
+ {
+ HStoreValue *s = (HStoreValue*)lfirst(cell);
+
+ v->size += s->size;
+
+ v->array.elems[i++] = *s;
+
+ if (v->size > HENTRY_POSMASK)
+ elog(ERROR, "array is too long");
+ }
+ }
+ else
+ {
+ v->array.elems = NULL;
+ }
+
+ return v;
+}
+
+static HStoreValue*
+makeHStoreValuePairs(List *list)
+{
+ HStoreValue *v = palloc(sizeof(*v));
+
+ v->type = hsvHash;
+ v->hash.npairs = list_length(list);
+ v->size = sizeof(uint32) /* header */ + sizeof(HEntry) /* parent's entry */ + sizeof(HEntry) - 1 /*alignment*/;
+
+ if (v->hash.npairs > 0)
+ {
+ ListCell *cell;
+ int i = 0;
+
+ v->hash.pairs = palloc(sizeof(HStorePair) * v->hash.npairs);
+
+ foreach(cell, list)
+ {
+ HStorePair *s = (HStorePair*)lfirst(cell);
+
+ v->size += s->key.size + s->value.size;
+ v->hash.pairs[i].order = i;
+ v->hash.pairs[i++] = *s;
+
+ if (v->size > HENTRY_POSMASK)
+ elog(ERROR, "hstore is too long");
+ }
+
+ uniqueHStoreValue(v);
+ }
+ else
+ {
+ v->hash.pairs = NULL;
+ }
+
+ return v;
+}
+
+static HStorePair*
+makeHStorePair(string *key, HStoreValue *value) {
+ HStorePair *v = palloc(sizeof(*v));
+
+ makeHStoreValueString(&v->key, key);
+ v->value = *value;
+
+ return v;
+}
+
+%}
+
+/* BISON Declarations */
+%pure-parser
+%expect 0
+%name-prefix="hstore_yy"
+%error-verbose
+
+%union {
+ string str;
+ Numeric numeric;
+ List *elems; /* list of HStoreValue */
+ List *pairs; /* list of HStorePair */
+
+ HStoreValue *hvalue;
+ HStorePair *pair;
+}
+
+%token <str> DELIMITER_P NULL_P STRING_P TRUE_P FALSE_P
+ NUMERIC_P
+
+%type <hvalue> result hstore value scalar_value
+%type <str> key
+
+%type <pair> pair
+
+%type <elems> value_list
+%type <pairs> pair_list
+
+/* Grammar follows */
+%%
+
+result:
+ pair_list { *((HStoreValue**)result) = makeHStoreValuePairs($1); }
+ | hstore {
+ if ($1->type == hsvNull)
+ *((HStoreValue**)result) = NULL;
+ else
+ *((HStoreValue**)result) = $1;
+ }
+ | scalar_value {
+ *((HStoreValue**)result) = makeHStoreValueArray(lappend(NIL, $1));
+ (*((HStoreValue**)result))->array.scalar = true;
+ }
+ | /* EMPTY */ { *((HStoreValue**)result) = NULL; }
+ ;
+
+hstore:
+ '{' pair_list '}' { $$ = makeHStoreValuePairs($2); }
+ | '{' value_list '}' { $$ = makeHStoreValueArray($2); }
+ | '[' value_list ']' { $$ = makeHStoreValueArray($2); }
+ | '{' value '}' { $$ = makeHStoreValueArray(lappend(NIL, $2)); }
+ | '[' value ']' { $$ = makeHStoreValueArray(lappend(NIL, $2)); }
+ | '{' '}' { $$ = makeHStoreValueString(NULL, NULL); }
+ | '[' ']' { $$ = makeHStoreValueString(NULL, NULL); }
+ ;
+
+scalar_value:
+ NULL_P { $$ = makeHStoreValueString(NULL, NULL); }
+ | STRING_P { $$ = makeHStoreValueString(NULL, &$1); }
+ | TRUE_P { $$ = makeHStoreValueBool(true); }
+ | FALSE_P { $$ = makeHStoreValueBool(false); }
+ | NUMERIC_P { $$ = makeHStoreValueNumeric(&$1); }
+ ;
+
+value:
+ scalar_value { $$ = $1; }
+ | hstore { $$ = $1; }
+ ;
+
+value_list:
+ value ',' value { $$ = lappend(lappend(NIL, $1), $3); }
+ | value_list ',' value { $$ = lappend($1, $3); }
+ ;
+
+/*
+ * key is always a string, not a bool or numeric
+ */
+key:
+ STRING_P { $$ = $1; }
+ | TRUE_P { $$ = $1; }
+ | FALSE_P { $$ = $1; }
+ | NUMERIC_P { $$ = $1; }
+ | NULL_P { $$ = $1; }
+ ;
+
+pair:
+ key DELIMITER_P value { $$ = makeHStorePair(&$1, $3); }
+ ;
+
+pair_list:
+ pair { $$ = lappend(NIL, $1); }
+ | pair_list ',' pair { $$ = lappend($1, $3); }
+ ;
+
+%%
+
+#include "hstore_scan.c"
projects / hstore.git / blobdiff