#include "btree_gist.h"
PG_FUNCTION_INFO_V1(btree_decompress);
-Datum btree_decompress(PG_FUNCTION_ARGS);
+Datum btree_decompress(PG_FUNCTION_ARGS);
/*
** GiST DeCompress methods
extern GIST_SPLITVEC *btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v,
BINARY_UNION bu, CMPFUNC cmp);
-
NDBOX *cube_in(char *str);
NDBOX *cube(text *str);
char *cube_out(NDBOX * cube);
-NDBOX *cube_f8(double *);
-NDBOX *cube_f8_f8(double *, double *);
-NDBOX *cube_c_f8(NDBOX *, double *);
-NDBOX *cube_c_f8_f8(NDBOX *, double *, double *);
-int4 cube_dim(NDBOX * a);
+NDBOX *cube_f8(double *);
+NDBOX *cube_f8_f8(double *, double *);
+NDBOX *cube_c_f8(NDBOX *, double *);
+NDBOX *cube_c_f8_f8(NDBOX *, double *, double *);
+int4 cube_dim(NDBOX * a);
double *cube_ll_coord(NDBOX * a, int4 n);
double *cube_ur_coord(NDBOX * a, int4 n);
bool equal = true;
int dim = cube->dim;
int i;
- int ndig;
+ int ndig;
initStringInfo(&buf);
* Get the number of digits to display.
*/
ndig = DBL_DIG + extra_float_digits;
- if (ndig < 1) ndig = 1;
+ if (ndig < 1)
+ ndig = 1;
/*
* while printing the first (LL) corner, check if it is equal to the
j,
k;
- if (n > CUBE_MAX_DIM) n = CUBE_MAX_DIM;
+ if (n > CUBE_MAX_DIM)
+ n = CUBE_MAX_DIM;
if (*r > 0 && n > 0)
dim = n;
if (a->dim > dim)
cube_f8(double *x1)
{
NDBOX *result;
- int size;
+ int size;
+
size = offsetof(NDBOX, x[0]) + sizeof(double) * 2;
result = (NDBOX *) palloc(size);
memset(result, 0, size);
result->size = size;
result->dim = 1;
- result->x[0] = *x1;
- result->x[1] = *x1;
+ result->x[0] = *x1;
+ result->x[1] = *x1;
return result;
}
cube_f8_f8(double *x1, double *x2)
{
NDBOX *result;
- int size;
+ int size;
+
size = offsetof(NDBOX, x[0]) + sizeof(double) * 2;
result = (NDBOX *) palloc(size);
memset(result, 0, size);
result->size = size;
result->dim = 1;
- result->x[0] = *x1;
- result->x[1] = *x2;
+ result->x[0] = *x1;
+ result->x[1] = *x2;
return result;
}
/* Add a dimension to an existing cube with the same values for the new
coordinate */
NDBOX *
-cube_c_f8(NDBOX *c, double *x1)
+cube_c_f8(NDBOX * c, double *x1)
{
NDBOX *result;
- int size;
- int i;
- size = offsetof(NDBOX, x[0]) + sizeof(double) * (c->dim + 1) * 2;
+ int size;
+ int i;
+
+ size = offsetof(NDBOX, x[0]) + sizeof(double) * (c->dim + 1) *2;
result = (NDBOX *) palloc(size);
memset(result, 0, size);
result->size = size;
result->dim = c->dim + 1;
- for (i = 0; i < c->dim; i++) {
- result->x[i] = c->x[i];
- result->x[result->dim + i] = c->x[c->dim + i];
- }
- result->x[result->dim - 1] = *x1;
- result->x[2 * result->dim - 1] = *x1;
+ for (i = 0; i < c->dim; i++)
+ {
+ result->x[i] = c->x[i];
+ result->x[result->dim + i] = c->x[c->dim + i];
+ }
+ result->x[result->dim - 1] = *x1;
+ result->x[2 * result->dim - 1] = *x1;
return result;
}
/* Add a dimension to an existing cube */
NDBOX *
-cube_c_f8_f8(NDBOX *c, double *x1, double *x2)
+cube_c_f8_f8(NDBOX * c, double *x1, double *x2)
{
NDBOX *result;
- int size;
- int i;
- size = offsetof(NDBOX, x[0]) + sizeof(double) * (c->dim + 1) * 2;
+ int size;
+ int i;
+
+ size = offsetof(NDBOX, x[0]) + sizeof(double) * (c->dim + 1) *2;
result = (NDBOX *) palloc(size);
memset(result, 0, size);
result->size = size;
result->dim = c->dim + 1;
- for (i = 0; i < c->dim; i++) {
- result->x[i] = c->x[i];
- result->x[result->dim + i] = c->x[c->dim + i];
- }
- result->x[result->dim - 1] = *x1;
- result->x[2 * result->dim - 1] = *x2;
+ for (i = 0; i < c->dim; i++)
+ {
+ result->x[i] = c->x[i];
+ result->x[result->dim + i] = c->x[c->dim + i];
+ }
+ result->x[result->dim - 1] = *x1;
+ result->x[2 * result->dim - 1] = *x2;
return result;
}
if (result == DBF_VALID)
{
query[0] = '\0';
- j = 0; /* counter for fields in the output */
+ j = 0; /* counter for fields in the output */
for (h = 0; h < dbh->db_nfields; h++)
{
- if (!strlen(fields[h].db_name)) /* When the new fieldname is empty, the field is skipped */
- {
+ if (!strlen(fields[h].db_name)) /* When the new fieldname
+ * is empty, the field is
+ * skipped */
continue;
- }
else
- {
j++;
- }
if (j > 1) /* not for the first field! */
strcat(query, "\t"); /* COPY statement field
typedef struct remoteConn
{
- PGconn *con; /* Hold the remote connection */
- bool remoteTrFlag; /* Indicates whether or not a transaction
- * on remote database is in progress*/
-} remoteConn;
+ PGconn *con; /* Hold the remote connection */
+ bool remoteTrFlag; /* Indicates whether or not a transaction
+ * on remote database is in progress */
+} remoteConn;
/*
* Internal declarations
*/
static remoteConn *getConnectionByName(const char *name);
static HTAB *createConnHash(void);
-static void createNewConnection(const char *name,remoteConn *con);
+static void createNewConnection(const char *name, remoteConn * con);
static void deleteConnection(const char *name);
static char **get_pkey_attnames(Oid relid, int16 *numatts);
static char *get_sql_insert(Oid relid, int16 *pkattnums, int16 pknumatts, char **src_pkattvals, char **tgt_pkattvals);
static char *generate_relation_name(Oid relid);
/* Global */
-List *res_id = NIL;
-int res_id_index = 0;
-PGconn *persistent_conn = NULL;
-static HTAB *remoteConnHash=NULL;
+List *res_id = NIL;
+int res_id_index = 0;
+PGconn *persistent_conn = NULL;
+static HTAB *remoteConnHash = NULL;
-/*
+/*
Following is list that holds multiple remote connections.
Calling convention of each dblink function changes to accept
-connection name as the first parameter. The connection list is
+connection name as the first parameter. The connection list is
much like ecpg e.g. a mapping between a name and a PGconn object.
*/
{
char name[NAMEDATALEN];
remoteConn *rcon;
-} remoteConnHashEnt;
+} remoteConnHashEnt;
/* initial number of connection hashes */
#define NUMCONN 16
PGconn *conn = NULL;
remoteConn *rcon = NULL;
- if(PG_NARGS()==2)
+ if (PG_NARGS() == 2)
{
connstr = GET_STR(PG_GETARG_TEXT_P(1));
connname = GET_STR(PG_GETARG_TEXT_P(0));
}
- else if(PG_NARGS()==1)
+ else if (PG_NARGS() == 1)
connstr = GET_STR(PG_GETARG_TEXT_P(0));
oldcontext = MemoryContextSwitchTo(TopMemoryContext);
- if(connname)
- rcon=(remoteConn *) palloc(sizeof(remoteConn));
+ if (connname)
+ rcon = (remoteConn *) palloc(sizeof(remoteConn));
conn = PQconnectdb(connstr);
MemoryContextSwitchTo(oldcontext);
{
msg = pstrdup(PQerrorMessage(conn));
PQfinish(conn);
- if(rcon)
+ if (rcon)
pfree(rcon);
ereport(ERROR,
- (errcode(ERRCODE_SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION),
- errmsg("could not establish connection"),
- errdetail("%s", msg)));
+ (errcode(ERRCODE_SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION),
+ errmsg("could not establish connection"),
+ errdetail("%s", msg)));
}
- if(connname)
+ if (connname)
{
rcon->con = conn;
createNewConnection(connname, rcon);
remoteConn *rcon = NULL;
PGconn *conn = NULL;
- if (PG_NARGS() ==1 )
+ if (PG_NARGS() == 1)
{
conname = GET_STR(PG_GETARG_TEXT_P(0));
rcon = getConnectionByName(conname);
StringInfo str = makeStringInfo();
remoteConn *rcon = NULL;
- if(PG_NARGS() == 2)
+ if (PG_NARGS() == 2)
{
curname = GET_STR(PG_GETARG_TEXT_P(0));
sql = GET_STR(PG_GETARG_TEXT_P(1));
conn = persistent_conn;
}
- else if(PG_NARGS() == 3)
+ else if (PG_NARGS() == 3)
{
conname = GET_STR(PG_GETARG_TEXT_P(0));
curname = GET_STR(PG_GETARG_TEXT_P(1));
curname = GET_STR(PG_GETARG_TEXT_P(0));
conn = persistent_conn;
}
- else if (PG_NARGS()==2)
+ else if (PG_NARGS() == 2)
{
conname = GET_STR(PG_GETARG_TEXT_P(0));
curname = GET_STR(PG_GETARG_TEXT_P(1));
rcon = getConnectionByName(conname);
- if(rcon)
+ if (rcon)
conn = rcon->con;
}
PGresult *res = NULL;
MemoryContext oldcontext;
char *conname = NULL;
- remoteConn *rcon=NULL;
+ remoteConn *rcon = NULL;
/* stuff done only on the first call of the function */
if (SRF_IS_FIRSTCALL())
howmany = PG_GETARG_INT32(2);
rcon = getConnectionByName(conname);
- if(rcon)
+ if (rcon)
conn = rcon->con;
}
else if (PG_NARGS() == 2)
conn = persistent_conn;
}
- if(!conn)
+ if (!conn)
DBLINK_CONN_NOT_AVAIL;
/* create a function context for cross-call persistence */
if (!res ||
(PQresultStatus(res) != PGRES_COMMAND_OK &&
PQresultStatus(res) != PGRES_TUPLES_OK))
- {
DBLINK_RES_ERROR("sql error");
- }
else if (PQresultStatus(res) == PGRES_COMMAND_OK)
{
/* cursor does not exist - closed already or bad name */
char *connstr = NULL;
char *sql = NULL;
char *conname = NULL;
- remoteConn *rcon=NULL;
+ remoteConn *rcon = NULL;
/* create a function context for cross-call persistence */
funcctx = SRF_FIRSTCALL_INIT();
/* shouldn't happen */
elog(ERROR, "wrong number of arguments");
- if(!conn)
+ if (!conn)
DBLINK_CONN_NOT_AVAIL;
res = PQexec(conn, sql);
TEXTOID, -1, 0, false);
/*
- * and save a copy of the command status string to return
- * as our result tuple
+ * and save a copy of the command status string to return as
+ * our result tuple
*/
sql_cmd_status = PQcmdStatus(res);
funcctx->max_calls = 1;
char *connstr = NULL;
char *sql = NULL;
char *conname = NULL;
- remoteConn *rcon=NULL;
+ remoteConn *rcon = NULL;
bool freeconn = true;
if (PG_NARGS() == 2)
/* shouldn't happen */
elog(ERROR, "wrong number of arguments");
- if(!conn)
+ if (!conn)
DBLINK_CONN_NOT_AVAIL;
res = PQexec(conn, sql);
TEXTOID, -1, 0, false);
/*
- * and save a copy of the command status string to return as
- * our result tuple
+ * and save a copy of the command status string to return as our
+ * result tuple
*/
sql_cmd_status = GET_TEXT(PQcmdStatus(res));
}
else
ereport(ERROR,
- (errcode(ERRCODE_S_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED),
- errmsg("statement returning results not allowed")));
+ (errcode(ERRCODE_S_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED),
+ errmsg("statement returning results not allowed")));
PQclear(res);
(errcode(ERRCODE_UNDEFINED_TABLE),
errmsg("relation \"%s\" does not exist",
GET_STR(PG_GETARG_TEXT_P(0)))));
+
/*
* need a tuple descriptor representing one INT and one TEXT
* column
if (src_nitems != pknumatts)
ereport(ERROR,
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
- errmsg("source key array length must match number of key " \
- "attributes")));
+ errmsg("source key array length must match number of key " \
+ "attributes")));
/*
* get array of pointers to c-strings from the input source array
if (tgt_nitems != pknumatts)
ereport(ERROR,
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
- errmsg("target key array length must match number of key " \
- "attributes")));
+ errmsg("target key array length must match number of key " \
+ "attributes")));
/*
* get array of pointers to c-strings from the input target array
if (tgt_nitems != pknumatts)
ereport(ERROR,
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
- errmsg("target key array length must match number of key " \
- "attributes")));
+ errmsg("target key array length must match number of key " \
+ "attributes")));
/*
* get array of pointers to c-strings from the input target array
if (src_nitems != pknumatts)
ereport(ERROR,
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
- errmsg("source key array length must match number of key " \
- "attributes")));
+ errmsg("source key array length must match number of key " \
+ "attributes")));
/*
* get array of pointers to c-strings from the input source array
if (tgt_nitems != pknumatts)
ereport(ERROR,
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
- errmsg("target key array length must match number of key " \
- "attributes")));
+ errmsg("target key array length must match number of key " \
+ "attributes")));
/*
* get array of pointers to c-strings from the input target array
ereport(ERROR,
(errcode(ERRCODE_MOST_SPECIFIC_TYPE_MISMATCH),
errmsg("field size mismatch"),
- errdetail("Size of remote field \"%s\" does not match " \
- "size of local type \"%s\".", attname,
- format_type_with_typemod(atttypid,
- atttypmod))));
+ errdetail("Size of remote field \"%s\" does not match " \
+ "size of local type \"%s\".", attname,
+ format_type_with_typemod(atttypid,
+ atttypmod))));
attdim = 0;
attisset = false;
static remoteConn *
getConnectionByName(const char *name)
{
- remoteConnHashEnt *hentry;
- char key[NAMEDATALEN];
+ remoteConnHashEnt *hentry;
+ char key[NAMEDATALEN];
- if(!remoteConnHash)
- remoteConnHash=createConnHash();
+ if (!remoteConnHash)
+ remoteConnHash = createConnHash();
MemSet(key, 0, NAMEDATALEN);
snprintf(key, NAMEDATALEN - 1, "%s", name);
- hentry = (remoteConnHashEnt*) hash_search(remoteConnHash,
- key, HASH_FIND, NULL);
+ hentry = (remoteConnHashEnt *) hash_search(remoteConnHash,
+ key, HASH_FIND, NULL);
- if(hentry)
- return(hentry->rcon);
+ if (hentry)
+ return (hentry->rcon);
- return(NULL);
+ return (NULL);
}
static HTAB *
createConnHash(void)
{
- HASHCTL ctl;
- HTAB *ptr;
+ HASHCTL ctl;
+ HTAB *ptr;
ctl.keysize = NAMEDATALEN;
ctl.entrysize = sizeof(remoteConnHashEnt);
- ptr=hash_create("Remote Con hash", NUMCONN, &ctl, HASH_ELEM);
+ ptr = hash_create("Remote Con hash", NUMCONN, &ctl, HASH_ELEM);
- if(!ptr)
+ if (!ptr)
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory")));
- return(ptr);
+ return (ptr);
}
static void
-createNewConnection(const char *name, remoteConn *con)
+createNewConnection(const char *name, remoteConn * con)
{
- remoteConnHashEnt *hentry;
- bool found;
- char key[NAMEDATALEN];
+ remoteConnHashEnt *hentry;
+ bool found;
+ char key[NAMEDATALEN];
- if(!remoteConnHash)
+ if (!remoteConnHash)
remoteConnHash = createConnHash();
MemSet(key, 0, NAMEDATALEN);
hentry = (remoteConnHashEnt *) hash_search(remoteConnHash, key,
HASH_ENTER, &found);
- if(!hentry)
+ if (!hentry)
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory")));
- if(found)
+ if (found)
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_OBJECT),
errmsg("duplicate connection name")));
static void
deleteConnection(const char *name)
{
- remoteConnHashEnt *hentry;
- bool found;
- char key[NAMEDATALEN];
+ remoteConnHashEnt *hentry;
+ bool found;
+ char key[NAMEDATALEN];
- if(!remoteConnHash)
- remoteConnHash=createConnHash();
+ if (!remoteConnHash)
+ remoteConnHash = createConnHash();
MemSet(key, 0, NAMEDATALEN);
snprintf(key, NAMEDATALEN - 1, "%s", name);
hentry = (remoteConnHashEnt *) hash_search(remoteConnHash,
key, HASH_REMOVE, &found);
- if(!hentry)
+ if (!hentry)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("undefined connection name")));
/****************************************************************************
* pending.c
- * $Id: pending.c,v 1.12 2003/07/24 17:52:20 tgl Exp $
+ * $Id: pending.c,v 1.13 2003/08/04 00:43:10 momjian Exp $
*
* This file contains a trigger for Postgresql-7.x to record changes to tables
* to a pending table for mirroring.
*
* Written by Steven Singer (ssinger@navtechinc.com)
* (c) 2001-2002 Navtech Systems Support Inc.
- * ALL RIGHTS RESERVED
+ * ALL RIGHTS RESERVED
*
* Permission to use, copy, modify, and distribute this software and its
* documentation for any purpose, without fee, and without a written agreement
HeapTuple retTuple = NULL;
char *tblname;
char op = 0;
- char *schemaname;
+ char *schemaname;
char *fullyqualtblname;
+
if (fcinfo->context != NULL)
{
tblname = SPI_getrelname(trigdata->tg_relation);
#ifndef NOSCHEMAS
schemaname = get_namespace_name(RelationGetNamespace(trigdata->tg_relation));
- fullyqualtblname = SPI_palloc(strlen(tblname) +
- strlen(schemaname) + 6);
- sprintf(fullyqualtblname,"\"%s\".\"%s\"",
- schemaname,tblname);
+ fullyqualtblname = SPI_palloc(strlen(tblname) +
+ strlen(schemaname) + 6);
+ sprintf(fullyqualtblname, "\"%s\".\"%s\"",
+ schemaname, tblname);
#else
fullyqualtblname = SPI_palloc(strlen(tblname) + 3);
- sprintf(fullyqualtblname,"\"%s\"",tblname);
+ sprintf(fullyqualtblname, "\"%s\"", tblname);
#endif
tupdesc = trigdata->tg_relation->rd_att;
if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
int iResult = 0;
HeapTuple tCurTuple;
- //Points the current tuple(before or after)
- Datum saPlanData[4];
+ /* Points the current tuple(before or after) */
+ Datum saPlanData[4];
Oid taPlanArgTypes[3] = {NAMEOID, CHAROID, INT4OID};
void *vpPlan;
if (cpKeyData == NULL)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
- /* cpTableName already contains quotes... */
+ /* cpTableName already contains quotes... */
errmsg("there is no PRIMARY KEY for table %s",
cpTableName)));
}
else
{
- sprintf(cpFormatedPtr," ");
+ sprintf(cpFormatedPtr, " ");
iUsedDataBlock++;
cpFormatedPtr++;
continue;
if (tpPKeys != NULL)
SPI_pfree(tpPKeys);
#if defined DEBUG_OUTPUT
- elog(NOTICE, "returning DataBlockSize:%d iUsedDataBlock:%d",iDataBlockSize,
- iUsedDataBlock);
+ elog(NOTICE, "returning DataBlockSize:%d iUsedDataBlock:%d", iDataBlockSize,
+ iUsedDataBlock);
#endif
memset(cpDataBlock + iUsedDataBlock, 0, iDataBlockSize - iUsedDataBlock);
if (!OidIsValid(dbid))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_DATABASE),
- errmsg("database \"%s\" does not exist", NameStr(*dbname))));
+ errmsg("database \"%s\" does not exist", NameStr(*dbname))));
dbpath = GetDatabasePath(dbid);
/* Earth's radius is in statute miles. */
-const double EARTH_RADIUS = 3958.747716;
-const double TWO_PI = 2.0 * M_PI;
+const double EARTH_RADIUS = 3958.747716;
+const double TWO_PI = 2.0 * M_PI;
double *geo_distance(Point *pt1, Point *pt2);
if (longdiff > M_PI)
longdiff = TWO_PI - longdiff;
- sino = sqrt(sin(fabs(lat1-lat2)/2.)*sin(fabs(lat1-lat2)/2.) +
- cos(lat1) * cos(lat2) * sin(longdiff/2.)*sin(longdiff/2.));
- if (sino > 1.) sino = 1.;
- *resultp = 2. * EARTH_RADIUS * asin(sino);
+ sino = sqrt(sin(fabs(lat1 - lat2) / 2.) * sin(fabs(lat1 - lat2) / 2.) +
+ cos(lat1) * cos(lat2) * sin(longdiff / 2.) * sin(longdiff / 2.));
+ if (sino > 1.)
+ sino = 1.;
+ *resultp = 2. * EARTH_RADIUS * asin(sino);
return resultp;
}
*
* Copyright 2002 by PostgreSQL Global Development Group
*
- * $Header: /cvsroot/pgsql/contrib/findoidjoins/Attic/findoidjoins.c,v 1.20 2003/05/14 03:25:56 tgl Exp $
+ * $Header: /cvsroot/pgsql/contrib/findoidjoins/Attic/findoidjoins.c,v 1.21 2003/08/04 00:43:10 momjian Exp $
*/
#include "postgres_fe.h"
int
main(int argc, char **argv)
{
- PGconn *conn;
- PQExpBufferData sql;
- PGresult *res;
- PGresult *pkrel_res;
- PGresult *fkrel_res;
- char *fk_relname;
- char *fk_nspname;
- char *fk_attname;
- char *pk_relname;
- char *pk_nspname;
- int fk, pk; /* loop counters */
+ PGconn *conn;
+ PQExpBufferData sql;
+ PGresult *res;
+ PGresult *pkrel_res;
+ PGresult *fkrel_res;
+ char *fk_relname;
+ char *fk_nspname;
+ char *fk_attname;
+ char *pk_relname;
+ char *pk_nspname;
+ int fk,
+ pk; /* loop counters */
if (argc != 2)
{
fprintf(stderr, "Usage: %s database\n", argv[0]);
exit(EXIT_FAILURE);
- }
+ }
initPQExpBuffer(&sql);
resetPQExpBuffer(&sql);
appendPQExpBuffer(&sql, "%s",
- "SET search_path = public;"
- "SELECT c.relname, (SELECT nspname FROM "
- "pg_catalog.pg_namespace n WHERE n.oid = c.relnamespace) AS nspname "
- "FROM pg_catalog.pg_class c "
- "WHERE c.relkind = 'r' "
- "AND c.relhasoids "
- "ORDER BY nspname, c.relname"
+ "SET search_path = public;"
+ "SELECT c.relname, (SELECT nspname FROM "
+ "pg_catalog.pg_namespace n WHERE n.oid = c.relnamespace) AS nspname "
+ "FROM pg_catalog.pg_class c "
+ "WHERE c.relkind = 'r' "
+ "AND c.relhasoids "
+ "ORDER BY nspname, c.relname"
);
res = PQexec(conn, sql.data);
resetPQExpBuffer(&sql);
appendPQExpBuffer(&sql, "%s",
- "SELECT c.relname, "
- "(SELECT nspname FROM pg_catalog.pg_namespace n WHERE n.oid = c.relnamespace) AS nspname, "
- "a.attname "
- "FROM pg_catalog.pg_class c, pg_catalog.pg_attribute a "
- "WHERE a.attnum > 0 AND c.relkind = 'r' "
- "AND a.attrelid = c.oid "
- "AND a.atttypid IN ('pg_catalog.oid'::regtype, "
- " 'pg_catalog.regclass'::regtype, "
- " 'pg_catalog.regoper'::regtype, "
- " 'pg_catalog.regoperator'::regtype, "
- " 'pg_catalog.regproc'::regtype, "
- " 'pg_catalog.regprocedure'::regtype, "
- " 'pg_catalog.regtype'::regtype) "
- "ORDER BY nspname, c.relname, a.attnum"
+ "SELECT c.relname, "
+ "(SELECT nspname FROM pg_catalog.pg_namespace n WHERE n.oid = c.relnamespace) AS nspname, "
+ "a.attname "
+ "FROM pg_catalog.pg_class c, pg_catalog.pg_attribute a "
+ "WHERE a.attnum > 0 AND c.relkind = 'r' "
+ "AND a.attrelid = c.oid "
+ "AND a.atttypid IN ('pg_catalog.oid'::regtype, "
+ " 'pg_catalog.regclass'::regtype, "
+ " 'pg_catalog.regoper'::regtype, "
+ " 'pg_catalog.regoperator'::regtype, "
+ " 'pg_catalog.regproc'::regtype, "
+ " 'pg_catalog.regprocedure'::regtype, "
+ " 'pg_catalog.regtype'::regtype) "
+ "ORDER BY nspname, c.relname, a.attnum"
);
res = PQexec(conn, sql.data);
fkrel_res = res;
/*
- * For each column and each relation-having-OIDs, look to see if
- * the column contains any values matching entries in the relation.
+ * For each column and each relation-having-OIDs, look to see if the
+ * column contains any values matching entries in the relation.
*/
for (fk = 0; fk < PQntuples(fkrel_res); fk++)
resetPQExpBuffer(&sql);
appendPQExpBuffer(&sql,
- "SELECT 1 "
- "FROM \"%s\".\"%s\" t1, "
- "\"%s\".\"%s\" t2 "
- "WHERE t1.\"%s\"::pg_catalog.oid = t2.oid "
- "LIMIT 1",
- fk_nspname, fk_relname, pk_nspname, pk_relname, fk_attname);
+ "SELECT 1 "
+ "FROM \"%s\".\"%s\" t1, "
+ "\"%s\".\"%s\" t2 "
+ "WHERE t1.\"%s\"::pg_catalog.oid = t2.oid "
+ "LIMIT 1",
+ fk_nspname, fk_relname, pk_nspname, pk_relname, fk_attname);
res = PQexec(conn, sql.data);
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_COLUMN),
errmsg("column \"%s\" of \"%s\" does not exist",
- args[i + 1], indexname)));
+ args[i + 1], indexname)));
/* Get the char* representation of the column */
column = SPI_getvalue(rettuple, tupdesc, colnum);
ret = SPI_execp(*(plan->splan), values, NULL, 0);
if (ret != SPI_OK_INSERT)
ereport(ERROR,
- (errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
- errmsg("error executing insert")));
+ (errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
+ errmsg("error executing insert")));
}
pfree(buff);
pfree(data);
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("argument exceeds max length: %d",
- MAX_LEVENSHTEIN_STRLEN)));
+ MAX_LEVENSHTEIN_STRLEN)));
/*
* If either rows or cols is 0, the answer is the other value. This
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("argument exceeds max length: %d",
- MAX_METAPHONE_STRLEN)));
+ MAX_METAPHONE_STRLEN)));
if (!(str_i_len > 0))
ereport(ERROR,
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("output length exceeds max length: %d",
- MAX_METAPHONE_STRLEN)));
+ MAX_METAPHONE_STRLEN)));
if (!(reqlen > 0))
ereport(ERROR,
/* use current transaction context */
pnew = palloc(cb);
+
/*
- * Fix up the fields in the new structure, so Postgres
- * understands
+ * Fix up the fields in the new structure, so Postgres understands
*/
memcpy(pnew, p, cb);
pnew->a.size = cb;
if (!rsi || !IsA(rsi, ReturnSetInfo))
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("int_enum called in context that cannot accept a set")));
+ errmsg("int_enum called in context that cannot accept a set")));
if (!p)
{
*/
typedef struct
{
- int4 len;
- int4 flag;
- char data[1];
-} GISTTYPE;
+ int4 len;
+ int4 flag;
+ char data[1];
+} GISTTYPE;
-#define ALLISTRUE 0x04
+#define ALLISTRUE 0x04
-#define ISALLTRUE(x) ( ((GISTTYPE*)x)->flag & ALLISTRUE )
+#define ISALLTRUE(x) ( ((GISTTYPE*)x)->flag & ALLISTRUE )
-#define GTHDRSIZE ( sizeof(int4)*2 )
+#define GTHDRSIZE ( sizeof(int4)*2 )
#define CALCGTSIZE(flag) ( GTHDRSIZE+(((flag) & ALLISTRUE) ? 0 : SIGLEN) )
-#define GETSIGN(x) ( (BITVECP)( (char*)x+GTHDRSIZE ) )
+#define GETSIGN(x) ( (BITVECP)( (char*)x+GTHDRSIZE ) )
/*
** types for functions
/*
** useful function
*/
-bool isort(int4 *a, const int len);
-ArrayType *new_intArrayType(int num);
-ArrayType *copy_intArrayType(ArrayType *a);
-ArrayType *resize_intArrayType(ArrayType *a, int num);
-int internal_size(int *a, int len);
-ArrayType *_int_unique(ArrayType *a);
-int32 intarray_match_first(ArrayType *a, int32 elem);
-ArrayType *intarray_add_elem(ArrayType *a, int32 elem);
-ArrayType *intarray_concat_arrays(ArrayType *a, ArrayType *b);
-ArrayType *int_to_intset(int32 elem);
-bool inner_int_overlap(ArrayType *a, ArrayType *b);
-bool inner_int_contains(ArrayType *a, ArrayType *b);
-ArrayType * inner_int_union(ArrayType *a, ArrayType *b);
-ArrayType * inner_int_inter(ArrayType *a, ArrayType *b);
-void rt__int_size(ArrayType *a, float *size);
-void gensign(BITVEC sign, int *a, int len);
+bool isort(int4 *a, const int len);
+ArrayType *new_intArrayType(int num);
+ArrayType *copy_intArrayType(ArrayType *a);
+ArrayType *resize_intArrayType(ArrayType *a, int num);
+int internal_size(int *a, int len);
+ArrayType *_int_unique(ArrayType *a);
+int32 intarray_match_first(ArrayType *a, int32 elem);
+ArrayType *intarray_add_elem(ArrayType *a, int32 elem);
+ArrayType *intarray_concat_arrays(ArrayType *a, ArrayType *b);
+ArrayType *int_to_intset(int32 elem);
+bool inner_int_overlap(ArrayType *a, ArrayType *b);
+bool inner_int_contains(ArrayType *a, ArrayType *b);
+ArrayType *inner_int_union(ArrayType *a, ArrayType *b);
+ArrayType *inner_int_inter(ArrayType *a, ArrayType *b);
+void rt__int_size(ArrayType *a, float *size);
+void gensign(BITVEC sign, int *a, int len);
/*****************************************************************************
#define COMPUTESIZE(size) ( HDRSIZEQT + size * sizeof(ITEM) )
#define GETQUERY(x) (ITEM*)( (char*)(x)+HDRSIZEQT )
-bool signconsistent(QUERYTYPE * query, BITVEC sign, bool calcnot);
-bool execconsistent(QUERYTYPE * query, ArrayType *array, bool calcnot);
-
-
+bool signconsistent(QUERYTYPE * query, BITVEC sign, bool calcnot);
+bool execconsistent(QUERYTYPE * query, ArrayType *array, bool calcnot);
-int compASC(const void *a, const void *b);
-int compDESC(const void *a, const void *b);
-#define QSORT(a, direction) \
-if (ARRNELEMS(a) > 1) \
- qsort((void*)ARRPTR(a), ARRNELEMS(a),sizeof(int4), \
- (direction) ? compASC : compDESC )
+int compASC(const void *a, const void *b);
+int compDESC(const void *a, const void *b);
+#define QSORT(a, direction) \
+if (ARRNELEMS(a) > 1) \
+ qsort((void*)ARRPTR(a), ARRNELEMS(a),sizeof(int4), \
+ (direction) ? compASC : compDESC )
GETQUERY(query) + query->size - 1,
(void *) sign, calcnot,
checkcondition_bit
- );
+ );
}
bool
boolop,
PG_GETARG_DATUM(1),
PG_GETARG_DATUM(0)
- );
+ );
}
Datum
PG_RETURN_POINTER(res);
}
-
}
Datum
-g_int_union(PG_FUNCTION_ARGS) {
- bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
- int *size = (int *) PG_GETARG_POINTER(1);
- int4 i,len = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
- ArrayType *res;
- int totlen=0,*ptr;
+g_int_union(PG_FUNCTION_ARGS)
+{
+ bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
+ int *size = (int *) PG_GETARG_POINTER(1);
+ int4 i,
+ len = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
+ ArrayType *res;
+ int totlen = 0,
+ *ptr;
for (i = 0; i < len; i++)
- totlen+=ARRNELEMS( GETENTRY(entryvec,i) );
+ totlen += ARRNELEMS(GETENTRY(entryvec, i));
- res=new_intArrayType(totlen);
- ptr=ARRPTR(res);
+ res = new_intArrayType(totlen);
+ ptr = ARRPTR(res);
- for (i = 0; i < len; i++) {
- memcpy(ptr, ARRPTR( GETENTRY(entryvec,i) ), ARRNELEMS( GETENTRY(entryvec,i) )*sizeof(int4) );
- ptr+=ARRNELEMS( GETENTRY(entryvec,i) );
+ for (i = 0; i < len; i++)
+ {
+ memcpy(ptr, ARRPTR(GETENTRY(entryvec, i)), ARRNELEMS(GETENTRY(entryvec, i)) * sizeof(int4));
+ ptr += ARRNELEMS(GETENTRY(entryvec, i));
}
- QSORT(res,1);
- res=_int_unique(res);
- *size = VARSIZE(res);
+ QSORT(res, 1);
+ res = _int_unique(res);
+ *size = VARSIZE(res);
PG_RETURN_POINTER(res);
}
** The GiST Penalty method for _intments
*/
Datum
-g_int_penalty(PG_FUNCTION_ARGS) {
- GISTENTRY *origentry = (GISTENTRY *) PG_GETARG_POINTER(0);
- GISTENTRY *newentry = (GISTENTRY *) PG_GETARG_POINTER(1);
- float *result = (float *) PG_GETARG_POINTER(2);
+g_int_penalty(PG_FUNCTION_ARGS)
+{
+ GISTENTRY *origentry = (GISTENTRY *) PG_GETARG_POINTER(0);
+ GISTENTRY *newentry = (GISTENTRY *) PG_GETARG_POINTER(1);
+ float *result = (float *) PG_GETARG_POINTER(2);
ArrayType *ud;
float tmp1,
tmp2;
ud = inner_int_union((ArrayType *) DatumGetPointer(origentry->key),
- (ArrayType *) DatumGetPointer(newentry->key));
+ (ArrayType *) DatumGetPointer(newentry->key));
rt__int_size(ud, &tmp1);
rt__int_size((ArrayType *) DatumGetPointer(origentry->key), &tmp2);
*result = tmp1 - tmp2;
pfree(ud);
- PG_RETURN_POINTER (result);
+ PG_RETURN_POINTER(result);
}
** We use Guttman's poly time split algorithm
*/
Datum
-g_int_picksplit(PG_FUNCTION_ARGS) {
- bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
+g_int_picksplit(PG_FUNCTION_ARGS)
+{
+ bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
OffsetNumber i,
j;
PG_RETURN_POINTER(v);
}
-
*data;
int num = ARRNELEMS(r);
- if ( num<2 )
+ if (num < 2)
return r;
data = tmp = dr = ARRPTR(r);
return 0;
return (*(int4 *) a < *(int4 *) b) ? 1 : -1;
}
-
if (ARR_NDIM(la) != 1)
ereport(ERROR,
- (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
- errmsg("array must be one-dimensional")));
+ (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
+ errmsg("array must be one-dimensional")));
if (found)
*found = NULL;
Datum
_lt_q_regex(PG_FUNCTION_ARGS)
{
- ArrayType *_tree = PG_GETARG_ARRAYTYPE_P(0);
- ArrayType *_query = PG_GETARG_ARRAYTYPE_P(1);
- lquery *query = (lquery *) ARR_DATA_PTR(_query);
- bool res = false;
- int num = ArrayGetNItems(ARR_NDIM(_query), ARR_DIMS(_query));
-
- if (ARR_NDIM(_query) != 1)
- ereport(ERROR,
+ ArrayType *_tree = PG_GETARG_ARRAYTYPE_P(0);
+ ArrayType *_query = PG_GETARG_ARRAYTYPE_P(1);
+ lquery *query = (lquery *) ARR_DATA_PTR(_query);
+ bool res = false;
+ int num = ArrayGetNItems(ARR_NDIM(_query), ARR_DIMS(_query));
+
+ if (ARR_NDIM(_query) != 1)
+ ereport(ERROR,
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
errmsg("array must be one-dimensional")));
- while (num > 0) {
- if ( array_iterator(_tree, ltq_regex, (void*)query, NULL) ) {
- res = true;
- break;
- }
- num--;
- query = (lquery*)NEXTVAL(query);
- }
-
- PG_FREE_IF_COPY(_tree, 0);
- PG_FREE_IF_COPY(_query, 1);
- PG_RETURN_BOOL(res);
+ while (num > 0)
+ {
+ if (array_iterator(_tree, ltq_regex, (void *) query, NULL))
+ {
+ res = true;
+ break;
+ }
+ num--;
+ query = (lquery *) NEXTVAL(query);
+ }
+
+ PG_FREE_IF_COPY(_tree, 0);
+ PG_FREE_IF_COPY(_query, 1);
+ PG_RETURN_BOOL(res);
}
Datum
_lt_q_rregex(PG_FUNCTION_ARGS)
{
- PG_RETURN_DATUM(DirectFunctionCall2(_lt_q_regex,
- PG_GETARG_DATUM(1),
- PG_GETARG_DATUM(0)
- ));
+ PG_RETURN_DATUM(DirectFunctionCall2(_lt_q_regex,
+ PG_GETARG_DATUM(1),
+ PG_GETARG_DATUM(0)
+ ));
}
}
bool
-compare_subnode(ltree_level * t, char *qn, int len, int (*cmpptr) (const char *, const char *, size_t), bool anyend)
+ compare_subnode(ltree_level * t, char *qn, int len, int (*cmpptr) (const char *, const char *, size_t), bool anyend)
{
char *endt = t->name + t->len;
char *endq = qn + len;
}
*/
-static struct {
- bool muse;
- uint32 high_pos;
-} SomeStack = {false,0,};
+static struct
+{
+ bool muse;
+ uint32 high_pos;
+} SomeStack =
+
+{
+ false, 0,
+};
static bool
checkCond(lquery_level * curq, int query_numlevel, ltree_level * curt, int tree_numlevel, FieldNot * ptr)
lquery_level *prevq = NULL;
ltree_level *prevt = NULL;
- if ( SomeStack.muse ) {
+ if (SomeStack.muse)
+ {
high_pos = SomeStack.high_pos;
qlen--;
prevq = curq;
curt = LEVEL_NEXT(curt);
tlen--;
cur_tpos++;
- if ( isok && prevq && prevq->numvar==0 && tlen>0 && cur_tpos <= high_pos ) {
- FieldNot tmpptr;
- if ( ptr )
- memcpy(&tmpptr,ptr,sizeof(FieldNot));
- SomeStack.high_pos = high_pos-cur_tpos;
+ if (isok && prevq && prevq->numvar == 0 && tlen > 0 && cur_tpos <= high_pos)
+ {
+ FieldNot tmpptr;
+
+ if (ptr)
+ memcpy(&tmpptr, ptr, sizeof(FieldNot));
+ SomeStack.high_pos = high_pos - cur_tpos;
SomeStack.muse = true;
- if ( checkCond(prevq, qlen+1, curt, tlen, (ptr) ? &tmpptr : NULL) )
+ if (checkCond(prevq, qlen + 1, curt, tlen, (ptr) ? &tmpptr : NULL))
return true;
}
if (!isok && ptr)
lt_q_regex(PG_FUNCTION_ARGS)
{
ltree *tree = PG_GETARG_LTREE(0);
- ArrayType *_query = PG_GETARG_ARRAYTYPE_P(1);
- lquery *query = (lquery *) ARR_DATA_PTR(_query);
- bool res = false;
- int num = ArrayGetNItems(ARR_NDIM(_query), ARR_DIMS(_query));
+ ArrayType *_query = PG_GETARG_ARRAYTYPE_P(1);
+ lquery *query = (lquery *) ARR_DATA_PTR(_query);
+ bool res = false;
+ int num = ArrayGetNItems(ARR_NDIM(_query), ARR_DIMS(_query));
- if (ARR_NDIM(_query) != 1)
- ereport(ERROR,
+ if (ARR_NDIM(_query) != 1)
+ ereport(ERROR,
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
errmsg("array must be one-dimensional")));
- while (num > 0) {
+ while (num > 0)
+ {
if (DatumGetBool(DirectFunctionCall2(ltq_regex,
- PointerGetDatum(tree), PointerGetDatum(query)))) {
+ PointerGetDatum(tree), PointerGetDatum(query))))
+ {
res = true;
break;
PG_GETARG_DATUM(0)
));
}
-
-
#define UNCHAR ereport(ERROR, \
(errcode(ERRCODE_SYNTAX_ERROR), \
- errmsg("syntax error at position %d near \"%c\"", \
+ errmsg("syntax error at position %d near \"%c\"", \
(int)(ptr-buf), *ptr)));
(errcode(ERRCODE_NAME_TOO_LONG),
errmsg("name of level is too long"),
errdetail("name length is %d, must " \
- "be < 256, in position %d",
- lptr->len, (int) (lptr->start - buf))));
+ "be < 256, in position %d",
+ lptr->len, (int) (lptr->start - buf))));
totallen += MAXALIGN(lptr->len + LEVEL_HDRSIZE);
lptr++;
(errcode(ERRCODE_NAME_TOO_LONG),
errmsg("name of level is too long"),
errdetail("name length is %d, must " \
- "be < 256, in position %d",
- lptr->len, (int) (lptr->start - buf))));
+ "be < 256, in position %d",
+ lptr->len, (int) (lptr->start - buf))));
totallen += MAXALIGN(lptr->len + LEVEL_HDRSIZE);
lptr++;
(errcode(ERRCODE_NAME_TOO_LONG),
errmsg("name of level is too long"),
errdetail("name length is %d, must " \
- "be < 256, in position %d",
- lptr->len, (int) (lptr->start - buf))));
+ "be < 256, in position %d",
+ lptr->len, (int) (lptr->start - buf))));
state = LQPRS_WAITVAR;
}
(errcode(ERRCODE_NAME_TOO_LONG),
errmsg("name of level is too long"),
errdetail("name length is %d, must " \
- "be < 256, in position %d",
- lptr->len, (int) (lptr->start - buf))));
+ "be < 256, in position %d",
+ lptr->len, (int) (lptr->start - buf))));
state = LQPRS_WAITLEVEL;
curqlevel = NEXTLEV(curqlevel);
(errcode(ERRCODE_NAME_TOO_LONG),
errmsg("name of level is too long"),
errdetail("name length is %d, must " \
- "be < 256, in position %d",
- lptr->len, (int) (lptr->start - buf))));
+ "be < 256, in position %d",
+ lptr->len, (int) (lptr->start - buf))));
}
else if (state == LQPRS_WAITOPEN)
curqlevel->high = 0xffff;
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("syntax error"),
errdetail("Low limit(%d) is greater than upper(%d).",
- curqlevel->low, curqlevel->high)));
+ curqlevel->low, curqlevel->high)));
curqlevel = NEXTLEV(curqlevel);
}
ltree_cmp(PG_FUNCTION_ARGS)
{
RUNCMP
- PG_RETURN_INT32(res);
+ PG_RETURN_INT32(res);
}
Datum
ltree_lt(PG_FUNCTION_ARGS)
{
RUNCMP
- PG_RETURN_BOOL((res < 0) ? true : false);
+ PG_RETURN_BOOL((res < 0) ? true : false);
}
Datum
ltree_le(PG_FUNCTION_ARGS)
{
RUNCMP
- PG_RETURN_BOOL((res <= 0) ? true : false);
+ PG_RETURN_BOOL((res <= 0) ? true : false);
}
Datum
ltree_eq(PG_FUNCTION_ARGS)
{
RUNCMP
- PG_RETURN_BOOL((res == 0) ? true : false);
+ PG_RETURN_BOOL((res == 0) ? true : false);
}
Datum
ltree_ge(PG_FUNCTION_ARGS)
{
RUNCMP
- PG_RETURN_BOOL((res >= 0) ? true : false);
+ PG_RETURN_BOOL((res >= 0) ? true : false);
}
Datum
ltree_gt(PG_FUNCTION_ARGS)
{
RUNCMP
- PG_RETURN_BOOL((res > 0) ? true : false);
+ PG_RETURN_BOOL((res > 0) ? true : false);
}
Datum
ltree_ne(PG_FUNCTION_ARGS)
{
RUNCMP
- PG_RETURN_BOOL((res != 0) ? true : false);
+ PG_RETURN_BOOL((res != 0) ? true : false);
}
Datum
{
ltree *a = PG_GETARG_LTREE(0);
ltree *b = PG_GETARG_LTREE(1);
- int start=(fcinfo->nargs == 3) ? PG_GETARG_INT32(2) : 0;
- int i,j;
- ltree_level *startptr, *aptr, *bptr;
- bool found=false;
-
- if ( start < 0 ) {
- if ( -start >= a->numlevel )
- start=0;
- else
- start = (int)(a->numlevel)+start;
+ int start = (fcinfo->nargs == 3) ? PG_GETARG_INT32(2) : 0;
+ int i,
+ j;
+ ltree_level *startptr,
+ *aptr,
+ *bptr;
+ bool found = false;
+
+ if (start < 0)
+ {
+ if (-start >= a->numlevel)
+ start = 0;
+ else
+ start = (int) (a->numlevel) + start;
}
- if ( a->numlevel - start < b->numlevel || a->numlevel==0 || b->numlevel==0 ) {
+ if (a->numlevel - start < b->numlevel || a->numlevel == 0 || b->numlevel == 0)
+ {
PG_FREE_IF_COPY(a, 0);
PG_FREE_IF_COPY(b, 1);
PG_RETURN_INT32(-1);
}
- startptr=LTREE_FIRST(a);
- for(i=0; i<=a->numlevel-b->numlevel; i++) {
- if ( i>=start ) {
- aptr=startptr;
- bptr=LTREE_FIRST(b);
- for(j=0;j<b->numlevel;j++) {
- if ( !(aptr->len==bptr->len && strncmp(aptr->name,bptr->name, aptr->len)==0) )
- break;
- aptr=LEVEL_NEXT(aptr);
- bptr=LEVEL_NEXT(bptr);
+ startptr = LTREE_FIRST(a);
+ for (i = 0; i <= a->numlevel - b->numlevel; i++)
+ {
+ if (i >= start)
+ {
+ aptr = startptr;
+ bptr = LTREE_FIRST(b);
+ for (j = 0; j < b->numlevel; j++)
+ {
+ if (!(aptr->len == bptr->len && strncmp(aptr->name, bptr->name, aptr->len) == 0))
+ break;
+ aptr = LEVEL_NEXT(aptr);
+ bptr = LEVEL_NEXT(bptr);
}
-
- if ( j==b->numlevel ) {
- found=true;
+
+ if (j == b->numlevel)
+ {
+ found = true;
break;
}
}
- startptr=LEVEL_NEXT(startptr);
+ startptr = LEVEL_NEXT(startptr);
}
-
- if ( !found )
- i=-1;
+
+ if (!found)
+ i = -1;
PG_FREE_IF_COPY(a, 0);
PG_FREE_IF_COPY(b, 1);
text2ltree(PG_FUNCTION_ARGS)
{
text *in = PG_GETARG_TEXT_P(0);
- char *s = (char *) palloc(VARSIZE(in) - VARHDRSZ + 1);
- ltree *out;
+ char *s = (char *) palloc(VARSIZE(in) - VARHDRSZ + 1);
+ ltree *out;
memcpy(s, VARDATA(in), VARSIZE(in) - VARHDRSZ);
s[VARSIZE(in) - VARHDRSZ] = '\0';
out = (ltree *) DatumGetPointer(DirectFunctionCall1(
- ltree_in,
- PointerGetDatum(s)
- ));
+ ltree_in,
+ PointerGetDatum(s)
+ ));
pfree(s);
- PG_FREE_IF_COPY(in,0);
+ PG_FREE_IF_COPY(in, 0);
PG_RETURN_POINTER(out);
}
ltree2text(PG_FUNCTION_ARGS)
{
ltree *in = PG_GETARG_LTREE(0);
- char *ptr;
- int i;
+ char *ptr;
+ int i;
ltree_level *curlevel;
- text *out;
-
- out=(text*)palloc(in->len+VARHDRSZ);
- ptr = VARDATA(out);
+ text *out;
+
+ out = (text *) palloc(in->len + VARHDRSZ);
+ ptr = VARDATA(out);
curlevel = LTREE_FIRST(in);
- for (i = 0; i < in->numlevel; i++) {
- if (i != 0) {
+ for (i = 0; i < in->numlevel; i++)
+ {
+ if (i != 0)
+ {
*ptr = '.';
ptr++;
}
ptr += curlevel->len;
curlevel = LEVEL_NEXT(curlevel);
}
-
- VARATT_SIZEP(out) = VARHDRSZ + (ptr-VARDATA(out));
+
+ VARATT_SIZEP(out) = VARHDRSZ + (ptr - VARDATA(out));
PG_FREE_IF_COPY(in, 0);
-
+
PG_RETURN_POINTER(out);
}
-
-
-
-
snprintf(todo, 1024, "select relfilenode,relname from pg_class order by relname");
else
snprintf(todo, 1024, "select relfilenode,relname from pg_class "
- "where relkind not in ('v','s', 'c') and "
- "relname not like 'pg_%%' order by relname");
+ "where relkind not in ('v','s', 'c') and "
+ "relname not like 'pg_%%' order by relname");
sql_exec(conn, todo, 0);
}
#include "pg_autovacuum.h"
#define TIMEBUFF 256
-FILE *LOGOUTPUT;
-char timebuffer[TIMEBUFF];
-char logbuffer[4096];
+FILE *LOGOUTPUT;
+char timebuffer[TIMEBUFF];
+char logbuffer[4096];
void
-log_entry (const char *logentry)
+log_entry(const char *logentry)
{
- time_t curtime;
- struct tm *loctime;
- curtime = time (NULL);
- loctime = localtime (&curtime);
- strftime (timebuffer, TIMEBUFF, "%Y-%m-%d %r", loctime); /* cbb - %F is not always available */
- fprintf (LOGOUTPUT, "[%s] %s\n", timebuffer, logentry);
+ time_t curtime;
+ struct tm *loctime;
+
+ curtime = time(NULL);
+ loctime = localtime(&curtime);
+ strftime(timebuffer, TIMEBUFF, "%Y-%m-%d %r", loctime); /* cbb - %F is not
+ * always available */
+ fprintf(LOGOUTPUT, "[%s] %s\n", timebuffer, logentry);
}
/* Function used to detatch the pg_autovacuum daemon from the tty and go into the background *
-* This code is mostly ripped directly from pm_dameonize in postmaster.c *
-* with unneeded code removed. */
-void daemonize ()
+* This code is mostly ripped directly from pm_dameonize in postmaster.c *
+* with unneeded code removed. */
+void
+daemonize()
{
- pid_t pid;
-
- pid = fork();
- if (pid == (pid_t) -1)
- {
- log_entry("Error: cannot disassociate from controlling TTY");
- fflush(LOGOUTPUT);
- _exit(1);
- }
- else if (pid)
- { /* parent */
- /* Parent should just exit, without doing any atexit cleanup */
- _exit(0);
- }
+ pid_t pid;
+
+ pid = fork();
+ if (pid == (pid_t) -1)
+ {
+ log_entry("Error: cannot disassociate from controlling TTY");
+ fflush(LOGOUTPUT);
+ _exit(1);
+ }
+ else if (pid)
+ { /* parent */
+ /* Parent should just exit, without doing any atexit cleanup */
+ _exit(0);
+ }
/* GH: If there's no setsid(), we hopefully don't need silent mode.
* Until there's a better solution. */
#ifdef HAVE_SETSID
- if (setsid() < 0)
- {
- log_entry("Error: cannot disassociate from controlling TTY");
- fflush(LOGOUTPUT);
- _exit(1);
- }
+ if (setsid() < 0)
+ {
+ log_entry("Error: cannot disassociate from controlling TTY");
+ fflush(LOGOUTPUT);
+ _exit(1);
+ }
#endif
}
/* Create and return tbl_info struct with initialized to values from row or res */
tbl_info *
-init_table_info (PGresult * res, int row, db_info *dbi)
+init_table_info(PGresult *res, int row, db_info * dbi)
{
- tbl_info *new_tbl = (tbl_info *) malloc (sizeof (tbl_info));
-
- if (!new_tbl) {
- log_entry ("init_table_info: Cannot get memory");
- fflush (LOGOUTPUT);
- return NULL;
- }
-
- if (NULL == res)
- return NULL;
-
- new_tbl->dbi = dbi; /* set pointer to db */
-
- new_tbl->schema_name = (char *)
- malloc (strlen (PQgetvalue (res, row, PQfnumber (res, "schemaname"))) + 1);
- if (!new_tbl->schema_name) {
- log_entry ("init_table_info: malloc failed on new_tbl->schema_name");
- fflush (LOGOUTPUT);
- return NULL;
- }
- strcpy (new_tbl->schema_name,
- PQgetvalue (res, row, PQfnumber (res, "schemaname")));
-
- new_tbl->table_name = (char *)
- malloc (strlen (PQgetvalue (res, row, PQfnumber (res, "relname"))) +
- strlen (new_tbl->schema_name) + 2);
- if (!new_tbl->table_name) {
- log_entry ("init_table_info: malloc failed on new_tbl->table_name");
- fflush (LOGOUTPUT);
- return NULL;
- }
- strcpy (new_tbl->table_name, new_tbl->schema_name);
- strcat (new_tbl->table_name, ".");
- strcat (new_tbl->table_name, PQgetvalue (res, row, PQfnumber (res, "relname")));
-
- new_tbl->CountAtLastAnalyze =
- (atol (PQgetvalue (res, row, PQfnumber (res, "n_tup_ins"))) +
- atol (PQgetvalue (res, row, PQfnumber (res, "n_tup_upd"))));
- new_tbl->curr_analyze_count = new_tbl->CountAtLastAnalyze;
-
- new_tbl->CountAtLastVacuum =
- (atol (PQgetvalue (res, row, PQfnumber (res, "n_tup_del"))) +
- atol (PQgetvalue (res, row, PQfnumber (res, "n_tup_upd"))));
- new_tbl->curr_vacuum_count = new_tbl->CountAtLastVacuum;
-
- new_tbl->relfilenode = atoi (PQgetvalue (res, row, PQfnumber (res, "relfilenode")));
- new_tbl->reltuples = atoi (PQgetvalue (res, row, PQfnumber (res, "reltuples")));
- new_tbl->relpages = atoi (PQgetvalue (res, row, PQfnumber (res, "relpages")));
-
- new_tbl->analyze_threshold =
- args->analyze_base_threshold + args->analyze_scaling_factor * new_tbl->reltuples;
- new_tbl->vacuum_threshold =
- args->vacuum_base_threshold + args->vacuum_scaling_factor * new_tbl->reltuples;
-
- if (args->debug >= 2) {
- print_table_info (new_tbl);
- }
-
- return new_tbl;
+ tbl_info *new_tbl = (tbl_info *) malloc(sizeof(tbl_info));
+
+ if (!new_tbl)
+ {
+ log_entry("init_table_info: Cannot get memory");
+ fflush(LOGOUTPUT);
+ return NULL;
+ }
+
+ if (NULL == res)
+ return NULL;
+
+ new_tbl->dbi = dbi; /* set pointer to db */
+
+ new_tbl->schema_name = (char *)
+ malloc(strlen(PQgetvalue(res, row, PQfnumber(res, "schemaname"))) + 1);
+ if (!new_tbl->schema_name)
+ {
+ log_entry("init_table_info: malloc failed on new_tbl->schema_name");
+ fflush(LOGOUTPUT);
+ return NULL;
+ }
+ strcpy(new_tbl->schema_name,
+ PQgetvalue(res, row, PQfnumber(res, "schemaname")));
+
+ new_tbl->table_name = (char *)
+ malloc(strlen(PQgetvalue(res, row, PQfnumber(res, "relname"))) +
+ strlen(new_tbl->schema_name) + 2);
+ if (!new_tbl->table_name)
+ {
+ log_entry("init_table_info: malloc failed on new_tbl->table_name");
+ fflush(LOGOUTPUT);
+ return NULL;
+ }
+ strcpy(new_tbl->table_name, new_tbl->schema_name);
+ strcat(new_tbl->table_name, ".");
+ strcat(new_tbl->table_name, PQgetvalue(res, row, PQfnumber(res, "relname")));
+
+ new_tbl->CountAtLastAnalyze =
+ (atol(PQgetvalue(res, row, PQfnumber(res, "n_tup_ins"))) +
+ atol(PQgetvalue(res, row, PQfnumber(res, "n_tup_upd"))));
+ new_tbl->curr_analyze_count = new_tbl->CountAtLastAnalyze;
+
+ new_tbl->CountAtLastVacuum =
+ (atol(PQgetvalue(res, row, PQfnumber(res, "n_tup_del"))) +
+ atol(PQgetvalue(res, row, PQfnumber(res, "n_tup_upd"))));
+ new_tbl->curr_vacuum_count = new_tbl->CountAtLastVacuum;
+
+ new_tbl->relfilenode = atoi(PQgetvalue(res, row, PQfnumber(res, "relfilenode")));
+ new_tbl->reltuples = atoi(PQgetvalue(res, row, PQfnumber(res, "reltuples")));
+ new_tbl->relpages = atoi(PQgetvalue(res, row, PQfnumber(res, "relpages")));
+
+ new_tbl->analyze_threshold =
+ args->analyze_base_threshold + args->analyze_scaling_factor * new_tbl->reltuples;
+ new_tbl->vacuum_threshold =
+ args->vacuum_base_threshold + args->vacuum_scaling_factor * new_tbl->reltuples;
+
+ if (args->debug >= 2)
+ print_table_info(new_tbl);
+
+ return new_tbl;
}
/* Set thresholds = base_value + scaling_factor * reltuples
Should be called after a vacuum since vacuum updates values in pg_class */
void
-update_table_thresholds (db_info * dbi, tbl_info * tbl,int vacuum_type)
+update_table_thresholds(db_info * dbi, tbl_info * tbl, int vacuum_type)
{
- PGresult *res = NULL;
- int disconnect = 0;
- char query[128];
-
- if (NULL == dbi->conn) {
- dbi->conn = db_connect (dbi);
- disconnect = 1;
- }
-
- if (NULL != dbi->conn) {
- snprintf (query, sizeof (query), PAGES_QUERY, tbl->relfilenode);
- res = send_query (query, dbi);
- if (NULL != res) {
- tbl->reltuples =
- atoi (PQgetvalue (res, 0, PQfnumber (res, "reltuples")));
- tbl->relpages = atoi (PQgetvalue (res, 0, PQfnumber (res, "relpages")));
-
- /* update vacuum thresholds only of we just did a vacuum analyze */
- if(VACUUM_ANALYZE == vacuum_type)
- {
- tbl->vacuum_threshold =
- (args->vacuum_base_threshold + args->vacuum_scaling_factor * tbl->reltuples);
- tbl->CountAtLastVacuum = tbl->curr_vacuum_count;
- }
-
- /* update analyze thresholds */
- tbl->analyze_threshold =
- (args->analyze_base_threshold + args->analyze_scaling_factor * tbl->reltuples);
- tbl->CountAtLastAnalyze = tbl->curr_analyze_count;
-
- PQclear (res);
-
- /* If the stats collector is reporting fewer updates then we have on record
- then the stats were probably reset, so we need to reset also */
- if ((tbl->curr_analyze_count < tbl->CountAtLastAnalyze) ||
- (tbl->curr_vacuum_count < tbl->CountAtLastVacuum))
- {
- tbl->CountAtLastAnalyze = tbl->curr_analyze_count;
- tbl->CountAtLastVacuum = tbl->curr_vacuum_count;
- }
- }
- }
- if (disconnect)
- db_disconnect (dbi);
+ PGresult *res = NULL;
+ int disconnect = 0;
+ char query[128];
+
+ if (NULL == dbi->conn)
+ {
+ dbi->conn = db_connect(dbi);
+ disconnect = 1;
+ }
+
+ if (NULL != dbi->conn)
+ {
+ snprintf(query, sizeof(query), PAGES_QUERY, tbl->relfilenode);
+ res = send_query(query, dbi);
+ if (NULL != res)
+ {
+ tbl->reltuples =
+ atoi(PQgetvalue(res, 0, PQfnumber(res, "reltuples")));
+ tbl->relpages = atoi(PQgetvalue(res, 0, PQfnumber(res, "relpages")));
+
+ /*
+ * update vacuum thresholds only of we just did a vacuum
+ * analyze
+ */
+ if (VACUUM_ANALYZE == vacuum_type)
+ {
+ tbl->vacuum_threshold =
+ (args->vacuum_base_threshold + args->vacuum_scaling_factor * tbl->reltuples);
+ tbl->CountAtLastVacuum = tbl->curr_vacuum_count;
+ }
+
+ /* update analyze thresholds */
+ tbl->analyze_threshold =
+ (args->analyze_base_threshold + args->analyze_scaling_factor * tbl->reltuples);
+ tbl->CountAtLastAnalyze = tbl->curr_analyze_count;
+
+ PQclear(res);
+
+ /*
+ * If the stats collector is reporting fewer updates then we
+ * have on record then the stats were probably reset, so we
+ * need to reset also
+ */
+ if ((tbl->curr_analyze_count < tbl->CountAtLastAnalyze) ||
+ (tbl->curr_vacuum_count < tbl->CountAtLastVacuum))
+ {
+ tbl->CountAtLastAnalyze = tbl->curr_analyze_count;
+ tbl->CountAtLastVacuum = tbl->curr_vacuum_count;
+ }
+ }
+ }
+ if (disconnect)
+ db_disconnect(dbi);
}
void
-update_table_list (db_info * dbi)
+update_table_list(db_info * dbi)
{
- int disconnect = 0;
- PGresult *res = NULL;
- tbl_info *tbl = NULL;
- Dlelem *tbl_elem = DLGetHead (dbi->table_list);
- int i = 0, t = 0, found_match = 0;
-
- if (NULL == dbi->conn) {
- dbi->conn = db_connect (dbi);
- disconnect = 1;
- }
-
- if (NULL != dbi->conn) {
- /* Get a result set that has all the information
- we will need to both remove tables from the list
- that no longer exist and add tables to the list
- that are new */
- res = send_query (query_table_stats (dbi), dbi);
- t = PQntuples (res);
-
- /* First: use the tbl_list as the outer loop and
- the result set as the inner loop, this will
- determine what tables should be removed */
- while (NULL != tbl_elem) {
- tbl = ((tbl_info *) DLE_VAL (tbl_elem));
- found_match = 0;
-
- for (i = 0; i < t; i++) { /* loop through result set looking for a match */
- if (tbl->relfilenode == atoi (PQgetvalue (res, i, PQfnumber (res, "relfilenode")))) {
- found_match = 1;
- break;
- }
- }
- if (0 == found_match) { /* then we didn't find this tbl_elem in the result set */
- Dlelem *elem_to_remove = tbl_elem;
- tbl_elem = DLGetSucc (tbl_elem);
- remove_table_from_list (elem_to_remove);
- }
- else
- tbl_elem = DLGetSucc (tbl_elem);
- } /* Done removing dropped tables from the table_list */
-
- /* Then loop use result set as outer loop and
- tbl_list as the inner loop to determine
- what tables are new */
- for (i = 0; i < t; i++)
- {
- tbl_elem = DLGetHead (dbi->table_list);
- found_match = 0;
- while (NULL != tbl_elem)
- {
- tbl = ((tbl_info *) DLE_VAL (tbl_elem));
- if (tbl->relfilenode == atoi (PQgetvalue (res, i, PQfnumber (res, "relfilenode"))))
- {
- found_match = 1;
- break;
- }
- tbl_elem = DLGetSucc (tbl_elem);
- }
- if (0 == found_match) /*then we didn't find this result now in the tbl_list */
- {
- DLAddTail (dbi->table_list, DLNewElem (init_table_info (res, i, dbi)));
- if (args->debug >= 1)
- {
- sprintf (logbuffer, "added table: %s.%s", dbi->dbname,
- ((tbl_info *) DLE_VAL (DLGetTail (dbi->table_list)))->table_name);
- log_entry (logbuffer);
- }
- }
- } /* end of for loop that adds tables */
- fflush (LOGOUTPUT);
- PQclear (res);
- res = NULL;
- if (args->debug >= 3) {
- print_table_list (dbi->table_list);
- }
- if (disconnect)
- db_disconnect (dbi);
- }
+ int disconnect = 0;
+ PGresult *res = NULL;
+ tbl_info *tbl = NULL;
+ Dlelem *tbl_elem = DLGetHead(dbi->table_list);
+ int i = 0,
+ t = 0,
+ found_match = 0;
+
+ if (NULL == dbi->conn)
+ {
+ dbi->conn = db_connect(dbi);
+ disconnect = 1;
+ }
+
+ if (NULL != dbi->conn)
+ {
+ /*
+ * Get a result set that has all the information we will need to
+ * both remove tables from the list that no longer exist and add
+ * tables to the list that are new
+ */
+ res = send_query(query_table_stats(dbi), dbi);
+ t = PQntuples(res);
+
+ /*
+ * First: use the tbl_list as the outer loop and the result set as
+ * the inner loop, this will determine what tables should be
+ * removed
+ */
+ while (NULL != tbl_elem)
+ {
+ tbl = ((tbl_info *) DLE_VAL(tbl_elem));
+ found_match = 0;
+
+ for (i = 0; i < t; i++)
+ { /* loop through result set looking for a
+ * match */
+ if (tbl->relfilenode == atoi(PQgetvalue(res, i, PQfnumber(res, "relfilenode"))))
+ {
+ found_match = 1;
+ break;
+ }
+ }
+ if (0 == found_match)
+ { /* then we didn't find this tbl_elem in
+ * the result set */
+ Dlelem *elem_to_remove = tbl_elem;
+
+ tbl_elem = DLGetSucc(tbl_elem);
+ remove_table_from_list(elem_to_remove);
+ }
+ else
+ tbl_elem = DLGetSucc(tbl_elem);
+ } /* Done removing dropped tables from the
+ * table_list */
+
+ /*
+ * Then loop use result set as outer loop and tbl_list as the
+ * inner loop to determine what tables are new
+ */
+ for (i = 0; i < t; i++)
+ {
+ tbl_elem = DLGetHead(dbi->table_list);
+ found_match = 0;
+ while (NULL != tbl_elem)
+ {
+ tbl = ((tbl_info *) DLE_VAL(tbl_elem));
+ if (tbl->relfilenode == atoi(PQgetvalue(res, i, PQfnumber(res, "relfilenode"))))
+ {
+ found_match = 1;
+ break;
+ }
+ tbl_elem = DLGetSucc(tbl_elem);
+ }
+ if (0 == found_match) /* then we didn't find this result
+ * now in the tbl_list */
+ {
+ DLAddTail(dbi->table_list, DLNewElem(init_table_info(res, i, dbi)));
+ if (args->debug >= 1)
+ {
+ sprintf(logbuffer, "added table: %s.%s", dbi->dbname,
+ ((tbl_info *) DLE_VAL(DLGetTail(dbi->table_list)))->table_name);
+ log_entry(logbuffer);
+ }
+ }
+ } /* end of for loop that adds tables */
+ fflush(LOGOUTPUT);
+ PQclear(res);
+ res = NULL;
+ if (args->debug >= 3)
+ print_table_list(dbi->table_list);
+ if (disconnect)
+ db_disconnect(dbi);
+ }
}
/* Free memory, and remove the node from the list */
void
-remove_table_from_list (Dlelem * tbl_to_remove)
+remove_table_from_list(Dlelem *tbl_to_remove)
{
- tbl_info *tbl = ((tbl_info *) DLE_VAL (tbl_to_remove));
-
- if (args->debug >= 1) {
- sprintf (logbuffer, "Removing table: %s from list.", tbl->table_name);
- log_entry (logbuffer);
- fflush (LOGOUTPUT);
- }
- DLRemove (tbl_to_remove);
-
- if (tbl->schema_name) {
- free (tbl->schema_name);
- tbl->schema_name = NULL;
- }
- if (tbl->table_name) {
- free (tbl->table_name);
- tbl->table_name = NULL;
- }
- if (tbl) {
- free (tbl);
- tbl = NULL;
- }
- DLFreeElem (tbl_to_remove);
+ tbl_info *tbl = ((tbl_info *) DLE_VAL(tbl_to_remove));
+
+ if (args->debug >= 1)
+ {
+ sprintf(logbuffer, "Removing table: %s from list.", tbl->table_name);
+ log_entry(logbuffer);
+ fflush(LOGOUTPUT);
+ }
+ DLRemove(tbl_to_remove);
+
+ if (tbl->schema_name)
+ {
+ free(tbl->schema_name);
+ tbl->schema_name = NULL;
+ }
+ if (tbl->table_name)
+ {
+ free(tbl->table_name);
+ tbl->table_name = NULL;
+ }
+ if (tbl)
+ {
+ free(tbl);
+ tbl = NULL;
+ }
+ DLFreeElem(tbl_to_remove);
}
/* Free the entire table list */
void
-free_tbl_list (Dllist * tbl_list)
+free_tbl_list(Dllist *tbl_list)
{
- Dlelem *tbl_elem = DLGetHead (tbl_list);
- Dlelem *tbl_elem_to_remove = NULL;
- while (NULL != tbl_elem) {
- tbl_elem_to_remove = tbl_elem;
- tbl_elem = DLGetSucc (tbl_elem);
- remove_table_from_list (tbl_elem_to_remove);
- }
- DLFreeList (tbl_list);
+ Dlelem *tbl_elem = DLGetHead(tbl_list);
+ Dlelem *tbl_elem_to_remove = NULL;
+
+ while (NULL != tbl_elem)
+ {
+ tbl_elem_to_remove = tbl_elem;
+ tbl_elem = DLGetSucc(tbl_elem);
+ remove_table_from_list(tbl_elem_to_remove);
+ }
+ DLFreeList(tbl_list);
}
void
-print_table_list (Dllist * table_list)
+print_table_list(Dllist *table_list)
{
- Dlelem *table_elem = DLGetHead (table_list);
- while (NULL != table_elem) {
- print_table_info (((tbl_info *) DLE_VAL (table_elem)));
- table_elem = DLGetSucc (table_elem);
- }
+ Dlelem *table_elem = DLGetHead(table_list);
+
+ while (NULL != table_elem)
+ {
+ print_table_info(((tbl_info *) DLE_VAL(table_elem)));
+ table_elem = DLGetSucc(table_elem);
+ }
}
void
-print_table_info (tbl_info * tbl)
+print_table_info(tbl_info * tbl)
{
- sprintf (logbuffer, " table name: %s.%s", tbl->dbi->dbname, tbl->table_name);
- log_entry (logbuffer);
- sprintf (logbuffer, " relfilenode: %i",tbl->relfilenode);
- log_entry (logbuffer);
- sprintf (logbuffer, " reltuples: %i; relpages: %i", tbl->reltuples, tbl->relpages);
- log_entry (logbuffer);
- sprintf (logbuffer, " curr_analyze_count: %li; cur_delete_count: %li",
- tbl->curr_analyze_count, tbl->curr_vacuum_count);
- log_entry (logbuffer);
- sprintf (logbuffer, " ins_at_last_analyze: %li; del_at_last_vacuum: %li",
- tbl->CountAtLastAnalyze, tbl->CountAtLastVacuum);
- log_entry (logbuffer);
- sprintf (logbuffer, " insert_threshold: %li; delete_threshold %li",
- tbl->analyze_threshold, tbl->vacuum_threshold);
- log_entry (logbuffer);
- fflush (LOGOUTPUT);
+ sprintf(logbuffer, " table name: %s.%s", tbl->dbi->dbname, tbl->table_name);
+ log_entry(logbuffer);
+ sprintf(logbuffer, " relfilenode: %i", tbl->relfilenode);
+ log_entry(logbuffer);
+ sprintf(logbuffer, " reltuples: %i; relpages: %i", tbl->reltuples, tbl->relpages);
+ log_entry(logbuffer);
+ sprintf(logbuffer, " curr_analyze_count: %li; cur_delete_count: %li",
+ tbl->curr_analyze_count, tbl->curr_vacuum_count);
+ log_entry(logbuffer);
+ sprintf(logbuffer, " ins_at_last_analyze: %li; del_at_last_vacuum: %li",
+ tbl->CountAtLastAnalyze, tbl->CountAtLastVacuum);
+ log_entry(logbuffer);
+ sprintf(logbuffer, " insert_threshold: %li; delete_threshold %li",
+ tbl->analyze_threshold, tbl->vacuum_threshold);
+ log_entry(logbuffer);
+ fflush(LOGOUTPUT);
}
/* End of table Management Functions */
/* init_db_list() creates the db_list and initalizes template1 */
Dllist *
-init_db_list ()
+init_db_list()
{
- Dllist *db_list = DLNewList ();
- db_info *dbs = NULL;
- PGresult *res = NULL;
-
- DLAddHead (db_list, DLNewElem (init_dbinfo ((char *) "template1", 0, 0)));
- if (NULL == DLGetHead (db_list)) { /* Make sure init_dbinfo was successful */
- log_entry ("init_db_list(): Error creating db_list for db: template1.");
- fflush (LOGOUTPUT);
- return NULL;
- }
-
- /* We do this just so we can set the proper oid for the template1 database */
- dbs = ((db_info *) DLE_VAL (DLGetHead (db_list)));
- dbs->conn = db_connect (dbs);
-
- if (NULL != dbs->conn) {
- res = send_query (FROZENOID_QUERY, dbs);
- dbs->oid = atoi (PQgetvalue (res, 0, PQfnumber (res, "oid")));
- dbs->age = atoi (PQgetvalue (res, 0, PQfnumber (res, "age")));
- if (res)
- PQclear (res);
-
- if (args->debug >= 2) {
- print_db_list (db_list, 0);
- }
- }
- return db_list;
+ Dllist *db_list = DLNewList();
+ db_info *dbs = NULL;
+ PGresult *res = NULL;
+
+ DLAddHead(db_list, DLNewElem(init_dbinfo((char *) "template1", 0, 0)));
+ if (NULL == DLGetHead(db_list))
+ { /* Make sure init_dbinfo was successful */
+ log_entry("init_db_list(): Error creating db_list for db: template1.");
+ fflush(LOGOUTPUT);
+ return NULL;
+ }
+
+ /*
+ * We do this just so we can set the proper oid for the template1
+ * database
+ */
+ dbs = ((db_info *) DLE_VAL(DLGetHead(db_list)));
+ dbs->conn = db_connect(dbs);
+
+ if (NULL != dbs->conn)
+ {
+ res = send_query(FROZENOID_QUERY, dbs);
+ dbs->oid = atoi(PQgetvalue(res, 0, PQfnumber(res, "oid")));
+ dbs->age = atoi(PQgetvalue(res, 0, PQfnumber(res, "age")));
+ if (res)
+ PQclear(res);
+
+ if (args->debug >= 2)
+ print_db_list(db_list, 0);
+ }
+ return db_list;
}
/* Simple function to create an instance of the dbinfo struct
- Initalizes all the pointers and connects to the database */
+ Initalizes all the pointers and connects to the database */
db_info *
-init_dbinfo (char *dbname, int oid, int age)
+init_dbinfo(char *dbname, int oid, int age)
{
- db_info *newdbinfo = (db_info *) malloc (sizeof (db_info));
- newdbinfo->analyze_threshold = args->vacuum_base_threshold;
- newdbinfo->vacuum_threshold = args->analyze_base_threshold;
- newdbinfo->dbname = (char *) malloc (strlen (dbname) + 1);
- strcpy (newdbinfo->dbname, dbname);
- newdbinfo->username = NULL;
- if (NULL != args->user) {
- newdbinfo->username = (char *) malloc (strlen (args->user) + 1);
- strcpy (newdbinfo->username, args->user);
- }
- newdbinfo->password = NULL;
- if (NULL != args->password) {
- newdbinfo->password = (char *) malloc (strlen (args->password) + 1);
- strcpy (newdbinfo->password, args->password);
- }
- newdbinfo->oid = oid;
- newdbinfo->age = age;
- newdbinfo->table_list = DLNewList ();
- newdbinfo->conn = NULL;
-
- if (args->debug >= 2) {
- print_table_list (newdbinfo->table_list);
- }
-
- return newdbinfo;
+ db_info *newdbinfo = (db_info *) malloc(sizeof(db_info));
+
+ newdbinfo->analyze_threshold = args->vacuum_base_threshold;
+ newdbinfo->vacuum_threshold = args->analyze_base_threshold;
+ newdbinfo->dbname = (char *) malloc(strlen(dbname) + 1);
+ strcpy(newdbinfo->dbname, dbname);
+ newdbinfo->username = NULL;
+ if (NULL != args->user)
+ {
+ newdbinfo->username = (char *) malloc(strlen(args->user) + 1);
+ strcpy(newdbinfo->username, args->user);
+ }
+ newdbinfo->password = NULL;
+ if (NULL != args->password)
+ {
+ newdbinfo->password = (char *) malloc(strlen(args->password) + 1);
+ strcpy(newdbinfo->password, args->password);
+ }
+ newdbinfo->oid = oid;
+ newdbinfo->age = age;
+ newdbinfo->table_list = DLNewList();
+ newdbinfo->conn = NULL;
+
+ if (args->debug >= 2)
+ print_table_list(newdbinfo->table_list);
+
+ return newdbinfo;
}
/* Function adds and removes databases from the db_list as appropriate */
void
-update_db_list (Dllist * db_list)
+update_db_list(Dllist *db_list)
{
- int disconnect = 0;
- PGresult *res = NULL;
- Dlelem *db_elem = DLGetHead (db_list);
- db_info *dbi = NULL;
- db_info *dbi_template1 = DLE_VAL (db_elem);
- int i = 0, t = 0, found_match = 0;
-
- if (args->debug >= 2) {
- log_entry ("updating the database list");
- fflush (LOGOUTPUT);
- }
-
- if (NULL == dbi_template1->conn) {
- dbi_template1->conn = db_connect (dbi_template1);
- disconnect = 1;
- }
-
- if (NULL != dbi_template1->conn) {
- /* Get a result set that has all the information
- we will need to both remove databasews from the list
- that no longer exist and add databases to the list
- that are new */
- res = send_query (FROZENOID_QUERY2, dbi_template1);
- t = PQntuples (res);
-
- /* First: use the db_list as the outer loop and
- the result set as the inner loop, this will
- determine what databases should be removed */
- while (NULL != db_elem) {
- dbi = ((db_info *) DLE_VAL (db_elem));
- found_match = 0;
-
- for (i = 0; i < t; i++) { /* loop through result set looking for a match */
- if (dbi->oid == atoi (PQgetvalue (res, i, PQfnumber (res, "oid")))) {
- found_match = 1;
- /* update the dbi->age so that we ensure xid_wraparound won't happen */
- dbi->age = atoi (PQgetvalue (res, i, PQfnumber (res, "age")));
- break;
- }
- }
- if (0 == found_match) { /*then we didn't find this db_elem in the result set */
- Dlelem *elem_to_remove = db_elem;
- db_elem = DLGetSucc (db_elem);
- remove_db_from_list (elem_to_remove);
- }
- else
- db_elem = DLGetSucc (db_elem);
- } /* Done removing dropped databases from the table_list */
-
- /* Then loop use result set as outer loop and
- db_list as the inner loop to determine
- what databases are new */
- for (i = 0; i < t; i++)
- {
- db_elem = DLGetHead (db_list);
- found_match = 0;
- while (NULL != db_elem)
- {
- dbi = ((db_info *) DLE_VAL (db_elem));
- if (dbi->oid == atoi (PQgetvalue (res, i, PQfnumber (res, "oid"))))
- {
- found_match = 1;
- break;
- }
- db_elem = DLGetSucc (db_elem);
- }
- if (0 == found_match) /*then we didn't find this result now in the tbl_list */
- {
- DLAddTail (db_list, DLNewElem (init_dbinfo
- (PQgetvalue(res, i, PQfnumber (res, "datname")),
- atoi (PQgetvalue(res, i, PQfnumber (res, "oid"))),
- atoi (PQgetvalue(res, i, PQfnumber (res, "age"))))));
- if (args->debug >= 1)
- {
- sprintf (logbuffer, "added database: %s",((db_info *) DLE_VAL (DLGetTail (db_list)))->dbname);
- log_entry (logbuffer);
- }
- }
- } /* end of for loop that adds tables */
- fflush (LOGOUTPUT);
- PQclear (res);
- res = NULL;
- if (args->debug >= 3) {
- print_db_list (db_list, 0);
- }
- if (disconnect)
- db_disconnect (dbi_template1);
- }
+ int disconnect = 0;
+ PGresult *res = NULL;
+ Dlelem *db_elem = DLGetHead(db_list);
+ db_info *dbi = NULL;
+ db_info *dbi_template1 = DLE_VAL(db_elem);
+ int i = 0,
+ t = 0,
+ found_match = 0;
+
+ if (args->debug >= 2)
+ {
+ log_entry("updating the database list");
+ fflush(LOGOUTPUT);
+ }
+
+ if (NULL == dbi_template1->conn)
+ {
+ dbi_template1->conn = db_connect(dbi_template1);
+ disconnect = 1;
+ }
+
+ if (NULL != dbi_template1->conn)
+ {
+ /*
+ * Get a result set that has all the information we will need to
+ * both remove databasews from the list that no longer exist and
+ * add databases to the list that are new
+ */
+ res = send_query(FROZENOID_QUERY2, dbi_template1);
+ t = PQntuples(res);
+
+ /*
+ * First: use the db_list as the outer loop and the result set as
+ * the inner loop, this will determine what databases should be
+ * removed
+ */
+ while (NULL != db_elem)
+ {
+ dbi = ((db_info *) DLE_VAL(db_elem));
+ found_match = 0;
+
+ for (i = 0; i < t; i++)
+ { /* loop through result set looking for a
+ * match */
+ if (dbi->oid == atoi(PQgetvalue(res, i, PQfnumber(res, "oid"))))
+ {
+ found_match = 1;
+
+ /*
+ * update the dbi->age so that we ensure
+ * xid_wraparound won't happen
+ */
+ dbi->age = atoi(PQgetvalue(res, i, PQfnumber(res, "age")));
+ break;
+ }
+ }
+ if (0 == found_match)
+ { /* then we didn't find this db_elem in the
+ * result set */
+ Dlelem *elem_to_remove = db_elem;
+
+ db_elem = DLGetSucc(db_elem);
+ remove_db_from_list(elem_to_remove);
+ }
+ else
+ db_elem = DLGetSucc(db_elem);
+ } /* Done removing dropped databases from
+ * the table_list */
+
+ /*
+ * Then loop use result set as outer loop and db_list as the inner
+ * loop to determine what databases are new
+ */
+ for (i = 0; i < t; i++)
+ {
+ db_elem = DLGetHead(db_list);
+ found_match = 0;
+ while (NULL != db_elem)
+ {
+ dbi = ((db_info *) DLE_VAL(db_elem));
+ if (dbi->oid == atoi(PQgetvalue(res, i, PQfnumber(res, "oid"))))
+ {
+ found_match = 1;
+ break;
+ }
+ db_elem = DLGetSucc(db_elem);
+ }
+ if (0 == found_match) /* then we didn't find this result
+ * now in the tbl_list */
+ {
+ DLAddTail(db_list, DLNewElem(init_dbinfo
+ (PQgetvalue(res, i, PQfnumber(res, "datname")),
+ atoi(PQgetvalue(res, i, PQfnumber(res, "oid"))),
+ atoi(PQgetvalue(res, i, PQfnumber(res, "age"))))));
+ if (args->debug >= 1)
+ {
+ sprintf(logbuffer, "added database: %s", ((db_info *) DLE_VAL(DLGetTail(db_list)))->dbname);
+ log_entry(logbuffer);
+ }
+ }
+ } /* end of for loop that adds tables */
+ fflush(LOGOUTPUT);
+ PQclear(res);
+ res = NULL;
+ if (args->debug >= 3)
+ print_db_list(db_list, 0);
+ if (disconnect)
+ db_disconnect(dbi_template1);
+ }
}
/* xid_wraparound_check
return 1 if the database needed a database wide vacuum
*/
int
-xid_wraparound_check (db_info * dbi)
+xid_wraparound_check(db_info * dbi)
{
- /* FIXME: should probably do something better here so that we don't vacuum all the
- databases on the server at the same time. We have 500million xacts to work with so
- we should be able to spread the load of full database vacuums a bit */
- if (1500000000 < dbi->age) {
- PGresult *res = NULL;
- res = send_query ("vacuum", dbi);
- /* FIXME: Perhaps should add a check for PQ_COMMAND_OK */
- PQclear (res);
- return 1;
- }
- return 0;
+ /*
+ * FIXME: should probably do something better here so that we don't
+ * vacuum all the databases on the server at the same time. We have
+ * 500million xacts to work with so we should be able to spread the
+ * load of full database vacuums a bit
+ */
+ if (1500000000 < dbi->age)
+ {
+ PGresult *res = NULL;
+
+ res = send_query("vacuum", dbi);
+ /* FIXME: Perhaps should add a check for PQ_COMMAND_OK */
+ PQclear(res);
+ return 1;
+ }
+ return 0;
}
/* Close DB connection, free memory, and remove the node from the list */
void
-remove_db_from_list (Dlelem * db_to_remove)
+remove_db_from_list(Dlelem *db_to_remove)
{
- db_info *dbi = ((db_info *) DLE_VAL (db_to_remove));
-
- if (args->debug >= 1) {
- sprintf (logbuffer, "Removing db: %s from list.", dbi->dbname);
- log_entry (logbuffer);
- fflush (LOGOUTPUT);
- }
- DLRemove (db_to_remove);
- if (dbi->conn)
- db_disconnect (dbi);
- if (dbi->dbname) {
- free (dbi->dbname);
- dbi->dbname = NULL;
- }
- if (dbi->username) {
- free (dbi->username);
- dbi->username = NULL;
- }
- if (dbi->password) {
- free (dbi->password);
- dbi->password = NULL;
- }
- if (dbi->table_list) {
- free_tbl_list (dbi->table_list);
- dbi->table_list = NULL;
- }
- if (dbi) {
- free (dbi);
- dbi = NULL;
- }
- DLFreeElem (db_to_remove);
+ db_info *dbi = ((db_info *) DLE_VAL(db_to_remove));
+
+ if (args->debug >= 1)
+ {
+ sprintf(logbuffer, "Removing db: %s from list.", dbi->dbname);
+ log_entry(logbuffer);
+ fflush(LOGOUTPUT);
+ }
+ DLRemove(db_to_remove);
+ if (dbi->conn)
+ db_disconnect(dbi);
+ if (dbi->dbname)
+ {
+ free(dbi->dbname);
+ dbi->dbname = NULL;
+ }
+ if (dbi->username)
+ {
+ free(dbi->username);
+ dbi->username = NULL;
+ }
+ if (dbi->password)
+ {
+ free(dbi->password);
+ dbi->password = NULL;
+ }
+ if (dbi->table_list)
+ {
+ free_tbl_list(dbi->table_list);
+ dbi->table_list = NULL;
+ }
+ if (dbi)
+ {
+ free(dbi);
+ dbi = NULL;
+ }
+ DLFreeElem(db_to_remove);
}
/* Function is called before program exit to free all memory
mostly it's just to keep valgrind happy */
void
-free_db_list (Dllist * db_list)
+free_db_list(Dllist *db_list)
{
- Dlelem *db_elem = DLGetHead (db_list);
- Dlelem *db_elem_to_remove = NULL;
- while (NULL != db_elem) {
- db_elem_to_remove = db_elem;
- db_elem = DLGetSucc (db_elem);
- remove_db_from_list (db_elem_to_remove);
- db_elem_to_remove = NULL;
- }
- DLFreeList (db_list);
+ Dlelem *db_elem = DLGetHead(db_list);
+ Dlelem *db_elem_to_remove = NULL;
+
+ while (NULL != db_elem)
+ {
+ db_elem_to_remove = db_elem;
+ db_elem = DLGetSucc(db_elem);
+ remove_db_from_list(db_elem_to_remove);
+ db_elem_to_remove = NULL;
+ }
+ DLFreeList(db_list);
}
void
-print_db_list (Dllist * db_list, int print_table_lists)
+print_db_list(Dllist *db_list, int print_table_lists)
{
- Dlelem *db_elem = DLGetHead (db_list);
- while (NULL != db_elem) {
- print_db_info (((db_info *) DLE_VAL (db_elem)), print_table_lists);
- db_elem = DLGetSucc (db_elem);
- }
+ Dlelem *db_elem = DLGetHead(db_list);
+
+ while (NULL != db_elem)
+ {
+ print_db_info(((db_info *) DLE_VAL(db_elem)), print_table_lists);
+ db_elem = DLGetSucc(db_elem);
+ }
}
void
-print_db_info (db_info * dbi, int print_tbl_list)
+print_db_info(db_info * dbi, int print_tbl_list)
{
- sprintf (logbuffer, "dbname: %s Username %s Passwd %s", dbi->dbname,
- dbi->username, dbi->password);
- log_entry (logbuffer);
- sprintf (logbuffer, " oid %i InsertThresh: %i DeleteThresh: %i", dbi->oid,
- dbi->analyze_threshold, dbi->vacuum_threshold);
- log_entry (logbuffer);
- if (NULL != dbi->conn)
- log_entry (" conn is valid, we are connected");
- else
- log_entry (" conn is null, we are not connected.");
-
- fflush (LOGOUTPUT);
- if (0 < print_tbl_list)
- print_table_list (dbi->table_list);
+ sprintf(logbuffer, "dbname: %s Username %s Passwd %s", dbi->dbname,
+ dbi->username, dbi->password);
+ log_entry(logbuffer);
+ sprintf(logbuffer, " oid %i InsertThresh: %i DeleteThresh: %i", dbi->oid,
+ dbi->analyze_threshold, dbi->vacuum_threshold);
+ log_entry(logbuffer);
+ if (NULL != dbi->conn)
+ log_entry(" conn is valid, we are connected");
+ else
+ log_entry(" conn is null, we are not connected.");
+
+ fflush(LOGOUTPUT);
+ if (0 < print_tbl_list)
+ print_table_list(dbi->table_list);
}
/* End of DB List Management Function */
char *
-query_table_stats (db_info * dbi)
+query_table_stats(db_info * dbi)
{
- if (!strcmp (dbi->dbname, "template1")) /* Use template1 to monitor the system tables */
- return (char *) TABLE_STATS_ALL;
- else
- return (char *) TABLE_STATS_USER;
+ if (!strcmp(dbi->dbname, "template1")) /* Use template1 to
+ * monitor the system
+ * tables */
+ return (char *) TABLE_STATS_ALL;
+ else
+ return (char *) TABLE_STATS_USER;
}
/* Perhaps add some test to this function to make sure that the stats we need are available */
PGconn *
-db_connect (db_info * dbi)
+db_connect(db_info * dbi)
{
- PGconn *db_conn =
- PQsetdbLogin (args->host, args->port, NULL, NULL, dbi->dbname,
- dbi->username, dbi->password);
-
- if (CONNECTION_OK != PQstatus (db_conn)) {
- sprintf (logbuffer, "Failed connection to database %s with error: %s.",
- dbi->dbname, PQerrorMessage (db_conn));
- log_entry (logbuffer);
- fflush (LOGOUTPUT);
- PQfinish (db_conn);
- db_conn = NULL;
- }
- return db_conn;
-} /* end of db_connect() */
+ PGconn *db_conn =
+ PQsetdbLogin(args->host, args->port, NULL, NULL, dbi->dbname,
+ dbi->username, dbi->password);
+
+ if (CONNECTION_OK != PQstatus(db_conn))
+ {
+ sprintf(logbuffer, "Failed connection to database %s with error: %s.",
+ dbi->dbname, PQerrorMessage(db_conn));
+ log_entry(logbuffer);
+ fflush(LOGOUTPUT);
+ PQfinish(db_conn);
+ db_conn = NULL;
+ }
+ return db_conn;
+} /* end of db_connect() */
void
-db_disconnect (db_info * dbi)
+db_disconnect(db_info * dbi)
{
- if (NULL != dbi->conn) {
- PQfinish (dbi->conn);
- dbi->conn = NULL;
- }
+ if (NULL != dbi->conn)
+ {
+ PQfinish(dbi->conn);
+ dbi->conn = NULL;
+ }
}
int
-check_stats_enabled (db_info * dbi)
+check_stats_enabled(db_info * dbi)
{
- PGresult *res = NULL;
- int ret = 0;
- res = send_query ("show stats_row_level", dbi);
- ret =
- strcmp ("on", PQgetvalue (res, 0, PQfnumber (res, "stats_row_level")));
- PQclear (res);
- return ret;
+ PGresult *res = NULL;
+ int ret = 0;
+
+ res = send_query("show stats_row_level", dbi);
+ ret =
+ strcmp("on", PQgetvalue(res, 0, PQfnumber(res, "stats_row_level")));
+ PQclear(res);
+ return ret;
}
PGresult *
-send_query (const char *query, db_info * dbi)
+send_query(const char *query, db_info * dbi)
{
- PGresult *res;
-
- if (NULL == dbi->conn)
- return NULL;
-
- res = PQexec (dbi->conn, query);
-
- if (!res) {
- sprintf (logbuffer,
- "Fatal error occured while sending query (%s) to database %s",
- query, dbi->dbname);
- log_entry (logbuffer);
- sprintf (logbuffer, "The error is [%s]", PQresultErrorMessage (res));
- log_entry (logbuffer);
- fflush (LOGOUTPUT);
- return NULL;
- }
- if (PQresultStatus (res) != PGRES_TUPLES_OK
- && PQresultStatus (res) != PGRES_COMMAND_OK) {
- sprintf (logbuffer,
- "Can not refresh statistics information from the database %s.",
- dbi->dbname);
- log_entry (logbuffer);
- sprintf (logbuffer, "The error is [%s]", PQresultErrorMessage (res));
- log_entry (logbuffer);
- fflush (LOGOUTPUT);
- PQclear (res);
- return NULL;
- }
- return res;
-} /* End of send_query() */
+ PGresult *res;
+
+ if (NULL == dbi->conn)
+ return NULL;
+
+ res = PQexec(dbi->conn, query);
+
+ if (!res)
+ {
+ sprintf(logbuffer,
+ "Fatal error occured while sending query (%s) to database %s",
+ query, dbi->dbname);
+ log_entry(logbuffer);
+ sprintf(logbuffer, "The error is [%s]", PQresultErrorMessage(res));
+ log_entry(logbuffer);
+ fflush(LOGOUTPUT);
+ return NULL;
+ }
+ if (PQresultStatus(res) != PGRES_TUPLES_OK
+ && PQresultStatus(res) != PGRES_COMMAND_OK)
+ {
+ sprintf(logbuffer,
+ "Can not refresh statistics information from the database %s.",
+ dbi->dbname);
+ log_entry(logbuffer);
+ sprintf(logbuffer, "The error is [%s]", PQresultErrorMessage(res));
+ log_entry(logbuffer);
+ fflush(LOGOUTPUT);
+ PQclear(res);
+ return NULL;
+ }
+ return res;
+} /* End of send_query() */
void
-free_cmd_args ()
+free_cmd_args()
{
- if (NULL != args) {
- if (NULL != args->user)
- free (args->user);
- if (NULL != args->user)
- free (args->password);
- free (args);
- }
+ if (NULL != args)
+ {
+ if (NULL != args->user)
+ free(args->user);
+ if (NULL != args->user)
+ free(args->password);
+ free(args);
+ }
}
cmd_args *
-get_cmd_args (int argc, char *argv[])
+get_cmd_args(int argc, char *argv[])
{
- int c;
- args = (cmd_args *) malloc (sizeof (cmd_args));
- args->sleep_base_value = SLEEPBASEVALUE;
- args->sleep_scaling_factor = SLEEPSCALINGFACTOR;
- args->vacuum_base_threshold = VACBASETHRESHOLD;
- args->vacuum_scaling_factor = VACSCALINGFACTOR;
- args->analyze_base_threshold = -1;
- args->analyze_scaling_factor = -1;
- args->debug = AUTOVACUUM_DEBUG;
- args->daemonize = 0;
-
- /* Fixme: Should add some sanity checking such as positive integer values etc */
- while (-1 != (c = getopt (argc, argv, "s:S:v:V:a:A:d:U:P:H:L:p:hD"))) {
- switch (c) {
- case 's':
- args->sleep_base_value = atoi (optarg);
- break;
- case 'S':
- args->sleep_scaling_factor = atof (optarg);
- break;
- case 'v':
- args->vacuum_base_threshold = atoi (optarg);
- break;
- case 'V':
- args->vacuum_scaling_factor = atof (optarg);
- break;
- case 'a':
- args->analyze_base_threshold = atoi (optarg);
- break;
- case 'A':
- args->analyze_scaling_factor = atof (optarg);
- break;
- case 'D':
- args->daemonize++;
- break;
- case 'd':
- args->debug = atoi (optarg);
- break;
- case 'U':
- args->user = optarg;
- break;
- case 'P':
- args->password = optarg;
- break;
- case 'H':
- args->host = optarg;
- break;
- case 'L':
- args->logfile = optarg;
- break;
- case 'p':
- args->port = optarg;
- break;
- case 'h':
- usage();
- exit (0);
- default:
- /* It's here that we know that things are invalid...
- It is not forcibly an error to call usage */
- fprintf (stderr, "Error: Invalid Command Line Options.\n");
- usage();
- exit (1);
- break;
- }
- /* if values for insert thresholds are not specified,
- then they default to 1/2 of the delete values */
- if(-1 == args->analyze_base_threshold)
- args->analyze_base_threshold = args->vacuum_base_threshold / 2;
- if(-1 == args->analyze_scaling_factor)
- args->analyze_scaling_factor = args->vacuum_scaling_factor / 2;
- }
- return args;
+ int c;
+
+ args = (cmd_args *) malloc(sizeof(cmd_args));
+ args->sleep_base_value = SLEEPBASEVALUE;
+ args->sleep_scaling_factor = SLEEPSCALINGFACTOR;
+ args->vacuum_base_threshold = VACBASETHRESHOLD;
+ args->vacuum_scaling_factor = VACSCALINGFACTOR;
+ args->analyze_base_threshold = -1;
+ args->analyze_scaling_factor = -1;
+ args->debug = AUTOVACUUM_DEBUG;
+ args->daemonize = 0;
+
+ /*
+ * Fixme: Should add some sanity checking such as positive integer
+ * values etc
+ */
+ while (-1 != (c = getopt(argc, argv, "s:S:v:V:a:A:d:U:P:H:L:p:hD")))
+ {
+ switch (c)
+ {
+ case 's':
+ args->sleep_base_value = atoi(optarg);
+ break;
+ case 'S':
+ args->sleep_scaling_factor = atof(optarg);
+ break;
+ case 'v':
+ args->vacuum_base_threshold = atoi(optarg);
+ break;
+ case 'V':
+ args->vacuum_scaling_factor = atof(optarg);
+ break;
+ case 'a':
+ args->analyze_base_threshold = atoi(optarg);
+ break;
+ case 'A':
+ args->analyze_scaling_factor = atof(optarg);
+ break;
+ case 'D':
+ args->daemonize++;
+ break;
+ case 'd':
+ args->debug = atoi(optarg);
+ break;
+ case 'U':
+ args->user = optarg;
+ break;
+ case 'P':
+ args->password = optarg;
+ break;
+ case 'H':
+ args->host = optarg;
+ break;
+ case 'L':
+ args->logfile = optarg;
+ break;
+ case 'p':
+ args->port = optarg;
+ break;
+ case 'h':
+ usage();
+ exit(0);
+ default:
+
+ /*
+ * It's here that we know that things are invalid... It is
+ * not forcibly an error to call usage
+ */
+ fprintf(stderr, "Error: Invalid Command Line Options.\n");
+ usage();
+ exit(1);
+ break;
+ }
+
+ /*
+ * if values for insert thresholds are not specified, then they
+ * default to 1/2 of the delete values
+ */
+ if (-1 == args->analyze_base_threshold)
+ args->analyze_base_threshold = args->vacuum_base_threshold / 2;
+ if (-1 == args->analyze_scaling_factor)
+ args->analyze_scaling_factor = args->vacuum_scaling_factor / 2;
+ }
+ return args;
}
-void usage()
+void
+usage()
{
- int i=0;
- float f=0;
- fprintf (stderr, "usage: pg_autovacuum \n");
- fprintf (stderr, " [-D] Daemonize (Detach from tty and run in the background)\n");
- i=AUTOVACUUM_DEBUG;
- fprintf (stderr, " [-d] debug (debug level=0,1,2,3; default=%i)\n",i);
-
- i=SLEEPBASEVALUE;
- fprintf (stderr, " [-s] sleep base value (default=%i)\n",i);
- f=SLEEPSCALINGFACTOR;
- fprintf (stderr, " [-S] sleep scaling factor (default=%f)\n",f);
-
- i=VACBASETHRESHOLD;
- fprintf (stderr, " [-v] vacuum base threshold (default=%i)\n",i);
- f=VACSCALINGFACTOR;
- fprintf (stderr, " [-V] vacuum scaling factor (default=%f)\n",f);
- i=i/2;
- fprintf (stderr, " [-a] analyze base threshold (default=%i)\n",i);
- f=f/2;
- fprintf (stderr, " [-A] analyze scaling factor (default=%f)\n",f);
-
- fprintf (stderr, " [-L] logfile (default=none)\n");
-
- fprintf (stderr, " [-U] username (libpq default)\n");
- fprintf (stderr, " [-P] password (libpq default)\n");
- fprintf (stderr, " [-H] host (libpq default)\n");
- fprintf (stderr, " [-p] port (libpq default)\n");
-
- fprintf (stderr, " [-h] help (Show this output)\n");
+ int i = 0;
+ float f = 0;
+
+ fprintf(stderr, "usage: pg_autovacuum \n");
+ fprintf(stderr, " [-D] Daemonize (Detach from tty and run in the background)\n");
+ i = AUTOVACUUM_DEBUG;
+ fprintf(stderr, " [-d] debug (debug level=0,1,2,3; default=%i)\n", i);
+
+ i = SLEEPBASEVALUE;
+ fprintf(stderr, " [-s] sleep base value (default=%i)\n", i);
+ f = SLEEPSCALINGFACTOR;
+ fprintf(stderr, " [-S] sleep scaling factor (default=%f)\n", f);
+
+ i = VACBASETHRESHOLD;
+ fprintf(stderr, " [-v] vacuum base threshold (default=%i)\n", i);
+ f = VACSCALINGFACTOR;
+ fprintf(stderr, " [-V] vacuum scaling factor (default=%f)\n", f);
+ i = i / 2;
+ fprintf(stderr, " [-a] analyze base threshold (default=%i)\n", i);
+ f = f / 2;
+ fprintf(stderr, " [-A] analyze scaling factor (default=%f)\n", f);
+
+ fprintf(stderr, " [-L] logfile (default=none)\n");
+
+ fprintf(stderr, " [-U] username (libpq default)\n");
+ fprintf(stderr, " [-P] password (libpq default)\n");
+ fprintf(stderr, " [-H] host (libpq default)\n");
+ fprintf(stderr, " [-p] port (libpq default)\n");
+
+ fprintf(stderr, " [-h] help (Show this output)\n");
}
void
-print_cmd_args ()
+print_cmd_args()
{
- sprintf (logbuffer, "Printing command_args");
- log_entry (logbuffer);
- sprintf (logbuffer, " args->host=%s", (args->host) ? args->host : "(null)");
- log_entry (logbuffer);
- sprintf (logbuffer, " args->port=%s", (args->port) ? args->port : "(null)");
- log_entry (logbuffer);
- sprintf (logbuffer, " args->user=%s", (args->user) ? args->user : "(null)");
- log_entry (logbuffer);
- sprintf (logbuffer, " args->password=%s",(args->password) ? args->password : "(null)");
- log_entry (logbuffer);
- sprintf (logbuffer, " args->logfile=%s",(args->logfile) ? args->logfile : "(null)");
- log_entry (logbuffer);
- sprintf (logbuffer, " args->daemonize=%i",args->daemonize);
- log_entry (logbuffer);
-
- sprintf (logbuffer, " args->sleep_base_value=%i", args->sleep_base_value);
- log_entry (logbuffer);
- sprintf (logbuffer, " args->sleep_scaling_factor=%f",args->sleep_scaling_factor);
- log_entry (logbuffer);
- sprintf (logbuffer, " args->vacuum_base_threshold=%i",args->vacuum_base_threshold);
- log_entry (logbuffer);
- sprintf (logbuffer, " args->vacuum_scaling_factor=%f",args->vacuum_scaling_factor);
- log_entry (logbuffer);
- sprintf (logbuffer, " args->analyze_base_threshold=%i",args->analyze_base_threshold);
- log_entry (logbuffer);
- sprintf (logbuffer, " args->analyze_scaling_factor=%f",args->analyze_scaling_factor);
- log_entry (logbuffer);
- sprintf (logbuffer, " args->debug=%i", args->debug);
- log_entry (logbuffer);
-
- fflush (LOGOUTPUT);
+ sprintf(logbuffer, "Printing command_args");
+ log_entry(logbuffer);
+ sprintf(logbuffer, " args->host=%s", (args->host) ? args->host : "(null)");
+ log_entry(logbuffer);
+ sprintf(logbuffer, " args->port=%s", (args->port) ? args->port : "(null)");
+ log_entry(logbuffer);
+ sprintf(logbuffer, " args->user=%s", (args->user) ? args->user : "(null)");
+ log_entry(logbuffer);
+ sprintf(logbuffer, " args->password=%s", (args->password) ? args->password : "(null)");
+ log_entry(logbuffer);
+ sprintf(logbuffer, " args->logfile=%s", (args->logfile) ? args->logfile : "(null)");
+ log_entry(logbuffer);
+ sprintf(logbuffer, " args->daemonize=%i", args->daemonize);
+ log_entry(logbuffer);
+
+ sprintf(logbuffer, " args->sleep_base_value=%i", args->sleep_base_value);
+ log_entry(logbuffer);
+ sprintf(logbuffer, " args->sleep_scaling_factor=%f", args->sleep_scaling_factor);
+ log_entry(logbuffer);
+ sprintf(logbuffer, " args->vacuum_base_threshold=%i", args->vacuum_base_threshold);
+ log_entry(logbuffer);
+ sprintf(logbuffer, " args->vacuum_scaling_factor=%f", args->vacuum_scaling_factor);
+ log_entry(logbuffer);
+ sprintf(logbuffer, " args->analyze_base_threshold=%i", args->analyze_base_threshold);
+ log_entry(logbuffer);
+ sprintf(logbuffer, " args->analyze_scaling_factor=%f", args->analyze_scaling_factor);
+ log_entry(logbuffer);
+ sprintf(logbuffer, " args->debug=%i", args->debug);
+ log_entry(logbuffer);
+
+ fflush(LOGOUTPUT);
}
/* Beginning of AutoVacuum Main Program */
int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
{
- char buf[256];
- int j = 0, loops = 0;
-/* int numInserts, numDeletes, */
- int sleep_secs;
- Dllist *db_list;
- Dlelem *db_elem, *tbl_elem;
- db_info *dbs;
- tbl_info *tbl;
- PGresult *res=NULL;
- long long diff = 0;
- struct timeval now, then;
-
- args = get_cmd_args (argc, argv); /* Get Command Line Args and put them in the args struct */
-
- /* Dameonize if requested */
- if (1 == args->daemonize){ daemonize(); }
-
- if (args->logfile) {
- LOGOUTPUT = fopen (args->logfile, "a");
- if (!LOGOUTPUT) {
- fprintf (stderr, "Could not open log file - [%s]\n", args->logfile);
- exit(-1);
- }
- }
- else {
- LOGOUTPUT = stderr;
- }
- if (args->debug >= 2) {
- print_cmd_args ();
- }
-
- /* Init the db list with template1 */
- db_list = init_db_list ();
- if (NULL == db_list)
- return 1;
-
- if (0 != check_stats_enabled (((db_info *) DLE_VAL (DLGetHead (db_list))))) {
- log_entry ("Error: GUC variable stats_row_level must be enabled.");
- log_entry (" Please fix the problems and try again.");
- fflush (LOGOUTPUT);
-
- exit (1);
- }
-
- gettimeofday (&then, 0); /* for use later to caluculate sleep time */
-
- while (1) { /* Main Loop */
- db_elem = DLGetHead (db_list); /* Reset cur_db_node to the beginning of the db_list */
-
- dbs = ((db_info *) DLE_VAL (db_elem)); /* get pointer to cur_db's db_info struct */
- if (NULL == dbs->conn) {
- dbs->conn = db_connect (dbs);
- if (NULL == dbs->conn) { /* Serious problem: We can't connect to template1 */
- log_entry ("Error: Cannot connect to template1, exiting.");
- fflush (LOGOUTPUT);
- fclose (LOGOUTPUT);
- exit (1);
- }
- }
-
- if (0 == (loops % UPDATE_INTERVAL)) /* Update the list if it's time */
- update_db_list (db_list); /* Add and remove databases from the list */
-
- while (NULL != db_elem) { /* Loop through databases in list */
- dbs = ((db_info *) DLE_VAL (db_elem)); /* get pointer to cur_db's db_info struct */
- if (NULL == dbs->conn)
- dbs->conn = db_connect (dbs);
-
- if (NULL != dbs->conn) {
- if (0 == (loops % UPDATE_INTERVAL)) /* Update the list if it's time */
- update_table_list (dbs); /* Add and remove tables from the list */
-
- if (0 == xid_wraparound_check (dbs));
- {
- res = send_query (query_table_stats (dbs), dbs); /* Get an updated snapshot of this dbs table stats */
- for (j = 0; j < PQntuples (res); j++) { /* loop through result set */
- tbl_elem = DLGetHead (dbs->table_list); /* Reset tbl_elem to top of dbs->table_list */
- while (NULL != tbl_elem) { /* Loop through tables in list */
- tbl = ((tbl_info *) DLE_VAL (tbl_elem)); /* set tbl_info = current_table */
- if (tbl->relfilenode == atoi (PQgetvalue(res, j, PQfnumber (res, "relfilenode")))) {
- tbl->curr_analyze_count =
- (atol (PQgetvalue (res, j, PQfnumber (res, "n_tup_ins"))) +
- atol (PQgetvalue (res, j, PQfnumber (res, "n_tup_upd"))) +
- atol (PQgetvalue (res, j, PQfnumber (res, "n_tup_del"))));
- tbl->curr_vacuum_count =
- (atol (PQgetvalue (res, j, PQfnumber (res, "n_tup_del"))) +
- atol (PQgetvalue (res, j, PQfnumber (res, "n_tup_upd"))));
-
- /* Check numDeletes to see if we need to vacuum, if so:
- Run vacuum analyze (adding analyze is small so we might as well)
- Update table thresholds and related information
- if numDeletes is not big enough for vacuum then check numInserts for analyze */
- if ((tbl->curr_vacuum_count - tbl->CountAtLastVacuum) >= tbl->vacuum_threshold)
- {
- snprintf (buf, sizeof (buf), "vacuum analyze %s", tbl->table_name);
- if (args->debug >= 1) {
- sprintf (logbuffer, "Performing: %s", buf);
- log_entry (logbuffer);
- fflush (LOGOUTPUT);
- }
- send_query (buf, dbs);
- update_table_thresholds (dbs, tbl, VACUUM_ANALYZE);
- if (args->debug >= 2) {print_table_info (tbl);}
- }
- else if ((tbl->curr_analyze_count - tbl->CountAtLastAnalyze) >= tbl->analyze_threshold)
- {
- snprintf (buf, sizeof (buf), "analyze %s", tbl->table_name);
- if (args->debug >= 1) {
- sprintf (logbuffer, "Performing: %s", buf);
- log_entry (logbuffer);
- fflush (LOGOUTPUT);
- }
- send_query (buf, dbs);
- update_table_thresholds (dbs, tbl, ANALYZE_ONLY);
- if (args->debug >= 2) { print_table_info (tbl); }
- }
-
- break; /* once we have found a match, no need to keep checking. */
- }
- /* Advance the table pointers for the next loop */
- tbl_elem = DLGetSucc (tbl_elem);
-
- } /* end for table while loop */
- } /* end for j loop (tuples in PGresult) */
- } /* close of if(xid_wraparound_check()) */
- /* Done working on this db, Clean up, then advance cur_db */
- PQclear (res);
- res = NULL;
- db_disconnect (dbs);
- }
- db_elem = DLGetSucc (db_elem); /* move on to next DB regardless */
- } /* end of db_list while loop */
-
- /* Figure out how long to sleep etc ... */
- gettimeofday (&now, 0);
- diff = (now.tv_sec - then.tv_sec) * 1000000 + (now.tv_usec - then.tv_usec);
-
- sleep_secs = args->sleep_base_value + args->sleep_scaling_factor * diff / 1000000;
- loops++;
- if (args->debug >= 2) {
- sprintf (logbuffer,
- "%i All DBs checked in: %lld usec, will sleep for %i secs.",
- loops, diff, sleep_secs);
- log_entry (logbuffer);
- }
-
- sleep (sleep_secs); /* Larger Pause between outer loops */
-
- gettimeofday (&then, 0); /* Reset time counter */
-
- } /* end of while loop */
-
- /* program is exiting, this should never run, but is here to make compiler / valgrind happy */
- free_db_list (db_list);
- free_cmd_args ();
- return EXIT_SUCCESS;
+ char buf[256];
+ int j = 0,
+ loops = 0;
+
+/* int numInserts, numDeletes, */
+ int sleep_secs;
+ Dllist *db_list;
+ Dlelem *db_elem,
+ *tbl_elem;
+ db_info *dbs;
+ tbl_info *tbl;
+ PGresult *res = NULL;
+ long long diff = 0;
+ struct timeval now,
+ then;
+
+ args = get_cmd_args(argc, argv); /* Get Command Line Args and put
+ * them in the args struct */
+
+ /* Dameonize if requested */
+ if (1 == args->daemonize)
+ daemonize();
+
+ if (args->logfile)
+ {
+ LOGOUTPUT = fopen(args->logfile, "a");
+ if (!LOGOUTPUT)
+ {
+ fprintf(stderr, "Could not open log file - [%s]\n", args->logfile);
+ exit(-1);
+ }
+ }
+ else
+ LOGOUTPUT = stderr;
+ if (args->debug >= 2)
+ print_cmd_args();
+
+ /* Init the db list with template1 */
+ db_list = init_db_list();
+ if (NULL == db_list)
+ return 1;
+
+ if (0 != check_stats_enabled(((db_info *) DLE_VAL(DLGetHead(db_list)))))
+ {
+ log_entry("Error: GUC variable stats_row_level must be enabled.");
+ log_entry(" Please fix the problems and try again.");
+ fflush(LOGOUTPUT);
+
+ exit(1);
+ }
+
+ gettimeofday(&then, 0); /* for use later to caluculate sleep time */
+
+ while (1)
+ { /* Main Loop */
+ db_elem = DLGetHead(db_list); /* Reset cur_db_node to the
+ * beginning of the db_list */
+
+ dbs = ((db_info *) DLE_VAL(db_elem)); /* get pointer to cur_db's
+ * db_info struct */
+ if (NULL == dbs->conn)
+ {
+ dbs->conn = db_connect(dbs);
+ if (NULL == dbs->conn)
+ { /* Serious problem: We can't connect to
+ * template1 */
+ log_entry("Error: Cannot connect to template1, exiting.");
+ fflush(LOGOUTPUT);
+ fclose(LOGOUTPUT);
+ exit(1);
+ }
+ }
+
+ if (0 == (loops % UPDATE_INTERVAL)) /* Update the list if it's
+ * time */
+ update_db_list(db_list); /* Add and remove databases from
+ * the list */
+
+ while (NULL != db_elem)
+ { /* Loop through databases in list */
+ dbs = ((db_info *) DLE_VAL(db_elem)); /* get pointer to
+ * cur_db's db_info
+ * struct */
+ if (NULL == dbs->conn)
+ dbs->conn = db_connect(dbs);
+
+ if (NULL != dbs->conn)
+ {
+ if (0 == (loops % UPDATE_INTERVAL)) /* Update the list if
+ * it's time */
+ update_table_list(dbs); /* Add and remove tables
+ * from the list */
+
+ if (0 == xid_wraparound_check(dbs));
+ {
+ res = send_query(query_table_stats(dbs), dbs); /* Get an updated
+ * snapshot of this dbs
+ * table stats */
+ for (j = 0; j < PQntuples(res); j++)
+ { /* loop through result set */
+ tbl_elem = DLGetHead(dbs->table_list); /* Reset tbl_elem to top
+ * of dbs->table_list */
+ while (NULL != tbl_elem)
+ { /* Loop through tables in list */
+ tbl = ((tbl_info *) DLE_VAL(tbl_elem)); /* set tbl_info =
+ * current_table */
+ if (tbl->relfilenode == atoi(PQgetvalue(res, j, PQfnumber(res, "relfilenode"))))
+ {
+ tbl->curr_analyze_count =
+ (atol(PQgetvalue(res, j, PQfnumber(res, "n_tup_ins"))) +
+ atol(PQgetvalue(res, j, PQfnumber(res, "n_tup_upd"))) +
+ atol(PQgetvalue(res, j, PQfnumber(res, "n_tup_del"))));
+ tbl->curr_vacuum_count =
+ (atol(PQgetvalue(res, j, PQfnumber(res, "n_tup_del"))) +
+ atol(PQgetvalue(res, j, PQfnumber(res, "n_tup_upd"))));
+
+ /*
+ * Check numDeletes to see if we need to
+ * vacuum, if so: Run vacuum analyze
+ * (adding analyze is small so we might as
+ * well) Update table thresholds and
+ * related information if numDeletes is
+ * not big enough for vacuum then check
+ * numInserts for analyze
+ */
+ if ((tbl->curr_vacuum_count - tbl->CountAtLastVacuum) >= tbl->vacuum_threshold)
+ {
+ snprintf(buf, sizeof(buf), "vacuum analyze %s", tbl->table_name);
+ if (args->debug >= 1)
+ {
+ sprintf(logbuffer, "Performing: %s", buf);
+ log_entry(logbuffer);
+ fflush(LOGOUTPUT);
+ }
+ send_query(buf, dbs);
+ update_table_thresholds(dbs, tbl, VACUUM_ANALYZE);
+ if (args->debug >= 2)
+ print_table_info(tbl);
+ }
+ else if ((tbl->curr_analyze_count - tbl->CountAtLastAnalyze) >= tbl->analyze_threshold)
+ {
+ snprintf(buf, sizeof(buf), "analyze %s", tbl->table_name);
+ if (args->debug >= 1)
+ {
+ sprintf(logbuffer, "Performing: %s", buf);
+ log_entry(logbuffer);
+ fflush(LOGOUTPUT);
+ }
+ send_query(buf, dbs);
+ update_table_thresholds(dbs, tbl, ANALYZE_ONLY);
+ if (args->debug >= 2)
+ print_table_info(tbl);
+ }
+
+ break; /* once we have found a match, no
+ * need to keep checking. */
+ }
+
+ /*
+ * Advance the table pointers for the next
+ * loop
+ */
+ tbl_elem = DLGetSucc(tbl_elem);
+
+ } /* end for table while loop */
+ } /* end for j loop (tuples in PGresult) */
+ } /* close of if(xid_wraparound_check()) */
+ /* Done working on this db, Clean up, then advance cur_db */
+ PQclear(res);
+ res = NULL;
+ db_disconnect(dbs);
+ }
+ db_elem = DLGetSucc(db_elem); /* move on to next DB
+ * regardless */
+ } /* end of db_list while loop */
+
+ /* Figure out how long to sleep etc ... */
+ gettimeofday(&now, 0);
+ diff = (now.tv_sec - then.tv_sec) * 1000000 + (now.tv_usec - then.tv_usec);
+
+ sleep_secs = args->sleep_base_value + args->sleep_scaling_factor * diff / 1000000;
+ loops++;
+ if (args->debug >= 2)
+ {
+ sprintf(logbuffer,
+ "%i All DBs checked in: %lld usec, will sleep for %i secs.",
+ loops, diff, sleep_secs);
+ log_entry(logbuffer);
+ }
+
+ sleep(sleep_secs); /* Larger Pause between outer loops */
+
+ gettimeofday(&then, 0); /* Reset time counter */
+
+ } /* end of while loop */
+
+ /*
+ * program is exiting, this should never run, but is here to make
+ * compiler / valgrind happy
+ */
+ free_db_list(db_list);
+ free_cmd_args();
+ return EXIT_SUCCESS;
}
#include "/usr/include/pgsql/server/lib/dllist.h"
*/
-#define AUTOVACUUM_DEBUG 1
-#define VACBASETHRESHOLD 1000
-#define VACSCALINGFACTOR 2
-#define SLEEPBASEVALUE 300
-#define SLEEPSCALINGFACTOR 2
-#define UPDATE_INTERVAL 2
+#define AUTOVACUUM_DEBUG 1
+#define VACBASETHRESHOLD 1000
+#define VACSCALINGFACTOR 2
+#define SLEEPBASEVALUE 300
+#define SLEEPSCALINGFACTOR 2
+#define UPDATE_INTERVAL 2
/* these two constants are used to tell update_table_stats what operation we just perfomred */
-#define VACUUM_ANALYZE 0
-#define ANALYZE_ONLY 1
+#define VACUUM_ANALYZE 0
+#define ANALYZE_ONLY 1
-#define TABLE_STATS_ALL "select a.relfilenode,a.relname,a.relnamespace,a.relpages,a.reltuples,b.schemaname,b.n_tup_ins,b.n_tup_upd,b.n_tup_del from pg_class a, pg_stat_all_tables b where a.relfilenode=b.relid"
-#define TABLE_STATS_USER "select a.relfilenode,a.relname,a.relnamespace,a.relpages,a.reltuples,b.schemaname,b.n_tup_ins,b.n_tup_upd,b.n_tup_del from pg_class a, pg_stat_user_tables b where a.relfilenode=b.relid"
+#define TABLE_STATS_ALL "select a.relfilenode,a.relname,a.relnamespace,a.relpages,a.reltuples,b.schemaname,b.n_tup_ins,b.n_tup_upd,b.n_tup_del from pg_class a, pg_stat_all_tables b where a.relfilenode=b.relid"
+#define TABLE_STATS_USER "select a.relfilenode,a.relname,a.relnamespace,a.relpages,a.reltuples,b.schemaname,b.n_tup_ins,b.n_tup_upd,b.n_tup_del from pg_class a, pg_stat_user_tables b where a.relfilenode=b.relid"
#define FRONTEND
#define PAGES_QUERY "select relfilenode,reltuples,relpages from pg_class where relfilenode=%i"
#define FROZENOID_QUERY "select oid,age(datfrozenxid) from pg_database where datname = 'template1'"
/* define cmd_args stucture */
struct cmdargs
{
- int vacuum_base_threshold, analyze_base_threshold, sleep_base_value, debug, daemonize;
- float vacuum_scaling_factor, analyze_scaling_factor, sleep_scaling_factor;
- char *user, *password, *host, *logfile, *port;
+ int vacuum_base_threshold,
+ analyze_base_threshold,
+ sleep_base_value,
+ debug,
+ daemonize;
+ float vacuum_scaling_factor,
+ analyze_scaling_factor,
+ sleep_scaling_factor;
+ char *user,
+ *password,
+ *host,
+ *logfile,
+ *port;
};
typedef struct cmdargs cmd_args;
/* define cmd_args as global so we can get to them everywhere */
-cmd_args *args;
+cmd_args *args;
/* Might need to add a time value for last time the whold database was vacuumed.
- I think we need to guarantee this happens approx every 1Million TX's */
+ I think we need to guarantee this happens approx every 1Million TX's */
struct dbinfo
{
- int oid, age;
- int analyze_threshold, vacuum_threshold; /* Use these as defaults for table thresholds */
- PGconn *conn;
- char *dbname, *username, *password;
- Dllist *table_list;
+ int oid,
+ age;
+ int analyze_threshold,
+ vacuum_threshold; /* Use these as defaults for table
+ * thresholds */
+ PGconn *conn;
+ char *dbname,
+ *username,
+ *password;
+ Dllist *table_list;
};
typedef struct dbinfo db_info;
struct tableinfo
{
- char *schema_name, *table_name;
- int relfilenode, reltuples, relpages;
- long analyze_threshold, vacuum_threshold;
- long CountAtLastAnalyze; /* equal to: inserts + updates as of the last analyze or initial values at startup */
- long CountAtLastVacuum; /* equal to: deletes + updates as of the last vacuum or initial values at startup */
- long curr_analyze_count, curr_vacuum_count; /* Latest values from stats system */
- db_info *dbi; /* pointer to the database that this table belongs to */
+ char *schema_name,
+ *table_name;
+ int relfilenode,
+ reltuples,
+ relpages;
+ long analyze_threshold,
+ vacuum_threshold;
+ long CountAtLastAnalyze; /* equal to: inserts + updates as
+ * of the last analyze or initial
+ * values at startup */
+ long CountAtLastVacuum; /* equal to: deletes + updates as
+ * of the last vacuum or initial
+ * values at startup */
+ long curr_analyze_count,
+ curr_vacuum_count; /* Latest values from stats system */
+ db_info *dbi; /* pointer to the database that this table
+ * belongs to */
};
typedef struct tableinfo tbl_info;
/* Functions for dealing with command line arguements */
-static cmd_args *get_cmd_args (int argc, char *argv[]);
-static void print_cmd_args (void);
-static void free_cmd_args (void);
-static void usage (void);
+static cmd_args *get_cmd_args(int argc, char *argv[]);
+static void print_cmd_args(void);
+static void free_cmd_args(void);
+static void usage(void);
/* Functions for managing database lists */
-static Dllist *init_db_list (void);
-static db_info *init_dbinfo (char *dbname, int oid, int age);
-static void update_db_list (Dllist * db_list);
-static void remove_db_from_list (Dlelem * db_to_remove);
-static void print_db_info (db_info * dbi, int print_table_list);
-static void print_db_list (Dllist * db_list, int print_table_lists);
-static int xid_wraparound_check (db_info * dbi);
-static void free_db_list (Dllist * db_list);
+static Dllist *init_db_list(void);
+static db_info *init_dbinfo(char *dbname, int oid, int age);
+static void update_db_list(Dllist *db_list);
+static void remove_db_from_list(Dlelem *db_to_remove);
+static void print_db_info(db_info * dbi, int print_table_list);
+static void print_db_list(Dllist *db_list, int print_table_lists);
+static int xid_wraparound_check(db_info * dbi);
+static void free_db_list(Dllist *db_list);
/* Functions for managing table lists */
-static tbl_info *init_table_info (PGresult * conn, int row, db_info *dbi);
-static void update_table_list (db_info * dbi);
-static void remove_table_from_list (Dlelem * tbl_to_remove);
-static void print_table_list (Dllist * tbl_node);
-static void print_table_info (tbl_info * tbl);
-static void update_table_thresholds (db_info * dbi, tbl_info * tbl, int vacuum_type);
-static void free_tbl_list (Dllist * tbl_list);
+static tbl_info *init_table_info(PGresult *conn, int row, db_info * dbi);
+static void update_table_list(db_info * dbi);
+static void remove_table_from_list(Dlelem *tbl_to_remove);
+static void print_table_list(Dllist *tbl_node);
+static void print_table_info(tbl_info * tbl);
+static void update_table_thresholds(db_info * dbi, tbl_info * tbl, int vacuum_type);
+static void free_tbl_list(Dllist *tbl_list);
/* A few database helper functions */
-static int check_stats_enabled (db_info * dbi);
-static PGconn *db_connect (db_info * dbi);
-static void db_disconnect (db_info * dbi);
-static PGresult *send_query (const char *query, db_info * dbi);
-static char *query_table_stats (db_info * dbi);
+static int check_stats_enabled(db_info * dbi);
+static PGconn *db_connect(db_info * dbi);
+static void db_disconnect(db_info * dbi);
+static PGresult *send_query(const char *query, db_info * dbi);
+static char *query_table_stats(db_info * dbi);
/* Other Generally needed Functions */
static void daemonize(void);
-static void log_entry (const char *logentry);
+static void log_entry(const char *logentry);
/* -------------------------------------------------------------------------
* pg_dumplo
*
- * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/main.c,v 1.16 2003/05/14 03:25:56 tgl Exp $
+ * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/main.c,v 1.17 2003/08/04 00:43:11 momjian Exp $
*
* Karel Zak 1999-2000
* -------------------------------------------------------------------------
#ifndef HAVE_GETOPT_LONG
#include "getopt_long.h"
-int optreset;
+int optreset;
#endif
char *progname = NULL;
/*
- * $Header: /cvsroot/pgsql/contrib/pgbench/pgbench.c,v 1.25 2003/08/01 02:21:17 tgl Exp $
+ * $Header: /cvsroot/pgsql/contrib/pgbench/pgbench.c,v 1.26 2003/08/04 00:43:11 momjian Exp $
*
* pgbench: a simple TPC-B like benchmark program for PostgreSQL
* written by Tatsuo Ishii
{
PGconn *con;
PGresult *res;
-
+
con = PQsetdbLogin(pghost, pgport, pgoptions, pgtty, dbName,
login, pwd);
if (con == NULL)
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
- * $Id: openssl.c,v 1.11 2002/11/15 02:54:44 momjian Exp $
+ * $Id: openssl.c,v 1.12 2003/08/04 00:43:11 momjian Exp $
*/
#include <postgres.h>
* of functions does not allow enough flexibility
* and forces some of the parameters (keylen,
* padding) to SSL defaults.
- *
+ *
* So need to manage ciphers ourselves.
*/
-struct ossl_cipher {
- int (*init) (PX_Cipher * c, const uint8 *key, unsigned klen, const uint8 *iv);
- int (*encrypt) (PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res);
- int (*decrypt) (PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res);
+struct ossl_cipher
+{
+ int (*init) (PX_Cipher * c, const uint8 *key, unsigned klen, const uint8 *iv);
+ int (*encrypt) (PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res);
+ int (*decrypt) (PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res);
- int block_size;
- int max_key_size;
- int stream_cipher;
+ int block_size;
+ int max_key_size;
+ int stream_cipher;
};
typedef struct
bf_ecb_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
{
unsigned bs = gen_ossl_block_size(c);
- unsigned i;
+ unsigned i;
ossldata *od = c->ptr;
for (i = 0; i < dlen / bs; i++)
ossl_des_init(PX_Cipher * c, const uint8 *key, unsigned klen, const uint8 *iv)
{
ossldata *od = c->ptr;
- des_cblock xkey;
+ des_cblock xkey;
memset(&xkey, 0, sizeof(xkey));
memcpy(&xkey, key, klen > 8 ? 8 : klen);
des_set_key(&xkey, od->u.des.key_schedule);
memset(&xkey, 0, sizeof(xkey));
-
+
if (iv)
memcpy(od->iv, iv, 8);
else
static int
ossl_des_ecb_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
- uint8 *res)
+ uint8 *res)
{
unsigned bs = gen_ossl_block_size(c);
- unsigned i;
+ unsigned i;
ossldata *od = c->ptr;
for (i = 0; i < dlen / bs; i++)
- des_ecb_encrypt((des_cblock*)(data + i * bs),
- (des_cblock*)(res + i * bs),
- od->u.des.key_schedule, 1);
+ des_ecb_encrypt((des_cblock *) (data + i * bs),
+ (des_cblock *) (res + i * bs),
+ od->u.des.key_schedule, 1);
return 0;
}
static int
ossl_des_ecb_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
- uint8 *res)
+ uint8 *res)
{
unsigned bs = gen_ossl_block_size(c);
- unsigned i;
+ unsigned i;
ossldata *od = c->ptr;
for (i = 0; i < dlen / bs; i++)
- des_ecb_encrypt((des_cblock*)(data + i * bs),
- (des_cblock*)(res + i * bs),
- od->u.des.key_schedule, 0);
+ des_ecb_encrypt((des_cblock *) (data + i * bs),
+ (des_cblock *) (res + i * bs),
+ od->u.des.key_schedule, 0);
return 0;
}
static int
ossl_des_cbc_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
- uint8 *res)
+ uint8 *res)
{
ossldata *od = c->ptr;
des_ncbc_encrypt(data, res, dlen, od->u.des.key_schedule,
- (des_cblock*)od->iv, 1);
+ (des_cblock *) od->iv, 1);
return 0;
}
static int
ossl_des_cbc_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
- uint8 *res)
+ uint8 *res)
{
ossldata *od = c->ptr;
des_ncbc_encrypt(data, res, dlen, od->u.des.key_schedule,
- (des_cblock*)od->iv, 0);
+ (des_cblock *) od->iv, 0);
return 0;
}
{
unsigned bs = gen_ossl_block_size(c);
ossldata *od = c->ptr;
- const uint8 *end = data + dlen - bs;
+ const uint8 *end = data + dlen - bs;
for (; data <= end; data += bs, res += bs)
CAST_ecb_encrypt(data, res, &od->u.cast_key, CAST_ENCRYPT);
{
unsigned bs = gen_ossl_block_size(c);
ossldata *od = c->ptr;
- const uint8 *end = data + dlen - bs;
+ const uint8 *end = data + dlen - bs;
for (; data <= end; data += bs, res += bs)
CAST_ecb_encrypt(data, res, &od->u.cast_key, CAST_DECRYPT);
static const struct ossl_cipher ossl_bf_cbc = {
bf_init, bf_cbc_encrypt, bf_cbc_decrypt,
- 64/8, 448/8, 0
+ 64 / 8, 448 / 8, 0
};
static const struct ossl_cipher ossl_bf_ecb = {
bf_init, bf_ecb_encrypt, bf_ecb_decrypt,
- 64/8, 448/8, 0
+ 64 / 8, 448 / 8, 0
};
static const struct ossl_cipher ossl_bf_cfb = {
bf_init, bf_cfb64_encrypt, bf_cfb64_decrypt,
- 64/8, 448/8, 1
+ 64 / 8, 448 / 8, 1
};
static const struct ossl_cipher ossl_des_ecb = {
ossl_des_init, ossl_des_ecb_encrypt, ossl_des_ecb_decrypt,
- 64/8, 64/8, 0
+ 64 / 8, 64 / 8, 0
};
static const struct ossl_cipher ossl_des_cbc = {
ossl_des_init, ossl_des_cbc_encrypt, ossl_des_cbc_decrypt,
- 64/8, 64/8, 0
+ 64 / 8, 64 / 8, 0
};
static const struct ossl_cipher ossl_cast_ecb = {
ossl_cast_init, ossl_cast_ecb_encrypt, ossl_cast_ecb_decrypt,
- 64/8, 128/8, 0
+ 64 / 8, 128 / 8, 0
};
static const struct ossl_cipher ossl_cast_cbc = {
ossl_cast_init, ossl_cast_cbc_encrypt, ossl_cast_cbc_decrypt,
- 64/8, 128/8, 0
+ 64 / 8, 128 / 8, 0
};
/*
*/
static const struct
{
- const char *name;
+ const char *name;
const struct ossl_cipher *ciph;
} ossl_cipher_types[] =
const struct ossl_cipher *ossl_ciph = NULL;
name = px_resolve_alias(ossl_aliases, name);
- for (i = 0; ossl_cipher_types[i].name; i++) {
- if (!strcmp(ossl_cipher_types[i].name, name)) {
+ for (i = 0; ossl_cipher_types[i].name; i++)
+ {
+ if (!strcmp(ossl_cipher_types[i].name, name))
+ {
ossl_ciph = ossl_cipher_types[i].ciph;
break;
}
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
- * $Id: pgcrypto.c,v 1.13 2003/07/24 17:52:33 tgl Exp $
+ * $Id: pgcrypto.c,v 1.14 2003/08/04 00:43:11 momjian Exp $
*/
#include <postgres.h>
if (len == 0)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("no such crypt algorithm or bad number of rounds")));
+ errmsg("no such crypt algorithm or bad number of rounds")));
res = (text *) palloc(len + VARHDRSZ);
VARATT_SIZEP(res) = len + VARHDRSZ;
/*
- * $Header: /cvsroot/pgsql/contrib/pgstattuple/pgstattuple.c,v 1.11 2003/08/01 02:21:17 tgl Exp $
+ * $Header: /cvsroot/pgsql/contrib/pgstattuple/pgstattuple.c,v 1.12 2003/08/04 00:43:11 momjian Exp $
*
* Copyright (c) 2001,2002 Tatsuo Ishii
*
pfree(values[i]);
pfree(values);
- return(result);
+ return (result);
}
if (SPI_gettypeid(tupdesc, attnum) != INT4OID)
ereport(ERROR,
(errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
- errmsg("attribute \"%s\" of \"%s\" must be type INT4",
- args[i], relname)));
+ errmsg("attribute \"%s\" of \"%s\" must be type INT4",
+ args[i], relname)));
val = DatumGetInt32(SPI_getbinval(rettuple, tupdesc, attnum, &isnull));
if (attnum < 0)
ereport(ERROR,
(errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
- errmsg("\"%s\" has no attribute \"%s\"", relname, args[0])));
+ errmsg("\"%s\" has no attribute \"%s\"", relname, args[0])));
if (SPI_gettypeid(tupdesc, attnum) != TEXTOID)
ereport(ERROR,
(errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
errmsg("attribute \"%s\" of \"%s\" must be type TEXT",
- args[0], relname)));
+ args[0], relname)));
/* create fields containing name */
newval = DirectFunctionCall1(textin,
- CStringGetDatum(GetUserNameFromId(GetUserId())));
+ CStringGetDatum(GetUserNameFromId(GetUserId())));
/* construct new tuple */
rettuple = SPI_modifytuple(rel, rettuple, 1, &attnum, &newval, NULL);
if (SPI_gettypeid(tupdesc, attnum) != TIMESTAMPOID)
ereport(ERROR,
(errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
- errmsg("attribute \"%s\" of \"%s\" must be type TIMESTAMP",
- args[0], relname)));
+ errmsg("attribute \"%s\" of \"%s\" must be type TIMESTAMP",
+ args[0], relname)));
/* 1 is the number of items in the arrays attnum and newdt.
attnum is the positional number of the field to be updated.
if (fnumber < 0)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_COLUMN),
- errmsg("there is no attribute \"%s\" in relation \"%s\"",
- args[i], SPI_getrelname(rel))));
+ errmsg("there is no attribute \"%s\" in relation \"%s\"",
+ args[i], SPI_getrelname(rel))));
/* Well, get binary (in internal format) value of column */
kvals[i] = SPI_getbinval(tuple, tupdesc, fnumber, &isnull);
if (fnumber < 0)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_COLUMN),
- errmsg("there is no attribute \"%s\" in relation \"%s\"",
- args[i], SPI_getrelname(rel))));
+ errmsg("there is no attribute \"%s\" in relation \"%s\"",
+ args[i], SPI_getrelname(rel))));
/* Well, get binary (in internal format) value of column */
kvals[i] = SPI_getbinval(trigtuple, tupdesc, fnumber, &isnull);
ereport(ERROR,
(errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
errmsg("\"%s\": tuple is referenced in \"%s\"",
- trigger->tgname, relname)));
+ trigger->tgname, relname)));
}
else
{
/* Modified by BÖJTHE Zoltán, Hungary, mailto:urdesobt@axelero.hu */
#include "executor/spi.h" /* this is what you need to work with SPI */
-#include "commands/trigger.h" /* -"- and triggers */
+#include "commands/trigger.h" /* -"- and triggers */
#include "miscadmin.h" /* for GetPgUserName() */
-#include <ctype.h> /* tolower () */
+#include <ctype.h> /* tolower () */
-#define ABSTIMEOID 702 /* it should be in pg_type.h */
+#define ABSTIMEOID 702 /* it should be in pg_type.h */
/* AbsoluteTime currabstime(void); */
Datum timetravel(PG_FUNCTION_ARGS);
typedef struct _TTOffList
{
- struct _TTOffList *next;
- char name[1];
-} TTOffList;
+ struct _TTOffList *next;
+ char name[1];
+} TTOffList;
-static TTOffList TTOff = {NULL,{0}};
+static TTOffList TTOff = {NULL, {0}};
-static int findTTStatus(char *name);
+static int findTTStatus(char *name);
static EPlan *find_plan(char *ident, EPlan ** eplan, int *nplans);
/*
PG_FUNCTION_INFO_V1(timetravel);
-Datum /* have to return HeapTuple to Executor */
+Datum /* have to return HeapTuple to Executor */
timetravel(PG_FUNCTION_ARGS)
{
- TriggerData *trigdata = (TriggerData *) fcinfo->context;
- Trigger *trigger; /* to get trigger name */
- int argc;
- char **args; /* arguments */
- int attnum[MaxAttrNum]; /* fnumbers of start/stop columns */
+ TriggerData *trigdata = (TriggerData *) fcinfo->context;
+ Trigger *trigger; /* to get trigger name */
+ int argc;
+ char **args; /* arguments */
+ int attnum[MaxAttrNum]; /* fnumbers of start/stop columns */
Datum oldtimeon,
- oldtimeoff;
+ oldtimeoff;
Datum newtimeon,
- newtimeoff,
- newuser,
- nulltext;
- Datum *cvals; /* column values */
- char *cnulls; /* column nulls */
- char *relname; /* triggered relation name */
+ newtimeoff,
+ newuser,
+ nulltext;
+ Datum *cvals; /* column values */
+ char *cnulls; /* column nulls */
+ char *relname; /* triggered relation name */
Relation rel; /* triggered relation */
HeapTuple trigtuple;
HeapTuple newtuple = NULL;
HeapTuple rettuple;
TupleDesc tupdesc; /* tuple description */
- int natts; /* # of attributes */
- EPlan *plan; /* prepared plan */
+ int natts; /* # of attributes */
+ EPlan *plan; /* prepared plan */
char ident[2 * NAMEDATALEN];
bool isnull; /* to know is some column NULL or not */
bool isinsert = false;
- int ret;
- int i;
+ int ret;
+ int i;
/*
* Some checks first...
*/
/* Called by trigger manager ? */
- if(!CALLED_AS_TRIGGER(fcinfo))
+ if (!CALLED_AS_TRIGGER(fcinfo))
elog(ERROR, "timetravel: not fired by trigger manager");
/* Should be called for ROW trigger */
- if(TRIGGER_FIRED_FOR_STATEMENT(trigdata->tg_event))
+ if (TRIGGER_FIRED_FOR_STATEMENT(trigdata->tg_event))
elog(ERROR, "timetravel: can't process STATEMENT events");
/* Should be called BEFORE */
- if(TRIGGER_FIRED_AFTER(trigdata->tg_event))
+ if (TRIGGER_FIRED_AFTER(trigdata->tg_event))
elog(ERROR, "timetravel: must be fired before event");
/* INSERT ? */
- if(TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))
+ if (TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))
isinsert = true;
- if(TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
+ if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
newtuple = trigdata->tg_newtuple;
trigtuple = trigdata->tg_trigtuple;
relname = SPI_getrelname(rel);
/* check if TT is OFF for this relation */
- if(0==findTTStatus(relname))
+ if (0 == findTTStatus(relname))
{
/* OFF - nothing to do */
pfree(relname);
trigger = trigdata->tg_trigger;
argc = trigger->tgnargs;
- if(argc != MinAttrNum && argc != MaxAttrNum)
+ if (argc != MinAttrNum && argc != MaxAttrNum)
elog(ERROR, "timetravel (%s): invalid (!= %d or %d) number of arguments %d",
relname, MinAttrNum, MaxAttrNum, trigger->tgnargs);
tupdesc = rel->rd_att;
natts = tupdesc->natts;
- for(i = 0 ; i < MinAttrNum ; i++)
+ for (i = 0; i < MinAttrNum; i++)
{
attnum[i] = SPI_fnumber(tupdesc, args[i]);
- if(attnum[i] < 0)
+ if (attnum[i] < 0)
elog(ERROR, "timetravel (%s): there is no attribute %s", relname, args[i]);
- if(SPI_gettypeid(tupdesc, attnum[i]) != ABSTIMEOID)
+ if (SPI_gettypeid(tupdesc, attnum[i]) != ABSTIMEOID)
elog(ERROR, "timetravel (%s): attribute %s must be of abstime type",
relname, args[i]);
}
- for( ; i < argc ; i++)
+ for (; i < argc; i++)
{
attnum[i] = SPI_fnumber(tupdesc, args[i]);
- if(attnum[i] < 0)
+ if (attnum[i] < 0)
elog(ERROR, "timetravel (%s): there is no attribute %s", relname, args[i]);
- if(SPI_gettypeid(tupdesc, attnum[i]) != TEXTOID)
+ if (SPI_gettypeid(tupdesc, attnum[i]) != TEXTOID)
elog(ERROR, "timetravel (%s): attribute %s must be of text type",
relname, args[i]);
}
/* create fields containing name */
- newuser = DirectFunctionCall1(textin, CStringGetDatum(GetUserNameFromId(GetUserId())));
+ newuser = DirectFunctionCall1(textin, CStringGetDatum(GetUserNameFromId(GetUserId())));
- nulltext = (Datum)NULL;
+ nulltext = (Datum) NULL;
- if(isinsert)
- { /* INSERT */
- int chnattrs = 0;
- int chattrs[MaxAttrNum];
- Datum newvals[MaxAttrNum];
- char newnulls[MaxAttrNum];
+ if (isinsert)
+ { /* INSERT */
+ int chnattrs = 0;
+ int chattrs[MaxAttrNum];
+ Datum newvals[MaxAttrNum];
+ char newnulls[MaxAttrNum];
oldtimeon = SPI_getbinval(trigtuple, tupdesc, attnum[a_time_on], &isnull);
- if(isnull)
+ if (isnull)
{
newvals[chnattrs] = GetCurrentAbsoluteTime();
newnulls[chnattrs] = ' ';
}
oldtimeoff = SPI_getbinval(trigtuple, tupdesc, attnum[a_time_off], &isnull);
- if(isnull)
+ if (isnull)
{
- if((chnattrs == 0 && DatumGetInt32(oldtimeon) >= NOEND_ABSTIME) ||
- (chnattrs > 0 && DatumGetInt32(newvals[a_time_on]) >= NOEND_ABSTIME))
+ if ((chnattrs == 0 && DatumGetInt32(oldtimeon) >= NOEND_ABSTIME) ||
+ (chnattrs > 0 && DatumGetInt32(newvals[a_time_on]) >= NOEND_ABSTIME))
elog(ERROR, "timetravel (%s): %s is infinity", relname, args[a_time_on]);
newvals[chnattrs] = NOEND_ABSTIME;
newnulls[chnattrs] = ' ';
}
else
{
- if((chnattrs == 0 && DatumGetInt32(oldtimeon) > DatumGetInt32(oldtimeoff)) ||
- (chnattrs > 0 && DatumGetInt32(newvals[a_time_on]) > DatumGetInt32(oldtimeoff)))
+ if ((chnattrs == 0 && DatumGetInt32(oldtimeon) > DatumGetInt32(oldtimeoff)) ||
+ (chnattrs > 0 && DatumGetInt32(newvals[a_time_on]) > DatumGetInt32(oldtimeoff)))
elog(ERROR, "timetravel (%s): %s gt %s", relname, args[a_time_on], args[a_time_off]);
}
pfree(relname);
- if(chnattrs <= 0)
+ if (chnattrs <= 0)
return PointerGetDatum(trigtuple);
- if(argc == MaxAttrNum)
+ if (argc == MaxAttrNum)
{
/* clear update_user value */
newvals[chnattrs] = nulltext;
/* UPDATE/DELETE: */
oldtimeon = SPI_getbinval(trigtuple, tupdesc, attnum[a_time_on], &isnull);
- if(isnull)
+ if (isnull)
elog(ERROR, "timetravel (%s): %s must be NOT NULL", relname, args[a_time_on]);
oldtimeoff = SPI_getbinval(trigtuple, tupdesc, attnum[a_time_off], &isnull);
- if(isnull)
+ if (isnull)
elog(ERROR, "timetravel (%s): %s must be NOT NULL", relname, args[a_time_off]);
/*
* If DELETE/UPDATE of tuple with stop_date neq INFINITY then say
* upper Executor to skip operation for this tuple
*/
- if(newtuple != NULL)
- { /* UPDATE */
+ if (newtuple != NULL)
+ { /* UPDATE */
newtimeon = SPI_getbinval(newtuple, tupdesc, attnum[a_time_on], &isnull);
- if(isnull)
+ if (isnull)
elog(ERROR, "timetravel (%s): %s must be NOT NULL", relname, args[a_time_on]);
newtimeoff = SPI_getbinval(newtuple, tupdesc, attnum[a_time_off], &isnull);
- if(isnull)
+ if (isnull)
elog(ERROR, "timetravel (%s): %s must be NOT NULL", relname, args[a_time_off]);
- if(oldtimeon != newtimeon || oldtimeoff != newtimeoff)
+ if (oldtimeon != newtimeon || oldtimeoff != newtimeoff)
elog(ERROR, "timetravel (%s): you can't change %s and/or %s columns (use set_timetravel)",
relname, args[a_time_on], args[a_time_off]);
}
- if(oldtimeoff != NOEND_ABSTIME)
- { /* current record is a deleted/updated record */
+ if (oldtimeoff != NOEND_ABSTIME)
+ { /* current record is a deleted/updated
+ * record */
pfree(relname);
return PointerGetDatum(NULL);
}
newtimeoff = GetCurrentAbsoluteTime();
/* Connect to SPI manager */
- if((ret = SPI_connect()) < 0)
+ if ((ret = SPI_connect()) < 0)
elog(ERROR, "timetravel (%s): SPI_connect returned %d", relname, ret);
/* Fetch tuple values and nulls */
cvals = (Datum *) palloc(natts * sizeof(Datum));
cnulls = (char *) palloc(natts * sizeof(char));
- for(i = 0; i < natts; i++)
+ for (i = 0; i < natts; i++)
{
cvals[i] = SPI_getbinval(trigtuple, tupdesc, i + 1, &isnull);
cnulls[i] = (isnull) ? 'n' : ' ';
}
/* change date column(s) */
- cvals[attnum[a_time_off] - 1] = newtimeoff; /* stop_date eq current date */
+ cvals[attnum[a_time_off] - 1] = newtimeoff; /* stop_date eq current
+ * date */
cnulls[attnum[a_time_off] - 1] = ' ';
- if(!newtuple)
- { /* DELETE */
- if(argc == MaxAttrNum)
+ if (!newtuple)
+ { /* DELETE */
+ if (argc == MaxAttrNum)
{
- cvals[attnum[a_del_user] - 1] = newuser; /* set delete user */
+ cvals[attnum[a_del_user] - 1] = newuser; /* set delete user */
cnulls[attnum[a_del_user] - 1] = ' ';
}
}
plan = find_plan(ident, &Plans, &nPlans);
/* if there is no plan ... */
- if(plan->splan == NULL)
+ if (plan->splan == NULL)
{
- void *pplan;
- Oid *ctypes;
- char sql[8192];
+ void *pplan;
+ Oid *ctypes;
+ char sql[8192];
/* allocate ctypes for preparation */
ctypes = (Oid *) palloc(natts * sizeof(Oid));
* Construct query: INSERT INTO _relation_ VALUES ($1, ...)
*/
snprintf(sql, sizeof(sql), "INSERT INTO %s VALUES (", relname);
- for(i = 1; i <= natts; i++)
+ for (i = 1; i <= natts; i++)
{
ctypes[i - 1] = SPI_gettypeid(tupdesc, i);
- if(!(tupdesc->attrs[i - 1]->attisdropped)) /* skip dropped columns */
- snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), "$%d%s",
- i, (i < natts) ? ", " : ")" );
+ if (!(tupdesc->attrs[i - 1]->attisdropped)) /* skip dropped columns */
+ snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), "$%d%s",
+ i, (i < natts) ? ", " : ")");
#if 0
- snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), "$%d /* %d */ %s",
- i, ctypes[i-1], (i < natts) ? ", " : ")" );
+ snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), "$%d /* %d */ %s",
+ i, ctypes[i - 1], (i < natts) ? ", " : ")");
#endif
}
/* Prepare plan for query */
pplan = SPI_prepare(sql, natts, ctypes);
- if(pplan == NULL)
+ if (pplan == NULL)
elog(ERROR, "timetravel (%s): SPI_prepare returned %d", relname, SPI_result);
/*
* use.
*/
pplan = SPI_saveplan(pplan);
- if(pplan == NULL)
+ if (pplan == NULL)
elog(ERROR, "timetravel (%s): SPI_saveplan returned %d", relname, SPI_result);
plan->splan = pplan;
*/
ret = SPI_execp(plan->splan, cvals, cnulls, 0);
- if(ret < 0)
+ if (ret < 0)
elog(ERROR, "timetravel (%s): SPI_execp returned %d", relname, ret);
/* Tuple to return to upper Executor ... */
- if(newtuple)
- { /* UPDATE */
- int chnattrs = 0;
- int chattrs[MaxAttrNum];
+ if (newtuple)
+ { /* UPDATE */
+ int chnattrs = 0;
+ int chattrs[MaxAttrNum];
Datum newvals[MaxAttrNum];
char newnulls[MaxAttrNum];
chattrs[chnattrs] = attnum[a_time_off];
chnattrs++;
- if(argc == MaxAttrNum)
+ if (argc == MaxAttrNum)
{
/* set update_user value */
newvals[chnattrs] = newuser;
*/
/* SPI_pfree(tmptuple); */
}
- else /* DELETE case */
+ else
+/* DELETE case */
rettuple = trigtuple;
SPI_finish(); /* don't forget say Bye to SPI mgr */
Datum
set_timetravel(PG_FUNCTION_ARGS)
{
- Name relname = PG_GETARG_NAME(0);
- int32 on = PG_GETARG_INT32(1);
- char *rname;
- char *d;
- char *s;
+ Name relname = PG_GETARG_NAME(0);
+ int32 on = PG_GETARG_INT32(1);
+ char *rname;
+ char *d;
+ char *s;
int32 ret;
- TTOffList *p,*pp;
+ TTOffList *p,
+ *pp;
- for(pp = (p = &TTOff)->next; pp; pp=(p=pp)->next)
+ for (pp = (p = &TTOff)->next; pp; pp = (p = pp)->next)
{
- if(namestrcmp(relname, pp->name) == 0)
+ if (namestrcmp(relname, pp->name) == 0)
break;
}
- if(pp)
+ if (pp)
{
/* OFF currently */
- if(on != 0)
+ if (on != 0)
{
/* turn ON */
p->next = pp->next;
else
{
/* ON currently */
- if(on == 0)
+ if (on == 0)
{
/* turn OFF */
s = rname = DatumGetCString(DirectFunctionCall1(nameout, NameGetDatum(relname)));
- if(s)
+ if (s)
{
- pp = malloc(sizeof(TTOffList)+strlen(rname));
- if(pp)
+ pp = malloc(sizeof(TTOffList) + strlen(rname));
+ if (pp)
{
pp->next = NULL;
p->next = pp;
d = pp->name;
while (*s)
- *d++ = tolower((unsigned char)*s++);
+ *d++ = tolower((unsigned char) *s++);
*d = '\0';
}
pfree(rname);
/*
* get_timetravel (relname) --
- * get timetravel status for specified relation (ON/OFF)
+ * get timetravel status for specified relation (ON/OFF)
*/
PG_FUNCTION_INFO_V1(get_timetravel);
get_timetravel(PG_FUNCTION_ARGS)
{
Name relname = PG_GETARG_NAME(0);
- TTOffList *pp;
+ TTOffList *pp;
- for(pp = TTOff.next; pp; pp = pp->next)
+ for (pp = TTOff.next; pp; pp = pp->next)
{
- if(namestrcmp(relname, pp->name) == 0)
+ if (namestrcmp(relname, pp->name) == 0)
PG_RETURN_INT32(0);
}
PG_RETURN_INT32(1);
static int
findTTStatus(char *name)
{
- TTOffList* pp;
- for(pp = TTOff.next; pp; pp = pp->next)
- if(strcasecmp(name, pp->name) == 0)
+ TTOffList *pp;
+
+ for (pp = TTOff.next; pp; pp = pp->next)
+ if (strcasecmp(name, pp->name) == 0)
return 0;
return 1;
}
static EPlan *
find_plan(char *ident, EPlan ** eplan, int *nplans)
{
- EPlan *newp;
- int i;
+ EPlan *newp;
+ int i;
- if(*nplans > 0)
+ if (*nplans > 0)
{
- for(i = 0; i < *nplans; i++)
+ for (i = 0; i < *nplans; i++)
{
- if(strcmp((*eplan)[i].ident, ident) == 0)
+ if (strcmp((*eplan)[i].ident, ident) == 0)
break;
}
- if(i != *nplans)
+ if (i != *nplans)
return (*eplan + i);
*eplan = (EPlan *) realloc(*eplan, (i + 1) * sizeof(EPlan));
newp = *eplan + i;
#include "tablefunc.h"
-static int load_categories_hash(char *cats_sql, MemoryContext per_query_ctx);
+static int load_categories_hash(char *cats_sql, MemoryContext per_query_ctx);
static Tuplestorestate *get_crosstab_tuplestore(char *sql,
- int num_categories,
- TupleDesc tupdesc,
- MemoryContext per_query_ctx);
+ int num_categories,
+ TupleDesc tupdesc,
+ MemoryContext per_query_ctx);
static void validateConnectbyTupleDesc(TupleDesc tupdesc, bool show_branch, bool show_serial);
static bool compatCrosstabTupleDescs(TupleDesc tupdesc1, TupleDesc tupdesc2);
static bool compatConnectbyTupleDescs(TupleDesc tupdesc1, TupleDesc tupdesc2);
static Tuplestorestate *connectby(char *relname,
char *key_fld,
char *parent_key_fld,
- char *orderby_fld,
+ char *orderby_fld,
char *branch_delim,
char *start_with,
int max_depth,
typedef struct crosstab_cat_desc
{
char *catname;
- int attidx; /* zero based */
+ int attidx; /* zero based */
} crosstab_cat_desc;
#define MAX_CATNAME_LEN NAMEDATALEN
/* hash table */
typedef struct crosstab_hashent
{
- char internal_catname[MAX_CATNAME_LEN];
- crosstab_cat_desc *catdesc;
-} crosstab_HashEnt;
+ char internal_catname[MAX_CATNAME_LEN];
+ crosstab_cat_desc *catdesc;
+} crosstab_HashEnt;
/*
* normal_rand - return requested number of random values
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("invalid source data SQL statement"),
errdetail("The provided SQL must return 3 " \
- " columns; rowid, category, and values.")));
+ " columns; rowid, category, and values.")));
}
else
{
}
/*
- * crosstab_hash - reimplement crosstab as materialized function and
+ * crosstab_hash - reimplement crosstab as materialized function and
* properly deal with missing values (i.e. don't pack remaining
* values to the left)
- *
+ *
* crosstab - create a crosstab of rowids and values columns from a
* SQL statement returning one rowid column, one category column,
* and one value column.
Datum
crosstab_hash(PG_FUNCTION_ARGS)
{
- char *sql = GET_STR(PG_GETARG_TEXT_P(0));
- char *cats_sql = GET_STR(PG_GETARG_TEXT_P(1));
- ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
- TupleDesc tupdesc;
- MemoryContext per_query_ctx;
- MemoryContext oldcontext;
- int num_categories;
+ char *sql = GET_STR(PG_GETARG_TEXT_P(0));
+ char *cats_sql = GET_STR(PG_GETARG_TEXT_P(1));
+ ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
+ TupleDesc tupdesc;
+ MemoryContext per_query_ctx;
+ MemoryContext oldcontext;
+ int num_categories;
/* check to see if caller supports us returning a tuplestore */
if (!rsinfo || !(rsinfo->allowedModes & SFRM_Materialize))
/*
* Check to make sure we have a reasonable tuple descriptor
*
- * Note we will attempt to coerce the values into whatever
- * the return attribute type is and depend on the "in"
- * function to complain if needed.
+ * Note we will attempt to coerce the values into whatever the return
+ * attribute type is and depend on the "in" function to complain if
+ * needed.
*/
if (tupdesc->natts < 2)
ereport(ERROR,
static int
load_categories_hash(char *cats_sql, MemoryContext per_query_ctx)
{
- HASHCTL ctl;
- int ret;
- int proc;
- MemoryContext SPIcontext;
- int num_categories = 0;
+ HASHCTL ctl;
+ int ret;
+ int proc;
+ MemoryContext SPIcontext;
+ int num_categories = 0;
/* initialize the category hash table */
ctl.keysize = MAX_CATNAME_LEN;
ctl.entrysize = sizeof(crosstab_HashEnt);
/*
- * use INIT_CATS, defined above as a guess of how
- * many hash table entries to create, initially
+ * use INIT_CATS, defined above as a guess of how many hash table
+ * entries to create, initially
*/
crosstab_HashTable = hash_create("crosstab hash", INIT_CATS, &ctl, HASH_ELEM);
/* Check for qualifying tuples */
if ((ret == SPI_OK_SELECT) && (proc > 0))
{
- SPITupleTable *spi_tuptable = SPI_tuptable;
- TupleDesc spi_tupdesc = spi_tuptable->tupdesc;
- int i;
+ SPITupleTable *spi_tuptable = SPI_tuptable;
+ TupleDesc spi_tupdesc = spi_tuptable->tupdesc;
+ int i;
/*
- * The provided categories SQL query must always return one column:
- * category - the label or identifier for each column
+ * The provided categories SQL query must always return one
+ * column: category - the label or identifier for each column
*/
if (spi_tupdesc->natts != 1)
ereport(ERROR,
for (i = 0; i < proc; i++)
{
- crosstab_cat_desc *catdesc;
- char *catname;
- HeapTuple spi_tuple;
+ crosstab_cat_desc *catdesc;
+ char *catname;
+ HeapTuple spi_tuple;
/* get the next sql result tuple */
spi_tuple = spi_tuptable->vals[i];
TupleDesc tupdesc,
MemoryContext per_query_ctx)
{
- Tuplestorestate *tupstore;
- AttInMetadata *attinmeta = TupleDescGetAttInMetadata(tupdesc);
- char **values;
- HeapTuple tuple;
- int ret;
- int proc;
- MemoryContext SPIcontext;
+ Tuplestorestate *tupstore;
+ AttInMetadata *attinmeta = TupleDescGetAttInMetadata(tupdesc);
+ char **values;
+ HeapTuple tuple;
+ int ret;
+ int proc;
+ MemoryContext SPIcontext;
/* initialize our tuplestore */
tupstore = tuplestore_begin_heap(true, false, SortMem);
/* Check for qualifying tuples */
if ((ret == SPI_OK_SELECT) && (proc > 0))
{
- SPITupleTable *spi_tuptable = SPI_tuptable;
- TupleDesc spi_tupdesc = spi_tuptable->tupdesc;
- int ncols = spi_tupdesc->natts;
- char *rowid;
- char *lastrowid = NULL;
- int i, j;
- int result_ncols;
+ SPITupleTable *spi_tuptable = SPI_tuptable;
+ TupleDesc spi_tupdesc = spi_tuptable->tupdesc;
+ int ncols = spi_tupdesc->natts;
+ char *rowid;
+ char *lastrowid = NULL;
+ int i,
+ j;
+ int result_ncols;
/*
- * The provided SQL query must always return at least three columns:
+ * The provided SQL query must always return at least three
+ * columns:
*
* 1. rowname the label for each row - column 1 in the final result
- * 2. category the label for each value-column in the final result
- * 3. value the values used to populate the value-columns
- *
+ * 2. category the label for each value-column in the final
+ * result 3. value the values used to populate the
+ * value-columns
+ *
* If there are more than three columns, the last two are taken as
- * "category" and "values". The first column is taken as "rowname".
- * Additional columns (2 thru N-2) are assumed the same for the same
- * "rowname", and are copied into the result tuple from the first
- * time we encounter a particular rowname.
+ * "category" and "values". The first column is taken as
+ * "rowname". Additional columns (2 thru N-2) are assumed the same
+ * for the same "rowname", and are copied into the result tuple
+ * from the first time we encounter a particular rowname.
*/
if (ncols < 3)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("invalid source data SQL statement"),
errdetail("The provided SQL must return 3 " \
- " columns; rowid, category, and values.")));
+ " columns; rowid, category, and values.")));
result_ncols = (ncols - 2) + num_categories;
errmsg("invalid return type"),
errdetail("query-specified return " \
"tuple has %d columns but crosstab " \
- "returns %d", tupdesc->natts, result_ncols)));
+ "returns %d", tupdesc->natts, result_ncols)));
/* allocate space */
values = (char **) palloc(result_ncols * sizeof(char *));
for (i = 0; i < proc; i++)
{
- HeapTuple spi_tuple;
- crosstab_cat_desc *catdesc;
- char *catname;
+ HeapTuple spi_tuple;
+ crosstab_cat_desc *catdesc;
+ char *catname;
/* get the next sql result tuple */
spi_tuple = spi_tuptable->vals[i];
*/
if (lastrowid != NULL)
{
- /* switch to appropriate context while storing the tuple */
+ /*
+ * switch to appropriate context while storing the
+ * tuple
+ */
SPIcontext = MemoryContextSwitchTo(per_query_ctx);
/* rowid changed, flush the previous output row */
crosstab_HashTableLookup(catname, catdesc);
if (catdesc)
- values[catdesc->attidx + ncols - 2] =
+ values[catdesc->attidx + ncols - 2] =
SPI_getvalue(spi_tuple, spi_tupdesc, ncols);
}
*
* keyid parent_keyid pos
* ------+------------+--
- * row1 NULL 0
- * row2 row1 0
- * row3 row1 0
- * row4 row2 1
- * row5 row2 0
- * row6 row4 0
- * row7 row3 0
- * row8 row6 0
- * row9 row5 0
+ * row1 NULL 0
+ * row2 row1 0
+ * row3 row1 0
+ * row4 row2 1
+ * row5 row2 0
+ * row6 row4 0
+ * row7 row3 0
+ * row8 row6 0
+ * row9 row5 0
*
*
* connectby(text relname, text keyid_fld, text parent_keyid_fld
- * [, text orderby_fld], text start_with, int max_depth
- * [, text branch_delim])
+ * [, text orderby_fld], text start_with, int max_depth
+ * [, text branch_delim])
* connectby('foo', 'keyid', 'parent_keyid', 'pos', 'row2', 0, '~') returns:
*
- * keyid parent_id level branch serial
+ * keyid parent_id level branch serial
* ------+-----------+--------+-----------------------
- * row2 NULL 0 row2 1
- * row5 row2 1 row2~row5 2
- * row9 row5 2 row2~row5~row9 3
- * row4 row2 1 row2~row4 4
- * row6 row4 2 row2~row4~row6 5
+ * row2 NULL 0 row2 1
+ * row5 row2 1 row2~row5 2
+ * row9 row5 2 row2~row5~row9 3
+ * row4 row2 1 row2~row4 4
+ * row6 row4 2 row2~row4~row6 5
* row8 row6 3 row2~row4~row6~row8 6
*
*/
rsinfo->setResult = connectby(relname,
key_fld,
parent_key_fld,
- NULL,
+ NULL,
branch_delim,
start_with,
max_depth,
char *branch_delim = NULL;
bool show_branch = false;
bool show_serial = true;
-
+
ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
TupleDesc tupdesc;
AttInMetadata *attinmeta;
rsinfo->setResult = connectby(relname,
key_fld,
parent_key_fld,
- orderby_fld,
+ orderby_fld,
branch_delim,
start_with,
max_depth,
connectby(char *relname,
char *key_fld,
char *parent_key_fld,
- char *orderby_fld,
+ char *orderby_fld,
char *branch_delim,
char *start_with,
int max_depth,
bool show_branch,
- bool show_serial,
+ bool show_serial,
MemoryContext per_query_ctx,
AttInMetadata *attinmeta)
{
int ret;
MemoryContext oldcontext;
- int serial = 1;
+ int serial = 1;
/* Connect to SPI manager */
if ((ret = SPI_connect()) < 0)
if (!show_serial)
{
appendStringInfo(sql, "SELECT %s, %s FROM %s WHERE %s = '%s' AND %s IS NOT NULL",
- key_fld,
- parent_key_fld,
- relname,
- parent_key_fld,
- start_with,
- key_fld);
- serial_column=0;
+ key_fld,
+ parent_key_fld,
+ relname,
+ parent_key_fld,
+ start_with,
+ key_fld);
+ serial_column = 0;
}
else
{
appendStringInfo(sql, "SELECT %s, %s FROM %s WHERE %s = '%s' AND %s IS NOT NULL ORDER BY %s",
- key_fld,
- parent_key_fld,
- relname,
- parent_key_fld,
- start_with,
- key_fld,
- orderby_fld);
- serial_column=1;
+ key_fld,
+ parent_key_fld,
+ relname,
+ parent_key_fld,
+ start_with,
+ key_fld,
+ orderby_fld);
+ serial_column = 1;
}
/* Retrieve the desired rows */
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("invalid return type"),
- errdetail("Return and SQL tuple descriptions are " \
- "incompatible.")));
+ errdetail("Return and SQL tuple descriptions are " \
+ "incompatible.")));
/* root value is the one we initially start with */
values[0] = start_with;
if (show_branch)
values[4] = serial_str;
else
- values[3] = serial_str;
+ values[3] = serial_str;
}
/* construct the tuple */
static void
validateConnectbyTupleDesc(TupleDesc tupdesc, bool show_branch, bool show_serial)
{
- int serial_column=0;
+ int serial_column = 0;
if (show_serial)
- serial_column=1;
-
+ serial_column = 1;
+
/* are there the correct number of columns */
if (show_branch)
{
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("invalid return type"),
errdetail("Third column must be type %s.",
- format_type_be(INT4OID))));
+ format_type_be(INT4OID))));
/* check that the type of the fourth column is TEXT if applicable */
if (show_branch && tupdesc->attrs[3]->atttypid != TEXTOID)
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("invalid return type"),
errdetail("Fourth column must be type %s.",
- format_type_be(TEXTOID))));
+ format_type_be(TEXTOID))));
/* check that the type of the fifth column is INT4 */
if (show_branch && show_serial && tupdesc->attrs[4]->atttypid != INT4OID)
if (!show_branch && show_serial && tupdesc->attrs[3]->atttypid != INT4OID)
elog(ERROR, "Query-specified return tuple not valid for Connectby: "
"fourth column must be type %s", format_type_be(INT4OID));
-
+
/* OK, the tupdesc is valid for our purposes */
}
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("invalid return type"),
errdetail("SQL parent key field datatype does " \
- "not match return parent key field datatype.")));
+ "not match return parent key field datatype.")));
/* OK, the two tupdescs are compatible for our purposes */
return true;
#undef DICT_TABLE
/* array for storing dictionary's objects (if needed) */
-void *dictobjs[lengthof(dicts)];
+void *dictobjs[
+ lengthof(dicts)];
#define STOPLEXEM -2
#define BYLOCALE -1
}
else if (nd == BYLOCALE)
{
- continue; /* no dict for current locale */
+ continue; /* no dict for current locale */
}
else
{
#include "ts_cfg.h"
#include "dict.h"
-text*
-char2text(char* in) {
+text *
+char2text(char *in)
+{
return charl2text(in, strlen(in));
}
-text* charl2text(char* in, int len) {
- text *out=(text*)palloc(len+VARHDRSZ);
+text *
+charl2text(char *in, int len)
+{
+ text *out = (text *) palloc(len + VARHDRSZ);
+
memcpy(VARDATA(out), in, len);
- VARATT_SIZEP(out) = len+VARHDRSZ;
+ VARATT_SIZEP(out) = len + VARHDRSZ;
return out;
}
-char
-*text2char(text* in) {
- char *out=palloc( VARSIZE(in) );
- memcpy(out, VARDATA(in), VARSIZE(in)-VARHDRSZ);
- out[ VARSIZE(in)-VARHDRSZ ] ='\0';
+char
+ *
+text2char(text *in)
+{
+ char *out = palloc(VARSIZE(in));
+
+ memcpy(out, VARDATA(in), VARSIZE(in) - VARHDRSZ);
+ out[VARSIZE(in) - VARHDRSZ] = '\0';
return out;
}
-char
-*pnstrdup(char* in, int len) {
- char *out=palloc( len+1 );
+char
+ *
+pnstrdup(char *in, int len)
+{
+ char *out = palloc(len + 1);
+
memcpy(out, in, len);
- out[len]='\0';
+ out[len] = '\0';
return out;
}
-text
-*ptextdup(text* in) {
- text *out=(text*)palloc( VARSIZE(in) );
- memcpy(out,in,VARSIZE(in));
+text
+ *
+ptextdup(text *in)
+{
+ text *out = (text *) palloc(VARSIZE(in));
+
+ memcpy(out, in, VARSIZE(in));
return out;
}
-text
-*mtextdup(text* in) {
- text *out=(text*)malloc( VARSIZE(in) );
- if ( !out )
+text
+ *
+mtextdup(text *in)
+{
+ text *out = (text *) malloc(VARSIZE(in));
+
+ if (!out)
ts_error(ERROR, "No memory");
- memcpy(out,in,VARSIZE(in));
+ memcpy(out, in, VARSIZE(in));
return out;
}
-void
-ts_error(int state, const char *format, ...) {
- va_list args;
- int tlen = 128, len=0;
- char *buf;
-
+void
+ts_error(int state, const char *format,...)
+{
+ va_list args;
+ int tlen = 128,
+ len = 0;
+ char *buf;
+
reset_cfg();
reset_dict();
reset_prs();
va_start(args, format);
buf = palloc(tlen);
- len = vsnprintf(buf, tlen-1, format, args);
- if ( len >= tlen ) {
- tlen=len+1;
- buf = repalloc( buf, tlen );
- vsnprintf(buf, tlen-1, format, args);
+ len = vsnprintf(buf, tlen - 1, format, args);
+ if (len >= tlen)
+ {
+ tlen = len + 1;
+ buf = repalloc(buf, tlen);
+ vsnprintf(buf, tlen - 1, format, args);
}
va_end(args);
-
+
/* ?? internal error ?? */
elog(state, "%s", buf);
pfree(buf);
}
-int
-text_cmp(text *a, text *b) {
- if ( VARSIZE(a) == VARSIZE(b) )
- return strncmp( VARDATA(a), VARDATA(b), VARSIZE(a)-VARHDRSZ );
- return (int)VARSIZE(a) - (int)VARSIZE(b);
+int
+text_cmp(text *a, text *b)
+{
+ if (VARSIZE(a) == VARSIZE(b))
+ return strncmp(VARDATA(a), VARDATA(b), VARSIZE(a) - VARHDRSZ);
+ return (int) VARSIZE(a) - (int) VARSIZE(b);
}
-
#define PG_NARGS() (fcinfo->nargs)
#endif
-text* char2text(char* in);
-text* charl2text(char* in, int len);
-char *text2char(text* in);
-char *pnstrdup(char* in, int len);
-text *ptextdup(text* in);
-text *mtextdup(text* in);
+text *char2text(char *in);
+text *charl2text(char *in, int len);
+char *text2char(text *in);
+char *pnstrdup(char *in, int len);
+text *ptextdup(text *in);
+text *mtextdup(text *in);
-int text_cmp(text *a, text *b);
+int text_cmp(text *a, text *b);
#define NEXTVAL(x) ( (text*)( (char*)(x) + INTALIGN( VARSIZE(x) ) ) )
#define ARRNELEMS(x) ArrayGetNItems( ARR_NDIM(x), ARR_DIMS(x))
-void ts_error(int state, const char *format, ...);
+void ts_error(int state, const char *format,...);
#endif
-/*
- * interface functions to dictionary
+/*
+ * interface functions to dictionary
* Teodor Sigaev <teodor@sigaev.ru>
*/
#include <errno.h>
/*********top interface**********/
-static void *plan_getdict=NULL;
+static void *plan_getdict = NULL;
void
-init_dict(Oid id, DictInfo *dict) {
- Oid arg[1]={ OIDOID };
- bool isnull;
- Datum pars[1]={ ObjectIdGetDatum(id) };
- int stat;
-
- memset(dict,0,sizeof(DictInfo));
+init_dict(Oid id, DictInfo * dict)
+{
+ Oid arg[1] = {OIDOID};
+ bool isnull;
+ Datum pars[1] = {ObjectIdGetDatum(id)};
+ int stat;
+
+ memset(dict, 0, sizeof(DictInfo));
SPI_connect();
- if ( !plan_getdict ) {
- plan_getdict = SPI_saveplan( SPI_prepare( "select dict_init, dict_initoption, dict_lexize from pg_ts_dict where oid = $1" , 1, arg ) );
- if ( !plan_getdict )
+ if (!plan_getdict)
+ {
+ plan_getdict = SPI_saveplan(SPI_prepare("select dict_init, dict_initoption, dict_lexize from pg_ts_dict where oid = $1", 1, arg));
+ if (!plan_getdict)
ts_error(ERROR, "SPI_prepare() failed");
}
stat = SPI_execp(plan_getdict, pars, " ", 1);
- if ( stat < 0 )
- ts_error (ERROR, "SPI_execp return %d", stat);
- if ( SPI_processed > 0 ) {
- Datum opt;
- Oid oid=InvalidOid;
- oid=DatumGetObjectId( SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull) );
- if ( !(isnull || oid==InvalidOid) ) {
- opt=SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 2, &isnull);
- dict->dictionary=(void*)DatumGetPointer(OidFunctionCall1(oid, opt));
+ if (stat < 0)
+ ts_error(ERROR, "SPI_execp return %d", stat);
+ if (SPI_processed > 0)
+ {
+ Datum opt;
+ Oid oid = InvalidOid;
+
+ oid = DatumGetObjectId(SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull));
+ if (!(isnull || oid == InvalidOid))
+ {
+ opt = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 2, &isnull);
+ dict->dictionary = (void *) DatumGetPointer(OidFunctionCall1(oid, opt));
}
- oid=DatumGetObjectId( SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 3, &isnull) );
- if ( isnull || oid==InvalidOid )
+ oid = DatumGetObjectId(SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 3, &isnull));
+ if (isnull || oid == InvalidOid)
ts_error(ERROR, "Null dict_lexize for dictonary %d", id);
fmgr_info_cxt(oid, &(dict->lexize_info), TopMemoryContext);
- dict->dict_id=id;
- } else
+ dict->dict_id = id;
+ }
+ else
ts_error(ERROR, "No dictionary with id %d", id);
SPI_finish();
}
-typedef struct {
- DictInfo *last_dict;
- int len;
- int reallen;
- DictInfo *list;
+typedef struct
+{
+ DictInfo *last_dict;
+ int len;
+ int reallen;
+ DictInfo *list;
SNMap name2id_map;
-} DictList;
+} DictList;
-static DictList DList = {NULL,0,0,NULL,{0,0,NULL}};
+static DictList DList = {NULL, 0, 0, NULL, {0, 0, NULL}};
void
-reset_dict(void) {
- freeSNMap( &(DList.name2id_map) );
+reset_dict(void)
+{
+ freeSNMap(&(DList.name2id_map));
/* XXX need to free DList.list[*].dictionary */
- if ( DList.list )
+ if (DList.list)
free(DList.list);
- memset(&DList,0,sizeof(DictList));
+ memset(&DList, 0, sizeof(DictList));
}
static int
-comparedict(const void *a, const void *b) {
- return ((DictInfo*)a)->dict_id - ((DictInfo*)b)->dict_id;
+comparedict(const void *a, const void *b)
+{
+ return ((DictInfo *) a)->dict_id - ((DictInfo *) b)->dict_id;
}
DictInfo *
-finddict(Oid id) {
+finddict(Oid id)
+{
/* last used dict */
- if ( DList.last_dict && DList.last_dict->dict_id==id )
+ if (DList.last_dict && DList.last_dict->dict_id == id)
return DList.last_dict;
/* already used dict */
- if ( DList.len != 0 ) {
- DictInfo key;
- key.dict_id=id;
+ if (DList.len != 0)
+ {
+ DictInfo key;
+
+ key.dict_id = id;
DList.last_dict = bsearch(&key, DList.list, DList.len, sizeof(DictInfo), comparedict);
- if ( DList.last_dict != NULL )
+ if (DList.last_dict != NULL)
return DList.last_dict;
}
/* last chance */
- if ( DList.len==DList.reallen ) {
- DictInfo *tmp;
- int reallen = ( DList.reallen ) ? 2*DList.reallen : 16;
- tmp=(DictInfo*)realloc(DList.list,sizeof(DictInfo)*reallen);
- if ( !tmp )
- ts_error(ERROR,"No memory");
- DList.reallen=reallen;
- DList.list=tmp;
+ if (DList.len == DList.reallen)
+ {
+ DictInfo *tmp;
+ int reallen = (DList.reallen) ? 2 * DList.reallen : 16;
+
+ tmp = (DictInfo *) realloc(DList.list, sizeof(DictInfo) * reallen);
+ if (!tmp)
+ ts_error(ERROR, "No memory");
+ DList.reallen = reallen;
+ DList.list = tmp;
}
- DList.last_dict=&(DList.list[DList.len]);
+ DList.last_dict = &(DList.list[DList.len]);
init_dict(id, DList.last_dict);
DList.len++;
qsort(DList.list, DList.len, sizeof(DictInfo), comparedict);
- return finddict(id); /* qsort changed order!! */;
+ return finddict(id); /* qsort changed order!! */ ;
}
-static void *plan_name2id=NULL;
+static void *plan_name2id = NULL;
Oid
-name2id_dict(text *name) {
- Oid arg[1]={ TEXTOID };
- bool isnull;
- Datum pars[1]={ PointerGetDatum(name) };
- int stat;
- Oid id=findSNMap_t( &(DList.name2id_map), name );
-
- if ( id )
+name2id_dict(text *name)
+{
+ Oid arg[1] = {TEXTOID};
+ bool isnull;
+ Datum pars[1] = {PointerGetDatum(name)};
+ int stat;
+ Oid id = findSNMap_t(&(DList.name2id_map), name);
+
+ if (id)
return id;
-
+
SPI_connect();
- if ( !plan_name2id ) {
- plan_name2id = SPI_saveplan( SPI_prepare( "select oid from pg_ts_dict where dict_name = $1" , 1, arg ) );
- if ( !plan_name2id )
+ if (!plan_name2id)
+ {
+ plan_name2id = SPI_saveplan(SPI_prepare("select oid from pg_ts_dict where dict_name = $1", 1, arg));
+ if (!plan_name2id)
ts_error(ERROR, "SPI_prepare() failed");
}
stat = SPI_execp(plan_name2id, pars, " ", 1);
- if ( stat < 0 )
- ts_error (ERROR, "SPI_execp return %d", stat);
- if ( SPI_processed > 0 )
- id=DatumGetObjectId( SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull) );
- else
+ if (stat < 0)
+ ts_error(ERROR, "SPI_execp return %d", stat);
+ if (SPI_processed > 0)
+ id = DatumGetObjectId(SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull));
+ else
ts_error(ERROR, "No dictionary with name '%s'", text2char(name));
SPI_finish();
- addSNMap_t( &(DList.name2id_map), name, id );
+ addSNMap_t(&(DList.name2id_map), name, id);
return id;
}
/******sql-level interface******/
PG_FUNCTION_INFO_V1(lexize);
-Datum lexize(PG_FUNCTION_ARGS);
+Datum lexize(PG_FUNCTION_ARGS);
Datum
-lexize(PG_FUNCTION_ARGS) {
- text *in=PG_GETARG_TEXT_P(1);
- DictInfo *dict = finddict( PG_GETARG_OID(0) );
- char **res, **ptr;
- Datum *da;
- ArrayType *a;
-
-
- ptr = res = (char**)DatumGetPointer(
- FunctionCall3(&(dict->lexize_info),
- PointerGetDatum(dict->dictionary),
- PointerGetDatum(VARDATA(in)),
- Int32GetDatum(VARSIZE(in)-VARHDRSZ)
- )
- );
+lexize(PG_FUNCTION_ARGS)
+{
+ text *in = PG_GETARG_TEXT_P(1);
+ DictInfo *dict = finddict(PG_GETARG_OID(0));
+ char **res,
+ **ptr;
+ Datum *da;
+ ArrayType *a;
+
+
+ ptr = res = (char **) DatumGetPointer(
+ FunctionCall3(&(dict->lexize_info),
+ PointerGetDatum(dict->dictionary),
+ PointerGetDatum(VARDATA(in)),
+ Int32GetDatum(VARSIZE(in) - VARHDRSZ)
+ )
+ );
PG_FREE_IF_COPY(in, 1);
- if ( !res ) {
- if (PG_NARGS() > 2)
+ if (!res)
+ {
+ if (PG_NARGS() > 2)
PG_RETURN_POINTER(NULL);
else
PG_RETURN_NULL();
}
- while(*ptr) ptr++;
- da = (Datum*)palloc(sizeof(Datum)*(ptr-res+1));
- ptr=res;
- while(*ptr) {
- da[ ptr-res ] = PointerGetDatum( char2text(*ptr) );
+ while (*ptr)
+ ptr++;
+ da = (Datum *) palloc(sizeof(Datum) * (ptr - res + 1));
+ ptr = res;
+ while (*ptr)
+ {
+ da[ptr - res] = PointerGetDatum(char2text(*ptr));
ptr++;
}
a = construct_array(
- da,
- ptr-res,
- TEXTOID,
- -1,
- false,
- 'i'
- );
-
- ptr=res;
- while(*ptr) {
- pfree( DatumGetPointer(da[ ptr-res ]) );
- pfree( *ptr );
+ da,
+ ptr - res,
+ TEXTOID,
+ -1,
+ false,
+ 'i'
+ );
+
+ ptr = res;
+ while (*ptr)
+ {
+ pfree(DatumGetPointer(da[ptr - res]));
+ pfree(*ptr);
ptr++;
}
pfree(res);
pfree(da);
-
- PG_RETURN_POINTER(a);
+
+ PG_RETURN_POINTER(a);
}
PG_FUNCTION_INFO_V1(lexize_byname);
-Datum lexize_byname(PG_FUNCTION_ARGS);
-Datum
-lexize_byname(PG_FUNCTION_ARGS) {
- text *dictname=PG_GETARG_TEXT_P(0);
- Datum res;
+Datum lexize_byname(PG_FUNCTION_ARGS);
+Datum
+lexize_byname(PG_FUNCTION_ARGS)
+{
+ text *dictname = PG_GETARG_TEXT_P(0);
+ Datum res;
strdup("simple");
- res=DirectFunctionCall3(
- lexize,
- ObjectIdGetDatum(name2id_dict(dictname)),
- PG_GETARG_DATUM(1),
- (Datum)0
- );
+ res = DirectFunctionCall3(
+ lexize,
+ ObjectIdGetDatum(name2id_dict(dictname)),
+ PG_GETARG_DATUM(1),
+ (Datum) 0
+ );
PG_FREE_IF_COPY(dictname, 0);
- if (res)
- PG_RETURN_DATUM(res);
- else
+ if (res)
+ PG_RETURN_DATUM(res);
+ else
PG_RETURN_NULL();
}
-static Oid currect_dictionary_id=0;
+static Oid currect_dictionary_id = 0;
PG_FUNCTION_INFO_V1(set_curdict);
-Datum set_curdict(PG_FUNCTION_ARGS);
+Datum set_curdict(PG_FUNCTION_ARGS);
Datum
-set_curdict(PG_FUNCTION_ARGS) {
+set_curdict(PG_FUNCTION_ARGS)
+{
finddict(PG_GETARG_OID(0));
- currect_dictionary_id=PG_GETARG_OID(0);
+ currect_dictionary_id = PG_GETARG_OID(0);
PG_RETURN_VOID();
}
PG_FUNCTION_INFO_V1(set_curdict_byname);
-Datum set_curdict_byname(PG_FUNCTION_ARGS);
+Datum set_curdict_byname(PG_FUNCTION_ARGS);
Datum
-set_curdict_byname(PG_FUNCTION_ARGS) {
- text *dictname=PG_GETARG_TEXT_P(0);
+set_curdict_byname(PG_FUNCTION_ARGS)
+{
+ text *dictname = PG_GETARG_TEXT_P(0);
DirectFunctionCall1(
- set_curdict,
- ObjectIdGetDatum( name2id_dict(dictname) )
- );
+ set_curdict,
+ ObjectIdGetDatum(name2id_dict(dictname))
+ );
PG_FREE_IF_COPY(dictname, 0);
PG_RETURN_VOID();
}
PG_FUNCTION_INFO_V1(lexize_bycurrent);
-Datum lexize_bycurrent(PG_FUNCTION_ARGS);
-Datum
-lexize_bycurrent(PG_FUNCTION_ARGS) {
- Datum res;
- if ( currect_dictionary_id == 0 )
+Datum lexize_bycurrent(PG_FUNCTION_ARGS);
+Datum
+lexize_bycurrent(PG_FUNCTION_ARGS)
+{
+ Datum res;
+
+ if (currect_dictionary_id == 0)
ereport(ERROR,
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
errmsg("no currect dictionary"),
errhint("Execute select set_curdict().")));
res = DirectFunctionCall3(
- lexize,
- ObjectIdGetDatum(currect_dictionary_id),
- PG_GETARG_DATUM(0),
- (Datum)0
- );
- if (res)
+ lexize,
+ ObjectIdGetDatum(currect_dictionary_id),
+ PG_GETARG_DATUM(0),
+ (Datum) 0
+ );
+ if (res)
PG_RETURN_DATUM(res);
- else
+ else
PG_RETURN_NULL();
}
-
-
#include "postgres.h"
#include "fmgr.h"
-typedef struct {
- int len;
- char **stop;
- char* (*wordop)(char*);
-} StopList;
-
-void sortstoplist(StopList *s);
-void freestoplist(StopList *s);
-void readstoplist(text *in, StopList *s);
-bool searchstoplist(StopList *s, char *key);
-char* lowerstr(char *str);
-
-typedef struct {
- Oid dict_id;
- FmgrInfo lexize_info;
- void *dictionary;
-} DictInfo;
-
-void init_dict(Oid id, DictInfo *dict);
-DictInfo* finddict(Oid id);
-Oid name2id_dict(text *name);
-void reset_dict(void);
+typedef struct
+{
+ int len;
+ char **stop;
+ char *(*wordop) (char *);
+} StopList;
+
+void sortstoplist(StopList * s);
+void freestoplist(StopList * s);
+void readstoplist(text *in, StopList * s);
+bool searchstoplist(StopList * s, char *key);
+char *lowerstr(char *str);
+
+typedef struct
+{
+ Oid dict_id;
+ FmgrInfo lexize_info;
+ void *dictionary;
+} DictInfo;
+
+void init_dict(Oid id, DictInfo * dict);
+DictInfo *finddict(Oid id);
+Oid name2id_dict(text *name);
+void reset_dict(void);
/* simple parser of cfg string */
-typedef struct {
- char *key;
- char *value;
-} Map;
+typedef struct
+{
+ char *key;
+ char *value;
+} Map;
-void parse_cfgdict(text *in, Map **m);
+void parse_cfgdict(text *in, Map ** m);
#endif
-/*
- * example of dictionary
+/*
+ * example of dictionary
* Teodor Sigaev <teodor@sigaev.ru>
*/
#include <errno.h>
#include "dict.h"
#include "common.h"
-typedef struct {
+typedef struct
+{
StopList stoplist;
-} DictExample;
+} DictExample;
PG_FUNCTION_INFO_V1(dex_init);
-Datum dex_init(PG_FUNCTION_ARGS);
+Datum dex_init(PG_FUNCTION_ARGS);
+
PG_FUNCTION_INFO_V1(dex_lexize);
-Datum dex_lexize(PG_FUNCTION_ARGS);
+Datum dex_lexize(PG_FUNCTION_ARGS);
-Datum
-dex_init(PG_FUNCTION_ARGS) {
- DictExample *d = (DictExample*)malloc( sizeof(DictExample) );
+Datum
+dex_init(PG_FUNCTION_ARGS)
+{
+ DictExample *d = (DictExample *) malloc(sizeof(DictExample));
- if ( !d )
+ if (!d)
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory")));
- memset(d,0,sizeof(DictExample));
+ memset(d, 0, sizeof(DictExample));
+
+ d->stoplist.wordop = lowerstr;
+
+ if (!PG_ARGISNULL(0) && PG_GETARG_POINTER(0) != NULL)
+ {
+ text *in = PG_GETARG_TEXT_P(0);
- d->stoplist.wordop=lowerstr;
-
- if ( !PG_ARGISNULL(0) && PG_GETARG_POINTER(0)!=NULL ) {
- text *in = PG_GETARG_TEXT_P(0);
readstoplist(in, &(d->stoplist));
sortstoplist(&(d->stoplist));
PG_FREE_IF_COPY(in, 0);
}
Datum
-dex_lexize(PG_FUNCTION_ARGS) {
- DictExample *d = (DictExample*)PG_GETARG_POINTER(0);
- char *in = (char*)PG_GETARG_POINTER(1);
- char *txt = pnstrdup(in, PG_GETARG_INT32(2));
- char **res=palloc(sizeof(char*)*2);
+dex_lexize(PG_FUNCTION_ARGS)
+{
+ DictExample *d = (DictExample *) PG_GETARG_POINTER(0);
+ char *in = (char *) PG_GETARG_POINTER(1);
+ char *txt = pnstrdup(in, PG_GETARG_INT32(2));
+ char **res = palloc(sizeof(char *) * 2);
- if ( *txt=='\0' || searchstoplist(&(d->stoplist),txt) ) {
+ if (*txt == '\0' || searchstoplist(&(d->stoplist), txt))
+ {
pfree(txt);
- res[0]=NULL;
- } else
- res[0]=txt;
- res[1]=NULL;
+ res[0] = NULL;
+ }
+ else
+ res[0] = txt;
+ res[1] = NULL;
PG_RETURN_POINTER(res);
}
-/*
+/*
* ISpell interface
* Teodor Sigaev <teodor@sigaev.ru>
*/
#include "common.h"
#include "ispell/spell.h"
-typedef struct {
+typedef struct
+{
StopList stoplist;
IspellDict obj;
-} DictISpell;
+} DictISpell;
PG_FUNCTION_INFO_V1(spell_init);
-Datum spell_init(PG_FUNCTION_ARGS);
+Datum spell_init(PG_FUNCTION_ARGS);
+
PG_FUNCTION_INFO_V1(spell_lexize);
-Datum spell_lexize(PG_FUNCTION_ARGS);
+Datum spell_lexize(PG_FUNCTION_ARGS);
static void
-freeDictISpell(DictISpell *d) {
+freeDictISpell(DictISpell * d)
+{
FreeIspell(&(d->obj));
freestoplist(&(d->stoplist));
free(d);
}
-Datum
-spell_init(PG_FUNCTION_ARGS) {
- DictISpell *d;
- Map *cfg, *pcfg;
- text *in;
- bool affloaded=false, dictloaded=false, stoploaded=false;
-
- if ( PG_ARGISNULL(0) || PG_GETARG_POINTER(0)==NULL )
+Datum
+spell_init(PG_FUNCTION_ARGS)
+{
+ DictISpell *d;
+ Map *cfg,
+ *pcfg;
+ text *in;
+ bool affloaded = false,
+ dictloaded = false,
+ stoploaded = false;
+
+ if (PG_ARGISNULL(0) || PG_GETARG_POINTER(0) == NULL)
ereport(ERROR,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("ISpell confguration error")));
-
- d = (DictISpell*)malloc( sizeof(DictISpell) );
- if ( !d )
+
+ d = (DictISpell *) malloc(sizeof(DictISpell));
+ if (!d)
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory")));
- memset(d,0,sizeof(DictISpell));
- d->stoplist.wordop=lowerstr;
+ memset(d, 0, sizeof(DictISpell));
+ d->stoplist.wordop = lowerstr;
in = PG_GETARG_TEXT_P(0);
- parse_cfgdict(in,&cfg);
+ parse_cfgdict(in, &cfg);
PG_FREE_IF_COPY(in, 0);
- pcfg=cfg;
- while(pcfg->key) {
- if ( strcasecmp("DictFile", pcfg->key) == 0 ) {
- if ( dictloaded ) {
+ pcfg = cfg;
+ while (pcfg->key)
+ {
+ if (strcasecmp("DictFile", pcfg->key) == 0)
+ {
+ if (dictloaded)
+ {
freeDictISpell(d);
ereport(ERROR,
- (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
- errmsg("dictionary already loaded")));
+ (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+ errmsg("dictionary already loaded")));
}
- if ( ImportDictionary(&(d->obj), pcfg->value) ) {
+ if (ImportDictionary(&(d->obj), pcfg->value))
+ {
freeDictISpell(d);
ereport(ERROR,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("could not load dictionary file \"%s\"",
pcfg->value)));
}
- dictloaded=true;
- } else if ( strcasecmp("AffFile", pcfg->key) == 0 ) {
- if ( affloaded ) {
+ dictloaded = true;
+ }
+ else if (strcasecmp("AffFile", pcfg->key) == 0)
+ {
+ if (affloaded)
+ {
freeDictISpell(d);
ereport(ERROR,
- (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
- errmsg("affixes already loaded")));
+ (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+ errmsg("affixes already loaded")));
}
- if ( ImportAffixes(&(d->obj), pcfg->value) ) {
+ if (ImportAffixes(&(d->obj), pcfg->value))
+ {
freeDictISpell(d);
ereport(ERROR,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("could not load affix file \"%s\"",
pcfg->value)));
}
- affloaded=true;
- } else if ( strcasecmp("StopFile", pcfg->key) == 0 ) {
- text *tmp=char2text(pcfg->value);
- if ( stoploaded ) {
+ affloaded = true;
+ }
+ else if (strcasecmp("StopFile", pcfg->key) == 0)
+ {
+ text *tmp = char2text(pcfg->value);
+
+ if (stoploaded)
+ {
freeDictISpell(d);
ereport(ERROR,
- (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
- errmsg("stop words already loaded")));
+ (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+ errmsg("stop words already loaded")));
}
readstoplist(tmp, &(d->stoplist));
sortstoplist(&(d->stoplist));
pfree(tmp);
- stoploaded=true;
- } else {
+ stoploaded = true;
+ }
+ else
+ {
freeDictISpell(d);
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("unrecognized option: %s => %s",
- pcfg->key, pcfg->value)));
+ pcfg->key, pcfg->value)));
}
pfree(pcfg->key);
pfree(pcfg->value);
}
pfree(cfg);
- if ( affloaded && dictloaded ) {
+ if (affloaded && dictloaded)
+ {
SortDictionary(&(d->obj));
SortAffixes(&(d->obj));
- } else if ( !affloaded ) {
+ }
+ else if (!affloaded)
+ {
freeDictISpell(d);
ereport(ERROR,
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
errmsg("no affixes")));
- } else {
+ }
+ else
+ {
freeDictISpell(d);
ereport(ERROR,
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
}
Datum
-spell_lexize(PG_FUNCTION_ARGS) {
- DictISpell *d = (DictISpell*)PG_GETARG_POINTER(0);
- char *in = (char*)PG_GETARG_POINTER(1);
- char *txt;
- char **res;
- char **ptr, **cptr;
-
- if ( !PG_GETARG_INT32(2) )
+spell_lexize(PG_FUNCTION_ARGS)
+{
+ DictISpell *d = (DictISpell *) PG_GETARG_POINTER(0);
+ char *in = (char *) PG_GETARG_POINTER(1);
+ char *txt;
+ char **res;
+ char **ptr,
+ **cptr;
+
+ if (!PG_GETARG_INT32(2))
PG_RETURN_POINTER(NULL);
- res=palloc(sizeof(char*)*2);
+ res = palloc(sizeof(char *) * 2);
txt = pnstrdup(in, PG_GETARG_INT32(2));
- res=NormalizeWord(&(d->obj), txt);
+ res = NormalizeWord(&(d->obj), txt);
pfree(txt);
- if ( res==NULL )
+ if (res == NULL)
PG_RETURN_POINTER(NULL);
- ptr=cptr=res;
- while(*ptr) {
- if ( searchstoplist(&(d->stoplist),*ptr) ) {
+ ptr = cptr = res;
+ while (*ptr)
+ {
+ if (searchstoplist(&(d->stoplist), *ptr))
+ {
pfree(*ptr);
- *ptr=NULL;
+ *ptr = NULL;
+ ptr++;
+ }
+ else
+ {
+ *cptr = *ptr;
+ cptr++;
ptr++;
- } else {
- *cptr=*ptr;
- cptr++; ptr++;
}
}
- *cptr=NULL;
+ *cptr = NULL;
PG_RETURN_POINTER(res);
}
-
-/*
+/*
* example of Snowball dictionary
- * http://snowball.tartarus.org/
+ * http://snowball.tartarus.org/
* Teodor Sigaev <teodor@sigaev.ru>
*/
#include <stdlib.h>
#include "snowball/english_stem.h"
#include "snowball/russian_stem.h"
-typedef struct {
+typedef struct
+{
struct SN_env *z;
StopList stoplist;
- int (*stem)(struct SN_env * z);
-} DictSnowball;
+ int (*stem) (struct SN_env * z);
+} DictSnowball;
PG_FUNCTION_INFO_V1(snb_en_init);
-Datum snb_en_init(PG_FUNCTION_ARGS);
+Datum snb_en_init(PG_FUNCTION_ARGS);
+
PG_FUNCTION_INFO_V1(snb_ru_init);
-Datum snb_ru_init(PG_FUNCTION_ARGS);
+Datum snb_ru_init(PG_FUNCTION_ARGS);
+
PG_FUNCTION_INFO_V1(snb_lexize);
-Datum snb_lexize(PG_FUNCTION_ARGS);
+Datum snb_lexize(PG_FUNCTION_ARGS);
-Datum
-snb_en_init(PG_FUNCTION_ARGS) {
- DictSnowball *d = (DictSnowball*)malloc( sizeof(DictSnowball) );
+Datum
+snb_en_init(PG_FUNCTION_ARGS)
+{
+ DictSnowball *d = (DictSnowball *) malloc(sizeof(DictSnowball));
- if ( !d )
+ if (!d)
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory")));
- memset(d,0,sizeof(DictSnowball));
- d->stoplist.wordop=lowerstr;
-
- if ( !PG_ARGISNULL(0) && PG_GETARG_POINTER(0)!=NULL ) {
- text *in = PG_GETARG_TEXT_P(0);
+ memset(d, 0, sizeof(DictSnowball));
+ d->stoplist.wordop = lowerstr;
+
+ if (!PG_ARGISNULL(0) && PG_GETARG_POINTER(0) != NULL)
+ {
+ text *in = PG_GETARG_TEXT_P(0);
+
readstoplist(in, &(d->stoplist));
sortstoplist(&(d->stoplist));
PG_FREE_IF_COPY(in, 0);
}
d->z = english_create_env();
- if (!d->z) {
+ if (!d->z)
+ {
freestoplist(&(d->stoplist));
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory")));
}
- d->stem=english_stem;
+ d->stem = english_stem;
PG_RETURN_POINTER(d);
}
-Datum
-snb_ru_init(PG_FUNCTION_ARGS) {
- DictSnowball *d = (DictSnowball*)malloc( sizeof(DictSnowball) );
+Datum
+snb_ru_init(PG_FUNCTION_ARGS)
+{
+ DictSnowball *d = (DictSnowball *) malloc(sizeof(DictSnowball));
- if ( !d )
+ if (!d)
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory")));
- memset(d,0,sizeof(DictSnowball));
- d->stoplist.wordop=lowerstr;
-
- if ( !PG_ARGISNULL(0) && PG_GETARG_POINTER(0)!=NULL ) {
- text *in = PG_GETARG_TEXT_P(0);
+ memset(d, 0, sizeof(DictSnowball));
+ d->stoplist.wordop = lowerstr;
+
+ if (!PG_ARGISNULL(0) && PG_GETARG_POINTER(0) != NULL)
+ {
+ text *in = PG_GETARG_TEXT_P(0);
+
readstoplist(in, &(d->stoplist));
sortstoplist(&(d->stoplist));
PG_FREE_IF_COPY(in, 0);
}
d->z = russian_create_env();
- if (!d->z) {
+ if (!d->z)
+ {
freestoplist(&(d->stoplist));
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory")));
}
- d->stem=russian_stem;
+ d->stem = russian_stem;
PG_RETURN_POINTER(d);
}
Datum
-snb_lexize(PG_FUNCTION_ARGS) {
- DictSnowball *d = (DictSnowball*)PG_GETARG_POINTER(0);
- char *in = (char*)PG_GETARG_POINTER(1);
- char *txt = pnstrdup(in, PG_GETARG_INT32(2));
- char **res=palloc(sizeof(char*)*2);
-
- if ( *txt=='\0' || searchstoplist(&(d->stoplist),txt) ) {
+snb_lexize(PG_FUNCTION_ARGS)
+{
+ DictSnowball *d = (DictSnowball *) PG_GETARG_POINTER(0);
+ char *in = (char *) PG_GETARG_POINTER(1);
+ char *txt = pnstrdup(in, PG_GETARG_INT32(2));
+ char **res = palloc(sizeof(char *) * 2);
+
+ if (*txt == '\0' || searchstoplist(&(d->stoplist), txt))
+ {
pfree(txt);
- res[0]=NULL;
- } else {
+ res[0] = NULL;
+ }
+ else
+ {
SN_set_current(d->z, strlen(txt), txt);
- (d->stem)(d->z);
- if ( d->z->p && d->z->l ) {
- txt=repalloc(txt, d->z->l+1);
- memcpy( txt, d->z->p, d->z->l);
- txt[d->z->l]='\0';
- }
- res[0]=txt;
+ (d->stem) (d->z);
+ if (d->z->p && d->z->l)
+ {
+ txt = repalloc(txt, d->z->l + 1);
+ memcpy(txt, d->z->p, d->z->l);
+ txt[d->z->l] = '\0';
+ }
+ res[0] = txt;
}
- res[1]=NULL;
+ res[1] = NULL;
PG_RETURN_POINTER(res);
}
-
-/*
+/*
* ISpell interface
* Teodor Sigaev <teodor@sigaev.ru>
*/
#include "common.h"
#define SYNBUFLEN 4096
-typedef struct {
- char *in;
- char *out;
-} Syn;
-
-typedef struct {
- int len;
- Syn *syn;
-} DictSyn;
+typedef struct
+{
+ char *in;
+ char *out;
+} Syn;
+
+typedef struct
+{
+ int len;
+ Syn *syn;
+} DictSyn;
PG_FUNCTION_INFO_V1(syn_init);
-Datum syn_init(PG_FUNCTION_ARGS);
+Datum syn_init(PG_FUNCTION_ARGS);
+
PG_FUNCTION_INFO_V1(syn_lexize);
-Datum syn_lexize(PG_FUNCTION_ARGS);
+Datum syn_lexize(PG_FUNCTION_ARGS);
static char *
-findwrd(char *in, char **end) {
- char *start;
+findwrd(char *in, char **end)
+{
+ char *start;
- *end=NULL;
- while(*in && isspace(*in))
+ *end = NULL;
+ while (*in && isspace(*in))
in++;
- if ( !in )
+ if (!in)
return NULL;
- start=in;
+ start = in;
- while(*in && !isspace(*in))
+ while (*in && !isspace(*in))
in++;
- *end=in;
+ *end = in;
return start;
}
static int
-compareSyn(const void *a, const void *b) {
- return strcmp( ((Syn*)a)->in, ((Syn*)b)->in );
+compareSyn(const void *a, const void *b)
+{
+ return strcmp(((Syn *) a)->in, ((Syn *) b)->in);
}
-Datum
-syn_init(PG_FUNCTION_ARGS) {
- text *in;
- DictSyn *d;
- int cur=0;
- FILE *fin;
- char *filename;
- char buf[SYNBUFLEN];
- char *starti,*starto,*end=NULL;
- int slen;
-
- if ( PG_ARGISNULL(0) || PG_GETARG_POINTER(0)==NULL )
+Datum
+syn_init(PG_FUNCTION_ARGS)
+{
+ text *in;
+ DictSyn *d;
+ int cur = 0;
+ FILE *fin;
+ char *filename;
+ char buf[SYNBUFLEN];
+ char *starti,
+ *starto,
+ *end = NULL;
+ int slen;
+
+ if (PG_ARGISNULL(0) || PG_GETARG_POINTER(0) == NULL)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("NULL config")));
in = PG_GETARG_TEXT_P(0);
- if ( VARSIZE(in) - VARHDRSZ == 0 )
+ if (VARSIZE(in) - VARHDRSZ == 0)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("VOID config")));
- filename=text2char(in);
+ filename = text2char(in);
PG_FREE_IF_COPY(in, 0);
- if ( (fin=fopen(filename,"r")) == NULL )
+ if ((fin = fopen(filename, "r")) == NULL)
ereport(ERROR,
(errcode_for_file_access(),
errmsg("could not open file \"%s\": %m",
- filename)));
+ filename)));
- d = (DictSyn*)malloc( sizeof(DictSyn) );
- if ( !d ) {
+ d = (DictSyn *) malloc(sizeof(DictSyn));
+ if (!d)
+ {
fclose(fin);
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory")));
}
- memset(d,0,sizeof(DictSyn));
+ memset(d, 0, sizeof(DictSyn));
- while( fgets(buf,SYNBUFLEN,fin) ) {
- slen = strlen(buf)-1;
+ while (fgets(buf, SYNBUFLEN, fin))
+ {
+ slen = strlen(buf) - 1;
buf[slen] = '\0';
- if ( *buf=='\0' ) continue;
- if (cur==d->len) {
- d->len = (d->len) ? 2*d->len : 16;
- d->syn=(Syn*)realloc( d->syn, sizeof(Syn)*d->len );
- if ( !d->syn ) {
+ if (*buf == '\0')
+ continue;
+ if (cur == d->len)
+ {
+ d->len = (d->len) ? 2 * d->len : 16;
+ d->syn = (Syn *) realloc(d->syn, sizeof(Syn) * d->len);
+ if (!d->syn)
+ {
fclose(fin);
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
}
}
- starti=findwrd(buf,&end);
- if ( !starti )
+ starti = findwrd(buf, &end);
+ if (!starti)
continue;
- *end='\0';
- if ( end >= buf+slen )
+ *end = '\0';
+ if (end >= buf + slen)
continue;
- starto= findwrd(end+1, &end);
- if ( !starto )
+ starto = findwrd(end + 1, &end);
+ if (!starto)
continue;
- *end='\0';
+ *end = '\0';
- d->syn[cur].in=strdup(lowerstr(starti));
- d->syn[cur].out=strdup(lowerstr(starto));
- if ( !(d->syn[cur].in && d->syn[cur].out) ) {
+ d->syn[cur].in = strdup(lowerstr(starti));
+ d->syn[cur].out = strdup(lowerstr(starto));
+ if (!(d->syn[cur].in && d->syn[cur].out))
+ {
fclose(fin);
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory")));
}
- cur++;
+ cur++;
}
-
- fclose(fin);
-
- d->len=cur;
- if ( cur>1 )
- qsort(d->syn, d->len, sizeof(Syn), compareSyn);
+
+ fclose(fin);
+
+ d->len = cur;
+ if (cur > 1)
+ qsort(d->syn, d->len, sizeof(Syn), compareSyn);
pfree(filename);
- PG_RETURN_POINTER(d);
+ PG_RETURN_POINTER(d);
}
Datum
-syn_lexize(PG_FUNCTION_ARGS) {
- DictSyn *d = (DictSyn*)PG_GETARG_POINTER(0);
- char *in = (char*)PG_GETARG_POINTER(1);
- Syn key,*found;
- char **res=NULL;
-
- if ( !PG_GETARG_INT32(2) )
+syn_lexize(PG_FUNCTION_ARGS)
+{
+ DictSyn *d = (DictSyn *) PG_GETARG_POINTER(0);
+ char *in = (char *) PG_GETARG_POINTER(1);
+ Syn key,
+ *found;
+ char **res = NULL;
+
+ if (!PG_GETARG_INT32(2))
PG_RETURN_POINTER(NULL);
- key.out=NULL;
- key.in=lowerstr(pnstrdup(in, PG_GETARG_INT32(2)));
+ key.out = NULL;
+ key.in = lowerstr(pnstrdup(in, PG_GETARG_INT32(2)));
- found=(Syn*)bsearch(&key, d->syn, d->len, sizeof(Syn), compareSyn);
+ found = (Syn *) bsearch(&key, d->syn, d->len, sizeof(Syn), compareSyn);
pfree(key.in);
- if ( !found )
+ if (!found)
PG_RETURN_POINTER(NULL);
- res=palloc(sizeof(char*)*2);
+ res = palloc(sizeof(char *) * 2);
- res[0]=pstrdup(found->out);
- res[1]=NULL;
+ res[0] = pstrdup(found->out);
+ res[1] = NULL;
- PG_RETURN_POINTER(res);
+ PG_RETURN_POINTER(res);
}
-
#define MAXNORMLEN 56
-#define STRNCASECMP(x,y) (strncasecmp(x,y,strlen(y)))
+#define STRNCASECMP(x,y) (strncasecmp(x,y,strlen(y)))
-static int cmpspell(const void *s1,const void *s2){
- return(strcmp(((const SPELL*)s1)->word,((const SPELL*)s2)->word));
+static int
+cmpspell(const void *s1, const void *s2)
+{
+ return (strcmp(((const SPELL *) s1)->word, ((const SPELL *) s2)->word));
}
-static void
-strlower( char * str ) {
- unsigned char *ptr = (unsigned char *)str;
- while ( *ptr ) {
- *ptr = tolower( *ptr );
+static void
+strlower(char *str)
+{
+ unsigned char *ptr = (unsigned char *) str;
+
+ while (*ptr)
+ {
+ *ptr = tolower(*ptr);
ptr++;
}
}
/* backward string compaire for suffix tree operations */
-static int
-strbcmp(const char *s1, const char *s2) {
- int l1 = strlen(s1)-1, l2 = strlen(s2)-1;
- while (l1 >= 0 && l2 >= 0) {
- if (s1[l1] < s2[l2]) return -1;
- if (s1[l1] > s2[l2]) return 1;
- l1--; l2--;
+static int
+strbcmp(const char *s1, const char *s2)
+{
+ int l1 = strlen(s1) - 1,
+ l2 = strlen(s2) - 1;
+
+ while (l1 >= 0 && l2 >= 0)
+ {
+ if (s1[l1] < s2[l2])
+ return -1;
+ if (s1[l1] > s2[l2])
+ return 1;
+ l1--;
+ l2--;
}
- if (l1 < l2) return -1;
- if (l1 > l2) return 1;
+ if (l1 < l2)
+ return -1;
+ if (l1 > l2)
+ return 1;
return 0;
}
-static int
-strbncmp(const char *s1, const char *s2, size_t count) {
- int l1 = strlen(s1) - 1, l2 = strlen(s2) - 1, l = count;
- while (l1 >= 0 && l2 >= 0 && l > 0) {
- if (s1[l1] < s2[l2]) return -1;
- if (s1[l1] > s2[l2]) return 1;
+static int
+strbncmp(const char *s1, const char *s2, size_t count)
+{
+ int l1 = strlen(s1) - 1,
+ l2 = strlen(s2) - 1,
+ l = count;
+
+ while (l1 >= 0 && l2 >= 0 && l > 0)
+ {
+ if (s1[l1] < s2[l2])
+ return -1;
+ if (s1[l1] > s2[l2])
+ return 1;
l1--;
l2--;
l--;
}
- if (l == 0) return 0;
- if (l1 < l2) return -1;
- if (l1 > l2) return 1;
+ if (l == 0)
+ return 0;
+ if (l1 < l2)
+ return -1;
+ if (l1 > l2)
+ return 1;
return 0;
}
-static int
-cmpaffix(const void *s1,const void *s2){
- if (((const AFFIX*)s1)->type < ((const AFFIX*)s2)->type) return -1;
- if (((const AFFIX*)s1)->type > ((const AFFIX*)s2)->type) return 1;
- if (((const AFFIX*)s1)->type == 'p')
- return(strcmp(((const AFFIX*)s1)->repl,((const AFFIX*)s2)->repl));
- else
- return(strbcmp(((const AFFIX*)s1)->repl,((const AFFIX*)s2)->repl));
+static int
+cmpaffix(const void *s1, const void *s2)
+{
+ if (((const AFFIX *) s1)->type < ((const AFFIX *) s2)->type)
+ return -1;
+ if (((const AFFIX *) s1)->type > ((const AFFIX *) s2)->type)
+ return 1;
+ if (((const AFFIX *) s1)->type == 'p')
+ return (strcmp(((const AFFIX *) s1)->repl, ((const AFFIX *) s2)->repl));
+ else
+ return (strbcmp(((const AFFIX *) s1)->repl, ((const AFFIX *) s2)->repl));
}
-int
-AddSpell(IspellDict * Conf,const char * word,const char *flag){
- if(Conf->nspell>=Conf->mspell){
- if(Conf->mspell){
- Conf->mspell+=1024*20;
- Conf->Spell=(SPELL *)realloc(Conf->Spell,Conf->mspell*sizeof(SPELL));
- }else{
- Conf->mspell=1024*20;
- Conf->Spell=(SPELL *)malloc(Conf->mspell*sizeof(SPELL));
+int
+AddSpell(IspellDict * Conf, const char *word, const char *flag)
+{
+ if (Conf->nspell >= Conf->mspell)
+ {
+ if (Conf->mspell)
+ {
+ Conf->mspell += 1024 * 20;
+ Conf->Spell = (SPELL *) realloc(Conf->Spell, Conf->mspell * sizeof(SPELL));
+ }
+ else
+ {
+ Conf->mspell = 1024 * 20;
+ Conf->Spell = (SPELL *) malloc(Conf->mspell * sizeof(SPELL));
}
- if ( Conf->Spell == NULL )
+ if (Conf->Spell == NULL)
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory")));
}
- Conf->Spell[Conf->nspell].word=strdup(word);
- if ( !Conf->Spell[Conf->nspell].word )
+ Conf->Spell[Conf->nspell].word = strdup(word);
+ if (!Conf->Spell[Conf->nspell].word)
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory")));
- strncpy(Conf->Spell[Conf->nspell].flag,flag,10);
+ strncpy(Conf->Spell[Conf->nspell].flag, flag, 10);
Conf->nspell++;
- return(0);
+ return (0);
}
-int
-ImportDictionary(IspellDict * Conf,const char *filename){
- unsigned char str[BUFSIZ];
- FILE *dict;
+int
+ImportDictionary(IspellDict * Conf, const char *filename)
+{
+ unsigned char str[BUFSIZ];
+ FILE *dict;
- if(!(dict=fopen(filename,"r")))return(1);
- while(fgets(str,sizeof(str),dict)){
+ if (!(dict = fopen(filename, "r")))
+ return (1);
+ while (fgets(str, sizeof(str), dict))
+ {
unsigned char *s;
const unsigned char *flag;
- flag = NULL;
- if((s=strchr(str,'/'))){
- *s=0;
- s++;flag=s;
- while(*s){
- if (((*s>='A')&&(*s<='Z'))||((*s>='a')&&(*s<='z')))
+ flag = NULL;
+ if ((s = strchr(str, '/')))
+ {
+ *s = 0;
+ s++;
+ flag = s;
+ while (*s)
+ {
+ if (((*s >= 'A') && (*s <= 'Z')) || ((*s >= 'a') && (*s <= 'z')))
s++;
- else {
- *s=0;
+ else
+ {
+ *s = 0;
break;
}
}
- }else{
- flag="";
}
+ else
+ flag = "";
strlower(str);
/* Dont load words if first letter is not required */
/* It allows to optimize loading at search time */
- s=str;
- while(*s){
- if(*s=='\r')*s=0;
- if(*s=='\n')*s=0;
+ s = str;
+ while (*s)
+ {
+ if (*s == '\r')
+ *s = 0;
+ if (*s == '\n')
+ *s = 0;
s++;
}
- AddSpell(Conf,str,flag);
+ AddSpell(Conf, str, flag);
}
fclose(dict);
- return(0);
+ return (0);
}
-static SPELL *
-FindWord(IspellDict * Conf, const char *word, int affixflag) {
- int l,c,r,resc,resl,resr, i;
+static SPELL *
+FindWord(IspellDict * Conf, const char *word, int affixflag)
+{
+ int l,
+ c,
+ r,
+ resc,
+ resl,
+ resr,
+ i;
- i = (int)(*word) & 255;
+ i = (int) (*word) & 255;
l = Conf->SpellTree.Left[i];
r = Conf->SpellTree.Right[i];
- if (l == -1) return (NULL);
- while(l<=r){
+ if (l == -1)
+ return (NULL);
+ while (l <= r)
+ {
c = (l + r) >> 1;
resc = strcmp(Conf->Spell[c].word, word);
- if( (resc == 0) &&
- ((affixflag == 0) || (strchr(Conf->Spell[c].flag, affixflag) != NULL)) ) {
- return(&Conf->Spell[c]);
- }
+ if ((resc == 0) &&
+ ((affixflag == 0) || (strchr(Conf->Spell[c].flag, affixflag) != NULL)))
+ return (&Conf->Spell[c]);
resl = strcmp(Conf->Spell[l].word, word);
- if( (resl == 0) &&
- ((affixflag == 0) || (strchr(Conf->Spell[l].flag, affixflag) != NULL)) ) {
- return(&Conf->Spell[l]);
- }
+ if ((resl == 0) &&
+ ((affixflag == 0) || (strchr(Conf->Spell[l].flag, affixflag) != NULL)))
+ return (&Conf->Spell[l]);
resr = strcmp(Conf->Spell[r].word, word);
- if( (resr == 0) &&
- ((affixflag == 0) || (strchr(Conf->Spell[r].flag, affixflag) != NULL)) ) {
- return(&Conf->Spell[r]);
- }
- if(resc < 0){
+ if ((resr == 0) &&
+ ((affixflag == 0) || (strchr(Conf->Spell[r].flag, affixflag) != NULL)))
+ return (&Conf->Spell[r]);
+ if (resc < 0)
+ {
l = c + 1;
r--;
- } else if(resc > 0){
+ }
+ else if (resc > 0)
+ {
r = c - 1;
l++;
- } else {
+ }
+ else
+ {
l++;
r--;
}
}
- return(NULL);
+ return (NULL);
}
-int
-AddAffix(IspellDict * Conf,int flag,const char *mask,const char *find,const char *repl,int type) {
- if(Conf->naffixes>=Conf->maffixes){
- if(Conf->maffixes){
- Conf->maffixes+=16;
- Conf->Affix = (AFFIX*)realloc((void*)Conf->Affix,Conf->maffixes*sizeof(AFFIX));
- }else{
- Conf->maffixes=16;
- Conf->Affix = (AFFIX*)malloc(Conf->maffixes * sizeof(AFFIX));
+int
+AddAffix(IspellDict * Conf, int flag, const char *mask, const char *find, const char *repl, int type)
+{
+ if (Conf->naffixes >= Conf->maffixes)
+ {
+ if (Conf->maffixes)
+ {
+ Conf->maffixes += 16;
+ Conf->Affix = (AFFIX *) realloc((void *) Conf->Affix, Conf->maffixes * sizeof(AFFIX));
+ }
+ else
+ {
+ Conf->maffixes = 16;
+ Conf->Affix = (AFFIX *) malloc(Conf->maffixes * sizeof(AFFIX));
}
- if ( Conf->Affix == NULL )
+ if (Conf->Affix == NULL)
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory")));
}
- if (type=='s') {
- sprintf(Conf->Affix[Conf->naffixes].mask,"%s$",mask);
- } else {
- sprintf(Conf->Affix[Conf->naffixes].mask,"^%s",mask);
- }
+ if (type == 's')
+ sprintf(Conf->Affix[Conf->naffixes].mask, "%s$", mask);
+ else
+ sprintf(Conf->Affix[Conf->naffixes].mask, "^%s", mask);
Conf->Affix[Conf->naffixes].compile = 1;
- Conf->Affix[Conf->naffixes].flag=flag;
- Conf->Affix[Conf->naffixes].type=type;
-
- strcpy(Conf->Affix[Conf->naffixes].find,find);
- strcpy(Conf->Affix[Conf->naffixes].repl,repl);
- Conf->Affix[Conf->naffixes].replen=strlen(repl);
+ Conf->Affix[Conf->naffixes].flag = flag;
+ Conf->Affix[Conf->naffixes].type = type;
+
+ strcpy(Conf->Affix[Conf->naffixes].find, find);
+ strcpy(Conf->Affix[Conf->naffixes].repl, repl);
+ Conf->Affix[Conf->naffixes].replen = strlen(repl);
Conf->naffixes++;
- return(0);
+ return (0);
}
-static char *
-remove_spaces(char *dist,char *src){
-char *d,*s;
- d=dist;
- s=src;
- while(*s){
- if(*s!=' '&&*s!='-'&&*s!='\t'){
- *d=*s;
+static char *
+remove_spaces(char *dist, char *src)
+{
+ char *d,
+ *s;
+
+ d = dist;
+ s = src;
+ while (*s)
+ {
+ if (*s != ' ' && *s != '-' && *s != '\t')
+ {
+ *d = *s;
d++;
}
s++;
}
- *d=0;
- return(dist);
+ *d = 0;
+ return (dist);
}
-int
-ImportAffixes(IspellDict * Conf,const char *filename){
+int
+ImportAffixes(IspellDict * Conf, const char *filename)
+{
unsigned char str[BUFSIZ];
- unsigned char flag=0;
- unsigned char mask[BUFSIZ]="";
- unsigned char find[BUFSIZ]="";
- unsigned char repl[BUFSIZ]="";
+ unsigned char flag = 0;
+ unsigned char mask[BUFSIZ] = "";
+ unsigned char find[BUFSIZ] = "";
+ unsigned char repl[BUFSIZ] = "";
unsigned char *s;
- int i;
- int suffixes=0;
- int prefixes=0;
- FILE *affix;
-
- if(!(affix=fopen(filename,"r")))
- return(1);
-
- while(fgets(str,sizeof(str),affix)){
- if(!STRNCASECMP(str,"suffixes")){
- suffixes=1;
- prefixes=0;
+ int i;
+ int suffixes = 0;
+ int prefixes = 0;
+ FILE *affix;
+
+ if (!(affix = fopen(filename, "r")))
+ return (1);
+
+ while (fgets(str, sizeof(str), affix))
+ {
+ if (!STRNCASECMP(str, "suffixes"))
+ {
+ suffixes = 1;
+ prefixes = 0;
continue;
}
- if(!STRNCASECMP(str,"prefixes")){
- suffixes=0;
- prefixes=1;
+ if (!STRNCASECMP(str, "prefixes"))
+ {
+ suffixes = 0;
+ prefixes = 1;
continue;
}
- if(!STRNCASECMP(str,"flag ")){
- s=str+5;
- while(strchr("* ",*s))
+ if (!STRNCASECMP(str, "flag "))
+ {
+ s = str + 5;
+ while (strchr("* ", *s))
s++;
- flag=*s;
+ flag = *s;
continue;
}
- if((!suffixes)&&(!prefixes))continue;
- if((s=strchr(str,'#')))*s=0;
- if(!*str)continue;
+ if ((!suffixes) && (!prefixes))
+ continue;
+ if ((s = strchr(str, '#')))
+ *s = 0;
+ if (!*str)
+ continue;
strlower(str);
- strcpy(mask,"");
- strcpy(find,"");
- strcpy(repl,"");
- i=sscanf(str,"%[^>\n]>%[^,\n],%[^\n]",mask,find,repl);
- remove_spaces(str,repl);strcpy(repl,str);
- remove_spaces(str,find);strcpy(find,str);
- remove_spaces(str,mask);strcpy(mask,str);
- switch(i){
+ strcpy(mask, "");
+ strcpy(find, "");
+ strcpy(repl, "");
+ i = sscanf(str, "%[^>\n]>%[^,\n],%[^\n]", mask, find, repl);
+ remove_spaces(str, repl);
+ strcpy(repl, str);
+ remove_spaces(str, find);
+ strcpy(find, str);
+ remove_spaces(str, mask);
+ strcpy(mask, str);
+ switch (i)
+ {
case 3:
break;
case 2:
- if(*find != '\0'){
- strcpy(repl,find);
- strcpy(find,"");
+ if (*find != '\0')
+ {
+ strcpy(repl, find);
+ strcpy(find, "");
}
break;
default:
continue;
}
-
- AddAffix(Conf,(int)flag,mask,find,repl,suffixes?'s':'p');
-
+
+ AddAffix(Conf, (int) flag, mask, find, repl, suffixes ? 's' : 'p');
+
}
fclose(affix);
-
- return(0);
+
+ return (0);
}
-void
-SortDictionary(IspellDict * Conf){
- int CurLet = -1, Let;size_t i;
+void
+SortDictionary(IspellDict * Conf)
+{
+ int CurLet = -1,
+ Let;
+ size_t i;
- qsort((void*)Conf->Spell,Conf->nspell,sizeof(SPELL),cmpspell);
+ qsort((void *) Conf->Spell, Conf->nspell, sizeof(SPELL), cmpspell);
- for(i = 0; i < 256 ; i++ )
+ for (i = 0; i < 256; i++)
Conf->SpellTree.Left[i] = -1;
- for(i = 0; i < Conf->nspell; i++) {
- Let = (int)(*(Conf->Spell[i].word)) & 255;
- if (CurLet != Let) {
- Conf->SpellTree.Left[Let] = i;
- CurLet = Let;
- }
- Conf->SpellTree.Right[Let] = i;
+ for (i = 0; i < Conf->nspell; i++)
+ {
+ Let = (int) (*(Conf->Spell[i].word)) & 255;
+ if (CurLet != Let)
+ {
+ Conf->SpellTree.Left[Let] = i;
+ CurLet = Let;
+ }
+ Conf->SpellTree.Right[Let] = i;
}
}
-void
-SortAffixes(IspellDict * Conf) {
- int CurLetP = -1, CurLetS = -1, Let;
- AFFIX *Affix; size_t i;
-
- if (Conf->naffixes > 1)
- qsort((void*)Conf->Affix,Conf->naffixes,sizeof(AFFIX),cmpaffix);
- for(i = 0; i < 256; i++) {
- Conf->PrefixTree.Left[i] = Conf->PrefixTree.Right[i] = -1;
- Conf->SuffixTree.Left[i] = Conf->SuffixTree.Right[i] = -1;
- }
-
- for(i = 0; i < Conf->naffixes; i++) {
- Affix = &(((AFFIX*)Conf->Affix)[i]);
- if(Affix->type == 'p') {
- Let = (int)(*(Affix->repl)) & 255;
- if (CurLetP != Let) {
- Conf->PrefixTree.Left[Let] = i;
- CurLetP = Let;
- }
- Conf->PrefixTree.Right[Let] = i;
- } else {
- Let = (Affix->replen) ? (int)(Affix->repl[Affix->replen-1]) & 255 : 0;
- if (CurLetS != Let) {
- Conf->SuffixTree.Left[Let] = i;
- CurLetS = Let;
- }
- Conf->SuffixTree.Right[Let] = i;
- }
- }
+void
+SortAffixes(IspellDict * Conf)
+{
+ int CurLetP = -1,
+ CurLetS = -1,
+ Let;
+ AFFIX *Affix;
+ size_t i;
+
+ if (Conf->naffixes > 1)
+ qsort((void *) Conf->Affix, Conf->naffixes, sizeof(AFFIX), cmpaffix);
+ for (i = 0; i < 256; i++)
+ {
+ Conf->PrefixTree.Left[i] = Conf->PrefixTree.Right[i] = -1;
+ Conf->SuffixTree.Left[i] = Conf->SuffixTree.Right[i] = -1;
+ }
+
+ for (i = 0; i < Conf->naffixes; i++)
+ {
+ Affix = &(((AFFIX *) Conf->Affix)[i]);
+ if (Affix->type == 'p')
+ {
+ Let = (int) (*(Affix->repl)) & 255;
+ if (CurLetP != Let)
+ {
+ Conf->PrefixTree.Left[Let] = i;
+ CurLetP = Let;
+ }
+ Conf->PrefixTree.Right[Let] = i;
+ }
+ else
+ {
+ Let = (Affix->replen) ? (int) (Affix->repl[Affix->replen - 1]) & 255 : 0;
+ if (CurLetS != Let)
+ {
+ Conf->SuffixTree.Left[Let] = i;
+ CurLetS = Let;
+ }
+ Conf->SuffixTree.Right[Let] = i;
+ }
+ }
}
-static char *
-CheckSuffix(const char *word, size_t len, AFFIX *Affix, int *res, IspellDict *Conf) {
- regmatch_t subs[2]; /* workaround for apache&linux */
- char newword[2*MAXNORMLEN] = "";
- int err;
-
- *res = strbncmp(word, Affix->repl, Affix->replen);
- if (*res < 0) {
- return NULL;
- }
- if (*res > 0) {
- return NULL;
- }
- strcpy(newword, word);
- strcpy(newword+len-Affix->replen, Affix->find);
-
- if (Affix->compile) {
- err = regcomp(&(Affix->reg),Affix->mask,REG_EXTENDED|REG_ICASE|REG_NOSUB);
- if(err){
- /*regerror(err, &(Affix->reg), regerrstr, ERRSTRSIZE);*/
- regfree(&(Affix->reg));
- return(NULL);
- }
- Affix->compile = 0;
- }
- if(!(err=regexec(&(Affix->reg),newword,1,subs,0))){
- if(FindWord(Conf, newword, Affix->flag))
- return pstrdup(newword);
- }
- return NULL;
+static char *
+CheckSuffix(const char *word, size_t len, AFFIX * Affix, int *res, IspellDict * Conf)
+{
+ regmatch_t subs[2]; /* workaround for apache&linux */
+ char newword[2 * MAXNORMLEN] = "";
+ int err;
+
+ *res = strbncmp(word, Affix->repl, Affix->replen);
+ if (*res < 0)
+ return NULL;
+ if (*res > 0)
+ return NULL;
+ strcpy(newword, word);
+ strcpy(newword + len - Affix->replen, Affix->find);
+
+ if (Affix->compile)
+ {
+ err = regcomp(&(Affix->reg), Affix->mask, REG_EXTENDED | REG_ICASE | REG_NOSUB);
+ if (err)
+ {
+ /* regerror(err, &(Affix->reg), regerrstr, ERRSTRSIZE); */
+ regfree(&(Affix->reg));
+ return (NULL);
+ }
+ Affix->compile = 0;
+ }
+ if (!(err = regexec(&(Affix->reg), newword, 1, subs, 0)))
+ {
+ if (FindWord(Conf, newword, Affix->flag))
+ return pstrdup(newword);
+ }
+ return NULL;
}
#define NS 1
#define MAX_NORM 512
-static int
-CheckPrefix(const char *word, size_t len, AFFIX *Affix, IspellDict *Conf, int pi,
- char **forms, char ***cur ) {
- regmatch_t subs[NS*2];
- char newword[2*MAXNORMLEN] = "";
- int err, ls, res, lres;
- size_t newlen;
- AFFIX *CAffix = Conf->Affix;
-
- res = strncmp(word, Affix->repl, Affix->replen);
- if (res != 0) {
- return res;
- }
- strcpy(newword, Affix->find);
- strcat(newword, word+Affix->replen);
-
- if (Affix->compile) {
- err = regcomp(&(Affix->reg),Affix->mask,REG_EXTENDED|REG_ICASE|REG_NOSUB);
- if(err){
- /*regerror(err, &(Affix->reg), regerrstr, ERRSTRSIZE);*/
- regfree(&(Affix->reg));
- return (0);
- }
- Affix->compile = 0;
- }
- if(!(err=regexec(&(Affix->reg),newword,1,subs,0))){
- SPELL * curspell;
-
- if((curspell=FindWord(Conf, newword, Affix->flag))){
- if ((*cur - forms) < (MAX_NORM-1)) {
- **cur = pstrdup(newword);
- (*cur)++; **cur = NULL;
- }
- }
- newlen = strlen(newword);
- ls = Conf->SuffixTree.Left[pi];
- if ( ls>=0 && ((*cur - forms) < (MAX_NORM-1)) ) {
- **cur = CheckSuffix(newword, newlen, &CAffix[ls], &lres, Conf);
- if (**cur) {
- (*cur)++; **cur = NULL;
+static int
+CheckPrefix(const char *word, size_t len, AFFIX * Affix, IspellDict * Conf, int pi,
+ char **forms, char ***cur)
+{
+ regmatch_t subs[NS * 2];
+ char newword[2 * MAXNORMLEN] = "";
+ int err,
+ ls,
+ res,
+ lres;
+ size_t newlen;
+ AFFIX *CAffix = Conf->Affix;
+
+ res = strncmp(word, Affix->repl, Affix->replen);
+ if (res != 0)
+ return res;
+ strcpy(newword, Affix->find);
+ strcat(newword, word + Affix->replen);
+
+ if (Affix->compile)
+ {
+ err = regcomp(&(Affix->reg), Affix->mask, REG_EXTENDED | REG_ICASE | REG_NOSUB);
+ if (err)
+ {
+ /* regerror(err, &(Affix->reg), regerrstr, ERRSTRSIZE); */
+ regfree(&(Affix->reg));
+ return (0);
+ }
+ Affix->compile = 0;
}
- }
- }
- return 0;
+ if (!(err = regexec(&(Affix->reg), newword, 1, subs, 0)))
+ {
+ SPELL *curspell;
+
+ if ((curspell = FindWord(Conf, newword, Affix->flag)))
+ {
+ if ((*cur - forms) < (MAX_NORM - 1))
+ {
+ **cur = pstrdup(newword);
+ (*cur)++;
+ **cur = NULL;
+ }
+ }
+ newlen = strlen(newword);
+ ls = Conf->SuffixTree.Left[pi];
+ if (ls >= 0 && ((*cur - forms) < (MAX_NORM - 1)))
+ {
+ **cur = CheckSuffix(newword, newlen, &CAffix[ls], &lres, Conf);
+ if (**cur)
+ {
+ (*cur)++;
+ **cur = NULL;
+ }
+ }
+ }
+ return 0;
}
-char **
-NormalizeWord(IspellDict * Conf,char *word){
+char **
+NormalizeWord(IspellDict * Conf, char *word)
+{
/*regmatch_t subs[NS];*/
-size_t len;
-char ** forms;
-char **cur;
-AFFIX * Affix;
-int ri, pi, ipi, lp, rp, cp, ls, rs;
-int lres, rres, cres = 0;
- SPELL *spell;
-
- len=strlen(word);
+ size_t len;
+ char **forms;
+ char **cur;
+ AFFIX *Affix;
+ int ri,
+ pi,
+ ipi,
+ lp,
+ rp,
+ cp,
+ ls,
+ rs;
+ int lres,
+ rres,
+ cres = 0;
+ SPELL *spell;
+
+ len = strlen(word);
if (len > MAXNORMLEN)
- return(NULL);
+ return (NULL);
strlower(word);
- forms=(char **) palloc(MAX_NORM*sizeof(char **));
- cur=forms;*cur=NULL;
+ forms = (char **) palloc(MAX_NORM * sizeof(char **));
+ cur = forms;
+ *cur = NULL;
- ri = (int)(*word) & 255;
- pi = (int)(word[strlen(word)-1]) & 255;
- Affix=(AFFIX*)Conf->Affix;
+ ri = (int) (*word) & 255;
+ pi = (int) (word[strlen(word) - 1]) & 255;
+ Affix = (AFFIX *) Conf->Affix;
/* Check that the word itself is normal form */
- if((spell = FindWord(Conf, word, 0))){
- *cur=pstrdup(word);
- cur++;*cur=NULL;
+ if ((spell = FindWord(Conf, word, 0)))
+ {
+ *cur = pstrdup(word);
+ cur++;
+ *cur = NULL;
}
/* Find all other NORMAL forms of the 'word' */
- for (ipi = 0; ipi <= pi; ipi += pi) {
-
- /* check prefix */
- lp = Conf->PrefixTree.Left[ri];
- rp = Conf->PrefixTree.Right[ri];
- while (lp >= 0 && lp <= rp) {
- cp = (lp + rp) >> 1;
- cres = 0;
- if ((cur - forms) < (MAX_NORM-1)) {
- cres = CheckPrefix(word, len, &Affix[cp], Conf, ipi, forms, &cur);
- }
- if ((lp < cp) && ((cur - forms) < (MAX_NORM-1)) ) {
- lres = CheckPrefix(word, len, &Affix[lp], Conf, ipi, forms, &cur);
- }
- if ( (rp > cp) && ((cur - forms) < (MAX_NORM-1)) ) {
- rres = CheckPrefix(word, len, &Affix[rp], Conf, ipi, forms, &cur);
- }
- if (cres < 0) {
- rp = cp - 1;
- lp++;
- } else if (cres > 0) {
- lp = cp + 1;
- rp--;
- } else {
- lp++;
- rp--;
- }
- }
-
- /* check suffix */
- ls = Conf->SuffixTree.Left[ipi];
- rs = Conf->SuffixTree.Right[ipi];
- while (ls >= 0 && ls <= rs) {
- if ( ((cur - forms) < (MAX_NORM-1)) ) {
- *cur = CheckSuffix(word, len, &Affix[ls], &lres, Conf);
- if (*cur) {
- cur++; *cur = NULL;
- }
- }
- if ( (rs > ls) && ((cur - forms) < (MAX_NORM-1)) ) {
- *cur = CheckSuffix(word, len, &Affix[rs], &rres, Conf);
- if (*cur) {
- cur++; *cur = NULL;
+ for (ipi = 0; ipi <= pi; ipi += pi)
+ {
+
+ /* check prefix */
+ lp = Conf->PrefixTree.Left[ri];
+ rp = Conf->PrefixTree.Right[ri];
+ while (lp >= 0 && lp <= rp)
+ {
+ cp = (lp + rp) >> 1;
+ cres = 0;
+ if ((cur - forms) < (MAX_NORM - 1))
+ cres = CheckPrefix(word, len, &Affix[cp], Conf, ipi, forms, &cur);
+ if ((lp < cp) && ((cur - forms) < (MAX_NORM - 1)))
+ lres = CheckPrefix(word, len, &Affix[lp], Conf, ipi, forms, &cur);
+ if ((rp > cp) && ((cur - forms) < (MAX_NORM - 1)))
+ rres = CheckPrefix(word, len, &Affix[rp], Conf, ipi, forms, &cur);
+ if (cres < 0)
+ {
+ rp = cp - 1;
+ lp++;
+ }
+ else if (cres > 0)
+ {
+ lp = cp + 1;
+ rp--;
+ }
+ else
+ {
+ lp++;
+ rp--;
+ }
}
- }
- ls++;
- rs--;
- } /* end while */
-
- } /* for ipi */
-
- if(cur==forms){
+
+ /* check suffix */
+ ls = Conf->SuffixTree.Left[ipi];
+ rs = Conf->SuffixTree.Right[ipi];
+ while (ls >= 0 && ls <= rs)
+ {
+ if (((cur - forms) < (MAX_NORM - 1)))
+ {
+ *cur = CheckSuffix(word, len, &Affix[ls], &lres, Conf);
+ if (*cur)
+ {
+ cur++;
+ *cur = NULL;
+ }
+ }
+ if ((rs > ls) && ((cur - forms) < (MAX_NORM - 1)))
+ {
+ *cur = CheckSuffix(word, len, &Affix[rs], &rres, Conf);
+ if (*cur)
+ {
+ cur++;
+ *cur = NULL;
+ }
+ }
+ ls++;
+ rs--;
+ } /* end while */
+
+ } /* for ipi */
+
+ if (cur == forms)
+ {
pfree(forms);
- return(NULL);
+ return (NULL);
}
- return(forms);
+ return (forms);
}
-void
-FreeIspell (IspellDict *Conf) {
- int i;
- AFFIX *Affix = (AFFIX *)Conf->Affix;
-
- for (i = 0; i < Conf->naffixes; i++) {
- if (Affix[i].compile == 0) {
- regfree(&(Affix[i].reg));
- }
- }
- for (i = 0; i < Conf->naffixes; i++) {
- free( Conf->Spell[i].word );
- }
- free(Conf->Affix);
- free(Conf->Spell);
- memset( (void*)Conf, 0, sizeof(IspellDict) );
- return;
+void
+FreeIspell(IspellDict * Conf)
+{
+ int i;
+ AFFIX *Affix = (AFFIX *) Conf->Affix;
+
+ for (i = 0; i < Conf->naffixes; i++)
+ {
+ if (Affix[i].compile == 0)
+ regfree(&(Affix[i].reg));
+ }
+ for (i = 0; i < Conf->naffixes; i++)
+ free(Conf->Spell[i].word);
+ free(Conf->Affix);
+ free(Conf->Spell);
+ memset((void *) Conf, 0, sizeof(IspellDict));
+ return;
}
#include <sys/types.h>
#include <regex.h>
-typedef struct spell_struct {
- char * word;
- char flag[10];
-} SPELL;
-
-typedef struct aff_struct {
- char flag;
- char type;
- char mask[33];
- char find[16];
- char repl[16];
- regex_t reg;
- size_t replen;
- char compile;
-} AFFIX;
-
-typedef struct Tree_struct {
- int Left[256], Right[256];
-} Tree_struct;
-
-typedef struct {
- int maffixes;
- int naffixes;
- AFFIX * Affix;
-
- int nspell;
- int mspell;
- SPELL *Spell;
- Tree_struct SpellTree;
- Tree_struct PrefixTree;
- Tree_struct SuffixTree;
-
-} IspellDict;
-
-char ** NormalizeWord(IspellDict * Conf,char *word);
-int ImportAffixes(IspellDict * Conf, const char *filename);
-int ImportDictionary(IspellDict * Conf,const char *filename);
-
-int AddSpell(IspellDict * Conf,const char * word,const char *flag);
-int AddAffix(IspellDict * Conf,int flag,const char *mask,const char *find,const char *repl,int type);
-void SortDictionary(IspellDict * Conf);
-void SortAffixes(IspellDict * Conf);
-void FreeIspell (IspellDict *Conf);
+typedef struct spell_struct
+{
+ char *word;
+ char flag[10];
+} SPELL;
+
+typedef struct aff_struct
+{
+ char flag;
+ char type;
+ char mask[33];
+ char find[16];
+ char repl[16];
+ regex_t reg;
+ size_t replen;
+ char compile;
+} AFFIX;
+
+typedef struct Tree_struct
+{
+ int Left[256],
+ Right[256];
+} Tree_struct;
+
+typedef struct
+{
+ int maffixes;
+ int naffixes;
+ AFFIX *Affix;
+
+ int nspell;
+ int mspell;
+ SPELL *Spell;
+ Tree_struct SpellTree;
+ Tree_struct PrefixTree;
+ Tree_struct SuffixTree;
+
+} IspellDict;
+
+char **NormalizeWord(IspellDict * Conf, char *word);
+int ImportAffixes(IspellDict * Conf, const char *filename);
+int ImportDictionary(IspellDict * Conf, const char *filename);
+
+int AddSpell(IspellDict * Conf, const char *word, const char *flag);
+int AddAffix(IspellDict * Conf, int flag, const char *mask, const char *find, const char *repl, int type);
+void SortDictionary(IspellDict * Conf);
+void SortAffixes(IspellDict * Conf);
+void FreeIspell(IspellDict * Conf);
#endif
-/*
- * Simple config parser
+/*
+ * Simple config parser
* Teodor Sigaev <teodor@sigaev.ru>
*/
#include <stdlib.h>
#define CS_WAITEQ 2
#define CS_WAITVALUE 3
#define CS_INVALUE 4
-#define CS_IN2VALUE 5
+#define CS_IN2VALUE 5
#define CS_WAITDELIM 6
#define CS_INESC 7
#define CS_IN2ESC 8
static char *
-nstrdup(char *ptr, int len) {
- char *res=palloc(len+1), *cptr;
- memcpy(res,ptr,len);
- res[len]='\0';
+nstrdup(char *ptr, int len)
+{
+ char *res = palloc(len + 1),
+ *cptr;
+
+ memcpy(res, ptr, len);
+ res[len] = '\0';
cptr = ptr = res;
- while(*ptr) {
- if ( *ptr == '\\' )
+ while (*ptr)
+ {
+ if (*ptr == '\\')
ptr++;
- *cptr=*ptr; ptr++; cptr++;
+ *cptr = *ptr;
+ ptr++;
+ cptr++;
}
- *cptr='\0';
+ *cptr = '\0';
return res;
}
void
-parse_cfgdict(text *in, Map **m) {
- Map *mptr;
- char *ptr=VARDATA(in), *begin=NULL;
- char num=0;
- int state=CS_WAITKEY;
+parse_cfgdict(text *in, Map ** m)
+{
+ Map *mptr;
+ char *ptr = VARDATA(in),
+ *begin = NULL;
+ char num = 0;
+ int state = CS_WAITKEY;
- while( ptr-VARDATA(in) < VARSIZE(in) - VARHDRSZ ) {
- if ( *ptr==',' ) num++;
+ while (ptr - VARDATA(in) < VARSIZE(in) - VARHDRSZ)
+ {
+ if (*ptr == ',')
+ num++;
ptr++;
}
- *m=mptr=(Map*)palloc( sizeof(Map)*(num+2) );
- memset(mptr, 0, sizeof(Map)*(num+2) );
- ptr=VARDATA(in);
- while( ptr-VARDATA(in) < VARSIZE(in) - VARHDRSZ ) {
- if (state==CS_WAITKEY) {
- if (isalpha(*ptr)) {
- begin=ptr;
- state=CS_INKEY;
- } else if ( !isspace(*ptr) )
+ *m = mptr = (Map *) palloc(sizeof(Map) * (num + 2));
+ memset(mptr, 0, sizeof(Map) * (num + 2));
+ ptr = VARDATA(in);
+ while (ptr - VARDATA(in) < VARSIZE(in) - VARHDRSZ)
+ {
+ if (state == CS_WAITKEY)
+ {
+ if (isalpha(*ptr))
+ {
+ begin = ptr;
+ state = CS_INKEY;
+ }
+ else if (!isspace(*ptr))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("syntax error"),
- errdetail("Syntax error in position %d near \"%c\"",
- (int) (ptr-VARDATA(in)), *ptr)));
- } else if (state==CS_INKEY) {
- if ( isspace(*ptr) ) {
- mptr->key=nstrdup(begin, ptr-begin);
- state=CS_WAITEQ;
- } else if ( *ptr=='=' ) {
- mptr->key=nstrdup(begin, ptr-begin);
- state=CS_WAITVALUE;
- } else if ( !isalpha(*ptr) )
+ errdetail("Syntax error in position %d near \"%c\"",
+ (int) (ptr - VARDATA(in)), *ptr)));
+ }
+ else if (state == CS_INKEY)
+ {
+ if (isspace(*ptr))
+ {
+ mptr->key = nstrdup(begin, ptr - begin);
+ state = CS_WAITEQ;
+ }
+ else if (*ptr == '=')
+ {
+ mptr->key = nstrdup(begin, ptr - begin);
+ state = CS_WAITVALUE;
+ }
+ else if (!isalpha(*ptr))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("syntax error"),
- errdetail("Syntax error in position %d near \"%c\"",
- (int) (ptr-VARDATA(in)), *ptr)));
- } else if ( state==CS_WAITEQ ) {
- if ( *ptr=='=' )
- state=CS_WAITVALUE;
- else if ( !isspace(*ptr) )
+ errdetail("Syntax error in position %d near \"%c\"",
+ (int) (ptr - VARDATA(in)), *ptr)));
+ }
+ else if (state == CS_WAITEQ)
+ {
+ if (*ptr == '=')
+ state = CS_WAITVALUE;
+ else if (!isspace(*ptr))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("syntax error"),
- errdetail("Syntax error in position %d near \"%c\"",
- (int) (ptr-VARDATA(in)), *ptr)));
- } else if ( state==CS_WAITVALUE ) {
- if ( *ptr=='"' ) {
- begin=ptr+1;
- state=CS_INVALUE;
- } else if ( !isspace(*ptr) ) {
- begin=ptr;
- state=CS_IN2VALUE;
+ errdetail("Syntax error in position %d near \"%c\"",
+ (int) (ptr - VARDATA(in)), *ptr)));
+ }
+ else if (state == CS_WAITVALUE)
+ {
+ if (*ptr == '"')
+ {
+ begin = ptr + 1;
+ state = CS_INVALUE;
+ }
+ else if (!isspace(*ptr))
+ {
+ begin = ptr;
+ state = CS_IN2VALUE;
}
- } else if ( state==CS_INVALUE ) {
- if ( *ptr=='"' ) {
- mptr->value = nstrdup(begin, ptr-begin);
+ }
+ else if (state == CS_INVALUE)
+ {
+ if (*ptr == '"')
+ {
+ mptr->value = nstrdup(begin, ptr - begin);
mptr++;
- state=CS_WAITDELIM;
- } else if ( *ptr=='\\' )
- state=CS_INESC;
- } else if ( state==CS_IN2VALUE ) {
- if ( isspace(*ptr) || *ptr==',' ) {
- mptr->value = nstrdup(begin, ptr-begin);
+ state = CS_WAITDELIM;
+ }
+ else if (*ptr == '\\')
+ state = CS_INESC;
+ }
+ else if (state == CS_IN2VALUE)
+ {
+ if (isspace(*ptr) || *ptr == ',')
+ {
+ mptr->value = nstrdup(begin, ptr - begin);
mptr++;
- state=( *ptr==',' ) ? CS_WAITKEY : CS_WAITDELIM;
- } else if ( *ptr=='\\' )
- state=CS_INESC;
- } else if ( state==CS_WAITDELIM ) {
- if ( *ptr==',' )
- state=CS_WAITKEY;
- else if ( !isspace(*ptr) )
+ state = (*ptr == ',') ? CS_WAITKEY : CS_WAITDELIM;
+ }
+ else if (*ptr == '\\')
+ state = CS_INESC;
+ }
+ else if (state == CS_WAITDELIM)
+ {
+ if (*ptr == ',')
+ state = CS_WAITKEY;
+ else if (!isspace(*ptr))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("syntax error"),
- errdetail("Syntax error in position %d near \"%c\"",
- (int) (ptr-VARDATA(in)), *ptr)));
- } else if ( state == CS_INESC ) {
- state=CS_INVALUE;
- } else if ( state == CS_IN2ESC ) {
- state=CS_IN2VALUE;
- } else
+ errdetail("Syntax error in position %d near \"%c\"",
+ (int) (ptr - VARDATA(in)), *ptr)));
+ }
+ else if (state == CS_INESC)
+ state = CS_INVALUE;
+ else if (state == CS_IN2ESC)
+ state = CS_IN2VALUE;
+ else
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("bad parser state"),
errdetail("%d at position %d near \"%c\"",
- state, (int) (ptr-VARDATA(in)), *ptr)));
+ state, (int) (ptr - VARDATA(in)), *ptr)));
ptr++;
}
- if (state==CS_IN2VALUE) {
- mptr->value = nstrdup(begin, ptr-begin);
+ if (state == CS_IN2VALUE)
+ {
+ mptr->value = nstrdup(begin, ptr - begin);
mptr++;
- } else if ( !(state==CS_WAITDELIM || state==CS_WAITKEY) )
+ }
+ else if (!(state == CS_WAITDELIM || state == CS_WAITKEY))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("unexpected end of line")));
}
-
-
TI_IN_STATE valstate;
/* tscfg */
- int cfg_id;
+ int cfg_id;
} QPRS_STATE;
-static char*
-get_weight(char *buf, int2 *weight) {
+static char *
+get_weight(char *buf, int2 *weight)
+{
*weight = 0;
- if ( *buf != ':' )
+ if (*buf != ':')
return buf;
buf++;
- while( *buf ) {
- switch(tolower(*buf)) {
- case 'a': *weight |= 1<<3; break;
- case 'b': *weight |= 1<<2; break;
- case 'c': *weight |= 1<<1; break;
- case 'd': *weight |= 1; break;
- default: return buf;
+ while (*buf)
+ {
+ switch (tolower(*buf))
+ {
+ case 'a':
+ *weight |= 1 << 3;
+ break;
+ case 'b':
+ *weight |= 1 << 2;
+ break;
+ case 'c':
+ *weight |= 1 << 1;
+ break;
+ case 'd':
+ *weight |= 1;
+ break;
+ default:
+ return buf;
}
buf++;
}
-
+
return buf;
}
state->count++;
(state->buf)++;
return OPEN;
- } else if ( *(state->buf) == ':' ) {
+ }
+ else if (*(state->buf) == ':')
+ {
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("error at start of operand")));
- } else if (*(state->buf) != ' ') {
+ }
+ else if (*(state->buf) != ' ')
+ {
state->valstate.prsbuf = state->buf;
state->state = WAITOPERATOR;
if (gettoken_tsvector(&(state->valstate)))
pushval_morph(QPRS_STATE * state, int typeval, char *strval, int lenval, int2 weight)
{
int4 count = 0;
- PRSTEXT prs;
+ PRSTEXT prs;
prs.lenwords = 32;
prs.curwords = 0;
parsetext_v2(findcfg(state->cfg_id), &prs, strval, lenval);
- for(count=0;count<prs.curwords;count++) {
+ for (count = 0; count < prs.curwords; count++)
+ {
pushval_asis(state, VAL, prs.words[count].word, prs.words[count].len, weight);
- pfree( prs.words[count].word );
+ pfree(prs.words[count].word);
if (count)
- pushquery(state, OPR, (int4) '&', 0, 0, 0 );
- }
+ pushquery(state, OPR, (int4) '&', 0, 0, 0);
+ }
pfree(prs.words);
/* XXX */
- if ( prs.curwords==0 )
+ if (prs.curwords == 0)
pushval_asis(state, VALTRUE, 0, 0, 0);
}
* check weight info
*/
static bool
-checkclass_str(CHKVAL * chkval, WordEntry * val, ITEM * item) {
- WordEntryPos *ptr = (WordEntryPos*) (chkval->values+val->pos+SHORTALIGN(val->len)+sizeof(uint16));
- uint16 len = *( (uint16*) (chkval->values+val->pos+SHORTALIGN(val->len)) );
- while (len--) {
- if ( item->weight & ( 1<<ptr->weight ) )
+checkclass_str(CHKVAL * chkval, WordEntry * val, ITEM * item)
+{
+ WordEntryPos *ptr = (WordEntryPos *) (chkval->values + val->pos + SHORTALIGN(val->len) + sizeof(uint16));
+ uint16 len = *((uint16 *) (chkval->values + val->pos + SHORTALIGN(val->len)));
+
+ while (len--)
+ {
+ if (item->weight & (1 << ptr->weight))
return true;
ptr++;
}
- return false;
+ return false;
}
/*
StopMiddle = StopLow + (StopHigh - StopLow) / 2;
difference = ValCompare((CHKVAL *) checkval, StopMiddle, val);
if (difference == 0)
- return ( val->weight && StopMiddle->haspos ) ?
- checkclass_str((CHKVAL *) checkval,StopMiddle, val) : true;
+ return (val->weight && StopMiddle->haspos) ?
+ checkclass_str((CHKVAL *) checkval, StopMiddle, val) : true;
else if (difference < 0)
StopLow = StopMiddle + 1;
else
Datum
exectsq(PG_FUNCTION_ARGS)
{
- tsvector *val = (tsvector *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));
+ tsvector *val = (tsvector *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));
QUERYTYPE *query = (QUERYTYPE *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(1)));
CHKVAL chkval;
bool result;
chkval.values = STRPTR(val);
chkval.operand = GETOPERAND(query);
result = TS_execute(
- GETQUERY(query),
- &chkval,
- true,
- checkcondition_str
+ GETQUERY(query),
+ &chkval,
+ true,
+ checkcondition_str
);
PG_FREE_IF_COPY(val, 0);
* input
*/
static QUERYTYPE *
-queryin(char *buf, void (*pushval) (QPRS_STATE *, int, char *, int, int2), int cfg_id)
+ queryin(char *buf, void (*pushval) (QPRS_STATE *, int, char *, int, int2), int cfg_id)
{
QPRS_STATE state;
int4 i;
state.count = 0;
state.num = 0;
state.str = NULL;
- state.cfg_id=cfg_id;
+ state.cfg_id = cfg_id;
/* init value parser's state */
state.valstate.oprisdelim = true;
}
*(in->cur) = '\'';
in->cur++;
- if ( in->curpol->weight ) {
- *(in->cur) = ':'; in->cur++;
- if ( in->curpol->weight & (1<<3) ) { *(in->cur) = 'A'; in->cur++; }
- if ( in->curpol->weight & (1<<2) ) { *(in->cur) = 'B'; in->cur++; }
- if ( in->curpol->weight & (1<<1) ) { *(in->cur) = 'C'; in->cur++; }
- if ( in->curpol->weight & 1 ) { *(in->cur) = 'D'; in->cur++; }
+ if (in->curpol->weight)
+ {
+ *(in->cur) = ':';
+ in->cur++;
+ if (in->curpol->weight & (1 << 3))
+ {
+ *(in->cur) = 'A';
+ in->cur++;
+ }
+ if (in->curpol->weight & (1 << 2))
+ {
+ *(in->cur) = 'B';
+ in->cur++;
+ }
+ if (in->curpol->weight & (1 << 1))
+ {
+ *(in->cur) = 'C';
+ in->cur++;
+ }
+ if (in->curpol->weight & 1)
+ {
+ *(in->cur) = 'D';
+ in->cur++;
+ }
}
*(in->cur) = '\0';
in->curpol++;
}
Datum
-to_tsquery(PG_FUNCTION_ARGS) {
- text *in = PG_GETARG_TEXT_P(1);
- char *str;
+to_tsquery(PG_FUNCTION_ARGS)
+{
+ text *in = PG_GETARG_TEXT_P(1);
+ char *str;
QUERYTYPE *query;
ITEM *res;
int4 len;
- str=text2char(in);
- PG_FREE_IF_COPY(in,1);
+ str = text2char(in);
+ PG_FREE_IF_COPY(in, 1);
query = queryin(str, pushval_morph, PG_GETARG_INT32(0));
res = clean_fakeval_v2(GETQUERY(query), &len);
}
Datum
-to_tsquery_name(PG_FUNCTION_ARGS) {
- text *name=PG_GETARG_TEXT_P(0);
- Datum res= DirectFunctionCall2(
- to_tsquery,
- Int32GetDatum( name2id_cfg(name) ),
- PG_GETARG_DATUM(1)
+to_tsquery_name(PG_FUNCTION_ARGS)
+{
+ text *name = PG_GETARG_TEXT_P(0);
+ Datum res = DirectFunctionCall2(
+ to_tsquery,
+ Int32GetDatum(name2id_cfg(name)),
+ PG_GETARG_DATUM(1)
);
-
- PG_FREE_IF_COPY(name,1);
+
+ PG_FREE_IF_COPY(name, 1);
PG_RETURN_DATUM(res);
}
Datum
-to_tsquery_current(PG_FUNCTION_ARGS) {
- PG_RETURN_DATUM( DirectFunctionCall2(
- to_tsquery,
- Int32GetDatum( get_currcfg() ),
- PG_GETARG_DATUM(0)
- ));
+to_tsquery_current(PG_FUNCTION_ARGS)
+{
+ PG_RETURN_DATUM(DirectFunctionCall2(
+ to_tsquery,
+ Int32GetDatum(get_currcfg()),
+ PG_GETARG_DATUM(0)
+ ));
}
-
-
int2 left;
int4 val;
/* user-friendly value, must correlate with WordEntry */
- uint32
- unused:1,
- length:11,
- distance:20;
+ uint32
+ unused:1,
+ length:11,
+ distance:20;
} ITEM;
/*
#define VALFALSE 7
bool TS_execute(ITEM * curitem, void *checkval,
- bool calcnot, bool (*chkcond) (void *checkval, ITEM * val));
+ bool calcnot, bool (*chkcond) (void *checkval, ITEM * val));
#endif
PG_FUNCTION_INFO_V1(get_covers);
Datum get_covers(PG_FUNCTION_ARGS);
-static float weights[]={0.1, 0.2, 0.4, 1.0};
+static float weights[] = {0.1, 0.2, 0.4, 1.0};
#define wpos(wep) ( w[ ((WordEntryPos*)(wep))->weight ] )
-#define DEF_NORM_METHOD 0
+#define DEF_NORM_METHOD 0
/*
* Returns a weight of a word collocation
*/
-static float4 word_distance ( int4 w ) {
- if ( w>100 )
- return 1e-30;
+static float4
+word_distance(int4 w)
+{
+ if (w > 100)
+ return 1e-30;
- return 1.0/(1.005+0.05*exp( ((float4)w)/1.5-2) );
+ return 1.0 / (1.005 + 0.05 * exp(((float4) w) / 1.5 - 2));
}
static int
-cnt_length( tsvector *t ) {
- WordEntry *ptr=ARRPTR(t), *end=(WordEntry*)STRPTR(t);
- int len = 0, clen;
-
- while(ptr < end) {
- if ( (clen=POSDATALEN(t, ptr)) == 0 )
+cnt_length(tsvector * t)
+{
+ WordEntry *ptr = ARRPTR(t),
+ *end = (WordEntry *) STRPTR(t);
+ int len = 0,
+ clen;
+
+ while (ptr < end)
+ {
+ if ((clen = POSDATALEN(t, ptr)) == 0)
len += 1;
else
len += clen;
}
static int4
-WordECompareITEM(char *eval, char *qval, WordEntry * ptr, ITEM * item) {
- if (ptr->len == item->length)
- return strncmp(
- eval + ptr->pos,
- qval + item->distance,
- item->length);
-
- return (ptr->len > item->length) ? 1 : -1;
+WordECompareITEM(char *eval, char *qval, WordEntry * ptr, ITEM * item)
+{
+ if (ptr->len == item->length)
+ return strncmp(
+ eval + ptr->pos,
+ qval + item->distance,
+ item->length);
+
+ return (ptr->len > item->length) ? 1 : -1;
}
-static WordEntry*
-find_wordentry(tsvector *t, QUERYTYPE *q, ITEM *item) {
- WordEntry *StopLow = ARRPTR(t);
- WordEntry *StopHigh = (WordEntry*)STRPTR(t);
- WordEntry *StopMiddle;
- int difference;
-
- /* Loop invariant: StopLow <= item < StopHigh */
-
- while (StopLow < StopHigh)
- {
- StopMiddle = StopLow + (StopHigh - StopLow) / 2;
- difference = WordECompareITEM(STRPTR(t), GETOPERAND(q), StopMiddle, item);
- if (difference == 0)
- return StopMiddle;
- else if (difference < 0)
- StopLow = StopMiddle + 1;
- else
- StopHigh = StopMiddle;
- }
-
- return NULL;
+static WordEntry *
+find_wordentry(tsvector * t, QUERYTYPE * q, ITEM * item)
+{
+ WordEntry *StopLow = ARRPTR(t);
+ WordEntry *StopHigh = (WordEntry *) STRPTR(t);
+ WordEntry *StopMiddle;
+ int difference;
+
+ /* Loop invariant: StopLow <= item < StopHigh */
+
+ while (StopLow < StopHigh)
+ {
+ StopMiddle = StopLow + (StopHigh - StopLow) / 2;
+ difference = WordECompareITEM(STRPTR(t), GETOPERAND(q), StopMiddle, item);
+ if (difference == 0)
+ return StopMiddle;
+ else if (difference < 0)
+ StopLow = StopMiddle + 1;
+ else
+ StopHigh = StopMiddle;
+ }
+
+ return NULL;
}
-static WordEntryPos POSNULL[]={
- {0,0},
- {0,MAXENTRYPOS-1}
+static WordEntryPos POSNULL[] = {
+ {0, 0},
+ {0, MAXENTRYPOS - 1}
};
static float
-calc_rank_and(float *w, tsvector *t, QUERYTYPE *q) {
- uint16 **pos=(uint16**)palloc(sizeof(uint16*) * q->size);
- int i,k,l,p;
- WordEntry *entry;
- WordEntryPos *post,*ct;
- int4 dimt,lenct,dist;
- float res=-1.0;
- ITEM *item=GETQUERY(q);
-
- memset(pos,0,sizeof(uint16**) * q->size);
- *(uint16*)POSNULL = lengthof(POSNULL)-1;
-
- for(i=0; i<q->size; i++) {
-
- if ( item[i].type != VAL )
+calc_rank_and(float *w, tsvector * t, QUERYTYPE * q)
+{
+ uint16 **pos = (uint16 **) palloc(sizeof(uint16 *) * q->size);
+ int i,
+ k,
+ l,
+ p;
+ WordEntry *entry;
+ WordEntryPos *post,
+ *ct;
+ int4 dimt,
+ lenct,
+ dist;
+ float res = -1.0;
+ ITEM *item = GETQUERY(q);
+
+ memset(pos, 0, sizeof(uint16 **) * q->size);
+ *(uint16 *) POSNULL = lengthof(POSNULL) - 1;
+
+ for (i = 0; i < q->size; i++)
+ {
+
+ if (item[i].type != VAL)
continue;
- entry=find_wordentry(t,q,&(item[i]));
- if ( !entry )
+ entry = find_wordentry(t, q, &(item[i]));
+ if (!entry)
continue;
- if ( entry->haspos )
- pos[i] = (uint16*)_POSDATAPTR(t,entry);
+ if (entry->haspos)
+ pos[i] = (uint16 *) _POSDATAPTR(t, entry);
else
- pos[i] = (uint16*)POSNULL;
-
-
- dimt = *(uint16*)(pos[i]);
- post = (WordEntryPos*)(pos[i]+1);
- for( k=0; k<i; k++ ) {
- if ( !pos[k] ) continue;
- lenct = *(uint16*)(pos[k]);
- ct = (WordEntryPos*)(pos[k]+1);
- for(l=0; l<dimt; l++) {
- for(p=0; p<lenct; p++) {
- dist = abs( post[l].pos - ct[p].pos );
- if ( dist || (dist==0 && (pos[i]==(uint16*)POSNULL || pos[k]==(uint16*)POSNULL) ) ) {
- float curw;
- if ( !dist ) dist=MAXENTRYPOS;
- curw= sqrt( wpos(&(post[l])) * wpos( &(ct[p]) ) * word_distance(dist) );
- res = ( res < 0 ) ? curw : 1.0 - ( 1.0 - res ) * ( 1.0 - curw );
+ pos[i] = (uint16 *) POSNULL;
+
+
+ dimt = *(uint16 *) (pos[i]);
+ post = (WordEntryPos *) (pos[i] + 1);
+ for (k = 0; k < i; k++)
+ {
+ if (!pos[k])
+ continue;
+ lenct = *(uint16 *) (pos[k]);
+ ct = (WordEntryPos *) (pos[k] + 1);
+ for (l = 0; l < dimt; l++)
+ {
+ for (p = 0; p < lenct; p++)
+ {
+ dist = abs(post[l].pos - ct[p].pos);
+ if (dist || (dist == 0 && (pos[i] == (uint16 *) POSNULL || pos[k] == (uint16 *) POSNULL)))
+ {
+ float curw;
+
+ if (!dist)
+ dist = MAXENTRYPOS;
+ curw = sqrt(wpos(&(post[l])) * wpos(&(ct[p])) * word_distance(dist));
+ res = (res < 0) ? curw : 1.0 - (1.0 - res) * (1.0 - curw);
}
}
}
}
}
pfree(pos);
- return res;
+ return res;
}
static float
-calc_rank_or(float *w, tsvector *t, QUERYTYPE *q) {
- WordEntry *entry;
- WordEntryPos *post;
- int4 dimt,j,i;
- float res=-1.0;
- ITEM *item=GETQUERY(q);
-
- *(uint16*)POSNULL = lengthof(POSNULL)-1;
-
- for(i=0; i<q->size; i++) {
- if ( item[i].type != VAL )
+calc_rank_or(float *w, tsvector * t, QUERYTYPE * q)
+{
+ WordEntry *entry;
+ WordEntryPos *post;
+ int4 dimt,
+ j,
+ i;
+ float res = -1.0;
+ ITEM *item = GETQUERY(q);
+
+ *(uint16 *) POSNULL = lengthof(POSNULL) - 1;
+
+ for (i = 0; i < q->size; i++)
+ {
+ if (item[i].type != VAL)
continue;
- entry=find_wordentry(t,q,&(item[i]));
- if ( !entry )
+ entry = find_wordentry(t, q, &(item[i]));
+ if (!entry)
continue;
- if ( entry->haspos ) {
- dimt = POSDATALEN(t,entry);
- post = POSDATAPTR(t,entry);
- } else {
- dimt = *(uint16*)POSNULL;
- post = POSNULL+1;
+ if (entry->haspos)
+ {
+ dimt = POSDATALEN(t, entry);
+ post = POSDATAPTR(t, entry);
+ }
+ else
+ {
+ dimt = *(uint16 *) POSNULL;
+ post = POSNULL + 1;
}
- for(j=0;j<dimt;j++) {
- if ( res < 0 )
- res = wpos( &(post[j]) );
+ for (j = 0; j < dimt; j++)
+ {
+ if (res < 0)
+ res = wpos(&(post[j]));
else
- res = 1.0 - ( 1.0-res ) * ( 1.0-wpos( &(post[j]) ) );
+ res = 1.0 - (1.0 - res) * (1.0 - wpos(&(post[j])));
}
}
return res;
}
static float
-calc_rank(float *w, tsvector *t, QUERYTYPE *q, int4 method) {
- ITEM *item = GETQUERY(q);
- float res=0.0;
+calc_rank(float *w, tsvector * t, QUERYTYPE * q, int4 method)
+{
+ ITEM *item = GETQUERY(q);
+ float res = 0.0;
if (!t->size || !q->size)
return 0.0;
- res = ( item->type != VAL && item->val == (int4) '&' ) ?
- calc_rank_and(w,t,q) : calc_rank_or(w,t,q);
+ res = (item->type != VAL && item->val == (int4) '&') ?
+ calc_rank_and(w, t, q) : calc_rank_or(w, t, q);
- if ( res < 0 )
+ if (res < 0)
res = 1e-20;
- switch(method) {
- case 0: break;
- case 1: res /= log((float)cnt_length(t)); break;
- case 2: res /= (float)cnt_length(t); break;
+ switch (method)
+ {
+ case 0:
+ break;
+ case 1:
+ res /= log((float) cnt_length(t));
+ break;
+ case 2:
+ res /= (float) cnt_length(t);
+ break;
default:
- /* internal error */
- elog(ERROR,"unrecognized normalization method: %d", method);
- }
+ /* internal error */
+ elog(ERROR, "unrecognized normalization method: %d", method);
+ }
return res;
}
Datum
-rank(PG_FUNCTION_ARGS) {
+rank(PG_FUNCTION_ARGS)
+{
ArrayType *win = (ArrayType *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
- tsvector *txt = (tsvector *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
+ tsvector *txt = (tsvector *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
QUERYTYPE *query = (QUERYTYPE *) PG_DETOAST_DATUM(PG_GETARG_DATUM(2));
- int method=DEF_NORM_METHOD;
- float res=0.0;
- float ws[ lengthof(weights) ];
- int i;
+ int method = DEF_NORM_METHOD;
+ float res = 0.0;
+ float ws[lengthof(weights)];
+ int i;
- if ( ARR_NDIM(win) != 1 )
+ if (ARR_NDIM(win) != 1)
ereport(ERROR,
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
errmsg("array of weight must be one-dimensional")));
- if ( ARRNELEMS(win) < lengthof(weights) )
+ if (ARRNELEMS(win) < lengthof(weights))
ereport(ERROR,
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
errmsg("array of weight is too short")));
- for(i=0;i<lengthof(weights);i++) {
- ws[ i ] = ( ((float4*)ARR_DATA_PTR(win))[i] >= 0 ) ? ((float4*)ARR_DATA_PTR(win))[i] : weights[i];
- if ( ws[ i ] > 1.0 )
+ for (i = 0; i < lengthof(weights); i++)
+ {
+ ws[i] = (((float4 *) ARR_DATA_PTR(win))[i] >= 0) ? ((float4 *) ARR_DATA_PTR(win))[i] : weights[i];
+ if (ws[i] > 1.0)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("weight out of range")));
- }
+ }
+
+ if (PG_NARGS() == 4)
+ method = PG_GETARG_INT32(3);
- if ( PG_NARGS() == 4 )
- method=PG_GETARG_INT32(3);
+ res = calc_rank(ws, txt, query, method);
- res=calc_rank(ws, txt, query, method);
-
PG_FREE_IF_COPY(win, 0);
PG_FREE_IF_COPY(txt, 1);
PG_FREE_IF_COPY(query, 2);
}
Datum
-rank_def(PG_FUNCTION_ARGS) {
- tsvector *txt = (tsvector *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
+rank_def(PG_FUNCTION_ARGS)
+{
+ tsvector *txt = (tsvector *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
QUERYTYPE *query = (QUERYTYPE *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
- float res=0.0;
- int method=DEF_NORM_METHOD;
+ float res = 0.0;
+ int method = DEF_NORM_METHOD;
- if ( PG_NARGS() == 3 )
- method=PG_GETARG_INT32(2);
+ if (PG_NARGS() == 3)
+ method = PG_GETARG_INT32(2);
+
+ res = calc_rank(weights, txt, query, method);
- res=calc_rank(weights, txt, query, method);
-
PG_FREE_IF_COPY(txt, 0);
PG_FREE_IF_COPY(query, 1);
PG_RETURN_FLOAT4(res);
}
-typedef struct {
- ITEM *item;
- int32 pos;
-} DocRepresentation;
+typedef struct
+{
+ ITEM *item;
+ int32 pos;
+} DocRepresentation;
static int
-compareDocR(const void *a, const void *b) {
- if ( ((DocRepresentation *) a)->pos == ((DocRepresentation *) b)->pos )
+compareDocR(const void *a, const void *b)
+{
+ if (((DocRepresentation *) a)->pos == ((DocRepresentation *) b)->pos)
return 1;
- return ( ((DocRepresentation *) a)->pos > ((DocRepresentation *) b)->pos ) ? 1 : -1;
+ return (((DocRepresentation *) a)->pos > ((DocRepresentation *) b)->pos) ? 1 : -1;
}
-typedef struct {
+typedef struct
+{
DocRepresentation *doc;
- int len;
+ int len;
} ChkDocR;
static bool
-checkcondition_DR(void *checkval, ITEM *val) {
- DocRepresentation *ptr = ((ChkDocR*)checkval)->doc;
+checkcondition_DR(void *checkval, ITEM * val)
+{
+ DocRepresentation *ptr = ((ChkDocR *) checkval)->doc;
- while( ptr - ((ChkDocR*)checkval)->doc < ((ChkDocR*)checkval)->len ) {
- if ( val == ptr->item )
+ while (ptr - ((ChkDocR *) checkval)->doc < ((ChkDocR *) checkval)->len)
+ {
+ if (val == ptr->item)
return true;
ptr++;
- }
+ }
return false;
}
static bool
-Cover(DocRepresentation *doc, int len, QUERYTYPE *query, int *pos, int *p, int *q) {
- int i;
- DocRepresentation *ptr,*f=(DocRepresentation*)0xffffffff;
- ITEM *item=GETQUERY(query);
- int lastpos=*pos;
- int oldq=*q;
-
- *p=0x7fffffff;
- *q=0;
-
- for(i=0; i<query->size; i++) {
- if ( item->type != VAL ) {
+Cover(DocRepresentation * doc, int len, QUERYTYPE * query, int *pos, int *p, int *q)
+{
+ int i;
+ DocRepresentation *ptr,
+ *f = (DocRepresentation *) 0xffffffff;
+ ITEM *item = GETQUERY(query);
+ int lastpos = *pos;
+ int oldq = *q;
+
+ *p = 0x7fffffff;
+ *q = 0;
+
+ for (i = 0; i < query->size; i++)
+ {
+ if (item->type != VAL)
+ {
item++;
continue;
}
ptr = doc + *pos;
- while(ptr-doc<len) {
- if ( ptr->item == item ) {
- if ( ptr->pos > *q ) {
+ while (ptr - doc < len)
+ {
+ if (ptr->item == item)
+ {
+ if (ptr->pos > *q)
+ {
*q = ptr->pos;
- lastpos= ptr - doc;
- }
+ lastpos = ptr - doc;
+ }
break;
- }
+ }
ptr++;
}
item++;
}
- if (*q==0 )
+ if (*q == 0)
return false;
- if (*q==oldq) { /* already check this pos */
+ if (*q == oldq)
+ { /* already check this pos */
(*pos)++;
- return Cover(doc, len, query, pos,p,q);
- }
+ return Cover(doc, len, query, pos, p, q);
+ }
- item=GETQUERY(query);
- for(i=0; i<query->size; i++) {
- if ( item->type != VAL ) {
+ item = GETQUERY(query);
+ for (i = 0; i < query->size; i++)
+ {
+ if (item->type != VAL)
+ {
item++;
continue;
}
ptr = doc + lastpos;
- while(ptr>=doc+*pos) {
- if ( ptr->item == item ) {
- if ( ptr->pos < *p ) {
+ while (ptr >= doc + *pos)
+ {
+ if (ptr->item == item)
+ {
+ if (ptr->pos < *p)
+ {
*p = ptr->pos;
- f=ptr;
+ f = ptr;
}
break;
}
}
item++;
}
-
- if ( *p<=*q ) {
- ChkDocR ch = { f, (doc + lastpos)-f+1 };
- *pos = f-doc+1;
- if ( TS_execute(GETQUERY(query), &ch, false, checkcondition_DR) ) {
- /*elog(NOTICE,"OP:%d NP:%d P:%d Q:%d", *pos, lastpos, *p, *q);*/
+
+ if (*p <= *q)
+ {
+ ChkDocR ch = {f, (doc + lastpos) - f + 1};
+
+ *pos = f - doc + 1;
+ if (TS_execute(GETQUERY(query), &ch, false, checkcondition_DR))
+ {
+ /*
+ * elog(NOTICE,"OP:%d NP:%d P:%d Q:%d", *pos, lastpos, *p,
+ * *q);
+ */
return true;
- } else
- return Cover(doc, len, query, pos,p,q);
+ }
+ else
+ return Cover(doc, len, query, pos, p, q);
}
-
+
return false;
}
-static DocRepresentation*
-get_docrep(tsvector *txt, QUERYTYPE *query, int *doclen) {
- ITEM *item=GETQUERY(query);
- WordEntry *entry;
- WordEntryPos *post;
- int4 dimt,j,i;
- int len=query->size*4,cur=0;
+static DocRepresentation *
+get_docrep(tsvector * txt, QUERYTYPE * query, int *doclen)
+{
+ ITEM *item = GETQUERY(query);
+ WordEntry *entry;
+ WordEntryPos *post;
+ int4 dimt,
+ j,
+ i;
+ int len = query->size * 4,
+ cur = 0;
DocRepresentation *doc;
- *(uint16*)POSNULL = lengthof(POSNULL)-1;
- doc = (DocRepresentation*)palloc(sizeof(DocRepresentation)*len);
- for(i=0; i<query->size; i++) {
- if ( item[i].type != VAL )
+ *(uint16 *) POSNULL = lengthof(POSNULL) - 1;
+ doc = (DocRepresentation *) palloc(sizeof(DocRepresentation) * len);
+ for (i = 0; i < query->size; i++)
+ {
+ if (item[i].type != VAL)
continue;
- entry=find_wordentry(txt,query,&(item[i]));
- if ( !entry )
+ entry = find_wordentry(txt, query, &(item[i]));
+ if (!entry)
continue;
- if ( entry->haspos ) {
- dimt = POSDATALEN(txt,entry);
- post = POSDATAPTR(txt,entry);
- } else {
- dimt = *(uint16*)POSNULL;
- post = POSNULL+1;
+ if (entry->haspos)
+ {
+ dimt = POSDATALEN(txt, entry);
+ post = POSDATAPTR(txt, entry);
+ }
+ else
+ {
+ dimt = *(uint16 *) POSNULL;
+ post = POSNULL + 1;
}
- while( cur+dimt >= len ) {
- len*=2;
- doc = (DocRepresentation*)repalloc(doc,sizeof(DocRepresentation)*len);
+ while (cur + dimt >= len)
+ {
+ len *= 2;
+ doc = (DocRepresentation *) repalloc(doc, sizeof(DocRepresentation) * len);
}
- for(j=0;j<dimt;j++) {
- doc[cur].item=&(item[i]);
- doc[cur].pos=post[j].pos;
+ for (j = 0; j < dimt; j++)
+ {
+ doc[cur].item = &(item[i]);
+ doc[cur].pos = post[j].pos;
cur++;
}
}
- *doclen=cur;
-
- if ( cur>0 ) {
- if ( cur>1 )
+ *doclen = cur;
+
+ if (cur > 0)
+ {
+ if (cur > 1)
qsort((void *) doc, cur, sizeof(DocRepresentation), compareDocR);
return doc;
}
-
+
pfree(doc);
return NULL;
}
Datum
-rank_cd(PG_FUNCTION_ARGS) {
- int K = PG_GETARG_INT32(0);
- tsvector *txt = (tsvector *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
+rank_cd(PG_FUNCTION_ARGS)
+{
+ int K = PG_GETARG_INT32(0);
+ tsvector *txt = (tsvector *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
QUERYTYPE *query = (QUERYTYPE *) PG_DETOAST_DATUM(PG_GETARG_DATUM(2));
- int method=DEF_NORM_METHOD;
- DocRepresentation *doc;
- float res=0.0;
- int p=0,q=0,len,cur;
+ int method = DEF_NORM_METHOD;
+ DocRepresentation *doc;
+ float res = 0.0;
+ int p = 0,
+ q = 0,
+ len,
+ cur;
doc = get_docrep(txt, query, &len);
- if ( !doc ) {
+ if (!doc)
+ {
PG_FREE_IF_COPY(txt, 1);
PG_FREE_IF_COPY(query, 2);
PG_RETURN_FLOAT4(0.0);
}
- cur=0;
- if (K<=0)
- K=4;
- while( Cover(doc, len, query, &cur, &p, &q) )
- res += ( q-p+1 > K ) ? ((float)K)/((float)(q-p+1)) : 1.0;
-
- if ( PG_NARGS() == 4 )
- method=PG_GETARG_INT32(3);
-
- switch(method) {
- case 0: break;
- case 1: res /= log((float)cnt_length(txt)); break;
- case 2: res /= (float)cnt_length(txt); break;
+ cur = 0;
+ if (K <= 0)
+ K = 4;
+ while (Cover(doc, len, query, &cur, &p, &q))
+ res += (q - p + 1 > K) ? ((float) K) / ((float) (q - p + 1)) : 1.0;
+
+ if (PG_NARGS() == 4)
+ method = PG_GETARG_INT32(3);
+
+ switch (method)
+ {
+ case 0:
+ break;
+ case 1:
+ res /= log((float) cnt_length(txt));
+ break;
+ case 2:
+ res /= (float) cnt_length(txt);
+ break;
default:
- /* internal error */
- elog(ERROR,"unrecognized normalization method: %d", method);
- }
+ /* internal error */
+ elog(ERROR, "unrecognized normalization method: %d", method);
+ }
pfree(doc);
PG_FREE_IF_COPY(txt, 1);
Datum
-rank_cd_def(PG_FUNCTION_ARGS) {
- PG_RETURN_DATUM( DirectFunctionCall4(
- rank_cd,
- Int32GetDatum(-1),
- PG_GETARG_DATUM(0),
- PG_GETARG_DATUM(1),
- ( PG_NARGS() == 3 ) ? PG_GETARG_DATUM(2) : Int32GetDatum(DEF_NORM_METHOD)
- ));
+rank_cd_def(PG_FUNCTION_ARGS)
+{
+ PG_RETURN_DATUM(DirectFunctionCall4(
+ rank_cd,
+ Int32GetDatum(-1),
+ PG_GETARG_DATUM(0),
+ PG_GETARG_DATUM(1),
+ (PG_NARGS() == 3) ? PG_GETARG_DATUM(2) : Int32GetDatum(DEF_NORM_METHOD)
+ ));
}
/**************debug*************/
-typedef struct {
- char *w;
- int2 len;
- int2 pos;
- int2 start;
- int2 finish;
-} DocWord;
+typedef struct
+{
+ char *w;
+ int2 len;
+ int2 pos;
+ int2 start;
+ int2 finish;
+} DocWord;
static int
-compareDocWord(const void *a, const void *b) {
- if ( ((DocWord *) a)->pos == ((DocWord *) b)->pos )
+compareDocWord(const void *a, const void *b)
+{
+ if (((DocWord *) a)->pos == ((DocWord *) b)->pos)
return 1;
- return ( ((DocWord *) a)->pos > ((DocWord *) b)->pos ) ? 1 : -1;
+ return (((DocWord *) a)->pos > ((DocWord *) b)->pos) ? 1 : -1;
}
-Datum
-get_covers(PG_FUNCTION_ARGS) {
- tsvector *txt = (tsvector *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
+Datum
+get_covers(PG_FUNCTION_ARGS)
+{
+ tsvector *txt = (tsvector *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
QUERYTYPE *query = (QUERYTYPE *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
- WordEntry *pptr=ARRPTR(txt);
- int i,dlen=0,j,cur=0,len=0,rlen;
- DocWord *dw,*dwptr;
- text *out;
- char *cptr;
+ WordEntry *pptr = ARRPTR(txt);
+ int i,
+ dlen = 0,
+ j,
+ cur = 0,
+ len = 0,
+ rlen;
+ DocWord *dw,
+ *dwptr;
+ text *out;
+ char *cptr;
DocRepresentation *doc;
- int pos=0,p,q,olddwpos=0;
- int ncover=1;
+ int pos = 0,
+ p,
+ q,
+ olddwpos = 0;
+ int ncover = 1;
doc = get_docrep(txt, query, &rlen);
- if ( !doc ) {
- out=palloc(VARHDRSZ);
+ if (!doc)
+ {
+ out = palloc(VARHDRSZ);
VARATT_SIZEP(out) = VARHDRSZ;
- PG_FREE_IF_COPY(txt,0);
- PG_FREE_IF_COPY(query,1);
+ PG_FREE_IF_COPY(txt, 0);
+ PG_FREE_IF_COPY(query, 1);
PG_RETURN_POINTER(out);
}
- for(i=0;i<txt->size;i++) {
+ for (i = 0; i < txt->size; i++)
+ {
if (!pptr[i].haspos)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("no pos info")));
- dlen += POSDATALEN(txt,&(pptr[i]));
+ dlen += POSDATALEN(txt, &(pptr[i]));
}
- dwptr=dw=palloc(sizeof(DocWord)*dlen);
- memset(dw,0,sizeof(DocWord)*dlen);
+ dwptr = dw = palloc(sizeof(DocWord) * dlen);
+ memset(dw, 0, sizeof(DocWord) * dlen);
+
+ for (i = 0; i < txt->size; i++)
+ {
+ WordEntryPos *posdata = POSDATAPTR(txt, &(pptr[i]));
- for(i=0;i<txt->size;i++) {
- WordEntryPos *posdata = POSDATAPTR(txt,&(pptr[i]));
- for(j=0;j<POSDATALEN(txt,&(pptr[i]));j++) {
- dw[cur].w=STRPTR(txt)+pptr[i].pos;
- dw[cur].len=pptr[i].len;
- dw[cur].pos=posdata[j].pos;
+ for (j = 0; j < POSDATALEN(txt, &(pptr[i])); j++)
+ {
+ dw[cur].w = STRPTR(txt) + pptr[i].pos;
+ dw[cur].len = pptr[i].len;
+ dw[cur].pos = posdata[j].pos;
cur++;
}
- len+=(pptr[i].len + 1) * (int)POSDATALEN(txt,&(pptr[i]));
+ len += (pptr[i].len + 1) * (int) POSDATALEN(txt, &(pptr[i]));
}
qsort((void *) dw, dlen, sizeof(DocWord), compareDocWord);
- while( Cover(doc, rlen, query, &pos, &p, &q) ) {
- dwptr=dw+olddwpos;
- while(dwptr->pos < p && dwptr-dw<dlen)
+ while (Cover(doc, rlen, query, &pos, &p, &q))
+ {
+ dwptr = dw + olddwpos;
+ while (dwptr->pos < p && dwptr - dw < dlen)
dwptr++;
- olddwpos=dwptr-dw;
- dwptr->start=ncover;
- while(dwptr->pos < q+1 && dwptr-dw<dlen)
+ olddwpos = dwptr - dw;
+ dwptr->start = ncover;
+ while (dwptr->pos < q + 1 && dwptr - dw < dlen)
dwptr++;
- (dwptr-1)->finish=ncover;
- len+= 4 /* {}+two spaces */ + 2*16 /*numbers*/;
- ncover++;
- }
-
- out=palloc(VARHDRSZ+len);
- cptr=((char*)out)+VARHDRSZ;
- dwptr=dw;
-
- while( dwptr-dw < dlen) {
- if ( dwptr->start ) {
- sprintf(cptr,"{%d ",dwptr->start);
- cptr=strchr(cptr,'\0');
+ (dwptr - 1)->finish = ncover;
+ len += 4 /* {}+two spaces */ + 2 * 16 /* numbers */ ;
+ ncover++;
+ }
+
+ out = palloc(VARHDRSZ + len);
+ cptr = ((char *) out) + VARHDRSZ;
+ dwptr = dw;
+
+ while (dwptr - dw < dlen)
+ {
+ if (dwptr->start)
+ {
+ sprintf(cptr, "{%d ", dwptr->start);
+ cptr = strchr(cptr, '\0');
}
- memcpy(cptr,dwptr->w,dwptr->len);
- cptr+=dwptr->len;
- *cptr=' ';
+ memcpy(cptr, dwptr->w, dwptr->len);
+ cptr += dwptr->len;
+ *cptr = ' ';
cptr++;
- if ( dwptr->finish ) {
- sprintf(cptr,"}%d ",dwptr->finish);
- cptr=strchr(cptr,'\0');
+ if (dwptr->finish)
+ {
+ sprintf(cptr, "}%d ", dwptr->finish);
+ cptr = strchr(cptr, '\0');
}
dwptr++;
- }
+ }
+
+ VARATT_SIZEP(out) = cptr - ((char *) out);
- VARATT_SIZEP(out) = cptr - ((char*)out);
-
pfree(dw);
pfree(doc);
- PG_FREE_IF_COPY(txt,0);
- PG_FREE_IF_COPY(query,1);
+ PG_FREE_IF_COPY(txt, 0);
+ PG_FREE_IF_COPY(query, 1);
PG_RETURN_POINTER(out);
}
-
-/*
+/*
* simple but fast map from str to Oid
* Teodor Sigaev <teodor@sigaev.ru>
*/
#include "common.h"
static int
-compareSNMapEntry(const void *a, const void *b) {
- return strcmp( ((SNMapEntry*)a)->key, ((SNMapEntry*)b)->key );
+compareSNMapEntry(const void *a, const void *b)
+{
+ return strcmp(((SNMapEntry *) a)->key, ((SNMapEntry *) b)->key);
}
-void
-addSNMap( SNMap *map, char *key, Oid value ) {
- if (map->len>=map->reallen) {
+void
+addSNMap(SNMap * map, char *key, Oid value)
+{
+ if (map->len >= map->reallen)
+ {
SNMapEntry *tmp;
- int len = (map->reallen) ? 2*map->reallen : 16;
- tmp=(SNMapEntry*)realloc(map->list, sizeof(SNMapEntry) * len);
- if ( !tmp )
+ int len = (map->reallen) ? 2 * map->reallen : 16;
+
+ tmp = (SNMapEntry *) realloc(map->list, sizeof(SNMapEntry) * len);
+ if (!tmp)
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory")));
- map->reallen=len;
- map->list=tmp;
+ map->reallen = len;
+ map->list = tmp;
}
- map->list[ map->len ].key = strdup(key);
- if ( ! map->list[ map->len ].key )
+ map->list[map->len].key = strdup(key);
+ if (!map->list[map->len].key)
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory")));
- map->list[ map->len ].value=value;
+ map->list[map->len].value = value;
map->len++;
- if ( map->len>1 ) qsort(map->list, map->len, sizeof(SNMapEntry), compareSNMapEntry);
+ if (map->len > 1)
+ qsort(map->list, map->len, sizeof(SNMapEntry), compareSNMapEntry);
}
-void
-addSNMap_t( SNMap *map, text *key, Oid value ) {
- char *k=text2char( key );
+void
+addSNMap_t(SNMap * map, text *key, Oid value)
+{
+ char *k = text2char(key);
+
addSNMap(map, k, value);
pfree(k);
}
-Oid
-findSNMap( SNMap *map, char *key ) {
+Oid
+findSNMap(SNMap * map, char *key)
+{
SNMapEntry *ptr;
- SNMapEntry ks = {key, 0};
- if ( map->len==0 || !map->list )
- return 0;
- ptr = (SNMapEntry*) bsearch(&ks, map->list, map->len, sizeof(SNMapEntry), compareSNMapEntry);
+ SNMapEntry ks = {key, 0};
+
+ if (map->len == 0 || !map->list)
+ return 0;
+ ptr = (SNMapEntry *) bsearch(&ks, map->list, map->len, sizeof(SNMapEntry), compareSNMapEntry);
return (ptr) ? ptr->value : 0;
}
-Oid
-findSNMap_t( SNMap *map, text *key ) {
- char *k=text2char(key);
- int res;
- res= findSNMap(map, k);
+Oid
+findSNMap_t(SNMap * map, text *key)
+{
+ char *k = text2char(key);
+ int res;
+
+ res = findSNMap(map, k);
pfree(k);
return res;
}
-void freeSNMap( SNMap *map ) {
- SNMapEntry *entry=map->list;
- if ( map->list ) {
- while( map->len ) {
- if ( entry->key ) free(entry->key);
- entry++; map->len--;
+void
+freeSNMap(SNMap * map)
+{
+ SNMapEntry *entry = map->list;
+
+ if (map->list)
+ {
+ while (map->len)
+ {
+ if (entry->key)
+ free(entry->key);
+ entry++;
+ map->len--;
}
- free( map->list );
+ free(map->list);
}
- memset(map,0,sizeof(SNMap));
+ memset(map, 0, sizeof(SNMap));
}
-
-
#include "postgres.h"
-typedef struct {
- char *key;
- Oid value;
-} SNMapEntry;
+typedef struct
+{
+ char *key;
+ Oid value;
+} SNMapEntry;
-typedef struct {
- int len;
- int reallen;
- SNMapEntry *list;
-} SNMap;
+typedef struct
+{
+ int len;
+ int reallen;
+ SNMapEntry *list;
+} SNMap;
-void addSNMap( SNMap *map, char *key, Oid value );
-void addSNMap_t( SNMap *map, text *key, Oid value );
-Oid findSNMap( SNMap *map, char *key );
-Oid findSNMap_t( SNMap *map, text *key );
-void freeSNMap( SNMap *map );
+void addSNMap(SNMap * map, char *key, Oid value);
+void addSNMap_t(SNMap * map, text *key, Oid value);
+Oid findSNMap(SNMap * map, char *key);
+Oid findSNMap_t(SNMap * map, text *key);
+void freeSNMap(SNMap * map);
#endif
#include "header.h"
-extern struct SN_env * SN_create_env(int S_size, int I_size, int B_size)
-{ struct SN_env * z = (struct SN_env *) calloc(1, sizeof(struct SN_env));
- z->p = create_s();
- if (S_size)
- { z->S = (symbol * *) calloc(S_size, sizeof(symbol *));
- { int i;
- for (i = 0; i < S_size; i++) z->S[i] = create_s();
- }
- z->S_size = S_size;
- }
-
- if (I_size)
- { z->I = (int *) calloc(I_size, sizeof(int));
- z->I_size = I_size;
- }
-
- if (B_size)
- { z->B = (symbol *) calloc(B_size, sizeof(symbol));
- z->B_size = B_size;
- }
-
- return z;
+extern struct SN_env *
+SN_create_env(int S_size, int I_size, int B_size)
+{
+ struct SN_env *z = (struct SN_env *) calloc(1, sizeof(struct SN_env));
+
+ z->p = create_s();
+ if (S_size)
+ {
+ z->S = (symbol * *) calloc(S_size, sizeof(symbol *));
+ {
+ int i;
+
+ for (i = 0; i < S_size; i++)
+ z->S[i] = create_s();
+ }
+ z->S_size = S_size;
+ }
+
+ if (I_size)
+ {
+ z->I = (int *) calloc(I_size, sizeof(int));
+ z->I_size = I_size;
+ }
+
+ if (B_size)
+ {
+ z->B = (symbol *) calloc(B_size, sizeof(symbol));
+ z->B_size = B_size;
+ }
+
+ return z;
}
-extern void SN_close_env(struct SN_env * z)
+extern void
+SN_close_env(struct SN_env * z)
{
- if (z->S_size)
- {
- { int i;
- for (i = 0; i < z->S_size; i++) lose_s(z->S[i]);
- }
- free(z->S);
- }
- if (z->I_size) free(z->I);
- if (z->B_size) free(z->B);
- if (z->p) lose_s(z->p);
- free(z);
+ if (z->S_size)
+ {
+ {
+ int i;
+
+ for (i = 0; i < z->S_size; i++)
+ lose_s(z->S[i]);
+ }
+ free(z->S);
+ }
+ if (z->I_size)
+ free(z->I);
+ if (z->B_size)
+ free(z->B);
+ if (z->p)
+ lose_s(z->p);
+ free(z);
}
-extern void SN_set_current(struct SN_env * z, int size, const symbol * s)
+extern void
+SN_set_current(struct SN_env * z, int size, const symbol * s)
{
- replace_s(z, 0, z->l, size, s);
- z->c = 0;
+ replace_s(z, 0, z->l, size, s);
+ z->c = 0;
}
-
*/
-struct SN_env {
- symbol * p;
- int c; int a; int l; int lb; int bra; int ket;
- int S_size; int I_size; int B_size;
- symbol * * S;
- int * I;
- symbol * B;
+struct SN_env
+{
+ symbol *p;
+ int c;
+ int a;
+ int l;
+ int lb;
+ int bra;
+ int ket;
+ int S_size;
+ int I_size;
+ int B_size;
+ symbol **S;
+ int *I;
+ symbol *B;
};
-extern struct SN_env * SN_create_env(int S_size, int I_size, int B_size);
+extern struct SN_env *SN_create_env(int S_size, int I_size, int B_size);
extern void SN_close_env(struct SN_env * z);
extern void SN_set_current(struct SN_env * z, int size, const symbol * s);
-
#include "header.h"
-extern int english_stem(struct SN_env * z);
-static int r_exception2(struct SN_env * z);
-static int r_exception1(struct SN_env * z);
-static int r_Step_5(struct SN_env * z);
-static int r_Step_4(struct SN_env * z);
-static int r_Step_3(struct SN_env * z);
-static int r_Step_2(struct SN_env * z);
-static int r_Step_1c(struct SN_env * z);
-static int r_Step_1b(struct SN_env * z);
-static int r_Step_1a(struct SN_env * z);
-static int r_R2(struct SN_env * z);
-static int r_R1(struct SN_env * z);
-static int r_shortv(struct SN_env * z);
-static int r_mark_regions(struct SN_env * z);
-static int r_postlude(struct SN_env * z);
-static int r_prelude(struct SN_env * z);
-
-extern struct SN_env * english_create_env(void);
+extern int english_stem(struct SN_env * z);
+static int r_exception2(struct SN_env * z);
+static int r_exception1(struct SN_env * z);
+static int r_Step_5(struct SN_env * z);
+static int r_Step_4(struct SN_env * z);
+static int r_Step_3(struct SN_env * z);
+static int r_Step_2(struct SN_env * z);
+static int r_Step_1c(struct SN_env * z);
+static int r_Step_1b(struct SN_env * z);
+static int r_Step_1a(struct SN_env * z);
+static int r_R2(struct SN_env * z);
+static int r_R1(struct SN_env * z);
+static int r_shortv(struct SN_env * z);
+static int r_mark_regions(struct SN_env * z);
+static int r_postlude(struct SN_env * z);
+static int r_prelude(struct SN_env * z);
+
+extern struct SN_env *english_create_env(void);
extern void english_close_env(struct SN_env * z);
-static symbol s_0_0[5] = { 'g', 'e', 'n', 'e', 'r' };
+static symbol s_0_0[5] = {'g', 'e', 'n', 'e', 'r'};
static struct among a_0[1] =
{
-/* 0 */ { 5, s_0_0, -1, -1, 0}
+ /* 0 */ {5, s_0_0, -1, -1, 0}
};
-static symbol s_1_0[3] = { 'i', 'e', 'd' };
-static symbol s_1_1[1] = { 's' };
-static symbol s_1_2[3] = { 'i', 'e', 's' };
-static symbol s_1_3[4] = { 's', 's', 'e', 's' };
-static symbol s_1_4[2] = { 's', 's' };
-static symbol s_1_5[2] = { 'u', 's' };
+static symbol s_1_0[3] = {'i', 'e', 'd'};
+static symbol s_1_1[1] = {'s'};
+static symbol s_1_2[3] = {'i', 'e', 's'};
+static symbol s_1_3[4] = {'s', 's', 'e', 's'};
+static symbol s_1_4[2] = {'s', 's'};
+static symbol s_1_5[2] = {'u', 's'};
static struct among a_1[6] =
{
-/* 0 */ { 3, s_1_0, -1, 2, 0},
-/* 1 */ { 1, s_1_1, -1, 3, 0},
-/* 2 */ { 3, s_1_2, 1, 2, 0},
-/* 3 */ { 4, s_1_3, 1, 1, 0},
-/* 4 */ { 2, s_1_4, 1, -1, 0},
-/* 5 */ { 2, s_1_5, 1, -1, 0}
+ /* 0 */ {3, s_1_0, -1, 2, 0},
+ /* 1 */ {1, s_1_1, -1, 3, 0},
+ /* 2 */ {3, s_1_2, 1, 2, 0},
+ /* 3 */ {4, s_1_3, 1, 1, 0},
+ /* 4 */ {2, s_1_4, 1, -1, 0},
+ /* 5 */ {2, s_1_5, 1, -1, 0}
};
-static symbol s_2_1[2] = { 'b', 'b' };
-static symbol s_2_2[2] = { 'd', 'd' };
-static symbol s_2_3[2] = { 'f', 'f' };
-static symbol s_2_4[2] = { 'g', 'g' };
-static symbol s_2_5[2] = { 'b', 'l' };
-static symbol s_2_6[2] = { 'm', 'm' };
-static symbol s_2_7[2] = { 'n', 'n' };
-static symbol s_2_8[2] = { 'p', 'p' };
-static symbol s_2_9[2] = { 'r', 'r' };
-static symbol s_2_10[2] = { 'a', 't' };
-static symbol s_2_11[2] = { 't', 't' };
-static symbol s_2_12[2] = { 'i', 'z' };
+static symbol s_2_1[2] = {'b', 'b'};
+static symbol s_2_2[2] = {'d', 'd'};
+static symbol s_2_3[2] = {'f', 'f'};
+static symbol s_2_4[2] = {'g', 'g'};
+static symbol s_2_5[2] = {'b', 'l'};
+static symbol s_2_6[2] = {'m', 'm'};
+static symbol s_2_7[2] = {'n', 'n'};
+static symbol s_2_8[2] = {'p', 'p'};
+static symbol s_2_9[2] = {'r', 'r'};
+static symbol s_2_10[2] = {'a', 't'};
+static symbol s_2_11[2] = {'t', 't'};
+static symbol s_2_12[2] = {'i', 'z'};
static struct among a_2[13] =
{
-/* 0 */ { 0, 0, -1, 3, 0},
-/* 1 */ { 2, s_2_1, 0, 2, 0},
-/* 2 */ { 2, s_2_2, 0, 2, 0},
-/* 3 */ { 2, s_2_3, 0, 2, 0},
-/* 4 */ { 2, s_2_4, 0, 2, 0},
-/* 5 */ { 2, s_2_5, 0, 1, 0},
-/* 6 */ { 2, s_2_6, 0, 2, 0},
-/* 7 */ { 2, s_2_7, 0, 2, 0},
-/* 8 */ { 2, s_2_8, 0, 2, 0},
-/* 9 */ { 2, s_2_9, 0, 2, 0},
-/* 10 */ { 2, s_2_10, 0, 1, 0},
-/* 11 */ { 2, s_2_11, 0, 2, 0},
-/* 12 */ { 2, s_2_12, 0, 1, 0}
+ /* 0 */ {0, 0, -1, 3, 0},
+ /* 1 */ {2, s_2_1, 0, 2, 0},
+ /* 2 */ {2, s_2_2, 0, 2, 0},
+ /* 3 */ {2, s_2_3, 0, 2, 0},
+ /* 4 */ {2, s_2_4, 0, 2, 0},
+ /* 5 */ {2, s_2_5, 0, 1, 0},
+ /* 6 */ {2, s_2_6, 0, 2, 0},
+ /* 7 */ {2, s_2_7, 0, 2, 0},
+ /* 8 */ {2, s_2_8, 0, 2, 0},
+ /* 9 */ {2, s_2_9, 0, 2, 0},
+ /* 10 */ {2, s_2_10, 0, 1, 0},
+ /* 11 */ {2, s_2_11, 0, 2, 0},
+ /* 12 */ {2, s_2_12, 0, 1, 0}
};
-static symbol s_3_0[2] = { 'e', 'd' };
-static symbol s_3_1[3] = { 'e', 'e', 'd' };
-static symbol s_3_2[3] = { 'i', 'n', 'g' };
-static symbol s_3_3[4] = { 'e', 'd', 'l', 'y' };
-static symbol s_3_4[5] = { 'e', 'e', 'd', 'l', 'y' };
-static symbol s_3_5[5] = { 'i', 'n', 'g', 'l', 'y' };
+static symbol s_3_0[2] = {'e', 'd'};
+static symbol s_3_1[3] = {'e', 'e', 'd'};
+static symbol s_3_2[3] = {'i', 'n', 'g'};
+static symbol s_3_3[4] = {'e', 'd', 'l', 'y'};
+static symbol s_3_4[5] = {'e', 'e', 'd', 'l', 'y'};
+static symbol s_3_5[5] = {'i', 'n', 'g', 'l', 'y'};
static struct among a_3[6] =
{
-/* 0 */ { 2, s_3_0, -1, 2, 0},
-/* 1 */ { 3, s_3_1, 0, 1, 0},
-/* 2 */ { 3, s_3_2, -1, 2, 0},
-/* 3 */ { 4, s_3_3, -1, 2, 0},
-/* 4 */ { 5, s_3_4, 3, 1, 0},
-/* 5 */ { 5, s_3_5, -1, 2, 0}
+ /* 0 */ {2, s_3_0, -1, 2, 0},
+ /* 1 */ {3, s_3_1, 0, 1, 0},
+ /* 2 */ {3, s_3_2, -1, 2, 0},
+ /* 3 */ {4, s_3_3, -1, 2, 0},
+ /* 4 */ {5, s_3_4, 3, 1, 0},
+ /* 5 */ {5, s_3_5, -1, 2, 0}
};
-static symbol s_4_0[4] = { 'a', 'n', 'c', 'i' };
-static symbol s_4_1[4] = { 'e', 'n', 'c', 'i' };
-static symbol s_4_2[3] = { 'o', 'g', 'i' };
-static symbol s_4_3[2] = { 'l', 'i' };
-static symbol s_4_4[3] = { 'b', 'l', 'i' };
-static symbol s_4_5[4] = { 'a', 'b', 'l', 'i' };
-static symbol s_4_6[4] = { 'a', 'l', 'l', 'i' };
-static symbol s_4_7[5] = { 'f', 'u', 'l', 'l', 'i' };
-static symbol s_4_8[6] = { 'l', 'e', 's', 's', 'l', 'i' };
-static symbol s_4_9[5] = { 'o', 'u', 's', 'l', 'i' };
-static symbol s_4_10[5] = { 'e', 'n', 't', 'l', 'i' };
-static symbol s_4_11[5] = { 'a', 'l', 'i', 't', 'i' };
-static symbol s_4_12[6] = { 'b', 'i', 'l', 'i', 't', 'i' };
-static symbol s_4_13[5] = { 'i', 'v', 'i', 't', 'i' };
-static symbol s_4_14[6] = { 't', 'i', 'o', 'n', 'a', 'l' };
-static symbol s_4_15[7] = { 'a', 't', 'i', 'o', 'n', 'a', 'l' };
-static symbol s_4_16[5] = { 'a', 'l', 'i', 's', 'm' };
-static symbol s_4_17[5] = { 'a', 't', 'i', 'o', 'n' };
-static symbol s_4_18[7] = { 'i', 'z', 'a', 't', 'i', 'o', 'n' };
-static symbol s_4_19[4] = { 'i', 'z', 'e', 'r' };
-static symbol s_4_20[4] = { 'a', 't', 'o', 'r' };
-static symbol s_4_21[7] = { 'i', 'v', 'e', 'n', 'e', 's', 's' };
-static symbol s_4_22[7] = { 'f', 'u', 'l', 'n', 'e', 's', 's' };
-static symbol s_4_23[7] = { 'o', 'u', 's', 'n', 'e', 's', 's' };
+static symbol s_4_0[4] = {'a', 'n', 'c', 'i'};
+static symbol s_4_1[4] = {'e', 'n', 'c', 'i'};
+static symbol s_4_2[3] = {'o', 'g', 'i'};
+static symbol s_4_3[2] = {'l', 'i'};
+static symbol s_4_4[3] = {'b', 'l', 'i'};
+static symbol s_4_5[4] = {'a', 'b', 'l', 'i'};
+static symbol s_4_6[4] = {'a', 'l', 'l', 'i'};
+static symbol s_4_7[5] = {'f', 'u', 'l', 'l', 'i'};
+static symbol s_4_8[6] = {'l', 'e', 's', 's', 'l', 'i'};
+static symbol s_4_9[5] = {'o', 'u', 's', 'l', 'i'};
+static symbol s_4_10[5] = {'e', 'n', 't', 'l', 'i'};
+static symbol s_4_11[5] = {'a', 'l', 'i', 't', 'i'};
+static symbol s_4_12[6] = {'b', 'i', 'l', 'i', 't', 'i'};
+static symbol s_4_13[5] = {'i', 'v', 'i', 't', 'i'};
+static symbol s_4_14[6] = {'t', 'i', 'o', 'n', 'a', 'l'};
+static symbol s_4_15[7] = {'a', 't', 'i', 'o', 'n', 'a', 'l'};
+static symbol s_4_16[5] = {'a', 'l', 'i', 's', 'm'};
+static symbol s_4_17[5] = {'a', 't', 'i', 'o', 'n'};
+static symbol s_4_18[7] = {'i', 'z', 'a', 't', 'i', 'o', 'n'};
+static symbol s_4_19[4] = {'i', 'z', 'e', 'r'};
+static symbol s_4_20[4] = {'a', 't', 'o', 'r'};
+static symbol s_4_21[7] = {'i', 'v', 'e', 'n', 'e', 's', 's'};
+static symbol s_4_22[7] = {'f', 'u', 'l', 'n', 'e', 's', 's'};
+static symbol s_4_23[7] = {'o', 'u', 's', 'n', 'e', 's', 's'};
static struct among a_4[24] =
{
-/* 0 */ { 4, s_4_0, -1, 3, 0},
-/* 1 */ { 4, s_4_1, -1, 2, 0},
-/* 2 */ { 3, s_4_2, -1, 13, 0},
-/* 3 */ { 2, s_4_3, -1, 16, 0},
-/* 4 */ { 3, s_4_4, 3, 12, 0},
-/* 5 */ { 4, s_4_5, 4, 4, 0},
-/* 6 */ { 4, s_4_6, 3, 8, 0},
-/* 7 */ { 5, s_4_7, 3, 14, 0},
-/* 8 */ { 6, s_4_8, 3, 15, 0},
-/* 9 */ { 5, s_4_9, 3, 10, 0},
-/* 10 */ { 5, s_4_10, 3, 5, 0},
-/* 11 */ { 5, s_4_11, -1, 8, 0},
-/* 12 */ { 6, s_4_12, -1, 12, 0},
-/* 13 */ { 5, s_4_13, -1, 11, 0},
-/* 14 */ { 6, s_4_14, -1, 1, 0},
-/* 15 */ { 7, s_4_15, 14, 7, 0},
-/* 16 */ { 5, s_4_16, -1, 8, 0},
-/* 17 */ { 5, s_4_17, -1, 7, 0},
-/* 18 */ { 7, s_4_18, 17, 6, 0},
-/* 19 */ { 4, s_4_19, -1, 6, 0},
-/* 20 */ { 4, s_4_20, -1, 7, 0},
-/* 21 */ { 7, s_4_21, -1, 11, 0},
-/* 22 */ { 7, s_4_22, -1, 9, 0},
-/* 23 */ { 7, s_4_23, -1, 10, 0}
+ /* 0 */ {4, s_4_0, -1, 3, 0},
+ /* 1 */ {4, s_4_1, -1, 2, 0},
+ /* 2 */ {3, s_4_2, -1, 13, 0},
+ /* 3 */ {2, s_4_3, -1, 16, 0},
+ /* 4 */ {3, s_4_4, 3, 12, 0},
+ /* 5 */ {4, s_4_5, 4, 4, 0},
+ /* 6 */ {4, s_4_6, 3, 8, 0},
+ /* 7 */ {5, s_4_7, 3, 14, 0},
+ /* 8 */ {6, s_4_8, 3, 15, 0},
+ /* 9 */ {5, s_4_9, 3, 10, 0},
+ /* 10 */ {5, s_4_10, 3, 5, 0},
+ /* 11 */ {5, s_4_11, -1, 8, 0},
+ /* 12 */ {6, s_4_12, -1, 12, 0},
+ /* 13 */ {5, s_4_13, -1, 11, 0},
+ /* 14 */ {6, s_4_14, -1, 1, 0},
+ /* 15 */ {7, s_4_15, 14, 7, 0},
+ /* 16 */ {5, s_4_16, -1, 8, 0},
+ /* 17 */ {5, s_4_17, -1, 7, 0},
+ /* 18 */ {7, s_4_18, 17, 6, 0},
+ /* 19 */ {4, s_4_19, -1, 6, 0},
+ /* 20 */ {4, s_4_20, -1, 7, 0},
+ /* 21 */ {7, s_4_21, -1, 11, 0},
+ /* 22 */ {7, s_4_22, -1, 9, 0},
+ /* 23 */ {7, s_4_23, -1, 10, 0}
};
-static symbol s_5_0[5] = { 'i', 'c', 'a', 't', 'e' };
-static symbol s_5_1[5] = { 'a', 't', 'i', 'v', 'e' };
-static symbol s_5_2[5] = { 'a', 'l', 'i', 'z', 'e' };
-static symbol s_5_3[5] = { 'i', 'c', 'i', 't', 'i' };
-static symbol s_5_4[4] = { 'i', 'c', 'a', 'l' };
-static symbol s_5_5[6] = { 't', 'i', 'o', 'n', 'a', 'l' };
-static symbol s_5_6[7] = { 'a', 't', 'i', 'o', 'n', 'a', 'l' };
-static symbol s_5_7[3] = { 'f', 'u', 'l' };
-static symbol s_5_8[4] = { 'n', 'e', 's', 's' };
+static symbol s_5_0[5] = {'i', 'c', 'a', 't', 'e'};
+static symbol s_5_1[5] = {'a', 't', 'i', 'v', 'e'};
+static symbol s_5_2[5] = {'a', 'l', 'i', 'z', 'e'};
+static symbol s_5_3[5] = {'i', 'c', 'i', 't', 'i'};
+static symbol s_5_4[4] = {'i', 'c', 'a', 'l'};
+static symbol s_5_5[6] = {'t', 'i', 'o', 'n', 'a', 'l'};
+static symbol s_5_6[7] = {'a', 't', 'i', 'o', 'n', 'a', 'l'};
+static symbol s_5_7[3] = {'f', 'u', 'l'};
+static symbol s_5_8[4] = {'n', 'e', 's', 's'};
static struct among a_5[9] =
{
-/* 0 */ { 5, s_5_0, -1, 4, 0},
-/* 1 */ { 5, s_5_1, -1, 6, 0},
-/* 2 */ { 5, s_5_2, -1, 3, 0},
-/* 3 */ { 5, s_5_3, -1, 4, 0},
-/* 4 */ { 4, s_5_4, -1, 4, 0},
-/* 5 */ { 6, s_5_5, -1, 1, 0},
-/* 6 */ { 7, s_5_6, 5, 2, 0},
-/* 7 */ { 3, s_5_7, -1, 5, 0},
-/* 8 */ { 4, s_5_8, -1, 5, 0}
+ /* 0 */ {5, s_5_0, -1, 4, 0},
+ /* 1 */ {5, s_5_1, -1, 6, 0},
+ /* 2 */ {5, s_5_2, -1, 3, 0},
+ /* 3 */ {5, s_5_3, -1, 4, 0},
+ /* 4 */ {4, s_5_4, -1, 4, 0},
+ /* 5 */ {6, s_5_5, -1, 1, 0},
+ /* 6 */ {7, s_5_6, 5, 2, 0},
+ /* 7 */ {3, s_5_7, -1, 5, 0},
+ /* 8 */ {4, s_5_8, -1, 5, 0}
};
-static symbol s_6_0[2] = { 'i', 'c' };
-static symbol s_6_1[4] = { 'a', 'n', 'c', 'e' };
-static symbol s_6_2[4] = { 'e', 'n', 'c', 'e' };
-static symbol s_6_3[4] = { 'a', 'b', 'l', 'e' };
-static symbol s_6_4[4] = { 'i', 'b', 'l', 'e' };
-static symbol s_6_5[3] = { 'a', 't', 'e' };
-static symbol s_6_6[3] = { 'i', 'v', 'e' };
-static symbol s_6_7[3] = { 'i', 'z', 'e' };
-static symbol s_6_8[3] = { 'i', 't', 'i' };
-static symbol s_6_9[2] = { 'a', 'l' };
-static symbol s_6_10[3] = { 'i', 's', 'm' };
-static symbol s_6_11[3] = { 'i', 'o', 'n' };
-static symbol s_6_12[2] = { 'e', 'r' };
-static symbol s_6_13[3] = { 'o', 'u', 's' };
-static symbol s_6_14[3] = { 'a', 'n', 't' };
-static symbol s_6_15[3] = { 'e', 'n', 't' };
-static symbol s_6_16[4] = { 'm', 'e', 'n', 't' };
-static symbol s_6_17[5] = { 'e', 'm', 'e', 'n', 't' };
+static symbol s_6_0[2] = {'i', 'c'};
+static symbol s_6_1[4] = {'a', 'n', 'c', 'e'};
+static symbol s_6_2[4] = {'e', 'n', 'c', 'e'};
+static symbol s_6_3[4] = {'a', 'b', 'l', 'e'};
+static symbol s_6_4[4] = {'i', 'b', 'l', 'e'};
+static symbol s_6_5[3] = {'a', 't', 'e'};
+static symbol s_6_6[3] = {'i', 'v', 'e'};
+static symbol s_6_7[3] = {'i', 'z', 'e'};
+static symbol s_6_8[3] = {'i', 't', 'i'};
+static symbol s_6_9[2] = {'a', 'l'};
+static symbol s_6_10[3] = {'i', 's', 'm'};
+static symbol s_6_11[3] = {'i', 'o', 'n'};
+static symbol s_6_12[2] = {'e', 'r'};
+static symbol s_6_13[3] = {'o', 'u', 's'};
+static symbol s_6_14[3] = {'a', 'n', 't'};
+static symbol s_6_15[3] = {'e', 'n', 't'};
+static symbol s_6_16[4] = {'m', 'e', 'n', 't'};
+static symbol s_6_17[5] = {'e', 'm', 'e', 'n', 't'};
static struct among a_6[18] =
{
-/* 0 */ { 2, s_6_0, -1, 1, 0},
-/* 1 */ { 4, s_6_1, -1, 1, 0},
-/* 2 */ { 4, s_6_2, -1, 1, 0},
-/* 3 */ { 4, s_6_3, -1, 1, 0},
-/* 4 */ { 4, s_6_4, -1, 1, 0},
-/* 5 */ { 3, s_6_5, -1, 1, 0},
-/* 6 */ { 3, s_6_6, -1, 1, 0},
-/* 7 */ { 3, s_6_7, -1, 1, 0},
-/* 8 */ { 3, s_6_8, -1, 1, 0},
-/* 9 */ { 2, s_6_9, -1, 1, 0},
-/* 10 */ { 3, s_6_10, -1, 1, 0},
-/* 11 */ { 3, s_6_11, -1, 2, 0},
-/* 12 */ { 2, s_6_12, -1, 1, 0},
-/* 13 */ { 3, s_6_13, -1, 1, 0},
-/* 14 */ { 3, s_6_14, -1, 1, 0},
-/* 15 */ { 3, s_6_15, -1, 1, 0},
-/* 16 */ { 4, s_6_16, 15, 1, 0},
-/* 17 */ { 5, s_6_17, 16, 1, 0}
+ /* 0 */ {2, s_6_0, -1, 1, 0},
+ /* 1 */ {4, s_6_1, -1, 1, 0},
+ /* 2 */ {4, s_6_2, -1, 1, 0},
+ /* 3 */ {4, s_6_3, -1, 1, 0},
+ /* 4 */ {4, s_6_4, -1, 1, 0},
+ /* 5 */ {3, s_6_5, -1, 1, 0},
+ /* 6 */ {3, s_6_6, -1, 1, 0},
+ /* 7 */ {3, s_6_7, -1, 1, 0},
+ /* 8 */ {3, s_6_8, -1, 1, 0},
+ /* 9 */ {2, s_6_9, -1, 1, 0},
+ /* 10 */ {3, s_6_10, -1, 1, 0},
+ /* 11 */ {3, s_6_11, -1, 2, 0},
+ /* 12 */ {2, s_6_12, -1, 1, 0},
+ /* 13 */ {3, s_6_13, -1, 1, 0},
+ /* 14 */ {3, s_6_14, -1, 1, 0},
+ /* 15 */ {3, s_6_15, -1, 1, 0},
+ /* 16 */ {4, s_6_16, 15, 1, 0},
+ /* 17 */ {5, s_6_17, 16, 1, 0}
};
-static symbol s_7_0[1] = { 'e' };
-static symbol s_7_1[1] = { 'l' };
+static symbol s_7_0[1] = {'e'};
+static symbol s_7_1[1] = {'l'};
static struct among a_7[2] =
{
-/* 0 */ { 1, s_7_0, -1, 1, 0},
-/* 1 */ { 1, s_7_1, -1, 2, 0}
+ /* 0 */ {1, s_7_0, -1, 1, 0},
+ /* 1 */ {1, s_7_1, -1, 2, 0}
};
-static symbol s_8_0[7] = { 's', 'u', 'c', 'c', 'e', 'e', 'd' };
-static symbol s_8_1[7] = { 'p', 'r', 'o', 'c', 'e', 'e', 'd' };
-static symbol s_8_2[6] = { 'e', 'x', 'c', 'e', 'e', 'd' };
-static symbol s_8_3[7] = { 'c', 'a', 'n', 'n', 'i', 'n', 'g' };
-static symbol s_8_4[6] = { 'i', 'n', 'n', 'i', 'n', 'g' };
-static symbol s_8_5[7] = { 'e', 'a', 'r', 'r', 'i', 'n', 'g' };
-static symbol s_8_6[7] = { 'h', 'e', 'r', 'r', 'i', 'n', 'g' };
-static symbol s_8_7[6] = { 'o', 'u', 't', 'i', 'n', 'g' };
+static symbol s_8_0[7] = {'s', 'u', 'c', 'c', 'e', 'e', 'd'};
+static symbol s_8_1[7] = {'p', 'r', 'o', 'c', 'e', 'e', 'd'};
+static symbol s_8_2[6] = {'e', 'x', 'c', 'e', 'e', 'd'};
+static symbol s_8_3[7] = {'c', 'a', 'n', 'n', 'i', 'n', 'g'};
+static symbol s_8_4[6] = {'i', 'n', 'n', 'i', 'n', 'g'};
+static symbol s_8_5[7] = {'e', 'a', 'r', 'r', 'i', 'n', 'g'};
+static symbol s_8_6[7] = {'h', 'e', 'r', 'r', 'i', 'n', 'g'};
+static symbol s_8_7[6] = {'o', 'u', 't', 'i', 'n', 'g'};
static struct among a_8[8] =
{
-/* 0 */ { 7, s_8_0, -1, -1, 0},
-/* 1 */ { 7, s_8_1, -1, -1, 0},
-/* 2 */ { 6, s_8_2, -1, -1, 0},
-/* 3 */ { 7, s_8_3, -1, -1, 0},
-/* 4 */ { 6, s_8_4, -1, -1, 0},
-/* 5 */ { 7, s_8_5, -1, -1, 0},
-/* 6 */ { 7, s_8_6, -1, -1, 0},
-/* 7 */ { 6, s_8_7, -1, -1, 0}
+ /* 0 */ {7, s_8_0, -1, -1, 0},
+ /* 1 */ {7, s_8_1, -1, -1, 0},
+ /* 2 */ {6, s_8_2, -1, -1, 0},
+ /* 3 */ {7, s_8_3, -1, -1, 0},
+ /* 4 */ {6, s_8_4, -1, -1, 0},
+ /* 5 */ {7, s_8_5, -1, -1, 0},
+ /* 6 */ {7, s_8_6, -1, -1, 0},
+ /* 7 */ {6, s_8_7, -1, -1, 0}
};
-static symbol s_9_0[5] = { 'a', 'n', 'd', 'e', 's' };
-static symbol s_9_1[5] = { 'a', 't', 'l', 'a', 's' };
-static symbol s_9_2[4] = { 'b', 'i', 'a', 's' };
-static symbol s_9_3[6] = { 'c', 'o', 's', 'm', 'o', 's' };
-static symbol s_9_4[5] = { 'd', 'y', 'i', 'n', 'g' };
-static symbol s_9_5[5] = { 'e', 'a', 'r', 'l', 'y' };
-static symbol s_9_6[6] = { 'g', 'e', 'n', 't', 'l', 'y' };
-static symbol s_9_7[4] = { 'h', 'o', 'w', 'e' };
-static symbol s_9_8[4] = { 'i', 'd', 'l', 'y' };
-static symbol s_9_9[5] = { 'l', 'y', 'i', 'n', 'g' };
-static symbol s_9_10[4] = { 'n', 'e', 'w', 's' };
-static symbol s_9_11[4] = { 'o', 'n', 'l', 'y' };
-static symbol s_9_12[6] = { 's', 'i', 'n', 'g', 'l', 'y' };
-static symbol s_9_13[5] = { 's', 'k', 'i', 'e', 's' };
-static symbol s_9_14[4] = { 's', 'k', 'i', 's' };
-static symbol s_9_15[3] = { 's', 'k', 'y' };
-static symbol s_9_16[5] = { 't', 'y', 'i', 'n', 'g' };
-static symbol s_9_17[4] = { 'u', 'g', 'l', 'y' };
+static symbol s_9_0[5] = {'a', 'n', 'd', 'e', 's'};
+static symbol s_9_1[5] = {'a', 't', 'l', 'a', 's'};
+static symbol s_9_2[4] = {'b', 'i', 'a', 's'};
+static symbol s_9_3[6] = {'c', 'o', 's', 'm', 'o', 's'};
+static symbol s_9_4[5] = {'d', 'y', 'i', 'n', 'g'};
+static symbol s_9_5[5] = {'e', 'a', 'r', 'l', 'y'};
+static symbol s_9_6[6] = {'g', 'e', 'n', 't', 'l', 'y'};
+static symbol s_9_7[4] = {'h', 'o', 'w', 'e'};
+static symbol s_9_8[4] = {'i', 'd', 'l', 'y'};
+static symbol s_9_9[5] = {'l', 'y', 'i', 'n', 'g'};
+static symbol s_9_10[4] = {'n', 'e', 'w', 's'};
+static symbol s_9_11[4] = {'o', 'n', 'l', 'y'};
+static symbol s_9_12[6] = {'s', 'i', 'n', 'g', 'l', 'y'};
+static symbol s_9_13[5] = {'s', 'k', 'i', 'e', 's'};
+static symbol s_9_14[4] = {'s', 'k', 'i', 's'};
+static symbol s_9_15[3] = {'s', 'k', 'y'};
+static symbol s_9_16[5] = {'t', 'y', 'i', 'n', 'g'};
+static symbol s_9_17[4] = {'u', 'g', 'l', 'y'};
static struct among a_9[18] =
{
-/* 0 */ { 5, s_9_0, -1, -1, 0},
-/* 1 */ { 5, s_9_1, -1, -1, 0},
-/* 2 */ { 4, s_9_2, -1, -1, 0},
-/* 3 */ { 6, s_9_3, -1, -1, 0},
-/* 4 */ { 5, s_9_4, -1, 3, 0},
-/* 5 */ { 5, s_9_5, -1, 9, 0},
-/* 6 */ { 6, s_9_6, -1, 7, 0},
-/* 7 */ { 4, s_9_7, -1, -1, 0},
-/* 8 */ { 4, s_9_8, -1, 6, 0},
-/* 9 */ { 5, s_9_9, -1, 4, 0},
-/* 10 */ { 4, s_9_10, -1, -1, 0},
-/* 11 */ { 4, s_9_11, -1, 10, 0},
-/* 12 */ { 6, s_9_12, -1, 11, 0},
-/* 13 */ { 5, s_9_13, -1, 2, 0},
-/* 14 */ { 4, s_9_14, -1, 1, 0},
-/* 15 */ { 3, s_9_15, -1, -1, 0},
-/* 16 */ { 5, s_9_16, -1, 5, 0},
-/* 17 */ { 4, s_9_17, -1, 8, 0}
+ /* 0 */ {5, s_9_0, -1, -1, 0},
+ /* 1 */ {5, s_9_1, -1, -1, 0},
+ /* 2 */ {4, s_9_2, -1, -1, 0},
+ /* 3 */ {6, s_9_3, -1, -1, 0},
+ /* 4 */ {5, s_9_4, -1, 3, 0},
+ /* 5 */ {5, s_9_5, -1, 9, 0},
+ /* 6 */ {6, s_9_6, -1, 7, 0},
+ /* 7 */ {4, s_9_7, -1, -1, 0},
+ /* 8 */ {4, s_9_8, -1, 6, 0},
+ /* 9 */ {5, s_9_9, -1, 4, 0},
+ /* 10 */ {4, s_9_10, -1, -1, 0},
+ /* 11 */ {4, s_9_11, -1, 10, 0},
+ /* 12 */ {6, s_9_12, -1, 11, 0},
+ /* 13 */ {5, s_9_13, -1, 2, 0},
+ /* 14 */ {4, s_9_14, -1, 1, 0},
+ /* 15 */ {3, s_9_15, -1, -1, 0},
+ /* 16 */ {5, s_9_16, -1, 5, 0},
+ /* 17 */ {4, s_9_17, -1, 8, 0}
};
-static unsigned char g_v[] = { 17, 65, 16, 1 };
-
-static unsigned char g_v_WXY[] = { 1, 17, 65, 208, 1 };
-
-static unsigned char g_valid_LI[] = { 55, 141, 2 };
-
-static symbol s_0[] = { 'y' };
-static symbol s_1[] = { 'Y' };
-static symbol s_2[] = { 'y' };
-static symbol s_3[] = { 'Y' };
-static symbol s_4[] = { 's', 's' };
-static symbol s_5[] = { 'i', 'e' };
-static symbol s_6[] = { 'i' };
-static symbol s_7[] = { 'e', 'e' };
-static symbol s_8[] = { 'e' };
-static symbol s_9[] = { 'e' };
-static symbol s_10[] = { 'y' };
-static symbol s_11[] = { 'Y' };
-static symbol s_12[] = { 'i' };
-static symbol s_13[] = { 't', 'i', 'o', 'n' };
-static symbol s_14[] = { 'e', 'n', 'c', 'e' };
-static symbol s_15[] = { 'a', 'n', 'c', 'e' };
-static symbol s_16[] = { 'a', 'b', 'l', 'e' };
-static symbol s_17[] = { 'e', 'n', 't' };
-static symbol s_18[] = { 'i', 'z', 'e' };
-static symbol s_19[] = { 'a', 't', 'e' };
-static symbol s_20[] = { 'a', 'l' };
-static symbol s_21[] = { 'f', 'u', 'l' };
-static symbol s_22[] = { 'o', 'u', 's' };
-static symbol s_23[] = { 'i', 'v', 'e' };
-static symbol s_24[] = { 'b', 'l', 'e' };
-static symbol s_25[] = { 'l' };
-static symbol s_26[] = { 'o', 'g' };
-static symbol s_27[] = { 'f', 'u', 'l' };
-static symbol s_28[] = { 'l', 'e', 's', 's' };
-static symbol s_29[] = { 't', 'i', 'o', 'n' };
-static symbol s_30[] = { 'a', 't', 'e' };
-static symbol s_31[] = { 'a', 'l' };
-static symbol s_32[] = { 'i', 'c' };
-static symbol s_33[] = { 's' };
-static symbol s_34[] = { 't' };
-static symbol s_35[] = { 'l' };
-static symbol s_36[] = { 's', 'k', 'i' };
-static symbol s_37[] = { 's', 'k', 'y' };
-static symbol s_38[] = { 'd', 'i', 'e' };
-static symbol s_39[] = { 'l', 'i', 'e' };
-static symbol s_40[] = { 't', 'i', 'e' };
-static symbol s_41[] = { 'i', 'd', 'l' };
-static symbol s_42[] = { 'g', 'e', 'n', 't', 'l' };
-static symbol s_43[] = { 'u', 'g', 'l', 'i' };
-static symbol s_44[] = { 'e', 'a', 'r', 'l', 'i' };
-static symbol s_45[] = { 'o', 'n', 'l', 'i' };
-static symbol s_46[] = { 's', 'i', 'n', 'g', 'l' };
-static symbol s_47[] = { 'Y' };
-static symbol s_48[] = { 'y' };
-
-static int r_prelude(struct SN_env * z) {
- z->B[0] = 0; /* unset Y_found, line 24 */
- { int c = z->c; /* do, line 25 */
- z->bra = z->c; /* [, line 25 */
- if (!(eq_s(z, 1, s_0))) goto lab0;
- z->ket = z->c; /* ], line 25 */
- if (!(in_grouping(z, g_v, 97, 121))) goto lab0;
- slice_from_s(z, 1, s_1); /* <-, line 25 */
- z->B[0] = 1; /* set Y_found, line 25 */
- lab0:
- z->c = c;
- }
- { int c = z->c; /* do, line 26 */
- while(1) { /* repeat, line 26 */
- int c = z->c;
- while(1) { /* goto, line 26 */
- int c = z->c;
- if (!(in_grouping(z, g_v, 97, 121))) goto lab3;
- z->bra = z->c; /* [, line 26 */
- if (!(eq_s(z, 1, s_2))) goto lab3;
- z->ket = z->c; /* ], line 26 */
- z->c = c;
- break;
- lab3:
- z->c = c;
- if (z->c >= z->l) goto lab2;
- z->c++;
- }
- slice_from_s(z, 1, s_3); /* <-, line 26 */
- z->B[0] = 1; /* set Y_found, line 26 */
- continue;
- lab2:
- z->c = c;
- break;
- }
- z->c = c;
- }
- return 1;
+static unsigned char g_v[] = {17, 65, 16, 1};
+
+static unsigned char g_v_WXY[] = {1, 17, 65, 208, 1};
+
+static unsigned char g_valid_LI[] = {55, 141, 2};
+
+static symbol s_0[] = {'y'};
+static symbol s_1[] = {'Y'};
+static symbol s_2[] = {'y'};
+static symbol s_3[] = {'Y'};
+static symbol s_4[] = {'s', 's'};
+static symbol s_5[] = {'i', 'e'};
+static symbol s_6[] = {'i'};
+static symbol s_7[] = {'e', 'e'};
+static symbol s_8[] = {'e'};
+static symbol s_9[] = {'e'};
+static symbol s_10[] = {'y'};
+static symbol s_11[] = {'Y'};
+static symbol s_12[] = {'i'};
+static symbol s_13[] = {'t', 'i', 'o', 'n'};
+static symbol s_14[] = {'e', 'n', 'c', 'e'};
+static symbol s_15[] = {'a', 'n', 'c', 'e'};
+static symbol s_16[] = {'a', 'b', 'l', 'e'};
+static symbol s_17[] = {'e', 'n', 't'};
+static symbol s_18[] = {'i', 'z', 'e'};
+static symbol s_19[] = {'a', 't', 'e'};
+static symbol s_20[] = {'a', 'l'};
+static symbol s_21[] = {'f', 'u', 'l'};
+static symbol s_22[] = {'o', 'u', 's'};
+static symbol s_23[] = {'i', 'v', 'e'};
+static symbol s_24[] = {'b', 'l', 'e'};
+static symbol s_25[] = {'l'};
+static symbol s_26[] = {'o', 'g'};
+static symbol s_27[] = {'f', 'u', 'l'};
+static symbol s_28[] = {'l', 'e', 's', 's'};
+static symbol s_29[] = {'t', 'i', 'o', 'n'};
+static symbol s_30[] = {'a', 't', 'e'};
+static symbol s_31[] = {'a', 'l'};
+static symbol s_32[] = {'i', 'c'};
+static symbol s_33[] = {'s'};
+static symbol s_34[] = {'t'};
+static symbol s_35[] = {'l'};
+static symbol s_36[] = {'s', 'k', 'i'};
+static symbol s_37[] = {'s', 'k', 'y'};
+static symbol s_38[] = {'d', 'i', 'e'};
+static symbol s_39[] = {'l', 'i', 'e'};
+static symbol s_40[] = {'t', 'i', 'e'};
+static symbol s_41[] = {'i', 'd', 'l'};
+static symbol s_42[] = {'g', 'e', 'n', 't', 'l'};
+static symbol s_43[] = {'u', 'g', 'l', 'i'};
+static symbol s_44[] = {'e', 'a', 'r', 'l', 'i'};
+static symbol s_45[] = {'o', 'n', 'l', 'i'};
+static symbol s_46[] = {'s', 'i', 'n', 'g', 'l'};
+static symbol s_47[] = {'Y'};
+static symbol s_48[] = {'y'};
+
+static int
+r_prelude(struct SN_env * z)
+{
+ z->B[0] = 0; /* unset Y_found, line 24 */
+ {
+ int c = z->c; /* do, line 25 */
+
+ z->bra = z->c; /* [, line 25 */
+ if (!(eq_s(z, 1, s_0)))
+ goto lab0;
+ z->ket = z->c; /* ], line 25 */
+ if (!(in_grouping(z, g_v, 97, 121)))
+ goto lab0;
+ slice_from_s(z, 1, s_1); /* <-, line 25 */
+ z->B[0] = 1; /* set Y_found, line 25 */
+lab0:
+ z->c = c;
+ }
+ {
+ int c = z->c; /* do, line 26 */
+
+ while (1)
+ { /* repeat, line 26 */
+ int c = z->c;
+
+ while (1)
+ { /* goto, line 26 */
+ int c = z->c;
+
+ if (!(in_grouping(z, g_v, 97, 121)))
+ goto lab3;
+ z->bra = z->c; /* [, line 26 */
+ if (!(eq_s(z, 1, s_2)))
+ goto lab3;
+ z->ket = z->c; /* ], line 26 */
+ z->c = c;
+ break;
+ lab3:
+ z->c = c;
+ if (z->c >= z->l)
+ goto lab2;
+ z->c++;
+ }
+ slice_from_s(z, 1, s_3); /* <-, line 26 */
+ z->B[0] = 1; /* set Y_found, line 26 */
+ continue;
+ lab2:
+ z->c = c;
+ break;
+ }
+ z->c = c;
+ }
+ return 1;
}
-static int r_mark_regions(struct SN_env * z) {
- z->I[0] = z->l;
- z->I[1] = z->l;
- { int c = z->c; /* do, line 32 */
- { int c = z->c; /* or, line 36 */
- if (!(find_among(z, a_0, 1))) goto lab2; /* among, line 33 */
- goto lab1;
- lab2:
- z->c = c;
- while(1) { /* gopast, line 36 */
- if (!(in_grouping(z, g_v, 97, 121))) goto lab3;
- break;
- lab3:
- if (z->c >= z->l) goto lab0;
- z->c++;
- }
- while(1) { /* gopast, line 36 */
- if (!(out_grouping(z, g_v, 97, 121))) goto lab4;
- break;
- lab4:
- if (z->c >= z->l) goto lab0;
- z->c++;
- }
- }
- lab1:
- z->I[0] = z->c; /* setmark p1, line 37 */
- while(1) { /* gopast, line 38 */
- if (!(in_grouping(z, g_v, 97, 121))) goto lab5;
- break;
- lab5:
- if (z->c >= z->l) goto lab0;
- z->c++;
- }
- while(1) { /* gopast, line 38 */
- if (!(out_grouping(z, g_v, 97, 121))) goto lab6;
- break;
- lab6:
- if (z->c >= z->l) goto lab0;
- z->c++;
- }
- z->I[1] = z->c; /* setmark p2, line 38 */
- lab0:
- z->c = c;
- }
- return 1;
+static int
+r_mark_regions(struct SN_env * z)
+{
+ z->I[0] = z->l;
+ z->I[1] = z->l;
+ {
+ int c = z->c; /* do, line 32 */
+
+ {
+ int c = z->c; /* or, line 36 */
+
+ if (!(find_among(z, a_0, 1)))
+ goto lab2; /* among, line 33 */
+ goto lab1;
+ lab2:
+ z->c = c;
+ while (1)
+ { /* gopast, line 36 */
+ if (!(in_grouping(z, g_v, 97, 121)))
+ goto lab3;
+ break;
+ lab3:
+ if (z->c >= z->l)
+ goto lab0;
+ z->c++;
+ }
+ while (1)
+ { /* gopast, line 36 */
+ if (!(out_grouping(z, g_v, 97, 121)))
+ goto lab4;
+ break;
+ lab4:
+ if (z->c >= z->l)
+ goto lab0;
+ z->c++;
+ }
+ }
+lab1:
+ z->I[0] = z->c; /* setmark p1, line 37 */
+ while (1)
+ { /* gopast, line 38 */
+ if (!(in_grouping(z, g_v, 97, 121)))
+ goto lab5;
+ break;
+ lab5:
+ if (z->c >= z->l)
+ goto lab0;
+ z->c++;
+ }
+ while (1)
+ { /* gopast, line 38 */
+ if (!(out_grouping(z, g_v, 97, 121)))
+ goto lab6;
+ break;
+ lab6:
+ if (z->c >= z->l)
+ goto lab0;
+ z->c++;
+ }
+ z->I[1] = z->c; /* setmark p2, line 38 */
+lab0:
+ z->c = c;
+ }
+ return 1;
}
-static int r_shortv(struct SN_env * z) {
- { int m = z->l - z->c; /* or, line 46 */
- if (!(out_grouping_b(z, g_v_WXY, 89, 121))) goto lab1;
- if (!(in_grouping_b(z, g_v, 97, 121))) goto lab1;
- if (!(out_grouping_b(z, g_v, 97, 121))) goto lab1;
- goto lab0;
- lab1:
- z->c = z->l - m;
- if (!(out_grouping_b(z, g_v, 97, 121))) return 0;
- if (!(in_grouping_b(z, g_v, 97, 121))) return 0;
- if (z->c > z->lb) return 0; /* atlimit, line 47 */
- }
+static int
+r_shortv(struct SN_env * z)
+{
+ {
+ int m = z->l - z->c; /* or, line 46 */
+
+ if (!(out_grouping_b(z, g_v_WXY, 89, 121)))
+ goto lab1;
+ if (!(in_grouping_b(z, g_v, 97, 121)))
+ goto lab1;
+ if (!(out_grouping_b(z, g_v, 97, 121)))
+ goto lab1;
+ goto lab0;
+lab1:
+ z->c = z->l - m;
+ if (!(out_grouping_b(z, g_v, 97, 121)))
+ return 0;
+ if (!(in_grouping_b(z, g_v, 97, 121)))
+ return 0;
+ if (z->c > z->lb)
+ return 0; /* atlimit, line 47 */
+ }
lab0:
- return 1;
+ return 1;
}
-static int r_R1(struct SN_env * z) {
- if (!(z->I[0] <= z->c)) return 0;
- return 1;
+static int
+r_R1(struct SN_env * z)
+{
+ if (!(z->I[0] <= z->c))
+ return 0;
+ return 1;
}
-static int r_R2(struct SN_env * z) {
- if (!(z->I[1] <= z->c)) return 0;
- return 1;
+static int
+r_R2(struct SN_env * z)
+{
+ if (!(z->I[1] <= z->c))
+ return 0;
+ return 1;
}
-static int r_Step_1a(struct SN_env * z) {
- int among_var;
- z->ket = z->c; /* [, line 54 */
- among_var = find_among_b(z, a_1, 6); /* substring, line 54 */
- if (!(among_var)) return 0;
- z->bra = z->c; /* ], line 54 */
- switch(among_var) {
- case 0: return 0;
- case 1:
- slice_from_s(z, 2, s_4); /* <-, line 55 */
- break;
- case 2:
- { int m = z->l - z->c; /* or, line 57 */
- if (z->c <= z->lb) goto lab1;
- z->c--; /* next, line 57 */
- if (z->c > z->lb) goto lab1; /* atlimit, line 57 */
- slice_from_s(z, 2, s_5); /* <-, line 57 */
- goto lab0;
- lab1:
- z->c = z->l - m;
- slice_from_s(z, 1, s_6); /* <-, line 57 */
- }
- lab0:
- break;
- case 3:
- if (z->c <= z->lb) return 0;
- z->c--; /* next, line 58 */
- while(1) { /* gopast, line 58 */
- if (!(in_grouping_b(z, g_v, 97, 121))) goto lab2;
- break;
- lab2:
- if (z->c <= z->lb) return 0;
- z->c--;
- }
- slice_del(z); /* delete, line 58 */
- break;
- }
- return 1;
+static int
+r_Step_1a(struct SN_env * z)
+{
+ int among_var;
+
+ z->ket = z->c; /* [, line 54 */
+ among_var = find_among_b(z, a_1, 6); /* substring, line 54 */
+ if (!(among_var))
+ return 0;
+ z->bra = z->c; /* ], line 54 */
+ switch (among_var)
+ {
+ case 0:
+ return 0;
+ case 1:
+ slice_from_s(z, 2, s_4); /* <-, line 55 */
+ break;
+ case 2:
+ {
+ int m = z->l - z->c; /* or, line 57 */
+
+ if (z->c <= z->lb)
+ goto lab1;
+ z->c--; /* next, line 57 */
+ if (z->c > z->lb)
+ goto lab1; /* atlimit, line 57 */
+ slice_from_s(z, 2, s_5); /* <-, line 57 */
+ goto lab0;
+ lab1:
+ z->c = z->l - m;
+ slice_from_s(z, 1, s_6); /* <-, line 57 */
+ }
+ lab0:
+ break;
+ case 3:
+ if (z->c <= z->lb)
+ return 0;
+ z->c--; /* next, line 58 */
+ while (1)
+ { /* gopast, line 58 */
+ if (!(in_grouping_b(z, g_v, 97, 121)))
+ goto lab2;
+ break;
+ lab2:
+ if (z->c <= z->lb)
+ return 0;
+ z->c--;
+ }
+ slice_del(z); /* delete, line 58 */
+ break;
+ }
+ return 1;
}
-static int r_Step_1b(struct SN_env * z) {
- int among_var;
- z->ket = z->c; /* [, line 64 */
- among_var = find_among_b(z, a_3, 6); /* substring, line 64 */
- if (!(among_var)) return 0;
- z->bra = z->c; /* ], line 64 */
- switch(among_var) {
- case 0: return 0;
- case 1:
- if (!r_R1(z)) return 0; /* call R1, line 66 */
- slice_from_s(z, 2, s_7); /* <-, line 66 */
- break;
- case 2:
- { int m_test = z->l - z->c; /* test, line 69 */
- while(1) { /* gopast, line 69 */
- if (!(in_grouping_b(z, g_v, 97, 121))) goto lab0;
- break;
- lab0:
- if (z->c <= z->lb) return 0;
- z->c--;
- }
- z->c = z->l - m_test;
- }
- slice_del(z); /* delete, line 69 */
- { int m_test = z->l - z->c; /* test, line 70 */
- among_var = find_among_b(z, a_2, 13); /* substring, line 70 */
- if (!(among_var)) return 0;
- z->c = z->l - m_test;
- }
- switch(among_var) {
- case 0: return 0;
- case 1:
- { int c = z->c;
- insert_s(z, z->c, z->c, 1, s_8); /* <+, line 72 */
- z->c = c;
- }
- break;
- case 2:
- z->ket = z->c; /* [, line 75 */
- if (z->c <= z->lb) return 0;
- z->c--; /* next, line 75 */
- z->bra = z->c; /* ], line 75 */
- slice_del(z); /* delete, line 75 */
- break;
- case 3:
- if (z->c != z->I[0]) return 0; /* atmark, line 76 */
- { int m_test = z->l - z->c; /* test, line 76 */
- if (!r_shortv(z)) return 0; /* call shortv, line 76 */
- z->c = z->l - m_test;
- }
- { int c = z->c;
- insert_s(z, z->c, z->c, 1, s_9); /* <+, line 76 */
- z->c = c;
- }
- break;
- }
- break;
- }
- return 1;
+static int
+r_Step_1b(struct SN_env * z)
+{
+ int among_var;
+
+ z->ket = z->c; /* [, line 64 */
+ among_var = find_among_b(z, a_3, 6); /* substring, line 64 */
+ if (!(among_var))
+ return 0;
+ z->bra = z->c; /* ], line 64 */
+ switch (among_var)
+ {
+ case 0:
+ return 0;
+ case 1:
+ if (!r_R1(z))
+ return 0; /* call R1, line 66 */
+ slice_from_s(z, 2, s_7); /* <-, line 66 */
+ break;
+ case 2:
+ {
+ int m_test = z->l - z->c; /* test, line 69 */
+
+ while (1)
+ { /* gopast, line 69 */
+ if (!(in_grouping_b(z, g_v, 97, 121)))
+ goto lab0;
+ break;
+ lab0:
+ if (z->c <= z->lb)
+ return 0;
+ z->c--;
+ }
+ z->c = z->l - m_test;
+ }
+ slice_del(z); /* delete, line 69 */
+ {
+ int m_test = z->l - z->c; /* test, line 70 */
+
+ among_var = find_among_b(z, a_2, 13); /* substring, line 70 */
+ if (!(among_var))
+ return 0;
+ z->c = z->l - m_test;
+ }
+ switch (among_var)
+ {
+ case 0:
+ return 0;
+ case 1:
+ {
+ int c = z->c;
+
+ insert_s(z, z->c, z->c, 1, s_8); /* <+, line 72 */
+ z->c = c;
+ }
+ break;
+ case 2:
+ z->ket = z->c; /* [, line 75 */
+ if (z->c <= z->lb)
+ return 0;
+ z->c--; /* next, line 75 */
+ z->bra = z->c; /* ], line 75 */
+ slice_del(z); /* delete, line 75 */
+ break;
+ case 3:
+ if (z->c != z->I[0])
+ return 0; /* atmark, line 76 */
+ {
+ int m_test = z->l - z->c; /* test, line 76 */
+
+ if (!r_shortv(z))
+ return 0; /* call shortv, line 76 */
+ z->c = z->l - m_test;
+ }
+ {
+ int c = z->c;
+
+ insert_s(z, z->c, z->c, 1, s_9); /* <+, line 76 */
+ z->c = c;
+ }
+ break;
+ }
+ break;
+ }
+ return 1;
}
-static int r_Step_1c(struct SN_env * z) {
- z->ket = z->c; /* [, line 83 */
- { int m = z->l - z->c; /* or, line 83 */
- if (!(eq_s_b(z, 1, s_10))) goto lab1;
- goto lab0;
- lab1:
- z->c = z->l - m;
- if (!(eq_s_b(z, 1, s_11))) return 0;
- }
+static int
+r_Step_1c(struct SN_env * z)
+{
+ z->ket = z->c; /* [, line 83 */
+ {
+ int m = z->l - z->c; /* or, line 83 */
+
+ if (!(eq_s_b(z, 1, s_10)))
+ goto lab1;
+ goto lab0;
+lab1:
+ z->c = z->l - m;
+ if (!(eq_s_b(z, 1, s_11)))
+ return 0;
+ }
lab0:
- z->bra = z->c; /* ], line 83 */
- if (!(out_grouping_b(z, g_v, 97, 121))) return 0;
- { int m = z->l - z->c; /* not, line 84 */
- if (z->c > z->lb) goto lab2; /* atlimit, line 84 */
- return 0;
- lab2:
- z->c = z->l - m;
- }
- slice_from_s(z, 1, s_12); /* <-, line 85 */
- return 1;
-}
+ z->bra = z->c; /* ], line 83 */
+ if (!(out_grouping_b(z, g_v, 97, 121)))
+ return 0;
+ {
+ int m = z->l - z->c; /* not, line 84 */
-static int r_Step_2(struct SN_env * z) {
- int among_var;
- z->ket = z->c; /* [, line 89 */
- among_var = find_among_b(z, a_4, 24); /* substring, line 89 */
- if (!(among_var)) return 0;
- z->bra = z->c; /* ], line 89 */
- if (!r_R1(z)) return 0; /* call R1, line 89 */
- switch(among_var) {
- case 0: return 0;
- case 1:
- slice_from_s(z, 4, s_13); /* <-, line 90 */
- break;
- case 2:
- slice_from_s(z, 4, s_14); /* <-, line 91 */
- break;
- case 3:
- slice_from_s(z, 4, s_15); /* <-, line 92 */
- break;
- case 4:
- slice_from_s(z, 4, s_16); /* <-, line 93 */
- break;
- case 5:
- slice_from_s(z, 3, s_17); /* <-, line 94 */
- break;
- case 6:
- slice_from_s(z, 3, s_18); /* <-, line 96 */
- break;
- case 7:
- slice_from_s(z, 3, s_19); /* <-, line 98 */
- break;
- case 8:
- slice_from_s(z, 2, s_20); /* <-, line 100 */
- break;
- case 9:
- slice_from_s(z, 3, s_21); /* <-, line 101 */
- break;
- case 10:
- slice_from_s(z, 3, s_22); /* <-, line 103 */
- break;
- case 11:
- slice_from_s(z, 3, s_23); /* <-, line 105 */
- break;
- case 12:
- slice_from_s(z, 3, s_24); /* <-, line 107 */
- break;
- case 13:
- if (!(eq_s_b(z, 1, s_25))) return 0;
- slice_from_s(z, 2, s_26); /* <-, line 108 */
- break;
- case 14:
- slice_from_s(z, 3, s_27); /* <-, line 109 */
- break;
- case 15:
- slice_from_s(z, 4, s_28); /* <-, line 110 */
- break;
- case 16:
- if (!(in_grouping_b(z, g_valid_LI, 99, 116))) return 0;
- slice_del(z); /* delete, line 111 */
- break;
- }
- return 1;
+ if (z->c > z->lb)
+ goto lab2; /* atlimit, line 84 */
+ return 0;
+lab2:
+ z->c = z->l - m;
+ }
+ slice_from_s(z, 1, s_12); /* <-, line 85 */
+ return 1;
}
-static int r_Step_3(struct SN_env * z) {
- int among_var;
- z->ket = z->c; /* [, line 116 */
- among_var = find_among_b(z, a_5, 9); /* substring, line 116 */
- if (!(among_var)) return 0;
- z->bra = z->c; /* ], line 116 */
- if (!r_R1(z)) return 0; /* call R1, line 116 */
- switch(among_var) {
- case 0: return 0;
- case 1:
- slice_from_s(z, 4, s_29); /* <-, line 117 */
- break;
- case 2:
- slice_from_s(z, 3, s_30); /* <-, line 118 */
- break;
- case 3:
- slice_from_s(z, 2, s_31); /* <-, line 119 */
- break;
- case 4:
- slice_from_s(z, 2, s_32); /* <-, line 121 */
- break;
- case 5:
- slice_del(z); /* delete, line 123 */
- break;
- case 6:
- if (!r_R2(z)) return 0; /* call R2, line 125 */
- slice_del(z); /* delete, line 125 */
- break;
- }
- return 1;
+static int
+r_Step_2(struct SN_env * z)
+{
+ int among_var;
+
+ z->ket = z->c; /* [, line 89 */
+ among_var = find_among_b(z, a_4, 24); /* substring, line 89 */
+ if (!(among_var))
+ return 0;
+ z->bra = z->c; /* ], line 89 */
+ if (!r_R1(z))
+ return 0; /* call R1, line 89 */
+ switch (among_var)
+ {
+ case 0:
+ return 0;
+ case 1:
+ slice_from_s(z, 4, s_13); /* <-, line 90 */
+ break;
+ case 2:
+ slice_from_s(z, 4, s_14); /* <-, line 91 */
+ break;
+ case 3:
+ slice_from_s(z, 4, s_15); /* <-, line 92 */
+ break;
+ case 4:
+ slice_from_s(z, 4, s_16); /* <-, line 93 */
+ break;
+ case 5:
+ slice_from_s(z, 3, s_17); /* <-, line 94 */
+ break;
+ case 6:
+ slice_from_s(z, 3, s_18); /* <-, line 96 */
+ break;
+ case 7:
+ slice_from_s(z, 3, s_19); /* <-, line 98 */
+ break;
+ case 8:
+ slice_from_s(z, 2, s_20); /* <-, line 100 */
+ break;
+ case 9:
+ slice_from_s(z, 3, s_21); /* <-, line 101 */
+ break;
+ case 10:
+ slice_from_s(z, 3, s_22); /* <-, line 103 */
+ break;
+ case 11:
+ slice_from_s(z, 3, s_23); /* <-, line 105 */
+ break;
+ case 12:
+ slice_from_s(z, 3, s_24); /* <-, line 107 */
+ break;
+ case 13:
+ if (!(eq_s_b(z, 1, s_25)))
+ return 0;
+ slice_from_s(z, 2, s_26); /* <-, line 108 */
+ break;
+ case 14:
+ slice_from_s(z, 3, s_27); /* <-, line 109 */
+ break;
+ case 15:
+ slice_from_s(z, 4, s_28); /* <-, line 110 */
+ break;
+ case 16:
+ if (!(in_grouping_b(z, g_valid_LI, 99, 116)))
+ return 0;
+ slice_del(z); /* delete, line 111 */
+ break;
+ }
+ return 1;
}
-static int r_Step_4(struct SN_env * z) {
- int among_var;
- z->ket = z->c; /* [, line 130 */
- among_var = find_among_b(z, a_6, 18); /* substring, line 130 */
- if (!(among_var)) return 0;
- z->bra = z->c; /* ], line 130 */
- if (!r_R2(z)) return 0; /* call R2, line 130 */
- switch(among_var) {
- case 0: return 0;
- case 1:
- slice_del(z); /* delete, line 133 */
- break;
- case 2:
- { int m = z->l - z->c; /* or, line 134 */
- if (!(eq_s_b(z, 1, s_33))) goto lab1;
- goto lab0;
- lab1:
- z->c = z->l - m;
- if (!(eq_s_b(z, 1, s_34))) return 0;
- }
- lab0:
- slice_del(z); /* delete, line 134 */
- break;
- }
- return 1;
+static int
+r_Step_3(struct SN_env * z)
+{
+ int among_var;
+
+ z->ket = z->c; /* [, line 116 */
+ among_var = find_among_b(z, a_5, 9); /* substring, line 116 */
+ if (!(among_var))
+ return 0;
+ z->bra = z->c; /* ], line 116 */
+ if (!r_R1(z))
+ return 0; /* call R1, line 116 */
+ switch (among_var)
+ {
+ case 0:
+ return 0;
+ case 1:
+ slice_from_s(z, 4, s_29); /* <-, line 117 */
+ break;
+ case 2:
+ slice_from_s(z, 3, s_30); /* <-, line 118 */
+ break;
+ case 3:
+ slice_from_s(z, 2, s_31); /* <-, line 119 */
+ break;
+ case 4:
+ slice_from_s(z, 2, s_32); /* <-, line 121 */
+ break;
+ case 5:
+ slice_del(z); /* delete, line 123 */
+ break;
+ case 6:
+ if (!r_R2(z))
+ return 0; /* call R2, line 125 */
+ slice_del(z); /* delete, line 125 */
+ break;
+ }
+ return 1;
}
-static int r_Step_5(struct SN_env * z) {
- int among_var;
- z->ket = z->c; /* [, line 139 */
- among_var = find_among_b(z, a_7, 2); /* substring, line 139 */
- if (!(among_var)) return 0;
- z->bra = z->c; /* ], line 139 */
- switch(among_var) {
- case 0: return 0;
- case 1:
- { int m = z->l - z->c; /* or, line 140 */
- if (!r_R2(z)) goto lab1; /* call R2, line 140 */
- goto lab0;
- lab1:
- z->c = z->l - m;
- if (!r_R1(z)) return 0; /* call R1, line 140 */
- { int m = z->l - z->c; /* not, line 140 */
- if (!r_shortv(z)) goto lab2; /* call shortv, line 140 */
- return 0;
- lab2:
- z->c = z->l - m;
- }
- }
- lab0:
- slice_del(z); /* delete, line 140 */
- break;
- case 2:
- if (!r_R2(z)) return 0; /* call R2, line 141 */
- if (!(eq_s_b(z, 1, s_35))) return 0;
- slice_del(z); /* delete, line 141 */
- break;
- }
- return 1;
+static int
+r_Step_4(struct SN_env * z)
+{
+ int among_var;
+
+ z->ket = z->c; /* [, line 130 */
+ among_var = find_among_b(z, a_6, 18); /* substring, line 130 */
+ if (!(among_var))
+ return 0;
+ z->bra = z->c; /* ], line 130 */
+ if (!r_R2(z))
+ return 0; /* call R2, line 130 */
+ switch (among_var)
+ {
+ case 0:
+ return 0;
+ case 1:
+ slice_del(z); /* delete, line 133 */
+ break;
+ case 2:
+ {
+ int m = z->l - z->c; /* or, line 134 */
+
+ if (!(eq_s_b(z, 1, s_33)))
+ goto lab1;
+ goto lab0;
+ lab1:
+ z->c = z->l - m;
+ if (!(eq_s_b(z, 1, s_34)))
+ return 0;
+ }
+ lab0:
+ slice_del(z); /* delete, line 134 */
+ break;
+ }
+ return 1;
}
-static int r_exception2(struct SN_env * z) {
- z->ket = z->c; /* [, line 147 */
- if (!(find_among_b(z, a_8, 8))) return 0; /* substring, line 147 */
- z->bra = z->c; /* ], line 147 */
- if (z->c > z->lb) return 0; /* atlimit, line 147 */
- return 1;
+static int
+r_Step_5(struct SN_env * z)
+{
+ int among_var;
+
+ z->ket = z->c; /* [, line 139 */
+ among_var = find_among_b(z, a_7, 2); /* substring, line 139 */
+ if (!(among_var))
+ return 0;
+ z->bra = z->c; /* ], line 139 */
+ switch (among_var)
+ {
+ case 0:
+ return 0;
+ case 1:
+ {
+ int m = z->l - z->c; /* or, line 140 */
+
+ if (!r_R2(z))
+ goto lab1; /* call R2, line 140 */
+ goto lab0;
+ lab1:
+ z->c = z->l - m;
+ if (!r_R1(z))
+ return 0; /* call R1, line 140 */
+ {
+ int m = z->l - z->c; /* not, line 140 */
+
+ if (!r_shortv(z))
+ goto lab2; /* call shortv, line 140 */
+ return 0;
+ lab2:
+ z->c = z->l - m;
+ }
+ }
+ lab0:
+ slice_del(z); /* delete, line 140 */
+ break;
+ case 2:
+ if (!r_R2(z))
+ return 0; /* call R2, line 141 */
+ if (!(eq_s_b(z, 1, s_35)))
+ return 0;
+ slice_del(z); /* delete, line 141 */
+ break;
+ }
+ return 1;
}
-static int r_exception1(struct SN_env * z) {
- int among_var;
- z->bra = z->c; /* [, line 159 */
- among_var = find_among(z, a_9, 18); /* substring, line 159 */
- if (!(among_var)) return 0;
- z->ket = z->c; /* ], line 159 */
- if (z->c < z->l) return 0; /* atlimit, line 159 */
- switch(among_var) {
- case 0: return 0;
- case 1:
- slice_from_s(z, 3, s_36); /* <-, line 163 */
- break;
- case 2:
- slice_from_s(z, 3, s_37); /* <-, line 164 */
- break;
- case 3:
- slice_from_s(z, 3, s_38); /* <-, line 165 */
- break;
- case 4:
- slice_from_s(z, 3, s_39); /* <-, line 166 */
- break;
- case 5:
- slice_from_s(z, 3, s_40); /* <-, line 167 */
- break;
- case 6:
- slice_from_s(z, 3, s_41); /* <-, line 171 */
- break;
- case 7:
- slice_from_s(z, 5, s_42); /* <-, line 172 */
- break;
- case 8:
- slice_from_s(z, 4, s_43); /* <-, line 173 */
- break;
- case 9:
- slice_from_s(z, 5, s_44); /* <-, line 174 */
- break;
- case 10:
- slice_from_s(z, 4, s_45); /* <-, line 175 */
- break;
- case 11:
- slice_from_s(z, 5, s_46); /* <-, line 176 */
- break;
- }
- return 1;
+static int
+r_exception2(struct SN_env * z)
+{
+ z->ket = z->c; /* [, line 147 */
+ if (!(find_among_b(z, a_8, 8)))
+ return 0; /* substring, line 147 */
+ z->bra = z->c; /* ], line 147 */
+ if (z->c > z->lb)
+ return 0; /* atlimit, line 147 */
+ return 1;
}
-static int r_postlude(struct SN_env * z) {
- if (!(z->B[0])) return 0; /* Boolean test Y_found, line 192 */
- while(1) { /* repeat, line 192 */
- int c = z->c;
- while(1) { /* goto, line 192 */
- int c = z->c;
- z->bra = z->c; /* [, line 192 */
- if (!(eq_s(z, 1, s_47))) goto lab1;
- z->ket = z->c; /* ], line 192 */
- z->c = c;
- break;
- lab1:
- z->c = c;
- if (z->c >= z->l) goto lab0;
- z->c++;
- }
- slice_from_s(z, 1, s_48); /* <-, line 192 */
- continue;
- lab0:
- z->c = c;
- break;
- }
- return 1;
+static int
+r_exception1(struct SN_env * z)
+{
+ int among_var;
+
+ z->bra = z->c; /* [, line 159 */
+ among_var = find_among(z, a_9, 18); /* substring, line 159 */
+ if (!(among_var))
+ return 0;
+ z->ket = z->c; /* ], line 159 */
+ if (z->c < z->l)
+ return 0; /* atlimit, line 159 */
+ switch (among_var)
+ {
+ case 0:
+ return 0;
+ case 1:
+ slice_from_s(z, 3, s_36); /* <-, line 163 */
+ break;
+ case 2:
+ slice_from_s(z, 3, s_37); /* <-, line 164 */
+ break;
+ case 3:
+ slice_from_s(z, 3, s_38); /* <-, line 165 */
+ break;
+ case 4:
+ slice_from_s(z, 3, s_39); /* <-, line 166 */
+ break;
+ case 5:
+ slice_from_s(z, 3, s_40); /* <-, line 167 */
+ break;
+ case 6:
+ slice_from_s(z, 3, s_41); /* <-, line 171 */
+ break;
+ case 7:
+ slice_from_s(z, 5, s_42); /* <-, line 172 */
+ break;
+ case 8:
+ slice_from_s(z, 4, s_43); /* <-, line 173 */
+ break;
+ case 9:
+ slice_from_s(z, 5, s_44); /* <-, line 174 */
+ break;
+ case 10:
+ slice_from_s(z, 4, s_45); /* <-, line 175 */
+ break;
+ case 11:
+ slice_from_s(z, 5, s_46); /* <-, line 176 */
+ break;
+ }
+ return 1;
}
-extern int english_stem(struct SN_env * z) {
- { int c = z->c; /* or, line 196 */
- if (!r_exception1(z)) goto lab1; /* call exception1, line 196 */
- goto lab0;
- lab1:
- z->c = c;
- { int c_test = z->c; /* test, line 198 */
- { int c = z->c + 3;
- if (0 > c || c > z->l) return 0;
- z->c = c; /* hop, line 198 */
- }
- z->c = c_test;
- }
- { int c = z->c; /* do, line 199 */
- if (!r_prelude(z)) goto lab2; /* call prelude, line 199 */
- lab2:
- z->c = c;
- }
- { int c = z->c; /* do, line 200 */
- if (!r_mark_regions(z)) goto lab3; /* call mark_regions, line 200 */
- lab3:
- z->c = c;
- }
- z->lb = z->c; z->c = z->l; /* backwards, line 201 */
-
- { int m = z->l - z->c; /* do, line 203 */
- if (!r_Step_1a(z)) goto lab4; /* call Step_1a, line 203 */
- lab4:
- z->c = z->l - m;
- }
- { int m = z->l - z->c; /* or, line 205 */
- if (!r_exception2(z)) goto lab6; /* call exception2, line 205 */
- goto lab5;
- lab6:
- z->c = z->l - m;
- { int m = z->l - z->c; /* do, line 207 */
- if (!r_Step_1b(z)) goto lab7; /* call Step_1b, line 207 */
- lab7:
- z->c = z->l - m;
- }
- { int m = z->l - z->c; /* do, line 208 */
- if (!r_Step_1c(z)) goto lab8; /* call Step_1c, line 208 */
- lab8:
- z->c = z->l - m;
- }
- { int m = z->l - z->c; /* do, line 210 */
- if (!r_Step_2(z)) goto lab9; /* call Step_2, line 210 */
- lab9:
- z->c = z->l - m;
- }
- { int m = z->l - z->c; /* do, line 211 */
- if (!r_Step_3(z)) goto lab10; /* call Step_3, line 211 */
- lab10:
- z->c = z->l - m;
- }
- { int m = z->l - z->c; /* do, line 212 */
- if (!r_Step_4(z)) goto lab11; /* call Step_4, line 212 */
- lab11:
- z->c = z->l - m;
- }
- { int m = z->l - z->c; /* do, line 214 */
- if (!r_Step_5(z)) goto lab12; /* call Step_5, line 214 */
- lab12:
- z->c = z->l - m;
- }
- }
- lab5:
- z->c = z->lb;
- { int c = z->c; /* do, line 217 */
- if (!r_postlude(z)) goto lab13; /* call postlude, line 217 */
- lab13:
- z->c = c;
- }
- }
+static int
+r_postlude(struct SN_env * z)
+{
+ if (!(z->B[0]))
+ return 0; /* Boolean test Y_found, line 192 */
+ while (1)
+ { /* repeat, line 192 */
+ int c = z->c;
+
+ while (1)
+ { /* goto, line 192 */
+ int c = z->c;
+
+ z->bra = z->c; /* [, line 192 */
+ if (!(eq_s(z, 1, s_47)))
+ goto lab1;
+ z->ket = z->c; /* ], line 192 */
+ z->c = c;
+ break;
+ lab1:
+ z->c = c;
+ if (z->c >= z->l)
+ goto lab0;
+ z->c++;
+ }
+ slice_from_s(z, 1, s_48); /* <-, line 192 */
+ continue;
lab0:
- return 1;
+ z->c = c;
+ break;
+ }
+ return 1;
}
-extern struct SN_env * english_create_env(void) { return SN_create_env(0, 2, 1); }
+extern int
+english_stem(struct SN_env * z)
+{
+ {
+ int c = z->c; /* or, line 196 */
+
+ if (!r_exception1(z))
+ goto lab1; /* call exception1, line 196 */
+ goto lab0;
+lab1:
+ z->c = c;
+ {
+ int c_test = z->c; /* test, line 198 */
+
+ {
+ int c = z->c + 3;
+
+ if (0 > c || c > z->l)
+ return 0;
+ z->c = c; /* hop, line 198 */
+ }
+ z->c = c_test;
+ }
+ {
+ int c = z->c; /* do, line 199 */
+
+ if (!r_prelude(z))
+ goto lab2; /* call prelude, line 199 */
+ lab2:
+ z->c = c;
+ }
+ {
+ int c = z->c; /* do, line 200 */
-extern void english_close_env(struct SN_env * z) { SN_close_env(z); }
+ if (!r_mark_regions(z))
+ goto lab3; /* call mark_regions, line 200 */
+ lab3:
+ z->c = c;
+ }
+ z->lb = z->c;
+ z->c = z->l; /* backwards, line 201 */
+ {
+ int m = z->l - z->c; /* do, line 203 */
+
+ if (!r_Step_1a(z))
+ goto lab4; /* call Step_1a, line 203 */
+ lab4:
+ z->c = z->l - m;
+ }
+ {
+ int m = z->l - z->c; /* or, line 205 */
+
+ if (!r_exception2(z))
+ goto lab6; /* call exception2, line 205 */
+ goto lab5;
+ lab6:
+ z->c = z->l - m;
+ {
+ int m = z->l - z->c; /* do, line 207 */
+
+ if (!r_Step_1b(z))
+ goto lab7; /* call Step_1b, line 207 */
+ lab7:
+ z->c = z->l - m;
+ }
+ {
+ int m = z->l - z->c; /* do, line 208 */
+
+ if (!r_Step_1c(z))
+ goto lab8; /* call Step_1c, line 208 */
+ lab8:
+ z->c = z->l - m;
+ }
+ {
+ int m = z->l - z->c; /* do, line 210 */
+
+ if (!r_Step_2(z))
+ goto lab9; /* call Step_2, line 210 */
+ lab9:
+ z->c = z->l - m;
+ }
+ {
+ int m = z->l - z->c; /* do, line 211 */
+
+ if (!r_Step_3(z))
+ goto lab10; /* call Step_3, line 211 */
+ lab10:
+ z->c = z->l - m;
+ }
+ {
+ int m = z->l - z->c; /* do, line 212 */
+
+ if (!r_Step_4(z))
+ goto lab11; /* call Step_4, line 212 */
+ lab11:
+ z->c = z->l - m;
+ }
+ {
+ int m = z->l - z->c; /* do, line 214 */
+
+ if (!r_Step_5(z))
+ goto lab12; /* call Step_5, line 214 */
+ lab12:
+ z->c = z->l - m;
+ }
+ }
+lab5:
+ z->c = z->lb;
+ {
+ int c = z->c; /* do, line 217 */
+
+ if (!r_postlude(z))
+ goto lab13; /* call postlude, line 217 */
+ lab13:
+ z->c = c;
+ }
+ }
+lab0:
+ return 1;
+}
+
+extern struct SN_env *english_create_env(void)
+{
+ return SN_create_env(0, 2, 1);
+}
+
+extern void english_close_env(struct SN_env * z)
+{
+ SN_close_env(z);
+}
/* This file was generated automatically by the Snowball to ANSI C compiler */
-extern struct SN_env * english_create_env(void);
+extern struct SN_env *english_create_env(void);
extern void english_close_env(struct SN_env * z);
-extern int english_stem(struct SN_env * z);
-
+extern int english_stem(struct SN_env * z);
#define HEAD 2*sizeof(int)
-#define SIZE(p) ((int *)(p))[-1]
+#define SIZE(p) ((int *)(p))[-1]
#define SET_SIZE(p, n) ((int *)(p))[-1] = n
#define CAPACITY(p) ((int *)(p))[-2]
struct among
-{ int s_size; /* number of chars in string */
- symbol * s; /* search string */
- int substring_i;/* index to longest matching substring */
- int result; /* result of the lookup */
- int (* function)(struct SN_env *);
+{
+ int s_size; /* number of chars in string */
+ symbol *s; /* search string */
+ int substring_i; /* index to longest matching substring */
+ int result; /* result of the lookup */
+ int (*function) (struct SN_env *);
};
-extern symbol * create_s(void);
+extern symbol *create_s(void);
extern void lose_s(symbol * p);
-extern int in_grouping(struct SN_env * z, unsigned char * s, int min, int max);
-extern int in_grouping_b(struct SN_env * z, unsigned char * s, int min, int max);
-extern int out_grouping(struct SN_env * z, unsigned char * s, int min, int max);
-extern int out_grouping_b(struct SN_env * z, unsigned char * s, int min, int max);
+extern int in_grouping(struct SN_env * z, unsigned char *s, int min, int max);
+extern int in_grouping_b(struct SN_env * z, unsigned char *s, int min, int max);
+extern int out_grouping(struct SN_env * z, unsigned char *s, int min, int max);
+extern int out_grouping_b(struct SN_env * z, unsigned char *s, int min, int max);
-extern int in_range(struct SN_env * z, int min, int max);
-extern int in_range_b(struct SN_env * z, int min, int max);
-extern int out_range(struct SN_env * z, int min, int max);
-extern int out_range_b(struct SN_env * z, int min, int max);
+extern int in_range(struct SN_env * z, int min, int max);
+extern int in_range_b(struct SN_env * z, int min, int max);
+extern int out_range(struct SN_env * z, int min, int max);
+extern int out_range_b(struct SN_env * z, int min, int max);
-extern int eq_s(struct SN_env * z, int s_size, symbol * s);
-extern int eq_s_b(struct SN_env * z, int s_size, symbol * s);
-extern int eq_v(struct SN_env * z, symbol * p);
-extern int eq_v_b(struct SN_env * z, symbol * p);
+extern int eq_s(struct SN_env * z, int s_size, symbol * s);
+extern int eq_s_b(struct SN_env * z, int s_size, symbol * s);
+extern int eq_v(struct SN_env * z, symbol * p);
+extern int eq_v_b(struct SN_env * z, symbol * p);
-extern int find_among(struct SN_env * z, struct among * v, int v_size);
-extern int find_among_b(struct SN_env * z, struct among * v, int v_size);
+extern int find_among(struct SN_env * z, struct among * v, int v_size);
+extern int find_among_b(struct SN_env * z, struct among * v, int v_size);
-extern symbol * increase_size(symbol * p, int n);
-extern int replace_s(struct SN_env * z, int c_bra, int c_ket, int s_size, const symbol * s);
+extern symbol *increase_size(symbol * p, int n);
+extern int replace_s(struct SN_env * z, int c_bra, int c_ket, int s_size, const symbol * s);
extern void slice_from_s(struct SN_env * z, int s_size, symbol * s);
extern void slice_from_v(struct SN_env * z, symbol * p);
extern void slice_del(struct SN_env * z);
extern void insert_s(struct SN_env * z, int bra, int ket, int s_size, symbol * s);
extern void insert_v(struct SN_env * z, int bra, int ket, symbol * p);
-extern symbol * slice_to(struct SN_env * z, symbol * p);
-extern symbol * assign_to(struct SN_env * z, symbol * p);
+extern symbol *slice_to(struct SN_env * z, symbol * p);
+extern symbol *assign_to(struct SN_env * z, symbol * p);
extern void debug(struct SN_env * z, int number, int line_count);
-
#include "header.h"
-extern int russian_stem(struct SN_env * z);
-static int r_tidy_up(struct SN_env * z);
-static int r_derivational(struct SN_env * z);
-static int r_noun(struct SN_env * z);
-static int r_verb(struct SN_env * z);
-static int r_reflexive(struct SN_env * z);
-static int r_adjectival(struct SN_env * z);
-static int r_adjective(struct SN_env * z);
-static int r_perfective_gerund(struct SN_env * z);
-static int r_R2(struct SN_env * z);
-static int r_mark_regions(struct SN_env * z);
-
-extern struct SN_env * russian_create_env(void);
+extern int russian_stem(struct SN_env * z);
+static int r_tidy_up(struct SN_env * z);
+static int r_derivational(struct SN_env * z);
+static int r_noun(struct SN_env * z);
+static int r_verb(struct SN_env * z);
+static int r_reflexive(struct SN_env * z);
+static int r_adjectival(struct SN_env * z);
+static int r_adjective(struct SN_env * z);
+static int r_perfective_gerund(struct SN_env * z);
+static int r_R2(struct SN_env * z);
+static int r_mark_regions(struct SN_env * z);
+
+extern struct SN_env *russian_create_env(void);
extern void russian_close_env(struct SN_env * z);
-static symbol s_0_0[3] = { 215, 219, 201 };
-static symbol s_0_1[4] = { 201, 215, 219, 201 };
-static symbol s_0_2[4] = { 217, 215, 219, 201 };
-static symbol s_0_3[1] = { 215 };
-static symbol s_0_4[2] = { 201, 215 };
-static symbol s_0_5[2] = { 217, 215 };
-static symbol s_0_6[5] = { 215, 219, 201, 211, 216 };
-static symbol s_0_7[6] = { 201, 215, 219, 201, 211, 216 };
-static symbol s_0_8[6] = { 217, 215, 219, 201, 211, 216 };
+static symbol s_0_0[3] = {215, 219, 201};
+static symbol s_0_1[4] = {201, 215, 219, 201};
+static symbol s_0_2[4] = {217, 215, 219, 201};
+static symbol s_0_3[1] = {215};
+static symbol s_0_4[2] = {201, 215};
+static symbol s_0_5[2] = {217, 215};
+static symbol s_0_6[5] = {215, 219, 201, 211, 216};
+static symbol s_0_7[6] = {201, 215, 219, 201, 211, 216};
+static symbol s_0_8[6] = {217, 215, 219, 201, 211, 216};
static struct among a_0[9] =
{
-/* 0 */ { 3, s_0_0, -1, 1, 0},
-/* 1 */ { 4, s_0_1, 0, 2, 0},
-/* 2 */ { 4, s_0_2, 0, 2, 0},
-/* 3 */ { 1, s_0_3, -1, 1, 0},
-/* 4 */ { 2, s_0_4, 3, 2, 0},
-/* 5 */ { 2, s_0_5, 3, 2, 0},
-/* 6 */ { 5, s_0_6, -1, 1, 0},
-/* 7 */ { 6, s_0_7, 6, 2, 0},
-/* 8 */ { 6, s_0_8, 6, 2, 0}
+ /* 0 */ {3, s_0_0, -1, 1, 0},
+ /* 1 */ {4, s_0_1, 0, 2, 0},
+ /* 2 */ {4, s_0_2, 0, 2, 0},
+ /* 3 */ {1, s_0_3, -1, 1, 0},
+ /* 4 */ {2, s_0_4, 3, 2, 0},
+ /* 5 */ {2, s_0_5, 3, 2, 0},
+ /* 6 */ {5, s_0_6, -1, 1, 0},
+ /* 7 */ {6, s_0_7, 6, 2, 0},
+ /* 8 */ {6, s_0_8, 6, 2, 0}
};
-static symbol s_1_0[2] = { 192, 192 };
-static symbol s_1_1[2] = { 197, 192 };
-static symbol s_1_2[2] = { 207, 192 };
-static symbol s_1_3[2] = { 213, 192 };
-static symbol s_1_4[2] = { 197, 197 };
-static symbol s_1_5[2] = { 201, 197 };
-static symbol s_1_6[2] = { 207, 197 };
-static symbol s_1_7[2] = { 217, 197 };
-static symbol s_1_8[2] = { 201, 200 };
-static symbol s_1_9[2] = { 217, 200 };
-static symbol s_1_10[3] = { 201, 205, 201 };
-static symbol s_1_11[3] = { 217, 205, 201 };
-static symbol s_1_12[2] = { 197, 202 };
-static symbol s_1_13[2] = { 201, 202 };
-static symbol s_1_14[2] = { 207, 202 };
-static symbol s_1_15[2] = { 217, 202 };
-static symbol s_1_16[2] = { 197, 205 };
-static symbol s_1_17[2] = { 201, 205 };
-static symbol s_1_18[2] = { 207, 205 };
-static symbol s_1_19[2] = { 217, 205 };
-static symbol s_1_20[3] = { 197, 199, 207 };
-static symbol s_1_21[3] = { 207, 199, 207 };
-static symbol s_1_22[2] = { 193, 209 };
-static symbol s_1_23[2] = { 209, 209 };
-static symbol s_1_24[3] = { 197, 205, 213 };
-static symbol s_1_25[3] = { 207, 205, 213 };
+static symbol s_1_0[2] = {192, 192};
+static symbol s_1_1[2] = {197, 192};
+static symbol s_1_2[2] = {207, 192};
+static symbol s_1_3[2] = {213, 192};
+static symbol s_1_4[2] = {197, 197};
+static symbol s_1_5[2] = {201, 197};
+static symbol s_1_6[2] = {207, 197};
+static symbol s_1_7[2] = {217, 197};
+static symbol s_1_8[2] = {201, 200};
+static symbol s_1_9[2] = {217, 200};
+static symbol s_1_10[3] = {201, 205, 201};
+static symbol s_1_11[3] = {217, 205, 201};
+static symbol s_1_12[2] = {197, 202};
+static symbol s_1_13[2] = {201, 202};
+static symbol s_1_14[2] = {207, 202};
+static symbol s_1_15[2] = {217, 202};
+static symbol s_1_16[2] = {197, 205};
+static symbol s_1_17[2] = {201, 205};
+static symbol s_1_18[2] = {207, 205};
+static symbol s_1_19[2] = {217, 205};
+static symbol s_1_20[3] = {197, 199, 207};
+static symbol s_1_21[3] = {207, 199, 207};
+static symbol s_1_22[2] = {193, 209};
+static symbol s_1_23[2] = {209, 209};
+static symbol s_1_24[3] = {197, 205, 213};
+static symbol s_1_25[3] = {207, 205, 213};
static struct among a_1[26] =
{
-/* 0 */ { 2, s_1_0, -1, 1, 0},
-/* 1 */ { 2, s_1_1, -1, 1, 0},
-/* 2 */ { 2, s_1_2, -1, 1, 0},
-/* 3 */ { 2, s_1_3, -1, 1, 0},
-/* 4 */ { 2, s_1_4, -1, 1, 0},
-/* 5 */ { 2, s_1_5, -1, 1, 0},
-/* 6 */ { 2, s_1_6, -1, 1, 0},
-/* 7 */ { 2, s_1_7, -1, 1, 0},
-/* 8 */ { 2, s_1_8, -1, 1, 0},
-/* 9 */ { 2, s_1_9, -1, 1, 0},
-/* 10 */ { 3, s_1_10, -1, 1, 0},
-/* 11 */ { 3, s_1_11, -1, 1, 0},
-/* 12 */ { 2, s_1_12, -1, 1, 0},
-/* 13 */ { 2, s_1_13, -1, 1, 0},
-/* 14 */ { 2, s_1_14, -1, 1, 0},
-/* 15 */ { 2, s_1_15, -1, 1, 0},
-/* 16 */ { 2, s_1_16, -1, 1, 0},
-/* 17 */ { 2, s_1_17, -1, 1, 0},
-/* 18 */ { 2, s_1_18, -1, 1, 0},
-/* 19 */ { 2, s_1_19, -1, 1, 0},
-/* 20 */ { 3, s_1_20, -1, 1, 0},
-/* 21 */ { 3, s_1_21, -1, 1, 0},
-/* 22 */ { 2, s_1_22, -1, 1, 0},
-/* 23 */ { 2, s_1_23, -1, 1, 0},
-/* 24 */ { 3, s_1_24, -1, 1, 0},
-/* 25 */ { 3, s_1_25, -1, 1, 0}
+ /* 0 */ {2, s_1_0, -1, 1, 0},
+ /* 1 */ {2, s_1_1, -1, 1, 0},
+ /* 2 */ {2, s_1_2, -1, 1, 0},
+ /* 3 */ {2, s_1_3, -1, 1, 0},
+ /* 4 */ {2, s_1_4, -1, 1, 0},
+ /* 5 */ {2, s_1_5, -1, 1, 0},
+ /* 6 */ {2, s_1_6, -1, 1, 0},
+ /* 7 */ {2, s_1_7, -1, 1, 0},
+ /* 8 */ {2, s_1_8, -1, 1, 0},
+ /* 9 */ {2, s_1_9, -1, 1, 0},
+ /* 10 */ {3, s_1_10, -1, 1, 0},
+ /* 11 */ {3, s_1_11, -1, 1, 0},
+ /* 12 */ {2, s_1_12, -1, 1, 0},
+ /* 13 */ {2, s_1_13, -1, 1, 0},
+ /* 14 */ {2, s_1_14, -1, 1, 0},
+ /* 15 */ {2, s_1_15, -1, 1, 0},
+ /* 16 */ {2, s_1_16, -1, 1, 0},
+ /* 17 */ {2, s_1_17, -1, 1, 0},
+ /* 18 */ {2, s_1_18, -1, 1, 0},
+ /* 19 */ {2, s_1_19, -1, 1, 0},
+ /* 20 */ {3, s_1_20, -1, 1, 0},
+ /* 21 */ {3, s_1_21, -1, 1, 0},
+ /* 22 */ {2, s_1_22, -1, 1, 0},
+ /* 23 */ {2, s_1_23, -1, 1, 0},
+ /* 24 */ {3, s_1_24, -1, 1, 0},
+ /* 25 */ {3, s_1_25, -1, 1, 0}
};
-static symbol s_2_0[2] = { 197, 205 };
-static symbol s_2_1[2] = { 206, 206 };
-static symbol s_2_2[2] = { 215, 219 };
-static symbol s_2_3[3] = { 201, 215, 219 };
-static symbol s_2_4[3] = { 217, 215, 219 };
-static symbol s_2_5[1] = { 221 };
-static symbol s_2_6[2] = { 192, 221 };
-static symbol s_2_7[3] = { 213, 192, 221 };
+static symbol s_2_0[2] = {197, 205};
+static symbol s_2_1[2] = {206, 206};
+static symbol s_2_2[2] = {215, 219};
+static symbol s_2_3[3] = {201, 215, 219};
+static symbol s_2_4[3] = {217, 215, 219};
+static symbol s_2_5[1] = {221};
+static symbol s_2_6[2] = {192, 221};
+static symbol s_2_7[3] = {213, 192, 221};
static struct among a_2[8] =
{
-/* 0 */ { 2, s_2_0, -1, 1, 0},
-/* 1 */ { 2, s_2_1, -1, 1, 0},
-/* 2 */ { 2, s_2_2, -1, 1, 0},
-/* 3 */ { 3, s_2_3, 2, 2, 0},
-/* 4 */ { 3, s_2_4, 2, 2, 0},
-/* 5 */ { 1, s_2_5, -1, 1, 0},
-/* 6 */ { 2, s_2_6, 5, 1, 0},
-/* 7 */ { 3, s_2_7, 6, 2, 0}
+ /* 0 */ {2, s_2_0, -1, 1, 0},
+ /* 1 */ {2, s_2_1, -1, 1, 0},
+ /* 2 */ {2, s_2_2, -1, 1, 0},
+ /* 3 */ {3, s_2_3, 2, 2, 0},
+ /* 4 */ {3, s_2_4, 2, 2, 0},
+ /* 5 */ {1, s_2_5, -1, 1, 0},
+ /* 6 */ {2, s_2_6, 5, 1, 0},
+ /* 7 */ {3, s_2_7, 6, 2, 0}
};
-static symbol s_3_0[2] = { 211, 209 };
-static symbol s_3_1[2] = { 211, 216 };
+static symbol s_3_0[2] = {211, 209};
+static symbol s_3_1[2] = {211, 216};
static struct among a_3[2] =
{
-/* 0 */ { 2, s_3_0, -1, 1, 0},
-/* 1 */ { 2, s_3_1, -1, 1, 0}
+ /* 0 */ {2, s_3_0, -1, 1, 0},
+ /* 1 */ {2, s_3_1, -1, 1, 0}
};
-static symbol s_4_0[1] = { 192 };
-static symbol s_4_1[2] = { 213, 192 };
-static symbol s_4_2[2] = { 204, 193 };
-static symbol s_4_3[3] = { 201, 204, 193 };
-static symbol s_4_4[3] = { 217, 204, 193 };
-static symbol s_4_5[2] = { 206, 193 };
-static symbol s_4_6[3] = { 197, 206, 193 };
-static symbol s_4_7[3] = { 197, 212, 197 };
-static symbol s_4_8[3] = { 201, 212, 197 };
-static symbol s_4_9[3] = { 202, 212, 197 };
-static symbol s_4_10[4] = { 197, 202, 212, 197 };
-static symbol s_4_11[4] = { 213, 202, 212, 197 };
-static symbol s_4_12[2] = { 204, 201 };
-static symbol s_4_13[3] = { 201, 204, 201 };
-static symbol s_4_14[3] = { 217, 204, 201 };
-static symbol s_4_15[1] = { 202 };
-static symbol s_4_16[2] = { 197, 202 };
-static symbol s_4_17[2] = { 213, 202 };
-static symbol s_4_18[1] = { 204 };
-static symbol s_4_19[2] = { 201, 204 };
-static symbol s_4_20[2] = { 217, 204 };
-static symbol s_4_21[2] = { 197, 205 };
-static symbol s_4_22[2] = { 201, 205 };
-static symbol s_4_23[2] = { 217, 205 };
-static symbol s_4_24[1] = { 206 };
-static symbol s_4_25[2] = { 197, 206 };
-static symbol s_4_26[2] = { 204, 207 };
-static symbol s_4_27[3] = { 201, 204, 207 };
-static symbol s_4_28[3] = { 217, 204, 207 };
-static symbol s_4_29[2] = { 206, 207 };
-static symbol s_4_30[3] = { 197, 206, 207 };
-static symbol s_4_31[3] = { 206, 206, 207 };
-static symbol s_4_32[2] = { 192, 212 };
-static symbol s_4_33[3] = { 213, 192, 212 };
-static symbol s_4_34[2] = { 197, 212 };
-static symbol s_4_35[3] = { 213, 197, 212 };
-static symbol s_4_36[2] = { 201, 212 };
-static symbol s_4_37[2] = { 209, 212 };
-static symbol s_4_38[2] = { 217, 212 };
-static symbol s_4_39[2] = { 212, 216 };
-static symbol s_4_40[3] = { 201, 212, 216 };
-static symbol s_4_41[3] = { 217, 212, 216 };
-static symbol s_4_42[3] = { 197, 219, 216 };
-static symbol s_4_43[3] = { 201, 219, 216 };
-static symbol s_4_44[2] = { 206, 217 };
-static symbol s_4_45[3] = { 197, 206, 217 };
+static symbol s_4_0[1] = {192};
+static symbol s_4_1[2] = {213, 192};
+static symbol s_4_2[2] = {204, 193};
+static symbol s_4_3[3] = {201, 204, 193};
+static symbol s_4_4[3] = {217, 204, 193};
+static symbol s_4_5[2] = {206, 193};
+static symbol s_4_6[3] = {197, 206, 193};
+static symbol s_4_7[3] = {197, 212, 197};
+static symbol s_4_8[3] = {201, 212, 197};
+static symbol s_4_9[3] = {202, 212, 197};
+static symbol s_4_10[4] = {197, 202, 212, 197};
+static symbol s_4_11[4] = {213, 202, 212, 197};
+static symbol s_4_12[2] = {204, 201};
+static symbol s_4_13[3] = {201, 204, 201};
+static symbol s_4_14[3] = {217, 204, 201};
+static symbol s_4_15[1] = {202};
+static symbol s_4_16[2] = {197, 202};
+static symbol s_4_17[2] = {213, 202};
+static symbol s_4_18[1] = {204};
+static symbol s_4_19[2] = {201, 204};
+static symbol s_4_20[2] = {217, 204};
+static symbol s_4_21[2] = {197, 205};
+static symbol s_4_22[2] = {201, 205};
+static symbol s_4_23[2] = {217, 205};
+static symbol s_4_24[1] = {206};
+static symbol s_4_25[2] = {197, 206};
+static symbol s_4_26[2] = {204, 207};
+static symbol s_4_27[3] = {201, 204, 207};
+static symbol s_4_28[3] = {217, 204, 207};
+static symbol s_4_29[2] = {206, 207};
+static symbol s_4_30[3] = {197, 206, 207};
+static symbol s_4_31[3] = {206, 206, 207};
+static symbol s_4_32[2] = {192, 212};
+static symbol s_4_33[3] = {213, 192, 212};
+static symbol s_4_34[2] = {197, 212};
+static symbol s_4_35[3] = {213, 197, 212};
+static symbol s_4_36[2] = {201, 212};
+static symbol s_4_37[2] = {209, 212};
+static symbol s_4_38[2] = {217, 212};
+static symbol s_4_39[2] = {212, 216};
+static symbol s_4_40[3] = {201, 212, 216};
+static symbol s_4_41[3] = {217, 212, 216};
+static symbol s_4_42[3] = {197, 219, 216};
+static symbol s_4_43[3] = {201, 219, 216};
+static symbol s_4_44[2] = {206, 217};
+static symbol s_4_45[3] = {197, 206, 217};
static struct among a_4[46] =
{
-/* 0 */ { 1, s_4_0, -1, 2, 0},
-/* 1 */ { 2, s_4_1, 0, 2, 0},
-/* 2 */ { 2, s_4_2, -1, 1, 0},
-/* 3 */ { 3, s_4_3, 2, 2, 0},
-/* 4 */ { 3, s_4_4, 2, 2, 0},
-/* 5 */ { 2, s_4_5, -1, 1, 0},
-/* 6 */ { 3, s_4_6, 5, 2, 0},
-/* 7 */ { 3, s_4_7, -1, 1, 0},
-/* 8 */ { 3, s_4_8, -1, 2, 0},
-/* 9 */ { 3, s_4_9, -1, 1, 0},
-/* 10 */ { 4, s_4_10, 9, 2, 0},
-/* 11 */ { 4, s_4_11, 9, 2, 0},
-/* 12 */ { 2, s_4_12, -1, 1, 0},
-/* 13 */ { 3, s_4_13, 12, 2, 0},
-/* 14 */ { 3, s_4_14, 12, 2, 0},
-/* 15 */ { 1, s_4_15, -1, 1, 0},
-/* 16 */ { 2, s_4_16, 15, 2, 0},
-/* 17 */ { 2, s_4_17, 15, 2, 0},
-/* 18 */ { 1, s_4_18, -1, 1, 0},
-/* 19 */ { 2, s_4_19, 18, 2, 0},
-/* 20 */ { 2, s_4_20, 18, 2, 0},
-/* 21 */ { 2, s_4_21, -1, 1, 0},
-/* 22 */ { 2, s_4_22, -1, 2, 0},
-/* 23 */ { 2, s_4_23, -1, 2, 0},
-/* 24 */ { 1, s_4_24, -1, 1, 0},
-/* 25 */ { 2, s_4_25, 24, 2, 0},
-/* 26 */ { 2, s_4_26, -1, 1, 0},
-/* 27 */ { 3, s_4_27, 26, 2, 0},
-/* 28 */ { 3, s_4_28, 26, 2, 0},
-/* 29 */ { 2, s_4_29, -1, 1, 0},
-/* 30 */ { 3, s_4_30, 29, 2, 0},
-/* 31 */ { 3, s_4_31, 29, 1, 0},
-/* 32 */ { 2, s_4_32, -1, 1, 0},
-/* 33 */ { 3, s_4_33, 32, 2, 0},
-/* 34 */ { 2, s_4_34, -1, 1, 0},
-/* 35 */ { 3, s_4_35, 34, 2, 0},
-/* 36 */ { 2, s_4_36, -1, 2, 0},
-/* 37 */ { 2, s_4_37, -1, 2, 0},
-/* 38 */ { 2, s_4_38, -1, 2, 0},
-/* 39 */ { 2, s_4_39, -1, 1, 0},
-/* 40 */ { 3, s_4_40, 39, 2, 0},
-/* 41 */ { 3, s_4_41, 39, 2, 0},
-/* 42 */ { 3, s_4_42, -1, 1, 0},
-/* 43 */ { 3, s_4_43, -1, 2, 0},
-/* 44 */ { 2, s_4_44, -1, 1, 0},
-/* 45 */ { 3, s_4_45, 44, 2, 0}
+ /* 0 */ {1, s_4_0, -1, 2, 0},
+ /* 1 */ {2, s_4_1, 0, 2, 0},
+ /* 2 */ {2, s_4_2, -1, 1, 0},
+ /* 3 */ {3, s_4_3, 2, 2, 0},
+ /* 4 */ {3, s_4_4, 2, 2, 0},
+ /* 5 */ {2, s_4_5, -1, 1, 0},
+ /* 6 */ {3, s_4_6, 5, 2, 0},
+ /* 7 */ {3, s_4_7, -1, 1, 0},
+ /* 8 */ {3, s_4_8, -1, 2, 0},
+ /* 9 */ {3, s_4_9, -1, 1, 0},
+ /* 10 */ {4, s_4_10, 9, 2, 0},
+ /* 11 */ {4, s_4_11, 9, 2, 0},
+ /* 12 */ {2, s_4_12, -1, 1, 0},
+ /* 13 */ {3, s_4_13, 12, 2, 0},
+ /* 14 */ {3, s_4_14, 12, 2, 0},
+ /* 15 */ {1, s_4_15, -1, 1, 0},
+ /* 16 */ {2, s_4_16, 15, 2, 0},
+ /* 17 */ {2, s_4_17, 15, 2, 0},
+ /* 18 */ {1, s_4_18, -1, 1, 0},
+ /* 19 */ {2, s_4_19, 18, 2, 0},
+ /* 20 */ {2, s_4_20, 18, 2, 0},
+ /* 21 */ {2, s_4_21, -1, 1, 0},
+ /* 22 */ {2, s_4_22, -1, 2, 0},
+ /* 23 */ {2, s_4_23, -1, 2, 0},
+ /* 24 */ {1, s_4_24, -1, 1, 0},
+ /* 25 */ {2, s_4_25, 24, 2, 0},
+ /* 26 */ {2, s_4_26, -1, 1, 0},
+ /* 27 */ {3, s_4_27, 26, 2, 0},
+ /* 28 */ {3, s_4_28, 26, 2, 0},
+ /* 29 */ {2, s_4_29, -1, 1, 0},
+ /* 30 */ {3, s_4_30, 29, 2, 0},
+ /* 31 */ {3, s_4_31, 29, 1, 0},
+ /* 32 */ {2, s_4_32, -1, 1, 0},
+ /* 33 */ {3, s_4_33, 32, 2, 0},
+ /* 34 */ {2, s_4_34, -1, 1, 0},
+ /* 35 */ {3, s_4_35, 34, 2, 0},
+ /* 36 */ {2, s_4_36, -1, 2, 0},
+ /* 37 */ {2, s_4_37, -1, 2, 0},
+ /* 38 */ {2, s_4_38, -1, 2, 0},
+ /* 39 */ {2, s_4_39, -1, 1, 0},
+ /* 40 */ {3, s_4_40, 39, 2, 0},
+ /* 41 */ {3, s_4_41, 39, 2, 0},
+ /* 42 */ {3, s_4_42, -1, 1, 0},
+ /* 43 */ {3, s_4_43, -1, 2, 0},
+ /* 44 */ {2, s_4_44, -1, 1, 0},
+ /* 45 */ {3, s_4_45, 44, 2, 0}
};
-static symbol s_5_0[1] = { 192 };
-static symbol s_5_1[2] = { 201, 192 };
-static symbol s_5_2[2] = { 216, 192 };
-static symbol s_5_3[1] = { 193 };
-static symbol s_5_4[1] = { 197 };
-static symbol s_5_5[2] = { 201, 197 };
-static symbol s_5_6[2] = { 216, 197 };
-static symbol s_5_7[2] = { 193, 200 };
-static symbol s_5_8[2] = { 209, 200 };
-static symbol s_5_9[3] = { 201, 209, 200 };
-static symbol s_5_10[1] = { 201 };
-static symbol s_5_11[2] = { 197, 201 };
-static symbol s_5_12[2] = { 201, 201 };
-static symbol s_5_13[3] = { 193, 205, 201 };
-static symbol s_5_14[3] = { 209, 205, 201 };
-static symbol s_5_15[4] = { 201, 209, 205, 201 };
-static symbol s_5_16[1] = { 202 };
-static symbol s_5_17[2] = { 197, 202 };
-static symbol s_5_18[3] = { 201, 197, 202 };
-static symbol s_5_19[2] = { 201, 202 };
-static symbol s_5_20[2] = { 207, 202 };
-static symbol s_5_21[2] = { 193, 205 };
-static symbol s_5_22[2] = { 197, 205 };
-static symbol s_5_23[3] = { 201, 197, 205 };
-static symbol s_5_24[2] = { 207, 205 };
-static symbol s_5_25[2] = { 209, 205 };
-static symbol s_5_26[3] = { 201, 209, 205 };
-static symbol s_5_27[1] = { 207 };
-static symbol s_5_28[1] = { 209 };
-static symbol s_5_29[2] = { 201, 209 };
-static symbol s_5_30[2] = { 216, 209 };
-static symbol s_5_31[1] = { 213 };
-static symbol s_5_32[2] = { 197, 215 };
-static symbol s_5_33[2] = { 207, 215 };
-static symbol s_5_34[1] = { 216 };
-static symbol s_5_35[1] = { 217 };
+static symbol s_5_0[1] = {192};
+static symbol s_5_1[2] = {201, 192};
+static symbol s_5_2[2] = {216, 192};
+static symbol s_5_3[1] = {193};
+static symbol s_5_4[1] = {197};
+static symbol s_5_5[2] = {201, 197};
+static symbol s_5_6[2] = {216, 197};
+static symbol s_5_7[2] = {193, 200};
+static symbol s_5_8[2] = {209, 200};
+static symbol s_5_9[3] = {201, 209, 200};
+static symbol s_5_10[1] = {201};
+static symbol s_5_11[2] = {197, 201};
+static symbol s_5_12[2] = {201, 201};
+static symbol s_5_13[3] = {193, 205, 201};
+static symbol s_5_14[3] = {209, 205, 201};
+static symbol s_5_15[4] = {201, 209, 205, 201};
+static symbol s_5_16[1] = {202};
+static symbol s_5_17[2] = {197, 202};
+static symbol s_5_18[3] = {201, 197, 202};
+static symbol s_5_19[2] = {201, 202};
+static symbol s_5_20[2] = {207, 202};
+static symbol s_5_21[2] = {193, 205};
+static symbol s_5_22[2] = {197, 205};
+static symbol s_5_23[3] = {201, 197, 205};
+static symbol s_5_24[2] = {207, 205};
+static symbol s_5_25[2] = {209, 205};
+static symbol s_5_26[3] = {201, 209, 205};
+static symbol s_5_27[1] = {207};
+static symbol s_5_28[1] = {209};
+static symbol s_5_29[2] = {201, 209};
+static symbol s_5_30[2] = {216, 209};
+static symbol s_5_31[1] = {213};
+static symbol s_5_32[2] = {197, 215};
+static symbol s_5_33[2] = {207, 215};
+static symbol s_5_34[1] = {216};
+static symbol s_5_35[1] = {217};
static struct among a_5[36] =
{
-/* 0 */ { 1, s_5_0, -1, 1, 0},
-/* 1 */ { 2, s_5_1, 0, 1, 0},
-/* 2 */ { 2, s_5_2, 0, 1, 0},
-/* 3 */ { 1, s_5_3, -1, 1, 0},
-/* 4 */ { 1, s_5_4, -1, 1, 0},
-/* 5 */ { 2, s_5_5, 4, 1, 0},
-/* 6 */ { 2, s_5_6, 4, 1, 0},
-/* 7 */ { 2, s_5_7, -1, 1, 0},
-/* 8 */ { 2, s_5_8, -1, 1, 0},
-/* 9 */ { 3, s_5_9, 8, 1, 0},
-/* 10 */ { 1, s_5_10, -1, 1, 0},
-/* 11 */ { 2, s_5_11, 10, 1, 0},
-/* 12 */ { 2, s_5_12, 10, 1, 0},
-/* 13 */ { 3, s_5_13, 10, 1, 0},
-/* 14 */ { 3, s_5_14, 10, 1, 0},
-/* 15 */ { 4, s_5_15, 14, 1, 0},
-/* 16 */ { 1, s_5_16, -1, 1, 0},
-/* 17 */ { 2, s_5_17, 16, 1, 0},
-/* 18 */ { 3, s_5_18, 17, 1, 0},
-/* 19 */ { 2, s_5_19, 16, 1, 0},
-/* 20 */ { 2, s_5_20, 16, 1, 0},
-/* 21 */ { 2, s_5_21, -1, 1, 0},
-/* 22 */ { 2, s_5_22, -1, 1, 0},
-/* 23 */ { 3, s_5_23, 22, 1, 0},
-/* 24 */ { 2, s_5_24, -1, 1, 0},
-/* 25 */ { 2, s_5_25, -1, 1, 0},
-/* 26 */ { 3, s_5_26, 25, 1, 0},
-/* 27 */ { 1, s_5_27, -1, 1, 0},
-/* 28 */ { 1, s_5_28, -1, 1, 0},
-/* 29 */ { 2, s_5_29, 28, 1, 0},
-/* 30 */ { 2, s_5_30, 28, 1, 0},
-/* 31 */ { 1, s_5_31, -1, 1, 0},
-/* 32 */ { 2, s_5_32, -1, 1, 0},
-/* 33 */ { 2, s_5_33, -1, 1, 0},
-/* 34 */ { 1, s_5_34, -1, 1, 0},
-/* 35 */ { 1, s_5_35, -1, 1, 0}
+ /* 0 */ {1, s_5_0, -1, 1, 0},
+ /* 1 */ {2, s_5_1, 0, 1, 0},
+ /* 2 */ {2, s_5_2, 0, 1, 0},
+ /* 3 */ {1, s_5_3, -1, 1, 0},
+ /* 4 */ {1, s_5_4, -1, 1, 0},
+ /* 5 */ {2, s_5_5, 4, 1, 0},
+ /* 6 */ {2, s_5_6, 4, 1, 0},
+ /* 7 */ {2, s_5_7, -1, 1, 0},
+ /* 8 */ {2, s_5_8, -1, 1, 0},
+ /* 9 */ {3, s_5_9, 8, 1, 0},
+ /* 10 */ {1, s_5_10, -1, 1, 0},
+ /* 11 */ {2, s_5_11, 10, 1, 0},
+ /* 12 */ {2, s_5_12, 10, 1, 0},
+ /* 13 */ {3, s_5_13, 10, 1, 0},
+ /* 14 */ {3, s_5_14, 10, 1, 0},
+ /* 15 */ {4, s_5_15, 14, 1, 0},
+ /* 16 */ {1, s_5_16, -1, 1, 0},
+ /* 17 */ {2, s_5_17, 16, 1, 0},
+ /* 18 */ {3, s_5_18, 17, 1, 0},
+ /* 19 */ {2, s_5_19, 16, 1, 0},
+ /* 20 */ {2, s_5_20, 16, 1, 0},
+ /* 21 */ {2, s_5_21, -1, 1, 0},
+ /* 22 */ {2, s_5_22, -1, 1, 0},
+ /* 23 */ {3, s_5_23, 22, 1, 0},
+ /* 24 */ {2, s_5_24, -1, 1, 0},
+ /* 25 */ {2, s_5_25, -1, 1, 0},
+ /* 26 */ {3, s_5_26, 25, 1, 0},
+ /* 27 */ {1, s_5_27, -1, 1, 0},
+ /* 28 */ {1, s_5_28, -1, 1, 0},
+ /* 29 */ {2, s_5_29, 28, 1, 0},
+ /* 30 */ {2, s_5_30, 28, 1, 0},
+ /* 31 */ {1, s_5_31, -1, 1, 0},
+ /* 32 */ {2, s_5_32, -1, 1, 0},
+ /* 33 */ {2, s_5_33, -1, 1, 0},
+ /* 34 */ {1, s_5_34, -1, 1, 0},
+ /* 35 */ {1, s_5_35, -1, 1, 0}
};
-static symbol s_6_0[3] = { 207, 211, 212 };
-static symbol s_6_1[4] = { 207, 211, 212, 216 };
+static symbol s_6_0[3] = {207, 211, 212};
+static symbol s_6_1[4] = {207, 211, 212, 216};
static struct among a_6[2] =
{
-/* 0 */ { 3, s_6_0, -1, 1, 0},
-/* 1 */ { 4, s_6_1, -1, 1, 0}
+ /* 0 */ {3, s_6_0, -1, 1, 0},
+ /* 1 */ {4, s_6_1, -1, 1, 0}
};
-static symbol s_7_0[4] = { 197, 202, 219, 197 };
-static symbol s_7_1[1] = { 206 };
-static symbol s_7_2[1] = { 216 };
-static symbol s_7_3[3] = { 197, 202, 219 };
+static symbol s_7_0[4] = {197, 202, 219, 197};
+static symbol s_7_1[1] = {206};
+static symbol s_7_2[1] = {216};
+static symbol s_7_3[3] = {197, 202, 219};
static struct among a_7[4] =
{
-/* 0 */ { 4, s_7_0, -1, 1, 0},
-/* 1 */ { 1, s_7_1, -1, 2, 0},
-/* 2 */ { 1, s_7_2, -1, 3, 0},
-/* 3 */ { 3, s_7_3, -1, 1, 0}
+ /* 0 */ {4, s_7_0, -1, 1, 0},
+ /* 1 */ {1, s_7_1, -1, 2, 0},
+ /* 2 */ {1, s_7_2, -1, 3, 0},
+ /* 3 */ {3, s_7_3, -1, 1, 0}
};
-static unsigned char g_v[] = { 35, 130, 34, 18 };
-
-static symbol s_0[] = { 193 };
-static symbol s_1[] = { 209 };
-static symbol s_2[] = { 193 };
-static symbol s_3[] = { 209 };
-static symbol s_4[] = { 193 };
-static symbol s_5[] = { 209 };
-static symbol s_6[] = { 206 };
-static symbol s_7[] = { 206 };
-static symbol s_8[] = { 206 };
-static symbol s_9[] = { 201 };
-
-static int r_mark_regions(struct SN_env * z) {
- z->I[0] = z->l;
- z->I[1] = z->l;
- { int c = z->c; /* do, line 100 */
- while(1) { /* gopast, line 101 */
- if (!(in_grouping(z, g_v, 192, 220))) goto lab1;
- break;
- lab1:
- if (z->c >= z->l) goto lab0;
- z->c++;
- }
- z->I[0] = z->c; /* setmark pV, line 101 */
- while(1) { /* gopast, line 101 */
- if (!(out_grouping(z, g_v, 192, 220))) goto lab2;
- break;
- lab2:
- if (z->c >= z->l) goto lab0;
- z->c++;
- }
- while(1) { /* gopast, line 102 */
- if (!(in_grouping(z, g_v, 192, 220))) goto lab3;
- break;
- lab3:
- if (z->c >= z->l) goto lab0;
- z->c++;
- }
- while(1) { /* gopast, line 102 */
- if (!(out_grouping(z, g_v, 192, 220))) goto lab4;
- break;
- lab4:
- if (z->c >= z->l) goto lab0;
- z->c++;
- }
- z->I[1] = z->c; /* setmark p2, line 102 */
- lab0:
- z->c = c;
- }
- return 1;
+static unsigned char g_v[] = {35, 130, 34, 18};
+
+static symbol s_0[] = {193};
+static symbol s_1[] = {209};
+static symbol s_2[] = {193};
+static symbol s_3[] = {209};
+static symbol s_4[] = {193};
+static symbol s_5[] = {209};
+static symbol s_6[] = {206};
+static symbol s_7[] = {206};
+static symbol s_8[] = {206};
+static symbol s_9[] = {201};
+
+static int
+r_mark_regions(struct SN_env * z)
+{
+ z->I[0] = z->l;
+ z->I[1] = z->l;
+ {
+ int c = z->c; /* do, line 100 */
+
+ while (1)
+ { /* gopast, line 101 */
+ if (!(in_grouping(z, g_v, 192, 220)))
+ goto lab1;
+ break;
+ lab1:
+ if (z->c >= z->l)
+ goto lab0;
+ z->c++;
+ }
+ z->I[0] = z->c; /* setmark pV, line 101 */
+ while (1)
+ { /* gopast, line 101 */
+ if (!(out_grouping(z, g_v, 192, 220)))
+ goto lab2;
+ break;
+ lab2:
+ if (z->c >= z->l)
+ goto lab0;
+ z->c++;
+ }
+ while (1)
+ { /* gopast, line 102 */
+ if (!(in_grouping(z, g_v, 192, 220)))
+ goto lab3;
+ break;
+ lab3:
+ if (z->c >= z->l)
+ goto lab0;
+ z->c++;
+ }
+ while (1)
+ { /* gopast, line 102 */
+ if (!(out_grouping(z, g_v, 192, 220)))
+ goto lab4;
+ break;
+ lab4:
+ if (z->c >= z->l)
+ goto lab0;
+ z->c++;
+ }
+ z->I[1] = z->c; /* setmark p2, line 102 */
+lab0:
+ z->c = c;
+ }
+ return 1;
}
-static int r_R2(struct SN_env * z) {
- if (!(z->I[1] <= z->c)) return 0;
- return 1;
+static int
+r_R2(struct SN_env * z)
+{
+ if (!(z->I[1] <= z->c))
+ return 0;
+ return 1;
}
-static int r_perfective_gerund(struct SN_env * z) {
- int among_var;
- z->ket = z->c; /* [, line 111 */
- among_var = find_among_b(z, a_0, 9); /* substring, line 111 */
- if (!(among_var)) return 0;
- z->bra = z->c; /* ], line 111 */
- switch(among_var) {
- case 0: return 0;
- case 1:
- { int m = z->l - z->c; /* or, line 115 */
- if (!(eq_s_b(z, 1, s_0))) goto lab1;
- goto lab0;
- lab1:
- z->c = z->l - m;
- if (!(eq_s_b(z, 1, s_1))) return 0;
- }
- lab0:
- slice_del(z); /* delete, line 115 */
- break;
- case 2:
- slice_del(z); /* delete, line 122 */
- break;
- }
- return 1;
+static int
+r_perfective_gerund(struct SN_env * z)
+{
+ int among_var;
+
+ z->ket = z->c; /* [, line 111 */
+ among_var = find_among_b(z, a_0, 9); /* substring, line 111 */
+ if (!(among_var))
+ return 0;
+ z->bra = z->c; /* ], line 111 */
+ switch (among_var)
+ {
+ case 0:
+ return 0;
+ case 1:
+ {
+ int m = z->l - z->c; /* or, line 115 */
+
+ if (!(eq_s_b(z, 1, s_0)))
+ goto lab1;
+ goto lab0;
+ lab1:
+ z->c = z->l - m;
+ if (!(eq_s_b(z, 1, s_1)))
+ return 0;
+ }
+ lab0:
+ slice_del(z); /* delete, line 115 */
+ break;
+ case 2:
+ slice_del(z); /* delete, line 122 */
+ break;
+ }
+ return 1;
}
-static int r_adjective(struct SN_env * z) {
- int among_var;
- z->ket = z->c; /* [, line 127 */
- among_var = find_among_b(z, a_1, 26); /* substring, line 127 */
- if (!(among_var)) return 0;
- z->bra = z->c; /* ], line 127 */
- switch(among_var) {
- case 0: return 0;
- case 1:
- slice_del(z); /* delete, line 136 */
- break;
- }
- return 1;
+static int
+r_adjective(struct SN_env * z)
+{
+ int among_var;
+
+ z->ket = z->c; /* [, line 127 */
+ among_var = find_among_b(z, a_1, 26); /* substring, line 127 */
+ if (!(among_var))
+ return 0;
+ z->bra = z->c; /* ], line 127 */
+ switch (among_var)
+ {
+ case 0:
+ return 0;
+ case 1:
+ slice_del(z); /* delete, line 136 */
+ break;
+ }
+ return 1;
}
-static int r_adjectival(struct SN_env * z) {
- int among_var;
- if (!r_adjective(z)) return 0; /* call adjective, line 141 */
- { int m = z->l - z->c; /* try, line 148 */
- z->ket = z->c; /* [, line 149 */
- among_var = find_among_b(z, a_2, 8); /* substring, line 149 */
- if (!(among_var)) { z->c = z->l - m; goto lab0; }
- z->bra = z->c; /* ], line 149 */
- switch(among_var) {
- case 0: { z->c = z->l - m; goto lab0; }
- case 1:
- { int m = z->l - z->c; /* or, line 154 */
- if (!(eq_s_b(z, 1, s_2))) goto lab2;
- goto lab1;
- lab2:
- z->c = z->l - m;
- if (!(eq_s_b(z, 1, s_3))) { z->c = z->l - m; goto lab0; }
- }
- lab1:
- slice_del(z); /* delete, line 154 */
- break;
- case 2:
- slice_del(z); /* delete, line 161 */
- break;
- }
- lab0:
- ;
- }
- return 1;
+static int
+r_adjectival(struct SN_env * z)
+{
+ int among_var;
+
+ if (!r_adjective(z))
+ return 0; /* call adjective, line 141 */
+ {
+ int m = z->l - z->c; /* try, line 148 */
+
+ z->ket = z->c; /* [, line 149 */
+ among_var = find_among_b(z, a_2, 8); /* substring, line 149 */
+ if (!(among_var))
+ {
+ z->c = z->l - m;
+ goto lab0;
+ }
+ z->bra = z->c; /* ], line 149 */
+ switch (among_var)
+ {
+ case 0:
+ {
+ z->c = z->l - m;
+ goto lab0;
+ }
+ case 1:
+ {
+ int m = z->l - z->c; /* or, line 154 */
+
+ if (!(eq_s_b(z, 1, s_2)))
+ goto lab2;
+ goto lab1;
+ lab2:
+ z->c = z->l - m;
+ if (!(eq_s_b(z, 1, s_3)))
+ {
+ z->c = z->l - m;
+ goto lab0;
+ }
+ }
+ lab1:
+ slice_del(z); /* delete, line 154 */
+ break;
+ case 2:
+ slice_del(z); /* delete, line 161 */
+ break;
+ }
+lab0:
+ ;
+ }
+ return 1;
}
-static int r_reflexive(struct SN_env * z) {
- int among_var;
- z->ket = z->c; /* [, line 168 */
- among_var = find_among_b(z, a_3, 2); /* substring, line 168 */
- if (!(among_var)) return 0;
- z->bra = z->c; /* ], line 168 */
- switch(among_var) {
- case 0: return 0;
- case 1:
- slice_del(z); /* delete, line 171 */
- break;
- }
- return 1;
+static int
+r_reflexive(struct SN_env * z)
+{
+ int among_var;
+
+ z->ket = z->c; /* [, line 168 */
+ among_var = find_among_b(z, a_3, 2); /* substring, line 168 */
+ if (!(among_var))
+ return 0;
+ z->bra = z->c; /* ], line 168 */
+ switch (among_var)
+ {
+ case 0:
+ return 0;
+ case 1:
+ slice_del(z); /* delete, line 171 */
+ break;
+ }
+ return 1;
}
-static int r_verb(struct SN_env * z) {
- int among_var;
- z->ket = z->c; /* [, line 176 */
- among_var = find_among_b(z, a_4, 46); /* substring, line 176 */
- if (!(among_var)) return 0;
- z->bra = z->c; /* ], line 176 */
- switch(among_var) {
- case 0: return 0;
- case 1:
- { int m = z->l - z->c; /* or, line 182 */
- if (!(eq_s_b(z, 1, s_4))) goto lab1;
- goto lab0;
- lab1:
- z->c = z->l - m;
- if (!(eq_s_b(z, 1, s_5))) return 0;
- }
- lab0:
- slice_del(z); /* delete, line 182 */
- break;
- case 2:
- slice_del(z); /* delete, line 190 */
- break;
- }
- return 1;
+static int
+r_verb(struct SN_env * z)
+{
+ int among_var;
+
+ z->ket = z->c; /* [, line 176 */
+ among_var = find_among_b(z, a_4, 46); /* substring, line 176 */
+ if (!(among_var))
+ return 0;
+ z->bra = z->c; /* ], line 176 */
+ switch (among_var)
+ {
+ case 0:
+ return 0;
+ case 1:
+ {
+ int m = z->l - z->c; /* or, line 182 */
+
+ if (!(eq_s_b(z, 1, s_4)))
+ goto lab1;
+ goto lab0;
+ lab1:
+ z->c = z->l - m;
+ if (!(eq_s_b(z, 1, s_5)))
+ return 0;
+ }
+ lab0:
+ slice_del(z); /* delete, line 182 */
+ break;
+ case 2:
+ slice_del(z); /* delete, line 190 */
+ break;
+ }
+ return 1;
}
-static int r_noun(struct SN_env * z) {
- int among_var;
- z->ket = z->c; /* [, line 199 */
- among_var = find_among_b(z, a_5, 36); /* substring, line 199 */
- if (!(among_var)) return 0;
- z->bra = z->c; /* ], line 199 */
- switch(among_var) {
- case 0: return 0;
- case 1:
- slice_del(z); /* delete, line 206 */
- break;
- }
- return 1;
+static int
+r_noun(struct SN_env * z)
+{
+ int among_var;
+
+ z->ket = z->c; /* [, line 199 */
+ among_var = find_among_b(z, a_5, 36); /* substring, line 199 */
+ if (!(among_var))
+ return 0;
+ z->bra = z->c; /* ], line 199 */
+ switch (among_var)
+ {
+ case 0:
+ return 0;
+ case 1:
+ slice_del(z); /* delete, line 206 */
+ break;
+ }
+ return 1;
}
-static int r_derivational(struct SN_env * z) {
- int among_var;
- z->ket = z->c; /* [, line 215 */
- among_var = find_among_b(z, a_6, 2); /* substring, line 215 */
- if (!(among_var)) return 0;
- z->bra = z->c; /* ], line 215 */
- if (!r_R2(z)) return 0; /* call R2, line 215 */
- switch(among_var) {
- case 0: return 0;
- case 1:
- slice_del(z); /* delete, line 218 */
- break;
- }
- return 1;
+static int
+r_derivational(struct SN_env * z)
+{
+ int among_var;
+
+ z->ket = z->c; /* [, line 215 */
+ among_var = find_among_b(z, a_6, 2); /* substring, line 215 */
+ if (!(among_var))
+ return 0;
+ z->bra = z->c; /* ], line 215 */
+ if (!r_R2(z))
+ return 0; /* call R2, line 215 */
+ switch (among_var)
+ {
+ case 0:
+ return 0;
+ case 1:
+ slice_del(z); /* delete, line 218 */
+ break;
+ }
+ return 1;
}
-static int r_tidy_up(struct SN_env * z) {
- int among_var;
- z->ket = z->c; /* [, line 223 */
- among_var = find_among_b(z, a_7, 4); /* substring, line 223 */
- if (!(among_var)) return 0;
- z->bra = z->c; /* ], line 223 */
- switch(among_var) {
- case 0: return 0;
- case 1:
- slice_del(z); /* delete, line 227 */
- z->ket = z->c; /* [, line 228 */
- if (!(eq_s_b(z, 1, s_6))) return 0;
- z->bra = z->c; /* ], line 228 */
- if (!(eq_s_b(z, 1, s_7))) return 0;
- slice_del(z); /* delete, line 228 */
- break;
- case 2:
- if (!(eq_s_b(z, 1, s_8))) return 0;
- slice_del(z); /* delete, line 231 */
- break;
- case 3:
- slice_del(z); /* delete, line 233 */
- break;
- }
- return 1;
+static int
+r_tidy_up(struct SN_env * z)
+{
+ int among_var;
+
+ z->ket = z->c; /* [, line 223 */
+ among_var = find_among_b(z, a_7, 4); /* substring, line 223 */
+ if (!(among_var))
+ return 0;
+ z->bra = z->c; /* ], line 223 */
+ switch (among_var)
+ {
+ case 0:
+ return 0;
+ case 1:
+ slice_del(z); /* delete, line 227 */
+ z->ket = z->c; /* [, line 228 */
+ if (!(eq_s_b(z, 1, s_6)))
+ return 0;
+ z->bra = z->c; /* ], line 228 */
+ if (!(eq_s_b(z, 1, s_7)))
+ return 0;
+ slice_del(z); /* delete, line 228 */
+ break;
+ case 2:
+ if (!(eq_s_b(z, 1, s_8)))
+ return 0;
+ slice_del(z); /* delete, line 231 */
+ break;
+ case 3:
+ slice_del(z); /* delete, line 233 */
+ break;
+ }
+ return 1;
}
-extern int russian_stem(struct SN_env * z) {
- { int c = z->c; /* do, line 240 */
- if (!r_mark_regions(z)) goto lab0; /* call mark_regions, line 240 */
- lab0:
- z->c = c;
- }
- z->lb = z->c; z->c = z->l; /* backwards, line 241 */
-
- { int m = z->l - z->c; /* setlimit, line 241 */
- int m3;
- if (z->c < z->I[0]) return 0;
- z->c = z->I[0]; /* tomark, line 241 */
- m3 = z->lb; z->lb = z->c;
- z->c = z->l - m;
- { int m = z->l - z->c; /* do, line 242 */
- { int m = z->l - z->c; /* or, line 243 */
- if (!r_perfective_gerund(z)) goto lab3; /* call perfective_gerund, line 243 */
- goto lab2;
- lab3:
- z->c = z->l - m;
- { int m = z->l - z->c; /* try, line 244 */
- if (!r_reflexive(z)) { z->c = z->l - m; goto lab4; } /* call reflexive, line 244 */
- lab4:
- ;
- }
- { int m = z->l - z->c; /* or, line 245 */
- if (!r_adjectival(z)) goto lab6; /* call adjectival, line 245 */
- goto lab5;
- lab6:
- z->c = z->l - m;
- if (!r_verb(z)) goto lab7; /* call verb, line 245 */
- goto lab5;
- lab7:
- z->c = z->l - m;
- if (!r_noun(z)) goto lab1; /* call noun, line 245 */
- }
- lab5:
- ;
- }
- lab2:
- lab1:
- z->c = z->l - m;
- }
- { int m = z->l - z->c; /* try, line 248 */
- z->ket = z->c; /* [, line 248 */
- if (!(eq_s_b(z, 1, s_9))) { z->c = z->l - m; goto lab8; }
- z->bra = z->c; /* ], line 248 */
- slice_del(z); /* delete, line 248 */
- lab8:
- ;
- }
- { int m = z->l - z->c; /* do, line 251 */
- if (!r_derivational(z)) goto lab9; /* call derivational, line 251 */
- lab9:
- z->c = z->l - m;
- }
- { int m = z->l - z->c; /* do, line 252 */
- if (!r_tidy_up(z)) goto lab10; /* call tidy_up, line 252 */
- lab10:
- z->c = z->l - m;
- }
- z->lb = m3;
- }
- z->c = z->lb;
- return 1;
+extern int
+russian_stem(struct SN_env * z)
+{
+ {
+ int c = z->c; /* do, line 240 */
+
+ if (!r_mark_regions(z))
+ goto lab0; /* call mark_regions, line 240 */
+lab0:
+ z->c = c;
+ }
+ z->lb = z->c;
+ z->c = z->l; /* backwards, line 241 */
+
+ {
+ int m = z->l - z->c; /* setlimit, line 241 */
+ int m3;
+
+ if (z->c < z->I[0])
+ return 0;
+ z->c = z->I[0]; /* tomark, line 241 */
+ m3 = z->lb;
+ z->lb = z->c;
+ z->c = z->l - m;
+ {
+ int m = z->l - z->c; /* do, line 242 */
+
+ {
+ int m = z->l - z->c; /* or, line 243 */
+
+ if (!r_perfective_gerund(z))
+ goto lab3; /* call perfective_gerund, line 243 */
+ goto lab2;
+ lab3:
+ z->c = z->l - m;
+ {
+ int m = z->l - z->c; /* try, line 244 */
+
+ if (!r_reflexive(z))
+ {
+ z->c = z->l - m;
+ goto lab4;
+ } /* call reflexive, line 244 */
+ lab4:
+ ;
+ }
+ {
+ int m = z->l - z->c; /* or, line 245 */
+
+ if (!r_adjectival(z))
+ goto lab6; /* call adjectival, line 245 */
+ goto lab5;
+ lab6:
+ z->c = z->l - m;
+ if (!r_verb(z))
+ goto lab7; /* call verb, line 245 */
+ goto lab5;
+ lab7:
+ z->c = z->l - m;
+ if (!r_noun(z))
+ goto lab1; /* call noun, line 245 */
+ }
+ lab5:
+ ;
+ }
+ lab2:
+ lab1:
+ z->c = z->l - m;
+ }
+ {
+ int m = z->l - z->c; /* try, line 248 */
+
+ z->ket = z->c; /* [, line 248 */
+ if (!(eq_s_b(z, 1, s_9)))
+ {
+ z->c = z->l - m;
+ goto lab8;
+ }
+ z->bra = z->c; /* ], line 248 */
+ slice_del(z); /* delete, line 248 */
+ lab8:
+ ;
+ }
+ {
+ int m = z->l - z->c; /* do, line 251 */
+
+ if (!r_derivational(z))
+ goto lab9; /* call derivational, line 251 */
+ lab9:
+ z->c = z->l - m;
+ }
+ {
+ int m = z->l - z->c; /* do, line 252 */
+
+ if (!r_tidy_up(z))
+ goto lab10; /* call tidy_up, line 252 */
+ lab10:
+ z->c = z->l - m;
+ }
+ z->lb = m3;
+ }
+ z->c = z->lb;
+ return 1;
}
-extern struct SN_env * russian_create_env(void) { return SN_create_env(0, 2, 0); }
-
-extern void russian_close_env(struct SN_env * z) { SN_close_env(z); }
+extern struct SN_env *russian_create_env(void)
+{
+ return SN_create_env(0, 2, 0);
+}
+extern void russian_close_env(struct SN_env * z)
+{
+ SN_close_env(z);
+}
/* This file was generated automatically by the Snowball to ANSI C compiler */
-extern struct SN_env * russian_create_env(void);
+extern struct SN_env *russian_create_env(void);
extern void russian_close_env(struct SN_env * z);
-extern int russian_stem(struct SN_env * z);
-
+extern int russian_stem(struct SN_env * z);
#define CREATE_SIZE 1
-extern symbol * create_s(void)
-{ symbol * p = (symbol *) (HEAD + (char *) malloc(HEAD + (CREATE_SIZE + 1) * sizeof(symbol)));
- CAPACITY(p) = CREATE_SIZE;
- SET_SIZE(p, CREATE_SIZE);
- return p;
+extern symbol *
+create_s(void)
+{
+ symbol *p = (symbol *) (HEAD + (char *) malloc(HEAD + (CREATE_SIZE + 1) * sizeof(symbol)));
+
+ CAPACITY(p) = CREATE_SIZE;
+ SET_SIZE(p, CREATE_SIZE);
+ return p;
}
-extern void lose_s(symbol * p) { free((char *) p - HEAD); }
+extern void lose_s(symbol * p)
+{
+ free((char *) p - HEAD);
+}
-extern int in_grouping(struct SN_env * z, unsigned char * s, int min, int max)
-{ if (z->c >= z->l) return 0;
- { int ch = z->p[z->c];
- if
- (ch > max || (ch -= min) < 0 ||
- (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return 0;
- }
- z->c++; return 1;
+extern int
+in_grouping(struct SN_env * z, unsigned char *s, int min, int max)
+{
+ if (z->c >= z->l)
+ return 0;
+ {
+ int ch = z->p[z->c];
+
+ if
+ (ch > max || (ch -= min) < 0 ||
+ (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0)
+ return 0;
+ }
+ z->c++;
+ return 1;
}
-extern int in_grouping_b(struct SN_env * z, unsigned char * s, int min, int max)
-{ if (z->c <= z->lb) return 0;
- { int ch = z->p[z->c - 1];
- if
- (ch > max || (ch -= min) < 0 ||
- (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return 0;
- }
- z->c--; return 1;
+extern int
+in_grouping_b(struct SN_env * z, unsigned char *s, int min, int max)
+{
+ if (z->c <= z->lb)
+ return 0;
+ {
+ int ch = z->p[z->c - 1];
+
+ if
+ (ch > max || (ch -= min) < 0 ||
+ (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0)
+ return 0;
+ }
+ z->c--;
+ return 1;
}
-extern int out_grouping(struct SN_env * z, unsigned char * s, int min, int max)
-{ if (z->c >= z->l) return 0;
- { int ch = z->p[z->c];
- unless
- (ch > max || (ch -= min) < 0 ||
- (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return 0;
- }
- z->c++; return 1;
+extern int
+out_grouping(struct SN_env * z, unsigned char *s, int min, int max)
+{
+ if (z->c >= z->l)
+ return 0;
+ {
+ int ch = z->p[z->c];
+
+ unless
+ (ch > max || (ch -= min) < 0 ||
+ (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return 0;
+ }
+ z->c++;
+ return 1;
}
-extern int out_grouping_b(struct SN_env * z, unsigned char * s, int min, int max)
-{ if (z->c <= z->lb) return 0;
- { int ch = z->p[z->c - 1];
- unless
- (ch > max || (ch -= min) < 0 ||
- (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return 0;
- }
- z->c--; return 1;
+extern int
+out_grouping_b(struct SN_env * z, unsigned char *s, int min, int max)
+{
+ if (z->c <= z->lb)
+ return 0;
+ {
+ int ch = z->p[z->c - 1];
+
+ unless
+ (ch > max || (ch -= min) < 0 ||
+ (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return 0;
+ }
+ z->c--;
+ return 1;
}
-extern int in_range(struct SN_env * z, int min, int max)
-{ if (z->c >= z->l) return 0;
- { int ch = z->p[z->c];
- if
- (ch > max || ch < min) return 0;
- }
- z->c++; return 1;
+extern int
+in_range(struct SN_env * z, int min, int max)
+{
+ if (z->c >= z->l)
+ return 0;
+ {
+ int ch = z->p[z->c];
+
+ if
+ (ch > max || ch < min)
+ return 0;
+ }
+ z->c++;
+ return 1;
}
-extern int in_range_b(struct SN_env * z, int min, int max)
-{ if (z->c <= z->lb) return 0;
- { int ch = z->p[z->c - 1];
- if
- (ch > max || ch < min) return 0;
- }
- z->c--; return 1;
+extern int
+in_range_b(struct SN_env * z, int min, int max)
+{
+ if (z->c <= z->lb)
+ return 0;
+ {
+ int ch = z->p[z->c - 1];
+
+ if
+ (ch > max || ch < min)
+ return 0;
+ }
+ z->c--;
+ return 1;
}
-extern int out_range(struct SN_env * z, int min, int max)
-{ if (z->c >= z->l) return 0;
- { int ch = z->p[z->c];
- unless
- (ch > max || ch < min) return 0;
- }
- z->c++; return 1;
+extern int
+out_range(struct SN_env * z, int min, int max)
+{
+ if (z->c >= z->l)
+ return 0;
+ {
+ int ch = z->p[z->c];
+
+ unless
+ (ch > max || ch < min) return 0;
+ }
+ z->c++;
+ return 1;
}
-extern int out_range_b(struct SN_env * z, int min, int max)
-{ if (z->c <= z->lb) return 0;
- { int ch = z->p[z->c - 1];
- unless
- (ch > max || ch < min) return 0;
- }
- z->c--; return 1;
+extern int
+out_range_b(struct SN_env * z, int min, int max)
+{
+ if (z->c <= z->lb)
+ return 0;
+ {
+ int ch = z->p[z->c - 1];
+
+ unless
+ (ch > max || ch < min) return 0;
+ }
+ z->c--;
+ return 1;
}
-extern int eq_s(struct SN_env * z, int s_size, symbol * s)
-{ if (z->l - z->c < s_size ||
- memcmp(z->p + z->c, s, s_size * sizeof(symbol)) != 0) return 0;
- z->c += s_size; return 1;
+extern int
+eq_s(struct SN_env * z, int s_size, symbol * s)
+{
+ if (z->l - z->c < s_size ||
+ memcmp(z->p + z->c, s, s_size * sizeof(symbol)) != 0)
+ return 0;
+ z->c += s_size;
+ return 1;
}
-extern int eq_s_b(struct SN_env * z, int s_size, symbol * s)
-{ if (z->c - z->lb < s_size ||
- memcmp(z->p + z->c - s_size, s, s_size * sizeof(symbol)) != 0) return 0;
- z->c -= s_size; return 1;
+extern int
+eq_s_b(struct SN_env * z, int s_size, symbol * s)
+{
+ if (z->c - z->lb < s_size ||
+ memcmp(z->p + z->c - s_size, s, s_size * sizeof(symbol)) != 0)
+ return 0;
+ z->c -= s_size;
+ return 1;
}
-extern int eq_v(struct SN_env * z, symbol * p)
-{ return eq_s(z, SIZE(p), p);
+extern int
+eq_v(struct SN_env * z, symbol * p)
+{
+ return eq_s(z, SIZE(p), p);
}
-extern int eq_v_b(struct SN_env * z, symbol * p)
-{ return eq_s_b(z, SIZE(p), p);
+extern int
+eq_v_b(struct SN_env * z, symbol * p)
+{
+ return eq_s_b(z, SIZE(p), p);
}
-extern int find_among(struct SN_env * z, struct among * v, int v_size)
+extern int
+find_among(struct SN_env * z, struct among * v, int v_size)
{
- int i = 0;
- int j = v_size;
-
- int c = z->c; int l = z->l;
- symbol * q = z->p + c;
-
- struct among * w;
-
- int common_i = 0;
- int common_j = 0;
-
- int first_key_inspected = 0;
-
- while(1)
- { int k = i + ((j - i) >> 1);
- int diff = 0;
- int common = common_i < common_j ? common_i : common_j; /* smaller */
- w = v + k;
- { int i; for (i = common; i < w->s_size; i++)
- { if (c + common == l) { diff = -1; break; }
- diff = q[common] - w->s[i];
- if (diff != 0) break;
- common++;
- }
- }
- if (diff < 0) { j = k; common_j = common; }
- else { i = k; common_i = common; }
- if (j - i <= 1)
- { if (i > 0) break; /* v->s has been inspected */
- if (j == i) break; /* only one item in v */
-
- /* - but now we need to go round once more to get
- v->s inspected. This looks messy, but is actually
- the optimal approach. */
-
- if (first_key_inspected) break;
- first_key_inspected = 1;
- }
- }
- while(1)
- { w = v + i;
- if (common_i >= w->s_size)
- { z->c = c + w->s_size;
- if (w->function == 0) return w->result;
- { int res = w->function(z);
- z->c = c + w->s_size;
- if (res) return w->result;
- }
- }
- i = w->substring_i;
- if (i < 0) return 0;
- }
+ int i = 0;
+ int j = v_size;
+
+ int c = z->c;
+ int l = z->l;
+ symbol *q = z->p + c;
+
+ struct among *w;
+
+ int common_i = 0;
+ int common_j = 0;
+
+ int first_key_inspected = 0;
+
+ while (1)
+ {
+ int k = i + ((j - i) >> 1);
+ int diff = 0;
+ int common = common_i < common_j ? common_i : common_j; /* smaller */
+
+ w = v + k;
+ {
+ int i;
+
+ for (i = common; i < w->s_size; i++)
+ {
+ if (c + common == l)
+ {
+ diff = -1;
+ break;
+ }
+ diff = q[common] - w->s[i];
+ if (diff != 0)
+ break;
+ common++;
+ }
+ }
+ if (diff < 0)
+ {
+ j = k;
+ common_j = common;
+ }
+ else
+ {
+ i = k;
+ common_i = common;
+ }
+ if (j - i <= 1)
+ {
+ if (i > 0)
+ break; /* v->s has been inspected */
+ if (j == i)
+ break; /* only one item in v */
+
+ /*
+ * - but now we need to go round once more to get v->s
+ * inspected. This looks messy, but is actually the optimal
+ * approach.
+ */
+
+ if (first_key_inspected)
+ break;
+ first_key_inspected = 1;
+ }
+ }
+ while (1)
+ {
+ w = v + i;
+ if (common_i >= w->s_size)
+ {
+ z->c = c + w->s_size;
+ if (w->function == 0)
+ return w->result;
+ {
+ int res = w->function(z);
+
+ z->c = c + w->s_size;
+ if (res)
+ return w->result;
+ }
+ }
+ i = w->substring_i;
+ if (i < 0)
+ return 0;
+ }
}
/* find_among_b is for backwards processing. Same comments apply */
-extern int find_among_b(struct SN_env * z, struct among * v, int v_size)
+extern int
+find_among_b(struct SN_env * z, struct among * v, int v_size)
{
- int i = 0;
- int j = v_size;
-
- int c = z->c; int lb = z->lb;
- symbol * q = z->p + c - 1;
-
- struct among * w;
-
- int common_i = 0;
- int common_j = 0;
-
- int first_key_inspected = 0;
-
- while(1)
- { int k = i + ((j - i) >> 1);
- int diff = 0;
- int common = common_i < common_j ? common_i : common_j;
- w = v + k;
- { int i; for (i = w->s_size - 1 - common; i >= 0; i--)
- { if (c - common == lb) { diff = -1; break; }
- diff = q[- common] - w->s[i];
- if (diff != 0) break;
- common++;
- }
- }
- if (diff < 0) { j = k; common_j = common; }
- else { i = k; common_i = common; }
- if (j - i <= 1)
- { if (i > 0) break;
- if (j == i) break;
- if (first_key_inspected) break;
- first_key_inspected = 1;
- }
- }
- while(1)
- { w = v + i;
- if (common_i >= w->s_size)
- { z->c = c - w->s_size;
- if (w->function == 0) return w->result;
- { int res = w->function(z);
- z->c = c - w->s_size;
- if (res) return w->result;
- }
- }
- i = w->substring_i;
- if (i < 0) return 0;
- }
+ int i = 0;
+ int j = v_size;
+
+ int c = z->c;
+ int lb = z->lb;
+ symbol *q = z->p + c - 1;
+
+ struct among *w;
+
+ int common_i = 0;
+ int common_j = 0;
+
+ int first_key_inspected = 0;
+
+ while (1)
+ {
+ int k = i + ((j - i) >> 1);
+ int diff = 0;
+ int common = common_i < common_j ? common_i : common_j;
+
+ w = v + k;
+ {
+ int i;
+
+ for (i = w->s_size - 1 - common; i >= 0; i--)
+ {
+ if (c - common == lb)
+ {
+ diff = -1;
+ break;
+ }
+ diff = q[-common] - w->s[i];
+ if (diff != 0)
+ break;
+ common++;
+ }
+ }
+ if (diff < 0)
+ {
+ j = k;
+ common_j = common;
+ }
+ else
+ {
+ i = k;
+ common_i = common;
+ }
+ if (j - i <= 1)
+ {
+ if (i > 0)
+ break;
+ if (j == i)
+ break;
+ if (first_key_inspected)
+ break;
+ first_key_inspected = 1;
+ }
+ }
+ while (1)
+ {
+ w = v + i;
+ if (common_i >= w->s_size)
+ {
+ z->c = c - w->s_size;
+ if (w->function == 0)
+ return w->result;
+ {
+ int res = w->function(z);
+
+ z->c = c - w->s_size;
+ if (res)
+ return w->result;
+ }
+ }
+ i = w->substring_i;
+ if (i < 0)
+ return 0;
+ }
}
-extern symbol * increase_size(symbol * p, int n)
-{ int new_size = n + 20;
- symbol * q = (symbol *) (HEAD + (char *) malloc(HEAD + (new_size + 1) * sizeof(symbol)));
- CAPACITY(q) = new_size;
- memmove(q, p, CAPACITY(p) * sizeof(symbol)); lose_s(p); return q;
+extern symbol *
+increase_size(symbol * p, int n)
+{
+ int new_size = n + 20;
+ symbol *q = (symbol *) (HEAD + (char *) malloc(HEAD + (new_size + 1) * sizeof(symbol)));
+
+ CAPACITY(q) = new_size;
+ memmove(q, p, CAPACITY(p) * sizeof(symbol));
+ lose_s(p);
+ return q;
}
/* to replace symbols between c_bra and c_ket in z->p by the
s_size symbols at s
*/
-extern int replace_s(struct SN_env * z, int c_bra, int c_ket, int s_size, const symbol * s)
-{ int adjustment = s_size - (c_ket - c_bra);
- int len = SIZE(z->p);
- if (adjustment != 0)
- { if (adjustment + len > CAPACITY(z->p)) z->p = increase_size(z->p, adjustment + len);
- memmove(z->p + c_ket + adjustment, z->p + c_ket, (len - c_ket) * sizeof(symbol));
- SET_SIZE(z->p, adjustment + len);
- z->l += adjustment;
- if (z->c >= c_ket) z->c += adjustment; else
- if (z->c > c_bra) z->c = c_bra;
- }
- unless (s_size == 0) memmove(z->p + c_bra, s, s_size * sizeof(symbol));
- return adjustment;
+extern int
+replace_s(struct SN_env * z, int c_bra, int c_ket, int s_size, const symbol * s)
+{
+ int adjustment = s_size - (c_ket - c_bra);
+ int len = SIZE(z->p);
+
+ if (adjustment != 0)
+ {
+ if (adjustment + len > CAPACITY(z->p))
+ z->p = increase_size(z->p, adjustment + len);
+ memmove(z->p + c_ket + adjustment, z->p + c_ket, (len - c_ket) * sizeof(symbol));
+ SET_SIZE(z->p, adjustment + len);
+ z->l += adjustment;
+ if (z->c >= c_ket)
+ z->c += adjustment;
+ else if (z->c > c_bra)
+ z->c = c_bra;
+ }
+ unless(s_size == 0) memmove(z->p + c_bra, s, s_size * sizeof(symbol));
+ return adjustment;
}
-static void slice_check(struct SN_env * z)
+static void
+slice_check(struct SN_env * z)
{
- if (!(0 <= z->bra &&
- z->bra <= z->ket &&
- z->ket <= z->l &&
- z->l <= SIZE(z->p))) /* this line could be removed */
- {
- fprintf(stderr, "faulty slice operation:\n");
- debug(z, -1, 0);
- exit(1);
- }
+ if (!(0 <= z->bra &&
+ z->bra <= z->ket &&
+ z->ket <= z->l &&
+ z->l <= SIZE(z->p))) /* this line could be removed */
+ {
+ fprintf(stderr, "faulty slice operation:\n");
+ debug(z, -1, 0);
+ exit(1);
+ }
}
-extern void slice_from_s(struct SN_env * z, int s_size, symbol * s)
-{ slice_check(z);
- replace_s(z, z->bra, z->ket, s_size, s);
+extern void
+slice_from_s(struct SN_env * z, int s_size, symbol * s)
+{
+ slice_check(z);
+ replace_s(z, z->bra, z->ket, s_size, s);
}
-extern void slice_from_v(struct SN_env * z, symbol * p)
-{ slice_from_s(z, SIZE(p), p);
+extern void
+slice_from_v(struct SN_env * z, symbol * p)
+{
+ slice_from_s(z, SIZE(p), p);
}
-extern void slice_del(struct SN_env * z)
-{ slice_from_s(z, 0, 0);
+extern void
+slice_del(struct SN_env * z)
+{
+ slice_from_s(z, 0, 0);
}
-extern void insert_s(struct SN_env * z, int bra, int ket, int s_size, symbol * s)
-{ int adjustment = replace_s(z, bra, ket, s_size, s);
- if (bra <= z->bra) z->bra += adjustment;
- if (bra <= z->ket) z->ket += adjustment;
+extern void
+insert_s(struct SN_env * z, int bra, int ket, int s_size, symbol * s)
+{
+ int adjustment = replace_s(z, bra, ket, s_size, s);
+
+ if (bra <= z->bra)
+ z->bra += adjustment;
+ if (bra <= z->ket)
+ z->ket += adjustment;
}
-extern void insert_v(struct SN_env * z, int bra, int ket, symbol * p)
-{ int adjustment = replace_s(z, bra, ket, SIZE(p), p);
- if (bra <= z->bra) z->bra += adjustment;
- if (bra <= z->ket) z->ket += adjustment;
+extern void
+insert_v(struct SN_env * z, int bra, int ket, symbol * p)
+{
+ int adjustment = replace_s(z, bra, ket, SIZE(p), p);
+
+ if (bra <= z->bra)
+ z->bra += adjustment;
+ if (bra <= z->ket)
+ z->ket += adjustment;
}
-extern symbol * slice_to(struct SN_env * z, symbol * p)
-{ slice_check(z);
- { int len = z->ket - z->bra;
- if (CAPACITY(p) < len) p = increase_size(p, len);
- memmove(p, z->p + z->bra, len * sizeof(symbol));
- SET_SIZE(p, len);
- }
- return p;
+extern symbol *
+slice_to(struct SN_env * z, symbol * p)
+{
+ slice_check(z);
+ {
+ int len = z->ket - z->bra;
+
+ if (CAPACITY(p) < len)
+ p = increase_size(p, len);
+ memmove(p, z->p + z->bra, len * sizeof(symbol));
+ SET_SIZE(p, len);
+ }
+ return p;
}
-extern symbol * assign_to(struct SN_env * z, symbol * p)
-{ int len = z->l;
- if (CAPACITY(p) < len) p = increase_size(p, len);
- memmove(p, z->p, len * sizeof(symbol));
- SET_SIZE(p, len);
- return p;
+extern symbol *
+assign_to(struct SN_env * z, symbol * p)
+{
+ int len = z->l;
+
+ if (CAPACITY(p) < len)
+ p = increase_size(p, len);
+ memmove(p, z->p, len * sizeof(symbol));
+ SET_SIZE(p, len);
+ return p;
}
-extern void debug(struct SN_env * z, int number, int line_count)
-{ int i;
- int limit = SIZE(z->p);
- /*if (number >= 0) printf("%3d (line %4d): '", number, line_count);*/
- if (number >= 0) printf("%3d (line %4d): [%d]'", number, line_count,limit);
- for (i = 0; i <= limit; i++)
- { if (z->lb == i) printf("{");
- if (z->bra == i) printf("[");
- if (z->c == i) printf("|");
- if (z->ket == i) printf("]");
- if (z->l == i) printf("}");
- if (i < limit)
- { int ch = z->p[i];
- if (ch == 0) ch = '#';
- printf("%c", ch);
- }
- }
- printf("'\n");
+extern void
+debug(struct SN_env * z, int number, int line_count)
+{
+ int i;
+ int limit = SIZE(z->p);
+
+ /* if (number >= 0) printf("%3d (line %4d): '", number, line_count); */
+ if (number >= 0)
+ printf("%3d (line %4d): [%d]'", number, line_count, limit);
+ for (i = 0; i <= limit; i++)
+ {
+ if (z->lb == i)
+ printf("{");
+ if (z->bra == i)
+ printf("[");
+ if (z->c == i)
+ printf("|");
+ if (z->ket == i)
+ printf("]");
+ if (z->l == i)
+ printf("}");
+ if (i < limit)
+ {
+ int ch = z->p[i];
+
+ if (ch == 0)
+ ch = '#';
+ printf("%c", ch);
+ }
+ }
+ printf("'\n");
}
-/*
+/*
* stopword library
* Teodor Sigaev <teodor@sigaev.ru>
*/
#define STOPBUFLEN 4096
-char*
-lowerstr(char *str) {
- char *ptr=str;
- while(*ptr) {
- *ptr = tolower(*(unsigned char*)ptr);
+char *
+lowerstr(char *str)
+{
+ char *ptr = str;
+
+ while (*ptr)
+ {
+ *ptr = tolower(*(unsigned char *) ptr);
ptr++;
}
return str;
}
void
-freestoplist(StopList *s) {
- char **ptr=s->stop;
- if ( ptr )
- while( *ptr && s->len >0 ) {
+freestoplist(StopList * s)
+{
+ char **ptr = s->stop;
+
+ if (ptr)
+ while (*ptr && s->len > 0)
+ {
free(*ptr);
- ptr++; s->len--;
- free(s->stop);
- }
- memset(s,0,sizeof(StopList));
+ ptr++;
+ s->len--;
+ free(s->stop);
+ }
+ memset(s, 0, sizeof(StopList));
}
void
-readstoplist(text *in, StopList *s) {
- char **stop=NULL;
- s->len=0;
- if ( in && VARSIZE(in) - VARHDRSZ > 0 ) {
- char *filename=text2char(in);
- FILE *hin=NULL;
- char buf[STOPBUFLEN];
- int reallen=0;
-
- if ( (hin=fopen(filename,"r")) == NULL )
+readstoplist(text *in, StopList * s)
+{
+ char **stop = NULL;
+
+ s->len = 0;
+ if (in && VARSIZE(in) - VARHDRSZ > 0)
+ {
+ char *filename = text2char(in);
+ FILE *hin = NULL;
+ char buf[STOPBUFLEN];
+ int reallen = 0;
+
+ if ((hin = fopen(filename, "r")) == NULL)
ereport(ERROR,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("could not open file \"%s\": %m",
- filename)));
+ filename)));
- while( fgets(buf,STOPBUFLEN,hin) ) {
- buf[strlen(buf)-1] = '\0';
- if ( *buf=='\0' ) continue;
+ while (fgets(buf, STOPBUFLEN, hin))
+ {
+ buf[strlen(buf) - 1] = '\0';
+ if (*buf == '\0')
+ continue;
- if ( s->len>= reallen ) {
- char **tmp;
- reallen=(reallen) ? reallen*2 : 16;
- tmp=(char**)realloc((void*)stop, sizeof(char*)*reallen);
- if (!tmp) {
+ if (s->len >= reallen)
+ {
+ char **tmp;
+
+ reallen = (reallen) ? reallen * 2 : 16;
+ tmp = (char **) realloc((void *) stop, sizeof(char *) * reallen);
+ if (!tmp)
+ {
freestoplist(s);
- fclose(hin);
+ fclose(hin);
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory")));
}
- stop=tmp;
+ stop = tmp;
}
-
- stop[s->len]=strdup(buf);
- if ( !stop[s->len] ) {
+
+ stop[s->len] = strdup(buf);
+ if (!stop[s->len])
+ {
freestoplist(s);
- fclose(hin);
+ fclose(hin);
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory")));
}
- if ( s->wordop )
- stop[s->len]=(s->wordop)(stop[s->len]);
+ if (s->wordop)
+ stop[s->len] = (s->wordop) (stop[s->len]);
- (s->len)++;
+ (s->len)++;
}
fclose(hin);
- pfree(filename);
+ pfree(filename);
}
- s->stop=stop;
-}
+ s->stop = stop;
+}
static int
-comparestr(const void *a, const void *b) {
- return strcmp( *(char**)a, *(char**)b );
+comparestr(const void *a, const void *b)
+{
+ return strcmp(*(char **) a, *(char **) b);
}
void
-sortstoplist(StopList *s) {
- if (s->stop && s->len>0)
- qsort(s->stop, s->len, sizeof(char*), comparestr);
+sortstoplist(StopList * s)
+{
+ if (s->stop && s->len > 0)
+ qsort(s->stop, s->len, sizeof(char *), comparestr);
}
bool
-searchstoplist(StopList *s, char *key) {
- if ( s->wordop )
- key=(*(s->wordop))(key);
- return ( s->stop && s->len>0 && bsearch(&key, s->stop, s->len, sizeof(char*), comparestr) ) ? true : false;
+searchstoplist(StopList * s, char *key)
+{
+ if (s->wordop)
+ key = (*(s->wordop)) (key);
+ return (s->stop && s->len > 0 && bsearch(&key, s->stop, s->len, sizeof(char *), comparestr)) ? true : false;
}
-
-
-/*
- * interface functions to tscfg
+/*
+ * interface functions to tscfg
* Teodor Sigaev <teodor@sigaev.ru>
*/
#include <errno.h>
/*********top interface**********/
-static void *plan_getcfg_bylocale=NULL;
-static void *plan_getcfg=NULL;
-static void *plan_getmap=NULL;
-static void *plan_name2id=NULL;
-static Oid current_cfg_id=0;
+static void *plan_getcfg_bylocale = NULL;
+static void *plan_getcfg = NULL;
+static void *plan_getmap = NULL;
+static void *plan_name2id = NULL;
+static Oid current_cfg_id = 0;
void
-init_cfg(Oid id, TSCfgInfo *cfg) {
- Oid arg[2]={ OIDOID, OIDOID };
- bool isnull;
- Datum pars[2]={ ObjectIdGetDatum(id), ObjectIdGetDatum(id) } ;
- int stat,i,j;
- text *ptr;
- text *prsname=NULL;
- MemoryContext oldcontext;
-
- memset(cfg,0,sizeof(TSCfgInfo));
+init_cfg(Oid id, TSCfgInfo * cfg)
+{
+ Oid arg[2] = {OIDOID, OIDOID};
+ bool isnull;
+ Datum pars[2] = {ObjectIdGetDatum(id), ObjectIdGetDatum(id)};
+ int stat,
+ i,
+ j;
+ text *ptr;
+ text *prsname = NULL;
+ MemoryContext oldcontext;
+
+ memset(cfg, 0, sizeof(TSCfgInfo));
SPI_connect();
- if ( !plan_getcfg ) {
- plan_getcfg = SPI_saveplan( SPI_prepare( "select prs_name from pg_ts_cfg where oid = $1" , 1, arg ) );
- if ( !plan_getcfg )
+ if (!plan_getcfg)
+ {
+ plan_getcfg = SPI_saveplan(SPI_prepare("select prs_name from pg_ts_cfg where oid = $1", 1, arg));
+ if (!plan_getcfg)
ts_error(ERROR, "SPI_prepare() failed");
}
stat = SPI_execp(plan_getcfg, pars, " ", 1);
- if ( stat < 0 )
- ts_error (ERROR, "SPI_execp return %d", stat);
- if ( SPI_processed > 0 ) {
- prsname = (text*) DatumGetPointer(
- SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull)
- );
+ if (stat < 0)
+ ts_error(ERROR, "SPI_execp return %d", stat);
+ if (SPI_processed > 0)
+ {
+ prsname = (text *) DatumGetPointer(
+ SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull)
+ );
oldcontext = MemoryContextSwitchTo(TopMemoryContext);
- prsname = ptextdup( prsname );
+ prsname = ptextdup(prsname);
MemoryContextSwitchTo(oldcontext);
-
- cfg->id=id;
- } else
+
+ cfg->id = id;
+ }
+ else
ts_error(ERROR, "No tsearch cfg with id %d", id);
- arg[0]=TEXTOID;
- if ( !plan_getmap ) {
- plan_getmap = SPI_saveplan( SPI_prepare( "select lt.tokid, pg_ts_cfgmap.dict_name from pg_ts_cfgmap, pg_ts_cfg, token_type( $1 ) as lt where lt.alias = pg_ts_cfgmap.tok_alias and pg_ts_cfgmap.ts_name = pg_ts_cfg.ts_name and pg_ts_cfg.oid= $2 order by lt.tokid desc;" , 2, arg ) );
- if ( !plan_getmap )
+ arg[0] = TEXTOID;
+ if (!plan_getmap)
+ {
+ plan_getmap = SPI_saveplan(SPI_prepare("select lt.tokid, pg_ts_cfgmap.dict_name from pg_ts_cfgmap, pg_ts_cfg, token_type( $1 ) as lt where lt.alias = pg_ts_cfgmap.tok_alias and pg_ts_cfgmap.ts_name = pg_ts_cfg.ts_name and pg_ts_cfg.oid= $2 order by lt.tokid desc;", 2, arg));
+ if (!plan_getmap)
ts_error(ERROR, "SPI_prepare() failed");
}
- pars[0]=PointerGetDatum( prsname );
+ pars[0] = PointerGetDatum(prsname);
stat = SPI_execp(plan_getmap, pars, " ", 0);
- if ( stat < 0 )
- ts_error (ERROR, "SPI_execp return %d", stat);
- if ( SPI_processed <= 0 )
+ if (stat < 0)
+ ts_error(ERROR, "SPI_execp return %d", stat);
+ if (SPI_processed <= 0)
ts_error(ERROR, "No parser with id %d", id);
- for(i=0;i<SPI_processed;i++) {
- int lexid = DatumGetInt32(SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 1, &isnull));
- ArrayType *toasted_a = (ArrayType*)PointerGetDatum(SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 2, &isnull));
- ArrayType *a;
-
- if ( !cfg->map ) {
- cfg->len=lexid+1;
- cfg->map = (ListDictionary*)malloc( sizeof(ListDictionary)*cfg->len );
- if ( !cfg->map )
+ for (i = 0; i < SPI_processed; i++)
+ {
+ int lexid = DatumGetInt32(SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 1, &isnull));
+ ArrayType *toasted_a = (ArrayType *) PointerGetDatum(SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 2, &isnull));
+ ArrayType *a;
+
+ if (!cfg->map)
+ {
+ cfg->len = lexid + 1;
+ cfg->map = (ListDictionary *) malloc(sizeof(ListDictionary) * cfg->len);
+ if (!cfg->map)
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory")));
- memset( cfg->map, 0, sizeof(ListDictionary)*cfg->len );
+ memset(cfg->map, 0, sizeof(ListDictionary) * cfg->len);
}
if (isnull)
continue;
- a=(ArrayType*)PointerGetDatum( PG_DETOAST_DATUM( DatumGetPointer(toasted_a) ) );
-
- if ( ARR_NDIM(a) != 1 )
- ts_error(ERROR,"Wrong dimension");
- if ( ARRNELEMS(a) < 1 )
+ a = (ArrayType *) PointerGetDatum(PG_DETOAST_DATUM(DatumGetPointer(toasted_a)));
+
+ if (ARR_NDIM(a) != 1)
+ ts_error(ERROR, "Wrong dimension");
+ if (ARRNELEMS(a) < 1)
continue;
- cfg->map[lexid].len=ARRNELEMS(a);
- cfg->map[lexid].dict_id=(Datum*)malloc( sizeof(Datum)*cfg->map[lexid].len );
- memset(cfg->map[lexid].dict_id,0,sizeof(Datum)*cfg->map[lexid].len );
- ptr=(text*)ARR_DATA_PTR(a);
+ cfg->map[lexid].len = ARRNELEMS(a);
+ cfg->map[lexid].dict_id = (Datum *) malloc(sizeof(Datum) * cfg->map[lexid].len);
+ memset(cfg->map[lexid].dict_id, 0, sizeof(Datum) * cfg->map[lexid].len);
+ ptr = (text *) ARR_DATA_PTR(a);
oldcontext = MemoryContextSwitchTo(TopMemoryContext);
- for(j=0;j<cfg->map[lexid].len;j++) {
+ for (j = 0; j < cfg->map[lexid].len; j++)
+ {
cfg->map[lexid].dict_id[j] = PointerGetDatum(ptextdup(ptr));
- ptr=NEXTVAL(ptr);
- }
+ ptr = NEXTVAL(ptr);
+ }
MemoryContextSwitchTo(oldcontext);
- if ( a != toasted_a )
+ if (a != toasted_a)
pfree(a);
}
-
+
SPI_finish();
- cfg->prs_id = name2id_prs( prsname );
+ cfg->prs_id = name2id_prs(prsname);
pfree(prsname);
- for(i=0;i<cfg->len;i++) {
- for(j=0;j<cfg->map[i].len;j++) {
- ptr = (text*)DatumGetPointer( cfg->map[i].dict_id[j] );
- cfg->map[i].dict_id[j] = ObjectIdGetDatum( name2id_dict(ptr) );
+ for (i = 0; i < cfg->len; i++)
+ {
+ for (j = 0; j < cfg->map[i].len; j++)
+ {
+ ptr = (text *) DatumGetPointer(cfg->map[i].dict_id[j]);
+ cfg->map[i].dict_id[j] = ObjectIdGetDatum(name2id_dict(ptr));
pfree(ptr);
}
}
}
-typedef struct {
- TSCfgInfo *last_cfg;
- int len;
- int reallen;
- TSCfgInfo *list;
+typedef struct
+{
+ TSCfgInfo *last_cfg;
+ int len;
+ int reallen;
+ TSCfgInfo *list;
SNMap name2id_map;
-} CFGList;
+} CFGList;
-static CFGList CList = {NULL,0,0,NULL,{0,0,NULL}};
+static CFGList CList = {NULL, 0, 0, NULL, {0, 0, NULL}};
void
-reset_cfg(void) {
- freeSNMap( &(CList.name2id_map) );
- if ( CList.list ) {
- int i,j;
- for(i=0;i<CList.len;i++)
- if ( CList.list[i].map ) {
- for(j=0;j<CList.list[i].len;j++)
- if ( CList.list[i].map[j].dict_id )
+reset_cfg(void)
+{
+ freeSNMap(&(CList.name2id_map));
+ if (CList.list)
+ {
+ int i,
+ j;
+
+ for (i = 0; i < CList.len; i++)
+ if (CList.list[i].map)
+ {
+ for (j = 0; j < CList.list[i].len; j++)
+ if (CList.list[i].map[j].dict_id)
free(CList.list[i].map[j].dict_id);
- free( CList.list[i].map );
+ free(CList.list[i].map);
}
- free(CList.list);
+ free(CList.list);
}
- memset(&CList,0,sizeof(CFGList));
+ memset(&CList, 0, sizeof(CFGList));
}
static int
-comparecfg(const void *a, const void *b) {
- return ((TSCfgInfo*)a)->id - ((TSCfgInfo*)b)->id;
+comparecfg(const void *a, const void *b)
+{
+ return ((TSCfgInfo *) a)->id - ((TSCfgInfo *) b)->id;
}
TSCfgInfo *
-findcfg(Oid id) {
+findcfg(Oid id)
+{
/* last used cfg */
- if ( CList.last_cfg && CList.last_cfg->id==id )
+ if (CList.last_cfg && CList.last_cfg->id == id)
return CList.last_cfg;
/* already used cfg */
- if ( CList.len != 0 ) {
- TSCfgInfo key;
- key.id=id;
+ if (CList.len != 0)
+ {
+ TSCfgInfo key;
+
+ key.id = id;
CList.last_cfg = bsearch(&key, CList.list, CList.len, sizeof(TSCfgInfo), comparecfg);
- if ( CList.last_cfg != NULL )
+ if (CList.last_cfg != NULL)
return CList.last_cfg;
}
/* last chance */
- if ( CList.len==CList.reallen ) {
- TSCfgInfo *tmp;
- int reallen = ( CList.reallen ) ? 2*CList.reallen : 16;
- tmp=(TSCfgInfo*)realloc(CList.list,sizeof(TSCfgInfo)*reallen);
- if ( !tmp )
- ts_error(ERROR,"No memory");
- CList.reallen=reallen;
- CList.list=tmp;
+ if (CList.len == CList.reallen)
+ {
+ TSCfgInfo *tmp;
+ int reallen = (CList.reallen) ? 2 * CList.reallen : 16;
+
+ tmp = (TSCfgInfo *) realloc(CList.list, sizeof(TSCfgInfo) * reallen);
+ if (!tmp)
+ ts_error(ERROR, "No memory");
+ CList.reallen = reallen;
+ CList.list = tmp;
}
- CList.last_cfg=&(CList.list[CList.len]);
+ CList.last_cfg = &(CList.list[CList.len]);
init_cfg(id, CList.last_cfg);
CList.len++;
qsort(CList.list, CList.len, sizeof(TSCfgInfo), comparecfg);
- return findcfg(id); /* qsort changed order!! */;
+ return findcfg(id); /* qsort changed order!! */ ;
}
Oid
-name2id_cfg(text *name) {
- Oid arg[1]={ TEXTOID };
- bool isnull;
- Datum pars[1]={ PointerGetDatum(name) };
- int stat;
- Oid id=findSNMap_t( &(CList.name2id_map), name );
-
- if ( id )
+name2id_cfg(text *name)
+{
+ Oid arg[1] = {TEXTOID};
+ bool isnull;
+ Datum pars[1] = {PointerGetDatum(name)};
+ int stat;
+ Oid id = findSNMap_t(&(CList.name2id_map), name);
+
+ if (id)
return id;
-
+
SPI_connect();
- if ( !plan_name2id ) {
- plan_name2id = SPI_saveplan( SPI_prepare( "select oid from pg_ts_cfg where ts_name = $1" , 1, arg ) );
- if ( !plan_name2id )
+ if (!plan_name2id)
+ {
+ plan_name2id = SPI_saveplan(SPI_prepare("select oid from pg_ts_cfg where ts_name = $1", 1, arg));
+ if (!plan_name2id)
/* internal error */
elog(ERROR, "SPI_prepare() failed");
}
stat = SPI_execp(plan_name2id, pars, " ", 1);
- if ( stat < 0 )
+ if (stat < 0)
/* internal error */
- elog (ERROR, "SPI_execp return %d", stat);
- if ( SPI_processed > 0 ) {
- id=DatumGetObjectId( SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull) );
- if ( isnull )
+ elog(ERROR, "SPI_execp return %d", stat);
+ if (SPI_processed > 0)
+ {
+ id = DatumGetObjectId(SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull));
+ if (isnull)
ereport(ERROR,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("null id for tsearch config")));
- } else
+ }
+ else
ereport(ERROR,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("no tsearch config")));
SPI_finish();
- addSNMap_t( &(CList.name2id_map), name, id );
+ addSNMap_t(&(CList.name2id_map), name, id);
return id;
}
-void
-parsetext_v2(TSCfgInfo *cfg, PRSTEXT * prs, char *buf, int4 buflen) {
- int type, lenlemm, i;
- char *lemm=NULL;
+void
+parsetext_v2(TSCfgInfo * cfg, PRSTEXT * prs, char *buf, int4 buflen)
+{
+ int type,
+ lenlemm,
+ i;
+ char *lemm = NULL;
WParserInfo *prsobj = findprs(cfg->prs_id);
- prsobj->prs=(void*)DatumGetPointer(
- FunctionCall2(
- &(prsobj->start_info),
- PointerGetDatum(buf),
- Int32GetDatum(buflen)
- )
- );
-
- while( ( type=DatumGetInt32(FunctionCall3(
- &(prsobj->getlexeme_info),
- PointerGetDatum(prsobj->prs),
- PointerGetDatum(&lemm),
- PointerGetDatum(&lenlemm))) ) != 0 ) {
-
- if ( lenlemm >= MAXSTRLEN )
+ prsobj->prs = (void *) DatumGetPointer(
+ FunctionCall2(
+ &(prsobj->start_info),
+ PointerGetDatum(buf),
+ Int32GetDatum(buflen)
+ )
+ );
+
+ while ((type = DatumGetInt32(FunctionCall3(
+ &(prsobj->getlexeme_info),
+ PointerGetDatum(prsobj->prs),
+ PointerGetDatum(&lemm),
+ PointerGetDatum(&lenlemm)))) != 0)
+ {
+
+ if (lenlemm >= MAXSTRLEN)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("word is too long")));
- if ( type >= cfg->len ) /* skip this type of lexem */
- continue;
-
- for(i=0;i<cfg->map[type].len;i++) {
- DictInfo *dict=finddict( DatumGetObjectId(cfg->map[type].dict_id[i]) );
- char **norms, **ptr;
-
- norms = ptr = (char**)DatumGetPointer(
- FunctionCall3(
- &(dict->lexize_info),
- PointerGetDatum(dict->dictionary),
- PointerGetDatum(lemm),
- PointerGetDatum(lenlemm)
- )
- );
- if ( !norms ) /* dictionary doesn't know this lexem */
+ if (type >= cfg->len) /* skip this type of lexem */
+ continue;
+
+ for (i = 0; i < cfg->map[type].len; i++)
+ {
+ DictInfo *dict = finddict(DatumGetObjectId(cfg->map[type].dict_id[i]));
+ char **norms,
+ **ptr;
+
+ norms = ptr = (char **) DatumGetPointer(
+ FunctionCall3(
+ &(dict->lexize_info),
+ PointerGetDatum(dict->dictionary),
+ PointerGetDatum(lemm),
+ PointerGetDatum(lenlemm)
+ )
+ );
+ if (!norms) /* dictionary doesn't know this lexem */
continue;
- prs->pos++; /*set pos*/
+ prs->pos++; /* set pos */
- while( *ptr ) {
- if (prs->curwords == prs->lenwords) {
+ while (*ptr)
+ {
+ if (prs->curwords == prs->lenwords)
+ {
prs->lenwords *= 2;
prs->words = (WORD *) repalloc((void *) prs->words, prs->lenwords * sizeof(WORD));
}
prs->curwords++;
}
pfree(norms);
- break; /* lexem already normalized or is stop word*/
+ break; /* lexem already normalized or is stop
+ * word */
}
}
FunctionCall1(
- &(prsobj->end_info),
- PointerGetDatum(prsobj->prs)
- );
+ &(prsobj->end_info),
+ PointerGetDatum(prsobj->prs)
+ );
}
static void
-hladdword(HLPRSTEXT * prs, char *buf, int4 buflen, int type) {
- while (prs->curwords >= prs->lenwords) {
+hladdword(HLPRSTEXT * prs, char *buf, int4 buflen, int type)
+{
+ while (prs->curwords >= prs->lenwords)
+ {
prs->lenwords *= 2;
prs->words = (HLWORD *) repalloc((void *) prs->words, prs->lenwords * sizeof(HLWORD));
}
- memset( &(prs->words[prs->curwords]), 0, sizeof(HLWORD) );
- prs->words[prs->curwords].type = (uint8)type;
- prs->words[prs->curwords].len = buflen;
+ memset(&(prs->words[prs->curwords]), 0, sizeof(HLWORD));
+ prs->words[prs->curwords].type = (uint8) type;
+ prs->words[prs->curwords].len = buflen;
prs->words[prs->curwords].word = palloc(buflen);
memcpy(prs->words[prs->curwords].word, buf, buflen);
- prs->curwords++;
+ prs->curwords++;
}
static void
-hlfinditem(HLPRSTEXT * prs, QUERYTYPE *query, char *buf, int buflen ) {
- int i;
- ITEM *item=GETQUERY(query);
- HLWORD *word=&( prs->words[prs->curwords-1] );
-
- while (prs->curwords + query->size >= prs->lenwords) {
+hlfinditem(HLPRSTEXT * prs, QUERYTYPE * query, char *buf, int buflen)
+{
+ int i;
+ ITEM *item = GETQUERY(query);
+ HLWORD *word = &(prs->words[prs->curwords - 1]);
+
+ while (prs->curwords + query->size >= prs->lenwords)
+ {
prs->lenwords *= 2;
prs->words = (HLWORD *) repalloc((void *) prs->words, prs->lenwords * sizeof(HLWORD));
}
- for(i=0; i<query->size; i++) {
- if ( item->type == VAL && item->length == buflen && strncmp( GETOPERAND(query) + item->distance, buf, buflen )==0 ) {
- if ( word->item ) {
- memcpy( &(prs->words[prs->curwords]), word, sizeof(HLWORD) );
- prs->words[prs->curwords].item=item;
- prs->words[prs->curwords].repeated=1;
+ for (i = 0; i < query->size; i++)
+ {
+ if (item->type == VAL && item->length == buflen && strncmp(GETOPERAND(query) + item->distance, buf, buflen) == 0)
+ {
+ if (word->item)
+ {
+ memcpy(&(prs->words[prs->curwords]), word, sizeof(HLWORD));
+ prs->words[prs->curwords].item = item;
+ prs->words[prs->curwords].repeated = 1;
prs->curwords++;
- } else
- word->item=item;
+ }
+ else
+ word->item = item;
}
item++;
}
}
-void
-hlparsetext(TSCfgInfo *cfg, HLPRSTEXT * prs, QUERYTYPE *query, char *buf, int4 buflen) {
- int type, lenlemm, i;
- char *lemm=NULL;
+void
+hlparsetext(TSCfgInfo * cfg, HLPRSTEXT * prs, QUERYTYPE * query, char *buf, int4 buflen)
+{
+ int type,
+ lenlemm,
+ i;
+ char *lemm = NULL;
WParserInfo *prsobj = findprs(cfg->prs_id);
- prsobj->prs=(void*)DatumGetPointer(
- FunctionCall2(
- &(prsobj->start_info),
- PointerGetDatum(buf),
- Int32GetDatum(buflen)
- )
- );
-
- while( ( type=DatumGetInt32(FunctionCall3(
- &(prsobj->getlexeme_info),
- PointerGetDatum(prsobj->prs),
- PointerGetDatum(&lemm),
- PointerGetDatum(&lenlemm))) ) != 0 ) {
-
- if ( lenlemm >= MAXSTRLEN )
+ prsobj->prs = (void *) DatumGetPointer(
+ FunctionCall2(
+ &(prsobj->start_info),
+ PointerGetDatum(buf),
+ Int32GetDatum(buflen)
+ )
+ );
+
+ while ((type = DatumGetInt32(FunctionCall3(
+ &(prsobj->getlexeme_info),
+ PointerGetDatum(prsobj->prs),
+ PointerGetDatum(&lemm),
+ PointerGetDatum(&lenlemm)))) != 0)
+ {
+
+ if (lenlemm >= MAXSTRLEN)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("word is too long")));
- hladdword(prs,lemm,lenlemm,type);
-
- if ( type >= cfg->len )
- continue;
-
- for(i=0;i<cfg->map[type].len;i++) {
- DictInfo *dict=finddict( DatumGetObjectId(cfg->map[type].dict_id[i]) );
- char **norms, **ptr;
-
- norms = ptr = (char**)DatumGetPointer(
- FunctionCall3(
- &(dict->lexize_info),
- PointerGetDatum(dict->dictionary),
- PointerGetDatum(lemm),
- PointerGetDatum(lenlemm)
- )
- );
- if ( !norms ) /* dictionary doesn't know this lexem */
+ hladdword(prs, lemm, lenlemm, type);
+
+ if (type >= cfg->len)
+ continue;
+
+ for (i = 0; i < cfg->map[type].len; i++)
+ {
+ DictInfo *dict = finddict(DatumGetObjectId(cfg->map[type].dict_id[i]));
+ char **norms,
+ **ptr;
+
+ &n
projects / users / rhaas / postgres.git / commitdiff