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=0000000000000000000000000000000000000000;hb=d43522a6d38fcb9081a3f0352088377bc0555231;hp=87e0d49c71e0833ec4d29afd8123fb5ef1aaff12;hpb=9a9c95ebabbb1d4d7dce627ed1baea130ea98766;p=helm.git diff --git a/helm/metadata/extractor/sthandler.c b/helm/metadata/extractor/sthandler.c deleted file mode 100644 index 87e0d49c7..000000000 --- a/helm/metadata/extractor/sthandler.c +++ /dev/null @@ -1,475 +0,0 @@ -/*********************************************************************/ -/* 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; - } -} - -void print_name(char *name, char *uri) -{ - size_t len = strlen(uri) + 1; - char *quri = malloc (sizeof(char) * len * 2); - PQescapeString(quri,uri,len); - len = strlen(name) + 1; - char *qname = malloc (sizeof(char) * len * 2); - PQescapeString(qname,name,len); - printf("INSERT INTO objectName VALUES ('%s', '%s');\n",quri,qname); - free(quri); - free(qname); -} - -/****************************************************************/ -/* 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); - free(qabout); - 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); - free(qabout); - 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); - free(qabout); - free(quri); - 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); - free(qabout); - } - 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); - free(qabout); - } - 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); - free(qabout); - free(quri); - } -} - -// 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); - free(qabout); - free(quri); -} - - /* 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); -} - - - - - -