X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fmetadata%2Fextractor%2Fsthandler.c;fp=helm%2Fmetadata%2Fextractor%2Fsthandler.c;h=6f87cdfb5448dd15e45c2dad08376803261639df;hb=407c75f92f1a641dc49243209cd246f6affd924d;hp=0000000000000000000000000000000000000000;hpb=f9c4a1158888982406aca8960b6d50cdce677507;p=helm.git diff --git a/helm/metadata/extractor/sthandler.c b/helm/metadata/extractor/sthandler.c new file mode 100644 index 000000000..6f87cdfb5 --- /dev/null +++ b/helm/metadata/extractor/sthandler.c @@ -0,0 +1,453 @@ +/*********************************************************************/ +/* 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 +#include +#include + +/****************************************************************/ +/* 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); +} + + + + + +