metadata/extractor/sthandler.c

   1 /*********************************************************************/
   2 /*  Copyright (C) 2000, HELM Team                                    */
   3 /*                                                                   */
   4 /* This file is part of HELM, an Hypertextual, Electronic            */
   5 /* Library of Mathematics, developed at the Computer Science         */
   6 /* Department, University of Bologna, Italy.                         */
   7 /*                                                                   */
   8 /* HELM is free software; you can redistribute it and/or             */
   9 /* modify it under the terms of the GNU General Public License       */
  10 /* as published by the Free Software Foundation; either version 2    */
  11 /* of the License, or (at your option) any later version.            */
  12 /*                                                                   */
  13 /* HELM is distributed in the hope that it will be useful,           */
  14 /* but WITHOUT ANY WARRANTY; without even the implied warranty of    */
  15 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the     */
  16 /* GNU General Public License for more details.                      */
  17 /*                                                                   */
  18 /* You should have received a copy of the GNU General Public License */
  19 /* along with HELM; if not, write to the Free Software               */
  20 /* Foundation, Inc., 59 Temple Place - Suite 330, Boston,            */
  21 /* MA  02111-1307, USA.                                              */
  22 /*                                                                   */
  23 /* For details, see the HELM World-Wide-Web page,                    */
  24 /* http://cs.unibo.it/helm/.                                         */
  25  /*********************************************************************/
  26
  27 /****************************************************************/
  28 /*                        STHANDLER.C                           */
  29 /****************************************************************/
  30 /* This module supplies routines for symbol table handling.     */
  31 /* - init_symbol_table(): it initializes the symbol table       */
  32 /*                        to void.                              */
  33 /* - search_bucket(): it searches the symbol table for the      */
  34 /*                    bucket containing a given identifier, and */
  35 /*                    inserts it if it is not present;          */
  36 /****************************************************************/
  37 /*           First draft 11/12/2001, by Andrea Asperti          */
  38 /****************************************************************/
  39
  40 /****************************************************************/
  41 /* 1. Inclusion of header files.                                */
  42 /****************************************************************/
  43
  44 #include                <stdio.h>
  45 #include                <malloc.h>
  46 #include                <string.h>
  47
  48 /****************************************************************/
  49 /* 2. Declarations                                              */
  50 /****************************************************************/
  51
  52
  53 #define         DICTSIZE                        211
  54 #define         HASH1                           4
  55 #define         HASH2                           0xf0000000
  56 #define         HASH3                           28
  57 #define         EOS                             '\0'
  58
  59 #define                 INBODY    0
  60 #define                 MAINHYP   1
  61 #define                 INHYP     2
  62 #define                 INCONCL   3
  63 #define                 MAINCONCL 4
  64 #define                 INTYPE    5
  65 #define                 NOTFOUND  6
  66
  67 /****************************************************************/
  68 /* 3. Types.                                                    */
  69 /****************************************************************/
  70
  71 struct int_list {
  72                 int                     val;
  73                 struct int_list         *next;
  74                   };
  75
  76 struct st_bucket {
  77                 char                    *id;
  78                                                 /* identifier */
  79                 int                     main_depth;
  80                 struct int_list         *depths;
  81                 struct st_bucket        *next_st_bucket;
  82                                                 /* next bucket in the list */
  83                 struct st_bucket        *all_next;
  84                                                /* all buckets in symbol
  85                                                   table are linked together */
  86                 int                     pos[5];
  87
  88                   };
  89
  90 struct st_bucket    *dictionary[DICTSIZE];
  91                                /* pointers to bucket lists */
  92
  93 /****************************************************************/
  94 /* 4. Local functions.                                          */
  95 /****************************************************************/
  96 struct int_list  *add(struct int_list  *,int);
  97 void allocate_bucket(struct st_bucket **st, char *id, int where);
  98 void print_mainhyp(char *about, char *uri,struct int_list *l);
  99 void print_mainconcl(char *about, char *uri, int depth);
 100 void move_bucket(struct st_bucket *st, int dict_index);
 101 void print_one(char *about, char *uri, int pos);
 102 int hash_pjw(char *id);
 103
 104 /* This function is copied from the file fe-exec.c of PostgreSQL. */
 105 /* Copyright (c) 1996-2003, PostgreSQL Global Development Group   */
 106 /* Copyright (c) 1994, Regents of the University of California    */
 107 size_t
 108 PQescapeString(char *to, const char *from, size_t length)
 109 {
 110   const char *source = from;
 111   char     *target = to;
 112   size_t    remaining = length;
 113
 114   while (remaining > 0 && *source != '\0')
 115   {
 116     switch (*source)
 117     {
 118       case '\\':
 119         *target++ = '\\';
 120         *target++ = '\\';
 121         break;
 122
 123       case '\'':
 124         *target++ = '\'';
 125         *target++ = '\'';
 126         break;
 127
 128       default:
 129         *target++ = *source;
 130         break;
 131     }
 132     source++;
 133     remaining--;
 134   }
 135
 136   /* Write the terminating NUL character. */
 137   *target = '\0';
 138
 139   return target - to;
 140 }
 141
 142
 143 /****************************************************************/
 144 /* 5. Definitions of functions to be exported.                  */
 145 /****************************************************************/
 146
 147 struct st_bucket        *all;
 148
 149  /* The following function initializes the symbol table to NULL */
 150 void init_symbol_table()
 151 {
 152         int                     i;
 153
 154         /* initialize the dictionary */
 155         for (i = 0; i < DICTSIZE; i++)
 156                 dictionary[i] = NULL;
 157         all = NULL;
 158 }
 159
 160  /* The following function searches the symbol table for an identifier */
 161  /* and inserts it if it is not present. */
 162  /* The bucket associated with the given identifier */
 163  /* becomes the first one in its list. */
 164
 165 int search_bucket(id, where, depth)
 166         char            *id;
 167                                         /* identifier */
 168         int             where;
 169         int             depth;
 170 {
 171         int             dict_index;
 172                                         /* value returned by the */
 173                                         /* hash function */
 174         struct st_bucket
 175                         *prev,
 176                         *curr;
 177
 178         struct st_bucket *st;
 179
 180         /* apply the hash function */
 181         dict_index = hash_pjw(id);
 182         /* fprintf(stderr,"%d\n", dict_index); */
 183
 184         /* scan the bucket list indicated by the hash function */
 185         prev = curr = dictionary[dict_index];
 186         while ((curr != NULL) && (strcmp(id, curr->id)))
 187           {
 188             prev = curr;
 189             curr = curr->next_st_bucket;
 190           }
 191         if (curr == NULL)
 192           /* the identifier is not in the list */
 193           {
 194             allocate_bucket(&st,id,where);
 195             if (where == MAINCONCL)
 196               st->main_depth = depth;
 197             else if (where == MAINHYP)
 198               st->depths = add(st->depths,depth);
 199             move_bucket(st,dict_index);
 200             return NOTFOUND;
 201           }
 202         else
 203           /*
 204              printf("uno=%s\n", id);
 205              printf("st=%s\n", curr->id); fflush(stdout) */
 206
 207           /* the identifier is already in the list */
 208           {
 209             /* st = curr; */
 210             curr->pos[where] = 1;
 211             if (where >= 1)
 212               curr->pos[INBODY] = 0; /* it will never be set again to 1 */
 213             if (where == MAINHYP)
 214               curr->depths=add(curr->depths,depth);
 215             else if (where == MAINCONCL)
 216               curr->main_depth = depth;
 217             if (prev != curr)
 218               /* the identifier is not in the first position */
 219               {
 220                 prev->next_st_bucket = curr->next_st_bucket;
 221                 move_bucket(curr,dict_index);
 222               };
 223             return where;
 224           }
 225 }
 226
 227 void print_all(about,conn)
 228      char       *about;
 229 {
 230
 231         int i;
 232         struct st_bucket *curr;
 233         curr = all;
 234         while (curr != NULL)
 235           {
 236             for (i = 0; i < 5; ++i)
 237               if ((curr->pos[i]) == 1)
 238                 {
 239                   if (i == MAINHYP)
 240                     print_mainhyp(about,curr->id,curr->depths);
 241                   else if (i == MAINCONCL)
 242                     print_mainconcl(about,curr->id,curr->main_depth);
 243                   else
 244                     print_one(about,curr->id,i);
 245                 }
 246             curr = curr->all_next;
 247           }
 248 }
 249
 250 void print_name(char *name, char *uri)
 251 {
 252   size_t len = strlen(uri) + 1;
 253   char *quri = malloc (sizeof(char) * len * 2);
 254   PQescapeString(quri,uri,len);
 255   len = strlen(name) + 1;
 256   char *qname = malloc (sizeof(char) * len * 2);
 257   PQescapeString(qname,name,len);
 258   printf("INSERT INTO objectName VALUES ('%s', '%s');\n",quri,qname);
 259   free(quri);
 260   free(qname);
 261 }
 262
 263 /****************************************************************/
 264 /* 5. Definitions of functions local to the module.             */
 265 /****************************************************************/
 266
 267 struct int_list  *add(l,m)
 268      struct int_list    *l;
 269      int                m;
 270 {
 271         struct int_list *curr;
 272         /* scan the list looking for m */
 273         curr = l;
 274         while ((curr != NULL) && (m != (curr->val)))
 275             curr = curr->next;
 276         if (curr == NULL)
 277           /* m is not in the list */
 278           {
 279             curr = (struct int_list *)malloc(sizeof(struct int_list));
 280             curr->val = m;
 281             curr->next = l;
 282             return curr;
 283           }
 284         else
 285         return l;
 286
 287 }
 288
 289 void print_mainhyp(about,uri,l)
 290      char                *about;
 291      char                *uri;
 292      struct int_list     *l;
 293 {
 294     struct int_list *curr;
 295     curr = l;
 296     if (!strcmp(uri,"Rel"))
 297       {
 298         /* scan the list */
 299         while (curr != NULL)
 300           {
 301             size_t len = strlen(about) + 1;
 302             char *qabout = malloc (sizeof(char) * len * 2);
 303             PQescapeString(qabout,about,len);
 304             printf("INSERT INTO refRel VALUES ('%s', 'http://www.cs.unibo.it/helm/schemas/schema-helm#MainHypothesis', %d);\n",qabout,curr->val);
 305             free(qabout);
 306             curr = curr->next;
 307           }
 308       }
 309    else if ((!strcmp(uri,"Prop")) || (!strcmp(uri,"Type")) ||
 310             (!strcmp(uri,"Set")))
 311       {
 312         /* scan the list */
 313         while (curr != NULL)
 314           {
 315             size_t len = strlen(about) + 1;
 316             char *qabout = malloc (sizeof(char) * len * 2);
 317             PQescapeString(qabout,about,len);
 318             printf("INSERT INTO refSort VALUES ('%s', 'http://www.cs.unibo.it/helm/schemas/schema-helm#MainHypothesis', %d, '%s');\n",qabout,curr->val,uri);
 319             free(qabout);
 320             curr = curr->next;
 321           }
 322       }
 323     else
 324      {
 325         /* scan the list */
 326         while (curr != NULL)
 327           {
 328             size_t len = strlen(about) + 1;
 329             char *qabout = malloc (sizeof(char) * len * 2);
 330             char *quri;
 331             PQescapeString(qabout,about,len);
 332             len = strlen(uri) + 1;
 333             quri = malloc (sizeof(char) * len * 2);
 334             PQescapeString(quri,uri,len);
 335             printf("INSERT INTO refObj VALUES ('%s', '%s', 'http://www.cs.unibo.it/helm/schemas/schema-helm#MainHypothesis', %d);\n",qabout,quri,curr->val);
 336             free(qabout);
 337             free(quri);
 338             curr = curr->next;
 339           }
 340       }
 341 }
 342
 343 void print_mainconcl(about,uri,depth)
 344      char    *about;
 345      char    *uri;
 346      int     depth;
 347
 348 {
 349     /* fprintf(stderr,"about = %s\n",about); */
 350     if (!strcmp(uri,"Rel"))
 351       {
 352         size_t len = strlen(about) + 1;
 353         char *qabout = malloc (sizeof(char) * len * 2);
 354         PQescapeString(qabout,about,len);
 355         printf("INSERT INTO refRel VALUES ('%s', 'http://www.cs.unibo.it/helm/schemas/schema-helm#MainConclusion', %d);\n",qabout,depth);
 356         free(qabout);
 357       }
 358     else if ((!strcmp(uri,"Prop")) || (!strcmp(uri,"Type")) ||
 359             (!strcmp(uri,"Set")))
 360       {
 361         size_t len = strlen(about) + 1;
 362         char *qabout = malloc (sizeof(char) * len * 2);
 363         PQescapeString(qabout,about,len);
 364         printf("INSERT INTO refSort VALUES ('%s', 'http://www.cs.unibo.it/helm/schemas/schema-helm#MainConclusion', %d, '%s');\n",qabout,depth,uri);
 365         free(qabout);
 366       }
 367     else
 368       {
 369         size_t len = strlen(about) + 1;
 370         char *qabout = malloc (sizeof(char) * len * 2);
 371         char *quri;
 372         PQescapeString(qabout,about,len);
 373         len = strlen(uri) + 1;
 374         quri = malloc (sizeof(char) * len * 2);
 375         PQescapeString(quri,uri,len);
 376         printf("INSERT INTO refObj VALUES ('%s', '%s','http://www.cs.unibo.it/helm/schemas/schema-helm#MainConclusion', %d);\n",qabout,quri,depth);
 377         free(qabout);
 378         free(quri);
 379       }
 380 }
 381
 382 // dome: cambiata per usare il modello con position
 383 void print_one(about,uri,pos)
 384      char    *about,
 385              *uri;
 386      int     pos;
 387 {
 388     char       *position = (char *)malloc((sizeof('a')*20));
 389     size_t len = strlen(about) + 1;
 390     char *qabout = malloc (sizeof(char) * len * 2);
 391     char *quri;
 392     PQescapeString(qabout,about,len);
 393     len = strlen(uri) + 1;
 394     quri = malloc (sizeof(char) * len * 2);
 395     PQescapeString(quri,uri,len);
 396     if (pos == INBODY)
 397        position="InBody";
 398     else if (pos == MAINHYP)
 399        position="MainHypothesis";  /* This should never happen */
 400     else if (pos == INHYP)
 401        position="InHypothesis";
 402     else if (pos == INCONCL)
 403        position="InConclusion";
 404     else if (pos == MAINCONCL)
 405        position="MainConclusion";  /* This should never happen */
 406     printf("INSERT INTO refObj VALUES ('%s', '%s', \
 407     'http://www.cs.unibo.it/helm/schemas/schema-helm#%s', NULL);\n",qabout,quri,position);
 408     free(qabout);
 409     free(quri);
 410 }
 411
 412  /* The following function allocates a bucket for an identifier. */
 413 void allocate_bucket(st, id, where)
 414         struct st_bucket
 415                         **st;
 416                                         /* pointer to the bucket to be */
 417                                         /* allocated */
 418         char            *id;
 419                                         /* identifier */
 420         int             where;
 421 {
 422         int i;
 423
 424         *st = (struct st_bucket *)malloc(sizeof(struct st_bucket));
 425         (*st)->id = (char *)malloc(sizeof('a')*(strlen(id) + 1));
 426         strcpy((*st)->id,id);
 427         (*st)->main_depth = 0;
 428         (*st)->depths = NULL;
 429         (*st)->next_st_bucket = NULL;
 430         (*st)->all_next = all;
 431         all = *st;
 432         for (i = 0; i < 5; ++i)
 433           (*st)->pos[i] = 0;
 434         (*st)->pos[where] = 1;
 435 }
 436
 437  /* The following function moves a bucket to the head of the */
 438  /* list in which it lies. */
 439 void move_bucket(st, dict_index)
 440         struct st_bucket
 441                         *st;
 442                                         /* pointer to the bucket to */
 443                                         /* be moved */
 444         int             dict_index;
 445                                         /* index corresponding to */
 446                                         /* the list in which the */
 447                                         /* bucket lies */
 448 {
 449         st->next_st_bucket = dictionary[dict_index];
 450         dictionary[dict_index] = st;
 451 }
 452
 453  /* The following function implements Weinberger's hash function. */
 454 int
 455 hash_pjw(id)
 456         char            *id;
 457                                         /* identifier to be hashed */
 458 {
 459         unsigned        h,
 460                         g;
 461
 462         for (h = 0; *id != EOS; id++)
 463         {
 464                 h = (h << HASH1) + (*id);
 465                 if ((g = h) & HASH2)
 466                         h = h ^ (g >> HASH3) ^ g;
 467         }
 468         return(h % DICTSIZE);
 469 }
 470
 471
 472
 473
 474
 475