]> matita.cs.unibo.it Git - helm.git/blobdiff - helm/metadata/extractor/sthandler.c
This commit was manufactured by cvs2svn to create branch 'moogle'.
[helm.git] / helm / metadata / extractor / sthandler.c
diff --git a/helm/metadata/extractor/sthandler.c b/helm/metadata/extractor/sthandler.c
deleted file mode 100644 (file)
index 87e0d49..0000000
+++ /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               <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;
-          }
-}
-
-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);
-}
-
-
-
-
-
-