helm/metadata/create_V7_mowgli/METADATA/meta_lex_ind.l

   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   */
  11  /* 2 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      */
  19  /* License 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  /*                        META_LEXAN                           */
  29  /*                 Automatic Metadata Extractor                */
  30  /*           First draft 11/12/2001, by Andrea Asperti         */
  31  /*      more bugs added by domenico lordi on mon 12/17/2001    */
  32  /***************************************************************/
  33
  34  /***************************************************************/
  35  /* 1. Inclusion of header files.                               */
  36  /***************************************************************/
  37
  38 %{
  39 #include                <string.h>
  40 #include                <stdlib.h>
  41 #include                <sys/stat.h>
  42 #include                "sthandler_ind.h"
  43 %}
  44
  45  /***************************************************************/
  46  /* 2. Constants and Variables Definitions                      */
  47  /***************************************************************/
  48
  49 %{
  50 #define                 NOWHERE   0
  51 #define                 CONST     1
  52 #define                 MUTIND    2
  53 #define                 MUTCONSTRUCT  3
  54 #define                 SORT      4
  55
  56 #define                 INBODY    0
  57 #define                 MAINHYP   1
  58 #define                 INHYP     2
  59 #define                 INCONCL   3
  60 #define                 MAINCONCL 4
  61 #define                 INTYPE    5
  62 #define                 NOTFOUND  6
  63
  64 #define                 HERE      0
  65 #define                 AFTER     1
  66
  67
  68 int                     where = NOWHERE;
  69 int                     found = NOTFOUND;
  70 int                     position = INBODY;
  71 int                     first_child = HERE;
  72 int                     skip = 0;     // boolean to skip the insertion of a URI
  73 int                     no_open_source =0;
  74 int                     spine_depth = 0;
  75 int                     depth = 0;
  76 int                     tmp_n;
  77 int                     inductive_type = 0;
  78 int                     constructor = 0;
  79 int                     deep_type = 0;
  80 char                    sep = '"';
  81 char                    *xpointer = "#xpointer(1/";
  82 char                    *uri;
  83 char                    *tmp;
  84 char                    *filename;
  85 char                    *file_uri;
  86 char                    *inductive_uri;
  87 char                    *filename_prefix;
  88 char                    *file_uri_prefix;
  89 %}
  90
  91  /***************************************************************/
  92  /* 3. Regular definitions.                                     */
  93  /***************************************************************/
  94
  95 uri                     [^"]+
  96 digits                  [0-9]+
  97 value                   [^"]+
  98
  99  /***************************************************************/
 100  /* 4. Rules.                                                   */
 101  /***************************************************************/
 102
 103
 104 %%
 105
 106 "<InductiveType"   {
 107                      /* fprintf(stderr,"uno"); */
 108                      init_symbol_table();
 109                      no_open_source = 0;
 110                      depth = 0;
 111                      spine_depth = 0;
 112                      /* fprintf(stderr,"due"); */
 113                      inductive_type++;
 114                      constructor=0;
 115                      position = INTYPE;
 116                      first_child = HERE;
 117                    }
 118
 119 "</arity>"         { tmp = (char *)malloc(sizeof('a')*128);
 120                      strcpy(filename,filename_prefix);
 121                      /* fprintf(stderr,"tre"); */
 122                      strcpy(file_uri,file_uri_prefix);
 123                      sprintf(tmp,",%d.xml", inductive_type);
 124                      /* fprintf(stderr,"quattro"); */
 125                      strcat(filename,tmp);
 126                      sprintf(tmp,"#xpointer(1/%d)", inductive_type);
 127                      strcat(file_uri,tmp);
 128                      /* fprintf(stderr,"cinque"); */
 129                      free(tmp);
 130                      print_file();
 131                    }
 132
 133 "<Constructor"     { init_symbol_table();
 134                      no_open_source = 0;
 135                      depth = 0;
 136                      spine_depth = 0;
 137                      constructor++;
 138                      strcpy(inductive_uri,file_uri_prefix);
 139                      position = INTYPE;
 140                      first_child = HERE;
 141                    }
 142
 143 "</Constructor>"   { tmp = (char *)malloc(sizeof('a')*128);
 144                      strcpy(filename,filename_prefix);
 145                      strcpy(file_uri,file_uri_prefix);
 146                      strcpy(inductive_uri,file_uri_prefix);
 147                      sprintf(tmp,",%d,%d.xml", inductive_type,constructor);
 148                      strcat(filename,tmp);
 149                      sprintf(tmp,"#xpointer(1/%d/%d)",inductive_type,constructor);
 150                      strcat(file_uri,tmp);
 151                      free(tmp);
 152                      print_file();
 153                    }
 154
 155 "<decl"            |
 156 "<def"             {
 157                     if (position == INTYPE)
 158                        position = MAINHYP;
 159                     else if (position == MAINHYP)
 160                         { position = INHYP;
 161                           no_open_source++;};
 162                    }
 163
 164 "</decl>"          |
 165 "</def"            {
 166                     if (position == INHYP)
 167                      {
 168                       no_open_source--;
 169                       if (no_open_source == 0)
 170                         {
 171                          position = MAINHYP;
 172                          depth++;
 173                          first_child = HERE;
 174                         }
 175                      }
 176                     else if (position == MAINHYP)
 177                       {
 178                        position = INTYPE;
 179                        spine_depth++;
 180                        depth = 0;
 181                       }
 182                     first_child = HERE;
 183                    }
 184
 185
 186 .|\n               {
 187                    }
 188
 189 "<LAMBDA"          |
 190 "<MUTCASE"         |
 191 "<FIX"             |
 192 "<COFIX"           {
 193                           first_child = AFTER;
 194                    }
 195
 196 "<REL"             {
 197                     if (((position == INTYPE) | (position == MAINHYP)) &&
 198                        (first_child == HERE))
 199                      {
 200                        if (position == INTYPE) /* REL on the spine */
 201                          {
 202                            position = INCONCL;
 203                            search("Rel",first_child,position,spine_depth);
 204                          }
 205                        else search("Rel",first_child,position,depth);
 206                        first_child = AFTER;
 207                      }
 208                    }
 209
 210 "<SORT"(" "|\n)+"value=\""{value}   {
 211                     if (((position == INTYPE) | (position == MAINHYP)) &&
 212                        (first_child == HERE))
 213                      {
 214                        tmp=(char *)malloc((sizeof('a')*200));
 215                        strcpy(tmp,yytext);
 216                        strsep(&tmp,&sep);
 217                        if (position == INTYPE) /* SORT on the spine */
 218                          {
 219                            position = INCONCL;
 220                            search(tmp,first_child,position,spine_depth);
 221                          }
 222                        else search(tmp,first_child,position,depth);
 223                        first_child = AFTER;
 224                      }
 225                    }
 226
 227 "<VAR"             {
 228                      skip = 1;
 229                      first_child = AFTER;
 230                    }
 231
 232 "<CONST"           {
 233                      if (position == INTYPE) /* CONST on the spine */
 234                         position = INCONCL;
 235                      where = CONST;
 236                    }
 237
 238 "<MUTIND"          {
 239                      if (position == INTYPE) /* MUTIND on the spine */
 240                         position = INCONCL;
 241                      where = MUTIND;
 242                    }
 243
 244 "<MUTCONSTRUCT"    {
 245                      if (position == INTYPE) /* MUTCONSTRUCT on the spine */
 246                         position = INCONCL;
 247                      where = MUTCONSTRUCT;
 248                    }
 249
 250 "uri=\""{uri}      {
 251                          if (!skip) {
 252                             uri=(char *)malloc((sizeof('a')*200));
 253                             strcpy(uri,yytext);
 254                             strsep(&uri,&sep);
 255                             if (where == CONST)
 256                               {
 257                                 if (position == INCONCL)
 258                                   search(uri,first_child,position,spine_depth);
 259                                 else search(uri,first_child,position,depth);
 260                                 where = NOWHERE;
 261                                 first_child = AFTER;
 262                                 free(uri);
 263                               };
 264                          } else skip = 0;
 265                    }
 266
 267 "noType=\""{digits} {
 268                          if ((where == MUTIND) || (where == MUTCONSTRUCT))
 269                           { strsep(&yytext,&sep);
 270                             tmp=(char *)malloc((sizeof(sep)*(strlen(yytext)+1)));
 271                             strcpy(tmp,yytext);
 272                             tmp_n = atoi(tmp)+1;
 273                             sprintf(tmp,"%d",tmp_n);
 274                             strcat(uri,"#xpointer(1/");
 275                             strcat(uri,tmp);
 276                           };
 277                          if (where == MUTIND)
 278                              {
 279                                strcat(uri,")");
 280                                if (position == INCONCL)
 281                                   search(uri,first_child,position,spine_depth);
 282                                else search(uri,first_child,position,depth);
 283                                free(uri);
 284                                free(tmp);
 285                                where = NOWHERE;
 286                                first_child = AFTER;};
 287                    }
 288
 289 "noConstr=\""{digits} {
 290                          if (where == MUTCONSTRUCT)
 291                           { strsep(&yytext,&sep);
 292                             tmp=(char *)malloc((sizeof(sep)*(strlen(yytext)+1)));
 293                             strcpy(tmp,yytext);
 294                             strcat(uri,"/");
 295                             strcat(uri,tmp);
 296                             strcat(uri,")");
 297                             if (position == INCONCL)
 298                               search(uri,first_child,position,spine_depth);
 299                             else search(uri,first_child,position,depth);
 300                             free(uri);
 301                             free(tmp);
 302                             where = NOWHERE;
 303                             first_child = AFTER;};
 304                    }
 305
 306
 307
 308 %%
 309
 310  /***************************************************************/
 311  /* 6. Auxiliary functions.                                     */
 312  /***************************************************************/
 313
 314 main(int argc, char *argv[])
 315 {
 316                    filename = malloc((sizeof('a')*2000));
 317                    file_uri = malloc((sizeof('a')*2000));
 318                    inductive_uri = malloc((sizeof('a')*2000));
 319                    filename_prefix=argv[1];
 320                    file_uri_prefix=argv[2];
 321                    /* fprintf(stderr,"qua"); */
 322                    yyin = fopen("tmp/inductive_type.xml", "r");
 323                    yylex();
 324 }
 325
 326 print_file()
 327 {
 328                    FILE *out, *outrel, *outsort;
 329
 330                    if (!(out = fopen(filename,"w")))
 331                      {
 332                       fprintf(stderr, "error in openinf file %s\n", filename);
 333                       exit(-1);
 334                      }
 335                    if (!(outrel = fopen("forward_rel.xml","a")))
 336                      {
 337                       fprintf(stderr, "error in openinf file forward_rel.xml\n");
 338                       exit(-1);
 339                      }
 340                    if (!(outsort = fopen("forward_sort.xml","a")))
 341                      {
 342                       fprintf(stderr, "error in openinf file forward_rel.xml\n");
 343                       exit(-1);
 344                      }
 345
 346                    // We process the type
 347
 348                    fprintf(out,"<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n\n");
 349 fprintf(out,"<!DOCTYPE rdf:RDF [
 350         <!ENTITY rdfns 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'>
 351         <!ENTITY hthns 'http://www.cs.unibo.it/helm/schemas/schema-helmth#'>
 352         <!ENTITY hns 'http://www.cs.unibo.it/helm/schemas/schema-helm#'>
 353
 354    ]>\n");
 355                    fprintf(out,"<rdf:RDF xml:lang=\"en\" xmlns:rdf=\"&rdfns;\" xmlns:h=\"&hns;\" xmlns:hth=\"&hthns;\">\n");
 356                    fprintf(out,"\t<h:Object rdf:about=\"");
 357                    fprintf(out,"%s",file_uri);
 358                    fprintf(out,"\">\n");
 359                    print_all(file_uri,out,outrel,outsort);
 360                    fprintf(out,"\t</h:Object>\n");
 361                    fprintf(out,"</rdf:RDF>\n");
 362                    fclose(out);
 363                    fclose(outrel);
 364                    fclose(outsort);
 365 }
 366
 367 search(uri,first_child,position,depth)
 368 char               *uri;
 369 int                first_child;
 370 int                position;
 371 {
 372                    if (position == MAINHYP)
 373                       {
 374                        if (first_child == HERE)
 375                            found = search_bucket(uri,MAINHYP,depth);
 376                        else
 377                            found = search_bucket(uri,INHYP,0);
 378                       }
 379                    else if (position == INCONCL)
 380                       {
 381                        if (first_child == HERE)
 382                            found = search_bucket(uri,MAINCONCL,depth);
 383                        else
 384                            found = search_bucket(uri,INCONCL,0);
 385                       }
 386
 387                    else
 388                       found = search_bucket(uri,position,depth);
 389                    /* if (found == NOTFOUND)
 390                          printf( "pos = %d, uri = %s\n", position, uri); */
 391 }
 392
 393
 394 int yywrap() {
 395                return 1;
 396              }
 397
 398
 399
 400