--- /dev/null
+/*********************************************************************/
+/* Copyright (C) 2000, HELM Team */
+/* */
+/* This file is part of HELM, an Hypertextual, Electronic */
+/* Library of Mathematics, developed at the Computer Science */
+/* Department, University of Bologna, Italy. */
+/* */
+/* HELM is free software; you can redistribute it and/or */
+/* modify it under the terms of the GNU General Public License */
+/* as published by the Free Software Foundation; either version 2 */
+/* of the License, or (at your option) any later version. */
+/* */
+/* HELM is distributed in the hope that it will be useful, */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
+/* GNU General Public License for more details. */
+/* */
+/* You should have received a copy of the GNU General Public License */
+/* along with HELM; if not, write to the Free Software */
+/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, */
+/* MA 02111-1307, USA. */
+/* */
+/* For details, see the HELM World-Wide-Web page, */
+/* http://cs.unibo.it/helm/. */
+ /*********************************************************************/
+
+/****************************************************************/
+/* STHANDLER.C */
+/****************************************************************/
+/* This module supplies routines for symbol table handling. */
+/* - init_symbol_table(): it initializes the symbol table */
+/* to void. */
+/* - search_bucket(): it searches the symbol table for the */
+/* bucket containing a given identifier, and */
+/* inserts it if it is not present; */
+/****************************************************************/
+/* First draft 11/12/2001, by Andrea Asperti */
+/****************************************************************/
+
+/****************************************************************/
+/* 1. Inclusion of header files. */
+/****************************************************************/
+
+#include <stdio.h>
+#include <malloc.h>
+#include <string.h>
+
+/****************************************************************/
+/* 2. Declarations */
+/****************************************************************/
+
+
+#define DICTSIZE 211
+#define HASH1 4
+#define HASH2 0xf0000000
+#define HASH3 28
+#define EOS '\0'
+
+#define INBODY 0
+#define MAINHYP 1
+#define INHYP 2
+#define INCONCL 3
+#define MAINCONCL 4
+#define INTYPE 5
+#define NOTFOUND 6
+
+/****************************************************************/
+/* 3. Types. */
+/****************************************************************/
+
+struct int_list {
+ int val;
+ struct int_list *next;
+ };
+
+struct st_bucket {
+ char *id;
+ /* identifier */
+ int main_depth;
+ struct int_list *depths;
+ struct st_bucket *next_st_bucket;
+ /* next bucket in the list */
+ struct st_bucket *all_next;
+ /* all buckets in symbol
+ table are linked together */
+ int pos[5];
+
+ };
+
+struct st_bucket *dictionary[DICTSIZE];
+ /* pointers to bucket lists */
+
+/****************************************************************/
+/* 4. Local functions. */
+/****************************************************************/
+struct int_list *add(struct int_list *,int);
+void allocate_bucket(struct st_bucket **st, char *id, int where);
+void print_mainhyp(char *about, char *uri,struct int_list *l);
+void print_mainconcl(char *about, char *uri, int depth);
+void move_bucket(struct st_bucket *st, int dict_index);
+void print_one(char *about, char *uri, int pos);
+int hash_pjw(char *id);
+
+/* This function is copied from the file fe-exec.c of PostgreSQL. */
+/* Copyright (c) 1996-2003, PostgreSQL Global Development Group */
+/* Copyright (c) 1994, Regents of the University of California */
+size_t
+PQescapeString(char *to, const char *from, size_t length)
+{
+ const char *source = from;
+ char *target = to;
+ size_t remaining = length;
+
+ while (remaining > 0 && *source != '\0')
+ {
+ switch (*source)
+ {
+ case '\\':
+ *target++ = '\\';
+ *target++ = '\\';
+ break;
+
+ case '\'':
+ *target++ = '\'';
+ *target++ = '\'';
+ break;
+
+ default:
+ *target++ = *source;
+ break;
+ }
+ source++;
+ remaining--;
+ }
+
+ /* Write the terminating NUL character. */
+ *target = '\0';
+
+ return target - to;
+}
+
+
+/****************************************************************/
+/* 5. Definitions of functions to be exported. */
+/****************************************************************/
+
+struct st_bucket *all;
+
+ /* The following function initializes the symbol table to NULL */
+void init_symbol_table()
+{
+ int i;
+
+ /* initialize the dictionary */
+ for (i = 0; i < DICTSIZE; i++)
+ dictionary[i] = NULL;
+ all = NULL;
+}
+
+ /* The following function searches the symbol table for an identifier */
+ /* and inserts it if it is not present. */
+ /* The bucket associated with the given identifier */
+ /* becomes the first one in its list. */
+
+int search_bucket(id, where, depth)
+ char *id;
+ /* identifier */
+ int where;
+ int depth;
+{
+ int dict_index;
+ /* value returned by the */
+ /* hash function */
+ struct st_bucket
+ *prev,
+ *curr;
+
+ struct st_bucket *st;
+
+ /* apply the hash function */
+ dict_index = hash_pjw(id);
+ /* fprintf(stderr,"%d\n", dict_index); */
+
+ /* scan the bucket list indicated by the hash function */
+ prev = curr = dictionary[dict_index];
+ while ((curr != NULL) && (strcmp(id, curr->id)))
+ {
+ prev = curr;
+ curr = curr->next_st_bucket;
+ }
+ if (curr == NULL)
+ /* the identifier is not in the list */
+ {
+ allocate_bucket(&st,id,where);
+ if (where == MAINCONCL)
+ st->main_depth = depth;
+ else if (where == MAINHYP)
+ st->depths = add(st->depths,depth);
+ move_bucket(st,dict_index);
+ return NOTFOUND;
+ }
+ else
+ /*
+ printf("uno=%s\n", id);
+ printf("st=%s\n", curr->id); fflush(stdout) */
+
+ /* the identifier is already in the list */
+ {
+ /* st = curr; */
+ curr->pos[where] = 1;
+ if (where >= 1)
+ curr->pos[INBODY] = 0; /* it will never be set again to 1 */
+ if (where == MAINHYP)
+ curr->depths=add(curr->depths,depth);
+ else if (where == MAINCONCL)
+ curr->main_depth = depth;
+ if (prev != curr)
+ /* the identifier is not in the first position */
+ {
+ prev->next_st_bucket = curr->next_st_bucket;
+ move_bucket(curr,dict_index);
+ };
+ return where;
+ }
+}
+
+void print_all(about,conn)
+ char *about;
+{
+
+ int i;
+ struct st_bucket *curr;
+ curr = all;
+ while (curr != NULL)
+ {
+ for (i = 0; i < 5; ++i)
+ if ((curr->pos[i]) == 1)
+ {
+ if (i == MAINHYP)
+ print_mainhyp(about,curr->id,curr->depths);
+ else if (i == MAINCONCL)
+ print_mainconcl(about,curr->id,curr->main_depth);
+ else
+ print_one(about,curr->id,i);
+ }
+ curr = curr->all_next;
+ }
+}
+
+
+/****************************************************************/
+/* 5. Definitions of functions local to the module. */
+/****************************************************************/
+
+struct int_list *add(l,m)
+ struct int_list *l;
+ int m;
+{
+ struct int_list *curr;
+ /* scan the list looking for m */
+ curr = l;
+ while ((curr != NULL) && (m != (curr->val)))
+ curr = curr->next;
+ if (curr == NULL)
+ /* m is not in the list */
+ {
+ curr = (struct int_list *)malloc(sizeof(struct int_list));
+ curr->val = m;
+ curr->next = l;
+ return curr;
+ }
+ else
+ return l;
+
+}
+
+void print_mainhyp(about,uri,l)
+ char *about;
+ char *uri;
+ struct int_list *l;
+{
+ struct int_list *curr;
+ curr = l;
+ if (!strcmp(uri,"Rel"))
+ {
+ /* scan the list */
+ while (curr != NULL)
+ {
+ size_t len = strlen(about) + 1;
+ char *qabout = malloc (sizeof(char) * len * 2);
+ PQescapeString(qabout,about,len);
+ printf("INSERT INTO refRel VALUES ('%s', 'http://www.cs.unibo.it/helm/schemas/schema-helm#MainHypothesis', %d);\n",qabout,curr->val);
+ curr = curr->next;
+ }
+ }
+ else if ((!strcmp(uri,"Prop")) || (!strcmp(uri,"Type")) ||
+ (!strcmp(uri,"Set")))
+ {
+ /* scan the list */
+ while (curr != NULL)
+ {
+ size_t len = strlen(about) + 1;
+ char *qabout = malloc (sizeof(char) * len * 2);
+ PQescapeString(qabout,about,len);
+ printf("INSERT INTO refSort VALUES ('%s', 'http://www.cs.unibo.it/helm/schemas/schema-helm#MainHypothesis', %d, '%s');\n",qabout,curr->val,uri);
+ curr = curr->next;
+ }
+ }
+ else
+ {
+ /* scan the list */
+ while (curr != NULL)
+ {
+ size_t len = strlen(about) + 1;
+ char *qabout = malloc (sizeof(char) * len * 2);
+ char *quri;
+ PQescapeString(qabout,about,len);
+ len = strlen(uri) + 1;
+ quri = malloc (sizeof(char) * len * 2);
+ PQescapeString(quri,uri,len);
+ printf("INSERT INTO refObj VALUES ('%s', '%s', 'http://www.cs.unibo.it/helm/schemas/schema-helm#MainHypothesis', %d);\n",qabout,quri,curr->val);
+ curr = curr->next;
+ }
+ }
+}
+
+void print_mainconcl(about,uri,depth)
+ char *about;
+ char *uri;
+ int depth;
+
+{
+ /* fprintf(stderr,"about = %s\n",about); */
+ if (!strcmp(uri,"Rel"))
+ {
+ size_t len = strlen(about) + 1;
+ char *qabout = malloc (sizeof(char) * len * 2);
+ PQescapeString(qabout,about,len);
+ printf("INSERT INTO refRel VALUES ('%s', 'http://www.cs.unibo.it/helm/schemas/schema-helm#MainConclusion', %d);\n",qabout,depth);
+ }
+ else if ((!strcmp(uri,"Prop")) || (!strcmp(uri,"Type")) ||
+ (!strcmp(uri,"Set")))
+ {
+ size_t len = strlen(about) + 1;
+ char *qabout = malloc (sizeof(char) * len * 2);
+ PQescapeString(qabout,about,len);
+ printf("INSERT INTO refSort VALUES ('%s', 'http://www.cs.unibo.it/helm/schemas/schema-helm#MainConclusion', %d, '%s');\n",qabout,depth,uri);
+ }
+ else
+ {
+ size_t len = strlen(about) + 1;
+ char *qabout = malloc (sizeof(char) * len * 2);
+ char *quri;
+ PQescapeString(qabout,about,len);
+ len = strlen(uri) + 1;
+ quri = malloc (sizeof(char) * len * 2);
+ PQescapeString(quri,uri,len);
+ printf("INSERT INTO refObj VALUES ('%s', '%s','http://www.cs.unibo.it/helm/schemas/schema-helm#MainConclusion', %d);\n",qabout,quri,depth);
+ }
+}
+
+// dome: cambiata per usare il modello con position
+void print_one(about,uri,pos)
+ char *about,
+ *uri;
+ int pos;
+{
+ char *position = (char *)malloc((sizeof('a')*20));
+ size_t len = strlen(about) + 1;
+ char *qabout = malloc (sizeof(char) * len * 2);
+ char *quri;
+ PQescapeString(qabout,about,len);
+ len = strlen(uri) + 1;
+ quri = malloc (sizeof(char) * len * 2);
+ PQescapeString(quri,uri,len);
+ if (pos == INBODY)
+ position="InBody";
+ else if (pos == MAINHYP)
+ position="MainHypothesis"; /* This should never happen */
+ else if (pos == INHYP)
+ position="InHypothesis";
+ else if (pos == INCONCL)
+ position="InConclusion";
+ else if (pos == MAINCONCL)
+ position="MainConclusion"; /* This should never happen */
+ printf("INSERT INTO refObj VALUES ('%s', '%s', \
+ 'http://www.cs.unibo.it/helm/schemas/schema-helm#%s', NULL);\n",qabout,quri,position);
+}
+
+ /* The following function allocates a bucket for an identifier. */
+void allocate_bucket(st, id, where)
+ struct st_bucket
+ **st;
+ /* pointer to the bucket to be */
+ /* allocated */
+ char *id;
+ /* identifier */
+ int where;
+{
+ int i;
+
+ *st = (struct st_bucket *)malloc(sizeof(struct st_bucket));
+ (*st)->id = (char *)malloc(sizeof('a')*(strlen(id) + 1));
+ strcpy((*st)->id,id);
+ (*st)->main_depth = 0;
+ (*st)->depths = NULL;
+ (*st)->next_st_bucket = NULL;
+ (*st)->all_next = all;
+ all = *st;
+ for (i = 0; i < 5; ++i)
+ (*st)->pos[i] = 0;
+ (*st)->pos[where] = 1;
+}
+
+ /* The following function moves a bucket to the head of the */
+ /* list in which it lies. */
+void move_bucket(st, dict_index)
+ struct st_bucket
+ *st;
+ /* pointer to the bucket to */
+ /* be moved */
+ int dict_index;
+ /* index corresponding to */
+ /* the list in which the */
+ /* bucket lies */
+{
+ st->next_st_bucket = dictionary[dict_index];
+ dictionary[dict_index] = st;
+}
+
+ /* The following function implements Weinberger's hash function. */
+int
+hash_pjw(id)
+ char *id;
+ /* identifier to be hashed */
+{
+ unsigned h,
+ g;
+
+ for (h = 0; *id != EOS; id++)
+ {
+ h = (h << HASH1) + (*id);
+ if ((g = h) & HASH2)
+ h = h ^ (g >> HASH3) ^ g;
+ }
+ return(h % DICTSIZE);
+}
+
+
+
+
+
+
projects / helm.git / blobdiff