From 0e6b8620b9c128c3f256c00b422cee7708321171 Mon Sep 17 00:00:00 2001 From: Claudio Sacerdoti Coen Date: Tue, 29 Oct 2002 12:32:44 +0000 Subject: [PATCH] New version for the new DTD. --- helm/metadata/create_V7_mowgli/.cvsignore | 2 + .../create_V7_mowgli/METADATA/.cvsignore | 2 + .../create_V7_mowgli/METADATA/Makefile | 30 + .../metadata/create_V7_mowgli/METADATA/README | 9 + .../create_V7_mowgli/METADATA/lex.yy.c | 1879 ++++++++++++++++ .../create_V7_mowgli/METADATA/lex.yy_ind.c | 1958 +++++++++++++++++ .../create_V7_mowgli/METADATA/meta_lex.l | 265 +++ .../create_V7_mowgli/METADATA/meta_lex_ind.l | 331 +++ .../create_V7_mowgli/METADATA/sthandler.c | 261 +++ .../create_V7_mowgli/METADATA/sthandler.h | 8 + .../create_V7_mowgli/METADATA/sthandler_ind.c | 263 +++ .../create_V7_mowgli/METADATA/sthandler_ind.h | 8 + helm/metadata/create_V7_mowgli/Makefile | 28 + helm/metadata/create_V7_mowgli/fix_rdf.pl | 29 + helm/metadata/create_V7_mowgli/invert.pl | 37 + helm/metadata/create_V7_mowgli/mkindex.sh | 4 + .../create_V7_mowgli/touch/.cvsignore | 1 + helm/metadata/create_V7_mowgli/touch/Makefile | 41 + helm/metadata/create_V7_mowgli/touch/touch.ml | 132 ++ .../create_V7_mowgli/uris_of_filenames.pl | 14 + 20 files changed, 5302 insertions(+) create mode 100644 helm/metadata/create_V7_mowgli/.cvsignore create mode 100644 helm/metadata/create_V7_mowgli/METADATA/.cvsignore create mode 100644 helm/metadata/create_V7_mowgli/METADATA/Makefile create mode 100644 helm/metadata/create_V7_mowgli/METADATA/README create mode 100644 helm/metadata/create_V7_mowgli/METADATA/lex.yy.c create mode 100644 helm/metadata/create_V7_mowgli/METADATA/lex.yy_ind.c create mode 100644 helm/metadata/create_V7_mowgli/METADATA/meta_lex.l create mode 100644 helm/metadata/create_V7_mowgli/METADATA/meta_lex_ind.l create mode 100644 helm/metadata/create_V7_mowgli/METADATA/sthandler.c create mode 100644 helm/metadata/create_V7_mowgli/METADATA/sthandler.h create mode 100644 helm/metadata/create_V7_mowgli/METADATA/sthandler_ind.c create mode 100644 helm/metadata/create_V7_mowgli/METADATA/sthandler_ind.h create mode 100644 helm/metadata/create_V7_mowgli/Makefile create mode 100755 helm/metadata/create_V7_mowgli/fix_rdf.pl create mode 100755 helm/metadata/create_V7_mowgli/invert.pl create mode 100755 helm/metadata/create_V7_mowgli/mkindex.sh create mode 100644 helm/metadata/create_V7_mowgli/touch/.cvsignore create mode 100644 helm/metadata/create_V7_mowgli/touch/Makefile create mode 100644 helm/metadata/create_V7_mowgli/touch/touch.ml create mode 100755 helm/metadata/create_V7_mowgli/uris_of_filenames.pl diff --git a/helm/metadata/create_V7_mowgli/.cvsignore b/helm/metadata/create_V7_mowgli/.cvsignore new file mode 100644 index 000000000..d6d5bf69d --- /dev/null +++ b/helm/metadata/create_V7_mowgli/.cvsignore @@ -0,0 +1,2 @@ +backward +forward diff --git a/helm/metadata/create_V7_mowgli/METADATA/.cvsignore b/helm/metadata/create_V7_mowgli/METADATA/.cvsignore new file mode 100644 index 000000000..321587a53 --- /dev/null +++ b/helm/metadata/create_V7_mowgli/METADATA/.cvsignore @@ -0,0 +1,2 @@ +meta +meta_ind diff --git a/helm/metadata/create_V7_mowgli/METADATA/Makefile b/helm/metadata/create_V7_mowgli/METADATA/Makefile new file mode 100644 index 000000000..cb7d5d714 --- /dev/null +++ b/helm/metadata/create_V7_mowgli/METADATA/Makefile @@ -0,0 +1,30 @@ +CC = gcc + +all: meta meta_ind + +meta: lex.yy.o sthandler.o + gcc lex.yy.o sthandler.o -o meta + +meta_ind: lex.yy_ind.o sthandler_ind.o + gcc lex.yy_ind.o sthandler_ind.o -o meta_ind + +lex.yy.c: meta_lex.l sthandler.h + flex meta_lex.l + +lex.yy_ind.c: meta_lex_ind.l sthandler_ind.h + flex -olex.yy_ind.c meta_lex_ind.l + +sthandler.o: sthandler.c sthandler.h + +sthandler.o: sthandler_ind.c sthandler_ind.h + +lex.yy.o: lex.yy.c sthandler.h + gcc -c lex.yy.c + +lex.yy_ind.o: lex.yy_ind.c sthandler_ind.h + gcc -c lex.yy_ind.c + +clean: + -rm *.o + -rm lex.yy.c lex.yy_ind.c + -rm meta meta_ind diff --git a/helm/metadata/create_V7_mowgli/METADATA/README b/helm/metadata/create_V7_mowgli/METADATA/README new file mode 100644 index 000000000..6c9fe0bcb --- /dev/null +++ b/helm/metadata/create_V7_mowgli/METADATA/README @@ -0,0 +1,9 @@ +Note: + - LetIn e Variabili con corpo: da pensarci (capita solamente una 30ina + di volte... per ora!) Per il momento ci mettiamo una pezza. + - Variabili: non consideriamo l'occorrenza di una variabile come una + vera occorrenza (perche' puo' essere istanziata). In ogni caso c'e' + l'attributo @params che fornisce questa informazione. + - META e IMPLICIT non trattati + - CAST non considerati ==> di default vado in ricorsione sia sul tipo + che sul corpo diff --git a/helm/metadata/create_V7_mowgli/METADATA/lex.yy.c b/helm/metadata/create_V7_mowgli/METADATA/lex.yy.c new file mode 100644 index 000000000..603c10e6c --- /dev/null +++ b/helm/metadata/create_V7_mowgli/METADATA/lex.yy.c @@ -0,0 +1,1879 @@ +/* A lexical scanner generated by flex */ + +/* Scanner skeleton version: + * $Header$ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include +#include + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include +#ifndef _WIN32 +#include +#else +#ifndef YY_ALWAYS_INTERACTIVE +#ifndef YY_NEVER_INTERACTIVE +extern int isatty YY_PROTO(( int )); +#endif +#endif +#endif + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include +#include +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct yy_buffer_state *YY_BUFFER_STATE; + +extern int yyleng; +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * yyless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the yyless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + *yy_cp = yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, yytext_ptr ) + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int yy_size_t; + + +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE yy_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER yy_current_buffer + + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; + +static int yy_n_chars; /* number of characters read into yy_ch_buf */ + + +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 1; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart YY_PROTO(( FILE *input_file )); + +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) + +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); + +static void *yy_flex_alloc YY_PROTO(( yy_size_t )); +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); +static void yy_flex_free YY_PROTO(( void * )); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) + +typedef unsigned char YY_CHAR; +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +typedef int yy_state_type; +extern char *yytext; +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state YY_PROTO(( void )); +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +static int yy_get_next_buffer YY_PROTO(( void )); +static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yytext_ptr = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 20 +#define YY_END_OF_BUFFER 21 +static yyconst short int yy_accept[110] = + { 0, + 0, 0, 21, 7, 7, 7, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 11, 0, 0, 9, 13, 0, + 0, 4, 0, 0, 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, + 12, 14, 0, 0, 0, 0, 0, 0, 0, 17, + 0, 5, 8, 0, 0, 15, 0, 0, 0, 0, + 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, + + 19, 2, 0, 0, 16, 0, 0, 1, 0 + } ; + +static yyconst int yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 3, 1, 4, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 5, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 1, 1, 7, + 8, 9, 1, 1, 10, 11, 12, 13, 14, 15, + 1, 1, 16, 1, 1, 17, 18, 19, 20, 1, + 1, 21, 22, 23, 24, 25, 1, 26, 1, 1, + 1, 1, 1, 1, 1, 1, 27, 28, 29, 30, + + 31, 32, 1, 1, 33, 1, 1, 34, 1, 35, + 36, 37, 1, 38, 39, 40, 41, 1, 1, 1, + 42, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst int yy_meta[43] = + { 0, + 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1 + } ; + +static yyconst short int yy_base[113] = + { 0, + 0, 1, 136, 137, 38, 99, 96, 0, 113, 116, + 121, 106, 115, 0, 97, 0, 94, 90, 94, 0, + 98, 105, 99, 104, 99, 81, 0, 82, 75, 108, + 85, 2, 98, 91, 137, 101, 1, 137, 137, 78, + 76, 137, 74, 71, 103, 64, 71, 137, 78, 80, + 89, 1, 82, 73, 137, 60, 67, 0, 88, 87, + 137, 137, 85, 72, 74, 79, 63, 50, 81, 0, + 2, 137, 137, 74, 65, 137, 52, 47, 80, 37, + 43, 137, 59, 50, 72, 73, 36, 56, 67, 71, + 68, 36, 43, 57, 44, 59, 33, 49, 55, 32, + + 48, 137, 29, 13, 137, 18, 3, 137, 137, 68, + 0, 70 + } ; + +static yyconst short int yy_def[113] = + { 0, + 110, 110, 109, 109, 109, 109, 109, 109, 109, 109, + 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, + 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, + 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, + 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, + 109, 109, 109, 109, 109, 109, 109, 111, 109, 109, + 109, 109, 109, 109, 109, 109, 109, 109, 109, 111, + 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, + 109, 109, 109, 109, 109, 109, 109, 109, 112, 109, + 109, 109, 109, 112, 109, 109, 109, 109, 109, 109, + + 109, 109, 109, 109, 109, 109, 109, 109, 0, 109, + 109, 109 + } ; + +static yyconst short int yy_nxt[180] = + { 0, + 70, 109, 109, 80, 80, 109, 5, 5, 81, 25, + 64, 28, 52, 109, 33, 109, 53, 109, 34, 109, + 65, 109, 29, 109, 109, 109, 26, 18, 41, 19, + 47, 42, 109, 48, 6, 6, 109, 109, 80, 80, + 7, 7, 8, 81, 108, 99, 99, 107, 106, 9, + 100, 105, 10, 101, 11, 12, 99, 99, 13, 104, + 103, 100, 14, 102, 101, 95, 98, 15, 4, 4, + 94, 94, 97, 91, 96, 95, 93, 92, 91, 90, + 89, 88, 87, 86, 85, 84, 83, 82, 79, 78, + 77, 76, 75, 74, 73, 72, 71, 69, 68, 67, + + 66, 63, 62, 61, 60, 59, 58, 57, 56, 55, + 54, 51, 50, 49, 46, 45, 44, 43, 40, 39, + 38, 37, 36, 35, 32, 31, 30, 27, 24, 23, + 22, 21, 20, 17, 16, 109, 3, 109, 109, 109, + 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, + 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, + 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, + 109, 109, 109, 109, 109, 109, 109, 109, 109 + } ; + +static yyconst short int yy_chk[180] = + { 0, + 111, 0, 0, 71, 71, 0, 1, 2, 71, 14, + 52, 16, 37, 0, 20, 0, 37, 0, 20, 0, + 52, 0, 16, 0, 0, 0, 14, 8, 27, 8, + 32, 27, 0, 32, 1, 2, 0, 0, 80, 80, + 1, 2, 5, 80, 107, 95, 95, 106, 104, 5, + 95, 103, 5, 101, 5, 5, 99, 99, 5, 100, + 98, 99, 5, 97, 96, 94, 93, 5, 110, 110, + 112, 112, 92, 91, 90, 89, 88, 87, 86, 85, + 84, 83, 81, 79, 78, 77, 75, 74, 69, 68, + 67, 66, 65, 64, 63, 60, 59, 57, 56, 54, + + 53, 51, 50, 49, 47, 46, 45, 44, 43, 41, + 40, 36, 34, 33, 31, 30, 29, 28, 26, 25, + 24, 23, 22, 21, 19, 18, 17, 15, 13, 12, + 11, 10, 9, 7, 6, 3, 109, 109, 109, 109, + 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, + 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, + 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, + 109, 109, 109, 109, 109, 109, 109, 109, 109 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "meta_lex.l" +#define INITIAL 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/. */ +/******************************************************************/ +/***************************************************************/ +/* META_LEXAN */ +/* Automatic Metadata Extractor */ +/* First draft 11/12/2001, by Andrea Asperti */ +/* more bugs added by domenico lordi on mon 12/17/2001 */ +/***************************************************************/ +/***************************************************************/ +/* 1. Inclusion of header files. */ +/***************************************************************/ +#line 39 "meta_lex.l" +#include +#include +#include +#include "sthandler.h" +/***************************************************************/ +/* 2. Constants and Variables Definitions */ +/***************************************************************/ +#line 50 "meta_lex.l" +#define NOWHERE 0 +#define CONST 1 +#define MUTIND 2 +#define MUTCONSTRUCT 3 + +#define INBODY 0 +#define MAINHYP 1 +#define INHYP 2 +#define INCONCL 3 +#define MAINCONCL 4 +#define INTYPE 5 +#define NOTFOUND 6 + +#define HERE 0 +#define AFTER 1 + + +int where = NOWHERE; +int found = NOTFOUND; +int position = INBODY; +int first_child = HERE; +int skip = 0; // boolean to skip the insertion of a URI +int no_open_source =0; +int tmp_n; +char sep = '"'; +char *xpointer = "#xpointer(1/"; +char *uri; +char *tmp; +/***************************************************************/ +/* 3. Regular definitions. */ +/***************************************************************/ +/***************************************************************/ +/* 4. Rules. */ +/***************************************************************/ +#line 523 "lex.yy.c" + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap YY_PROTO(( void )); +#else +extern int yywrap YY_PROTO(( void )); +#endif +#endif + +#ifndef YY_NO_UNPUT +static void yyunput YY_PROTO(( int c, char *buf_ptr )); +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen YY_PROTO(( yyconst char * )); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput YY_PROTO(( void )); +#else +static int input YY_PROTO(( void )); +#endif +#endif + +#if YY_STACK_USED +static int yy_start_stack_ptr = 0; +static int yy_start_stack_depth = 0; +static int *yy_start_stack = 0; +#ifndef YY_NO_PUSH_STATE +static void yy_push_state YY_PROTO(( int new_state )); +#endif +#ifndef YY_NO_POP_STATE +static void yy_pop_state YY_PROTO(( void )); +#endif +#ifndef YY_NO_TOP_STATE +static int yy_top_state YY_PROTO(( void )); +#endif + +#else +#define YY_NO_PUSH_STATE 1 +#define YY_NO_POP_STATE 1 +#define YY_NO_TOP_STATE 1 +#endif + +#ifdef YY_MALLOC_DECL +YY_MALLOC_DECL +#else +#if __STDC__ +#ifndef __cplusplus +#include +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( yy_current_buffer->yy_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else \ + { \ + errno=0; \ + while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ + { \ + if( errno != EINTR) \ + { \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + break; \ + } \ + errno=0; \ + clearerr(yyin); \ + } \ + } +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int yylex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +YY_DECL + { + register yy_state_type yy_current_state; + register char *yy_cp, *yy_bp; + register int yy_act; + +#line 92 "meta_lex.l" + + +#line 688 "lex.yy.c" + + if ( yy_init ) + { + yy_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yy_start ) + yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! yy_current_buffer ) + yy_current_buffer = + yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_cp = yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start; +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 110 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 137 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 94 "meta_lex.l" +{ + position = INBODY; // Variables have both a body and a type + } + YY_BREAK +case 2: +YY_RULE_SETUP +#line 98 "meta_lex.l" +{ + position = INTYPE; // Variables have both a body and a type + } + YY_BREAK +case 3: +#line 103 "meta_lex.l" +case 4: +YY_RULE_SETUP +#line 103 "meta_lex.l" +{ + if ((position == INTYPE) || + (position == INHYP)) + { position = INHYP; + no_open_source++;}; + } + YY_BREAK +case 5: +#line 111 "meta_lex.l" +case 6: +YY_RULE_SETUP +#line 111 "meta_lex.l" +{ + if (position == INHYP) + { + no_open_source--; + if (no_open_source == 0) + { position = INTYPE; + first_child = HERE; }; + }; + } + YY_BREAK +case 7: +YY_RULE_SETUP +#line 122 "meta_lex.l" +{ + } + YY_BREAK +case 8: +#line 126 "meta_lex.l" +case 9: +#line 127 "meta_lex.l" +case 10: +#line 128 "meta_lex.l" +case 11: +#line 129 "meta_lex.l" +case 12: +YY_RULE_SETUP +#line 129 "meta_lex.l" +{ + first_child = AFTER; + } + YY_BREAK +case 13: +YY_RULE_SETUP +#line 133 "meta_lex.l" +{ + skip = 1; + first_child = AFTER; + } + YY_BREAK +case 14: +YY_RULE_SETUP +#line 138 "meta_lex.l" +{ + if (position == INTYPE) /* CONST on the spine */ + position = INCONCL; + where = CONST; + } + YY_BREAK +case 15: +YY_RULE_SETUP +#line 144 "meta_lex.l" +{ + if (position == INTYPE) /* MUTIND on the spine */ + position = INCONCL; + where = MUTIND; + } + YY_BREAK +case 16: +YY_RULE_SETUP +#line 150 "meta_lex.l" +{ + if (position == INTYPE) /* MUTCONSTRUCT on the spine */ + position = INCONCL; + where = MUTCONSTRUCT; + } + YY_BREAK +case 17: +YY_RULE_SETUP +#line 156 "meta_lex.l" +{ + if (!skip) { + uri=(char *)malloc((sizeof('a')*200)); + strcpy(uri,yytext); + strsep(&uri,&sep); + if (where == CONST) + { + search(uri,first_child,position); + where = NOWHERE; + first_child = AFTER; + free(uri); + }; + } else skip = 0; + } + YY_BREAK +case 18: +YY_RULE_SETUP +#line 171 "meta_lex.l" +{ + if ((where == MUTIND) || (where == MUTCONSTRUCT)) + { strsep(&yytext,&sep); + tmp=(char *)malloc((sizeof(sep)*(strlen(yytext)+1))); + strcpy(tmp,yytext); + tmp_n = atoi(tmp)+1; + sprintf(tmp,"%d",tmp_n); + strcat(uri,"#xpointer(1/"); + strcat(uri,tmp); + }; + if (where == MUTIND) + { + strcat(uri,")"); + search(uri,first_child,position); + free(uri); + free(tmp); + where = NOWHERE; + first_child = AFTER;}; + } + YY_BREAK +case 19: +YY_RULE_SETUP +#line 191 "meta_lex.l" +{ + if (where == MUTCONSTRUCT) + { strsep(&yytext,&sep); + tmp=(char *)malloc((sizeof(sep)*(strlen(yytext)+1))); + strcpy(tmp,yytext); + strcat(uri,"/"); + strcat(uri,tmp); + strcat(uri,")"); + search(uri,first_child,position); + free(uri); + free(tmp); + where = NOWHERE; + first_child = AFTER;}; + } + YY_BREAK +case 20: +YY_RULE_SETUP +#line 208 "meta_lex.l" +ECHO; + YY_BREAK +#line 932 "lex.yy.c" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between yy_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yy_n_chars = yy_current_buffer->yy_n_chars; + yy_current_buffer->yy_input_file = yyin; + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + yy_did_buffer_switch_on_eof = 0; + + if ( yywrap() ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = + yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yy_c_buf_p = + &yy_current_buffer->yy_ch_buf[yy_n_chars]; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of yylex */ + + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int yy_get_next_buffer() + { + register char *dest = yy_current_buffer->yy_ch_buf; + register char *source = yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( yy_current_buffer->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + yy_current_buffer->yy_n_chars = yy_n_chars = 0; + + else + { + int num_to_read = + yy_current_buffer->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = yy_current_buffer; + + int yy_c_buf_p_offset = + (int) (yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yy_flex_realloc( (void *) b->yy_ch_buf, + b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = yy_current_buffer->yy_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), + yy_n_chars, num_to_read ); + + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + if ( yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + yy_current_buffer->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + yy_n_chars += number_to_move; + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; + + return ret_val; + } + + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +static yy_state_type yy_get_previous_state() + { + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = yy_start; + + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 110 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; + } + + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) +#else +static yy_state_type yy_try_NUL_trans( yy_current_state ) +yy_state_type yy_current_state; +#endif + { + register int yy_is_jam; + register char *yy_cp = yy_c_buf_p; + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 110 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 109); + + return yy_is_jam ? 0 : yy_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void yyunput( int c, register char *yy_bp ) +#else +static void yyunput( c, yy_bp ) +int c; +register char *yy_bp; +#endif + { + register char *yy_cp = yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yy_hold_char; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = yy_n_chars + 2; + register char *dest = &yy_current_buffer->yy_ch_buf[ + yy_current_buffer->yy_buf_size + 2]; + register char *source = + &yy_current_buffer->yy_ch_buf[number_to_move]; + + while ( source > yy_current_buffer->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + yy_current_buffer->yy_n_chars = + yy_n_chars = yy_current_buffer->yy_buf_size; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + + yytext_ptr = yy_bp; + yy_hold_char = *yy_cp; + yy_c_buf_p = yy_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifdef __cplusplus +static int yyinput() +#else +static int input() +#endif + { + int c; + + *yy_c_buf_p = yy_hold_char; + + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* This was really a NUL. */ + *yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = yy_c_buf_p - yytext_ptr; + ++yy_c_buf_p; + + switch ( yy_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap() ) + return EOF; + + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ + *yy_c_buf_p = '\0'; /* preserve yytext */ + yy_hold_char = *++yy_c_buf_p; + + + return c; + } + + +#ifdef YY_USE_PROTOS +void yyrestart( FILE *input_file ) +#else +void yyrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! yy_current_buffer ) + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_init_buffer( yy_current_buffer, input_file ); + yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( yy_current_buffer == new_buffer ) + return; + + if ( yy_current_buffer ) + { + /* Flush out information for old buffer. */ + *yy_c_buf_p = yy_hold_char; + yy_current_buffer->yy_buf_pos = yy_c_buf_p; + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + yy_current_buffer = new_buffer; + yy_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void yy_load_buffer_state( void ) +#else +void yy_load_buffer_state() +#endif + { + yy_n_chars = yy_current_buffer->yy_n_chars; + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; + yyin = yy_current_buffer->yy_input_file; + yy_hold_char = *yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == yy_current_buffer ) + yy_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yy_flex_free( (void *) b->yy_ch_buf ); + + yy_flex_free( (void *) b ); + } + + +#ifndef _WIN32 +#include +#else +#ifndef YY_ALWAYS_INTERACTIVE +#ifndef YY_NEVER_INTERACTIVE +extern int isatty YY_PROTO(( int )); +#endif +#endif +#endif + +#ifdef YY_USE_PROTOS +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->yy_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->yy_is_interactive = 0; +#else + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void yy_flush_buffer( YY_BUFFER_STATE b ) +#else +void yy_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == yy_current_buffer ) + yy_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) +#else +YY_BUFFER_STATE yy_scan_buffer( base, size ) +char *base; +yy_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) +#else +YY_BUFFER_STATE yy_scan_string( yy_str ) +yyconst char *yy_str; +#endif + { + int len; + for ( len = 0; yy_str[len]; ++len ) + ; + + return yy_scan_bytes( yy_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) +#else +YY_BUFFER_STATE yy_scan_bytes( bytes, len ) +yyconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) yy_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void yy_push_state( int new_state ) +#else +static void yy_push_state( new_state ) +int new_state; +#endif + { + if ( yy_start_stack_ptr >= yy_start_stack_depth ) + { + yy_size_t new_size; + + yy_start_stack_depth += YY_START_STACK_INCR; + new_size = yy_start_stack_depth * sizeof( int ); + + if ( ! yy_start_stack ) + yy_start_stack = (int *) yy_flex_alloc( new_size ); + + else + yy_start_stack = (int *) yy_flex_realloc( + (void *) yy_start_stack, new_size ); + + if ( ! yy_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + yy_start_stack[yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void yy_pop_state() + { + if ( --yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(yy_start_stack[yy_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int yy_top_state() + { + return yy_start_stack[yy_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void yy_fatal_error( yyconst char msg[] ) +#else +static void yy_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + yytext[yyleng] = yy_hold_char; \ + yy_c_buf_p = yytext + n; \ + yy_hold_char = *yy_c_buf_p; \ + *yy_c_buf_p = '\0'; \ + yyleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef yytext_ptr +#ifdef YY_USE_PROTOS +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) +#else +static void yy_flex_strncpy( s1, s2, n ) +char *s1; +yyconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int yy_flex_strlen( yyconst char *s ) +#else +static int yy_flex_strlen( s ) +yyconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *yy_flex_alloc( yy_size_t size ) +#else +static void *yy_flex_alloc( size ) +yy_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *yy_flex_realloc( void *ptr, yy_size_t size ) +#else +static void *yy_flex_realloc( ptr, size ) +void *ptr; +yy_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void yy_flex_free( void *ptr ) +#else +static void yy_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + yylex(); + return 0; + } +#endif +#line 208 "meta_lex.l" + + + /***************************************************************/ + /* 6. Auxiliary functions. */ + /***************************************************************/ + +main(int argc, char *argv[]) +{ + struct stat buf; + init_symbol_table(); + + // We process the body + if (!stat("tmp/body.xml",&buf)) { + yyin = fopen("tmp/body.xml", "r"); + position = INBODY; + yylex(); + fclose(yyin); + } + + // We process the type + yyin = fopen("tmp/type.xml", "r"); + position = INTYPE; + first_child = HERE; + yylex(); + + printf("\n\n"); + printf("\n"); + printf("\t\n"); + print_all(); + printf("\t\n"); + printf("\n"); + fclose(yyin); + } + +search(uri,first_child,position) +char *uri; +int first_child; +int position; +{ + if (first_child == HERE) + { + if (position == INHYP) + found = search_bucket(uri,MAINHYP); + else if (position == INCONCL) + found = search_bucket(uri,MAINCONCL); + /* if (found == NOTFOUND) + printf( "pos = %d, uri = %s\n", MAINCONCL, uri); */ + } + else found = search_bucket(uri,position); + /* if (found == NOTFOUND) + printf( "pos = %d, uri = %s\n", position, uri); */ + } + +int yywrap() { + return 1; + } diff --git a/helm/metadata/create_V7_mowgli/METADATA/lex.yy_ind.c b/helm/metadata/create_V7_mowgli/METADATA/lex.yy_ind.c new file mode 100644 index 000000000..2095824ae --- /dev/null +++ b/helm/metadata/create_V7_mowgli/METADATA/lex.yy_ind.c @@ -0,0 +1,1958 @@ +#line 2 "lex.yy_ind.c" +/* A lexical scanner generated by flex */ + +/* Scanner skeleton version: + * $Header$ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include +#include + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include +#ifndef _WIN32 +#include +#else +#ifndef YY_ALWAYS_INTERACTIVE +#ifndef YY_NEVER_INTERACTIVE +extern int isatty YY_PROTO(( int )); +#endif +#endif +#endif + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include +#include +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct yy_buffer_state *YY_BUFFER_STATE; + +extern int yyleng; +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * yyless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the yyless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + *yy_cp = yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, yytext_ptr ) + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int yy_size_t; + + +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE yy_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER yy_current_buffer + + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; + +static int yy_n_chars; /* number of characters read into yy_ch_buf */ + + +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 1; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart YY_PROTO(( FILE *input_file )); + +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) + +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); + +static void *yy_flex_alloc YY_PROTO(( yy_size_t )); +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); +static void yy_flex_free YY_PROTO(( void * )); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) + +typedef unsigned char YY_CHAR; +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +typedef int yy_state_type; +extern char *yytext; +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state YY_PROTO(( void )); +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +static int yy_get_next_buffer YY_PROTO(( void )); +static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yytext_ptr = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 22 +#define YY_END_OF_BUFFER 23 +static yyconst short int yy_accept[125] = + { 0, + 0, 0, 23, 9, 9, 9, 9, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, + 0, 0, 0, 11, 15, 0, 6, 0, 0, 0, + 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, + 0, 5, 0, 0, 0, 0, 0, 0, 14, 16, + 0, 0, 0, 0, 0, 0, 0, 0, 19, 0, + 0, 7, 0, 0, 10, 0, 0, 17, 0, 0, + 0, 2, 0, 0, 12, 0, 0, 0, 0, 0, + + 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 21, 0, 3, 0, 0, 0, 0, + 18, 4, 1, 0 + } ; + +static yyconst int yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 4, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 1, 1, 6, + 7, 8, 1, 1, 9, 10, 11, 12, 13, 14, + 1, 1, 15, 1, 1, 16, 17, 18, 19, 1, + 1, 20, 21, 22, 23, 24, 1, 25, 1, 1, + 1, 1, 1, 1, 1, 1, 26, 1, 27, 28, + + 29, 30, 1, 1, 31, 1, 1, 32, 1, 33, + 34, 35, 1, 36, 37, 38, 39, 40, 1, 1, + 41, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst int yy_meta[42] = + { 0, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1 + } ; + +static yyconst short int yy_base[127] = + { 0, + 0, 1, 139, 140, 37, 104, 101, 0, 1, 121, + 102, 125, 110, 119, 122, 101, 1, 98, 94, 91, + 97, 0, 92, 99, 95, 105, 99, 104, 99, 0, + 84, 76, 109, 82, 83, 2, 98, 91, 74, 140, + 71, 99, 2, 140, 140, 76, 140, 74, 71, 102, + 67, 65, 70, 140, 76, 78, 61, 71, 85, 0, + 78, 140, 58, 65, 0, 55, 51, 83, 140, 140, + 54, 51, 79, 66, 68, 73, 46, 76, 0, 46, + 73, 140, 41, 48, 140, 65, 56, 140, 40, 72, + 35, 140, 46, 32, 140, 49, 63, 64, 41, 26, + + 34, 42, 57, 54, 20, 22, 33, 27, 44, 13, + 10, 4, 33, 38, 6, 140, 3, 15, 28, 2, + 140, 140, 140, 140, 65, 0 + } ; + +static yyconst short int yy_def[127] = + { 0, + 125, 125, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 124, 124, 126, 124, 124, 124, 124, 124, + 124, 124, 124, 124, 124, 124, 124, 124, 126, 124, + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 124, 0, 124, 124 + } ; + +static yyconst short int yy_nxt[182] = + { 0, + 79, 124, 124, 124, 124, 5, 5, 124, 74, 124, + 19, 31, 60, 37, 124, 124, 61, 38, 75, 22, + 124, 124, 32, 124, 124, 20, 46, 21, 53, 47, + 123, 54, 6, 6, 23, 122, 121, 120, 7, 7, + 8, 119, 114, 118, 117, 116, 115, 9, 114, 113, + 10, 11, 12, 13, 112, 111, 14, 110, 104, 109, + 15, 108, 107, 106, 16, 4, 4, 105, 104, 103, + 102, 101, 100, 99, 98, 97, 96, 95, 94, 93, + 92, 91, 90, 89, 88, 87, 86, 85, 84, 83, + 82, 81, 80, 78, 77, 76, 73, 72, 71, 70, + + 69, 68, 67, 66, 65, 64, 63, 62, 59, 58, + 57, 56, 55, 52, 51, 50, 49, 48, 45, 44, + 43, 42, 41, 40, 39, 36, 35, 34, 33, 30, + 29, 28, 27, 26, 25, 24, 18, 17, 124, 3, + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124 + } ; + +static yyconst short int yy_chk[182] = + { 0, + 126, 0, 0, 0, 0, 1, 2, 0, 60, 0, + 8, 17, 43, 22, 0, 0, 43, 22, 60, 9, + 0, 0, 17, 0, 0, 8, 30, 8, 36, 30, + 120, 36, 1, 2, 9, 119, 118, 117, 1, 2, + 5, 115, 114, 113, 112, 111, 110, 5, 109, 108, + 5, 5, 5, 5, 107, 106, 5, 105, 104, 103, + 5, 102, 101, 100, 5, 125, 125, 99, 98, 97, + 96, 94, 93, 91, 90, 89, 87, 86, 84, 83, + 81, 80, 78, 77, 76, 75, 74, 73, 72, 71, + 68, 67, 66, 64, 63, 61, 59, 58, 57, 56, + + 55, 53, 52, 51, 50, 49, 48, 46, 42, 41, + 39, 38, 37, 35, 34, 33, 32, 31, 29, 28, + 27, 26, 25, 24, 23, 21, 20, 19, 18, 16, + 15, 14, 13, 12, 11, 10, 7, 6, 3, 124, + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "meta_lex_ind.l" +#define INITIAL 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/. */ +/******************************************************************/ +/***************************************************************/ +/* META_LEXAN */ +/* Automatic Metadata Extractor */ +/* First draft 11/12/2001, by Andrea Asperti */ +/* more bugs added by domenico lordi on mon 12/17/2001 */ +/***************************************************************/ +/***************************************************************/ +/* 1. Inclusion of header files. */ +/***************************************************************/ +#line 39 "meta_lex_ind.l" +#include +#include +#include "sthandler_ind.h" +/***************************************************************/ +/* 2. Constants and Variables Definitions */ +/***************************************************************/ +#line 49 "meta_lex_ind.l" +#define NOWHERE 0 +#define CONST 1 +#define MUTIND 2 +#define MUTCONSTRUCT 3 + +#define INBODY 0 +#define MAINHYP 1 +#define INHYP 2 +#define INCONCL 3 +#define MAINCONCL 4 +#define INTYPE 5 +#define NOTFOUND 6 + +#define HERE 0 +#define AFTER 1 + + +int where = NOWHERE; +int found = NOTFOUND; +int position = INTYPE; +int first_child = HERE; +int skip = 0; // boolean to skip the insertion of a URI +int no_open_source =0; +int tmp_n; +int inductive_type =0; +int constructor = 0; +int deep_type = 0; +char sep = '"'; +char *xpointer = "#xpointer(1/"; +char *uri; +char *tmp; +char *filename; +char *file_uri; +char *inductive_uri; +char *filename_prefix; +char *file_uri_prefix; + +/*%x deeptype*/ +/***************************************************************/ +/* 3. Regular definitions. */ +/***************************************************************/ +/***************************************************************/ +/* 4. Rules. */ +/***************************************************************/ +/* +"" { + BEGIN(deeptype); + deep_type++; + } + +"" { + deep_type++; + } + +"" { + deep_type--; + if (deeptype == 0) BEGIN(0); + } + +.|\n { + } +*/ +#line 557 "lex.yy_ind.c" + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap YY_PROTO(( void )); +#else +extern int yywrap YY_PROTO(( void )); +#endif +#endif + +#ifndef YY_NO_UNPUT +static void yyunput YY_PROTO(( int c, char *buf_ptr )); +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen YY_PROTO(( yyconst char * )); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput YY_PROTO(( void )); +#else +static int input YY_PROTO(( void )); +#endif +#endif + +#if YY_STACK_USED +static int yy_start_stack_ptr = 0; +static int yy_start_stack_depth = 0; +static int *yy_start_stack = 0; +#ifndef YY_NO_PUSH_STATE +static void yy_push_state YY_PROTO(( int new_state )); +#endif +#ifndef YY_NO_POP_STATE +static void yy_pop_state YY_PROTO(( void )); +#endif +#ifndef YY_NO_TOP_STATE +static int yy_top_state YY_PROTO(( void )); +#endif + +#else +#define YY_NO_PUSH_STATE 1 +#define YY_NO_POP_STATE 1 +#define YY_NO_TOP_STATE 1 +#endif + +#ifdef YY_MALLOC_DECL +YY_MALLOC_DECL +#else +#if __STDC__ +#ifndef __cplusplus +#include +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( yy_current_buffer->yy_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else \ + { \ + errno=0; \ + while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ + { \ + if( errno != EINTR) \ + { \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + break; \ + } \ + errno=0; \ + clearerr(yyin); \ + } \ + } +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int yylex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +YY_DECL + { + register yy_state_type yy_current_state; + register char *yy_cp, *yy_bp; + register int yy_act; + +#line 121 "meta_lex_ind.l" + + +#line 722 "lex.yy_ind.c" + + if ( yy_init ) + { + yy_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yy_start ) + yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! yy_current_buffer ) + yy_current_buffer = + yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_cp = yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start; +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 125 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 140 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 123 "meta_lex_ind.l" +{ + fprintf(stderr,"uno"); + init_symbol_table(); + fprintf(stderr,"due"); + inductive_type++; + constructor=0; + position = INTYPE; + first_child = HERE; + } + YY_BREAK +case 2: +YY_RULE_SETUP +#line 133 "meta_lex_ind.l" +{ tmp = (char *)malloc(sizeof('a')*128); + strcpy(filename,filename_prefix); + fprintf(stderr,"tre"); + strcpy(file_uri,file_uri_prefix); + sprintf(tmp,",%d.xml", inductive_type); + fprintf(stderr,"quattro"); + strcat(filename,tmp); + sprintf(tmp,"#xpointer(1/%d)", inductive_type); + strcat(file_uri,tmp); + fprintf(stderr,"cinque"); + free(tmp); + print_file(); + } + YY_BREAK +case 3: +YY_RULE_SETUP +#line 147 "meta_lex_ind.l" +{ init_symbol_table(); + constructor++; + strcpy(inductive_uri,file_uri_prefix); + position = INTYPE; + first_child = HERE; + } + YY_BREAK +case 4: +YY_RULE_SETUP +#line 154 "meta_lex_ind.l" +{ tmp = (char *)malloc(sizeof('a')*128); + strcpy(filename,filename_prefix); + strcpy(file_uri,file_uri_prefix); + strcpy(inductive_uri,file_uri_prefix); + sprintf(tmp,",%d,%d.xml", inductive_type,constructor); + strcat(filename,tmp); + sprintf(tmp,"#xpointer(1/%d/%d)",inductive_type,constructor); + strcat(file_uri,tmp); + free(tmp); + print_file(); + } + YY_BREAK +case 5: +#line 167 "meta_lex_ind.l" +case 6: +YY_RULE_SETUP +#line 167 "meta_lex_ind.l" +{ + if ((position == INTYPE) || + (position == INHYP)) + { position = INHYP; + no_open_source++;}; + } + YY_BREAK +case 7: +#line 175 "meta_lex_ind.l" +case 8: +YY_RULE_SETUP +#line 175 "meta_lex_ind.l" +{ + if (position == INHYP) + { + no_open_source--; + if (no_open_source == 0) + { position = INTYPE; + first_child = HERE; }; + }; + } + YY_BREAK +case 9: +YY_RULE_SETUP +#line 185 "meta_lex_ind.l" +{ + } + YY_BREAK +case 10: +#line 189 "meta_lex_ind.l" +case 11: +#line 190 "meta_lex_ind.l" +case 12: +#line 191 "meta_lex_ind.l" +case 13: +#line 192 "meta_lex_ind.l" +case 14: +YY_RULE_SETUP +#line 192 "meta_lex_ind.l" +{ + first_child = AFTER; + } + YY_BREAK +case 15: +YY_RULE_SETUP +#line 196 "meta_lex_ind.l" +{ + skip = 1; + first_child = AFTER; + } + YY_BREAK +case 16: +YY_RULE_SETUP +#line 201 "meta_lex_ind.l" +{ + if (position == INTYPE) /* CONST on the spine */ + position = INCONCL; + where = CONST; + } + YY_BREAK +case 17: +YY_RULE_SETUP +#line 207 "meta_lex_ind.l" +{ + if (position == INTYPE) /* MUTIND on the spine */ + position = INCONCL; + where = MUTIND; + } + YY_BREAK +case 18: +YY_RULE_SETUP +#line 213 "meta_lex_ind.l" +{ + if (position == INTYPE) /* MUTCONSTRUCT on the spine */ + position = INCONCL; + where = MUTCONSTRUCT; + } + YY_BREAK +case 19: +YY_RULE_SETUP +#line 219 "meta_lex_ind.l" +{ + if (!skip) { + uri=(char *)malloc((sizeof('a')*200)); + strcpy(uri,yytext); + strsep(&uri,&sep); + if (where == CONST) + { + search(uri,first_child,position); + where = NOWHERE; + first_child = AFTER; + free(uri); + }; + } else skip = 0; + } + YY_BREAK +case 20: +YY_RULE_SETUP +#line 234 "meta_lex_ind.l" +{ + if ((where == MUTIND) || (where == MUTCONSTRUCT)) + { strsep(&yytext,&sep); + tmp=(char *)malloc((sizeof(sep)*(strlen(yytext)+1))); + strcpy(tmp,yytext); + tmp_n = atoi(tmp)+1; + sprintf(tmp,"%d",tmp_n); + strcat(uri,"#xpointer(1/"); + strcat(uri,tmp); + }; + if (where == MUTIND) + { + strcat(uri,")"); + search(uri,first_child,position); + free(uri); + free(tmp); + where = NOWHERE; + first_child = AFTER;}; + } + YY_BREAK +case 21: +YY_RULE_SETUP +#line 254 "meta_lex_ind.l" +{ + if (where == MUTCONSTRUCT) + { strsep(&yytext,&sep); + tmp=(char *)malloc((sizeof(sep)*(strlen(yytext)+1))); + strcpy(tmp,yytext); + strcat(uri,"/"); + strcat(uri,tmp); + strcat(uri,")"); + search(uri,first_child,position); + free(uri); + free(tmp); + where = NOWHERE; + first_child = AFTER;}; + } + YY_BREAK +case 22: +YY_RULE_SETUP +#line 270 "meta_lex_ind.l" +ECHO; + YY_BREAK +#line 1007 "lex.yy_ind.c" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between yy_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yy_n_chars = yy_current_buffer->yy_n_chars; + yy_current_buffer->yy_input_file = yyin; + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + yy_did_buffer_switch_on_eof = 0; + + if ( yywrap() ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = + yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yy_c_buf_p = + &yy_current_buffer->yy_ch_buf[yy_n_chars]; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of yylex */ + + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int yy_get_next_buffer() + { + register char *dest = yy_current_buffer->yy_ch_buf; + register char *source = yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( yy_current_buffer->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + yy_current_buffer->yy_n_chars = yy_n_chars = 0; + + else + { + int num_to_read = + yy_current_buffer->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = yy_current_buffer; + + int yy_c_buf_p_offset = + (int) (yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yy_flex_realloc( (void *) b->yy_ch_buf, + b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = yy_current_buffer->yy_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), + yy_n_chars, num_to_read ); + + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + if ( yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + yy_current_buffer->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + yy_n_chars += number_to_move; + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; + + return ret_val; + } + + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +static yy_state_type yy_get_previous_state() + { + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = yy_start; + + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 125 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; + } + + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) +#else +static yy_state_type yy_try_NUL_trans( yy_current_state ) +yy_state_type yy_current_state; +#endif + { + register int yy_is_jam; + register char *yy_cp = yy_c_buf_p; + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 125 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 124); + + return yy_is_jam ? 0 : yy_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void yyunput( int c, register char *yy_bp ) +#else +static void yyunput( c, yy_bp ) +int c; +register char *yy_bp; +#endif + { + register char *yy_cp = yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yy_hold_char; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = yy_n_chars + 2; + register char *dest = &yy_current_buffer->yy_ch_buf[ + yy_current_buffer->yy_buf_size + 2]; + register char *source = + &yy_current_buffer->yy_ch_buf[number_to_move]; + + while ( source > yy_current_buffer->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + yy_current_buffer->yy_n_chars = + yy_n_chars = yy_current_buffer->yy_buf_size; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + + yytext_ptr = yy_bp; + yy_hold_char = *yy_cp; + yy_c_buf_p = yy_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifdef __cplusplus +static int yyinput() +#else +static int input() +#endif + { + int c; + + *yy_c_buf_p = yy_hold_char; + + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* This was really a NUL. */ + *yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = yy_c_buf_p - yytext_ptr; + ++yy_c_buf_p; + + switch ( yy_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap() ) + return EOF; + + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ + *yy_c_buf_p = '\0'; /* preserve yytext */ + yy_hold_char = *++yy_c_buf_p; + + + return c; + } + + +#ifdef YY_USE_PROTOS +void yyrestart( FILE *input_file ) +#else +void yyrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! yy_current_buffer ) + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_init_buffer( yy_current_buffer, input_file ); + yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( yy_current_buffer == new_buffer ) + return; + + if ( yy_current_buffer ) + { + /* Flush out information for old buffer. */ + *yy_c_buf_p = yy_hold_char; + yy_current_buffer->yy_buf_pos = yy_c_buf_p; + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + yy_current_buffer = new_buffer; + yy_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void yy_load_buffer_state( void ) +#else +void yy_load_buffer_state() +#endif + { + yy_n_chars = yy_current_buffer->yy_n_chars; + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; + yyin = yy_current_buffer->yy_input_file; + yy_hold_char = *yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == yy_current_buffer ) + yy_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yy_flex_free( (void *) b->yy_ch_buf ); + + yy_flex_free( (void *) b ); + } + + +#ifndef _WIN32 +#include +#else +#ifndef YY_ALWAYS_INTERACTIVE +#ifndef YY_NEVER_INTERACTIVE +extern int isatty YY_PROTO(( int )); +#endif +#endif +#endif + +#ifdef YY_USE_PROTOS +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->yy_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->yy_is_interactive = 0; +#else + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void yy_flush_buffer( YY_BUFFER_STATE b ) +#else +void yy_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == yy_current_buffer ) + yy_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) +#else +YY_BUFFER_STATE yy_scan_buffer( base, size ) +char *base; +yy_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) +#else +YY_BUFFER_STATE yy_scan_string( yy_str ) +yyconst char *yy_str; +#endif + { + int len; + for ( len = 0; yy_str[len]; ++len ) + ; + + return yy_scan_bytes( yy_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) +#else +YY_BUFFER_STATE yy_scan_bytes( bytes, len ) +yyconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) yy_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void yy_push_state( int new_state ) +#else +static void yy_push_state( new_state ) +int new_state; +#endif + { + if ( yy_start_stack_ptr >= yy_start_stack_depth ) + { + yy_size_t new_size; + + yy_start_stack_depth += YY_START_STACK_INCR; + new_size = yy_start_stack_depth * sizeof( int ); + + if ( ! yy_start_stack ) + yy_start_stack = (int *) yy_flex_alloc( new_size ); + + else + yy_start_stack = (int *) yy_flex_realloc( + (void *) yy_start_stack, new_size ); + + if ( ! yy_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + yy_start_stack[yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void yy_pop_state() + { + if ( --yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(yy_start_stack[yy_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int yy_top_state() + { + return yy_start_stack[yy_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void yy_fatal_error( yyconst char msg[] ) +#else +static void yy_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + yytext[yyleng] = yy_hold_char; \ + yy_c_buf_p = yytext + n; \ + yy_hold_char = *yy_c_buf_p; \ + *yy_c_buf_p = '\0'; \ + yyleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef yytext_ptr +#ifdef YY_USE_PROTOS +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) +#else +static void yy_flex_strncpy( s1, s2, n ) +char *s1; +yyconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int yy_flex_strlen( yyconst char *s ) +#else +static int yy_flex_strlen( s ) +yyconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *yy_flex_alloc( yy_size_t size ) +#else +static void *yy_flex_alloc( size ) +yy_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *yy_flex_realloc( void *ptr, yy_size_t size ) +#else +static void *yy_flex_realloc( ptr, size ) +void *ptr; +yy_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void yy_flex_free( void *ptr ) +#else +static void yy_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + yylex(); + return 0; + } +#endif +#line 270 "meta_lex_ind.l" + + + /***************************************************************/ + /* 6. Auxiliary functions. */ + /***************************************************************/ + +main(int argc, char *argv[]) +{ + filename = malloc((sizeof('a')*2000)); + file_uri = malloc((sizeof('a')*2000)); + inductive_uri = malloc((sizeof('a')*2000)); + filename_prefix=argv[1]; + file_uri_prefix=argv[2]; + fprintf(stderr,"qua"); + yyin = fopen("tmp/inductive_type.xml", "r"); + yylex(); + } + +print_file() +{ + FILE *out; + if (!(out = fopen(filename,"w"))) + { + fprintf(stderr, "error in openinf file %s\n", filename); + exit(-1); + } + else + { + fprintf(out,"\n\n"); + fprintf(out,"\n"); + fprintf(out,"\t\n"); + print_all(out); + fprintf(out,"\t\n"); + fprintf(out,"\n"); + fclose(out); + } +} + +search(uri,first_child,position) +char *uri; +int first_child; +int position; +{ + if (first_child == HERE) + { + if (position == INHYP) + found = search_bucket(uri,MAINHYP); + else if (position == INCONCL) + found = search_bucket(uri,MAINCONCL); + /* if (found == NOTFOUND) + printf( "pos = %d, uri = %s\n", MAINCONCL, uri); */ + } + else found = search_bucket(uri,position); + /* if (found == NOTFOUND) + printf( "pos = %d, uri = %s\n", position, uri); */ + } + +int yywrap() { + return 1; + } diff --git a/helm/metadata/create_V7_mowgli/METADATA/meta_lex.l b/helm/metadata/create_V7_mowgli/METADATA/meta_lex.l new file mode 100644 index 000000000..967fbc00c --- /dev/null +++ b/helm/metadata/create_V7_mowgli/METADATA/meta_lex.l @@ -0,0 +1,265 @@ + /******************************************************************/ + /* 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/. */ + /******************************************************************/ + + /***************************************************************/ + /* META_LEXAN */ + /* Automatic Metadata Extractor */ + /* First draft 11/12/2001, by Andrea Asperti */ + /* more bugs added by domenico lordi on mon 12/17/2001 */ + /***************************************************************/ + + /***************************************************************/ + /* 1. Inclusion of header files. */ + /***************************************************************/ + +%{ +#include +#include +#include +#include "sthandler.h" +%} + + /***************************************************************/ + /* 2. Constants and Variables Definitions */ + /***************************************************************/ + +%{ +#define NOWHERE 0 +#define CONST 1 +#define MUTIND 2 +#define MUTCONSTRUCT 3 + +#define INBODY 0 +#define MAINHYP 1 +#define INHYP 2 +#define INCONCL 3 +#define MAINCONCL 4 +#define INTYPE 5 +#define NOTFOUND 6 + +#define HERE 0 +#define AFTER 1 + + +int where = NOWHERE; +int found = NOTFOUND; +int position = INBODY; +int first_child = HERE; +int skip = 0; // boolean to skip the insertion of a URI +int no_open_source =0; +int tmp_n; +char sep = '"'; +char *xpointer = "#xpointer(1/"; +char *uri; +char *tmp; +%} + + /***************************************************************/ + /* 3. Regular definitions. */ + /***************************************************************/ + +uri [^"]+ +digits [0-9]+ + + /***************************************************************/ + /* 4. Rules. */ + /***************************************************************/ + + +%% + +"]*">"(" "|\n)*""(" "|\n)*"" | +"\n\n"); + printf("\n"); + printf("\t\n"); + print_all(); + printf("\t\n"); + printf("\n"); + fclose(yyin); + } + +search(uri,first_child,position) +char *uri; +int first_child; +int position; +{ + if (first_child == HERE) + { + if (position == INHYP) + found = search_bucket(uri,MAINHYP); + else if (position == INCONCL) + found = search_bucket(uri,MAINCONCL); + /* if (found == NOTFOUND) + printf( "pos = %d, uri = %s\n", MAINCONCL, uri); */ + } + else found = search_bucket(uri,position); + /* if (found == NOTFOUND) + printf( "pos = %d, uri = %s\n", position, uri); */ + } + +int yywrap() { + return 1; + } diff --git a/helm/metadata/create_V7_mowgli/METADATA/meta_lex_ind.l b/helm/metadata/create_V7_mowgli/METADATA/meta_lex_ind.l new file mode 100644 index 000000000..6d09578f9 --- /dev/null +++ b/helm/metadata/create_V7_mowgli/METADATA/meta_lex_ind.l @@ -0,0 +1,331 @@ + /******************************************************************/ + /* 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/. */ + /******************************************************************/ + + /***************************************************************/ + /* META_LEXAN */ + /* Automatic Metadata Extractor */ + /* First draft 11/12/2001, by Andrea Asperti */ + /* more bugs added by domenico lordi on mon 12/17/2001 */ + /***************************************************************/ + + /***************************************************************/ + /* 1. Inclusion of header files. */ + /***************************************************************/ + +%{ +#include +#include +#include "sthandler_ind.h" +%} + + /***************************************************************/ + /* 2. Constants and Variables Definitions */ + /***************************************************************/ + +%{ +#define NOWHERE 0 +#define CONST 1 +#define MUTIND 2 +#define MUTCONSTRUCT 3 + +#define INBODY 0 +#define MAINHYP 1 +#define INHYP 2 +#define INCONCL 3 +#define MAINCONCL 4 +#define INTYPE 5 +#define NOTFOUND 6 + +#define HERE 0 +#define AFTER 1 + + +int where = NOWHERE; +int found = NOTFOUND; +int position = INTYPE; +int first_child = HERE; +int skip = 0; // boolean to skip the insertion of a URI +int no_open_source =0; +int tmp_n; +int inductive_type =0; +int constructor = 0; +int deep_type = 0; +char sep = '"'; +char *xpointer = "#xpointer(1/"; +char *uri; +char *tmp; +char *filename; +char *file_uri; +char *inductive_uri; +char *filename_prefix; +char *file_uri_prefix; + +%} + +/*%x deeptype*/ + + + /***************************************************************/ + /* 3. Regular definitions. */ + /***************************************************************/ + +uri [^"]+ +digits [0-9]+ + + /***************************************************************/ + /* 4. Rules. */ + /***************************************************************/ + +/* +"" { + BEGIN(deeptype); + deep_type++; + } + +"" { + deep_type++; + } + +"" { + deep_type--; + if (deeptype == 0) BEGIN(0); + } + +.|\n { + } +*/ + +%% + +"" { tmp = (char *)malloc(sizeof('a')*128); + strcpy(filename,filename_prefix); + fprintf(stderr,"tre"); + strcpy(file_uri,file_uri_prefix); + sprintf(tmp,",%d.xml", inductive_type); + fprintf(stderr,"quattro"); + strcat(filename,tmp); + sprintf(tmp,"#xpointer(1/%d)", inductive_type); + strcat(file_uri,tmp); + fprintf(stderr,"cinque"); + free(tmp); + print_file(); + } + +"" { tmp = (char *)malloc(sizeof('a')*128); + strcpy(filename,filename_prefix); + strcpy(file_uri,file_uri_prefix); + strcpy(inductive_uri,file_uri_prefix); + sprintf(tmp,",%d,%d.xml", inductive_type,constructor); + strcat(filename,tmp); + sprintf(tmp,"#xpointer(1/%d/%d)",inductive_type,constructor); + strcat(file_uri,tmp); + free(tmp); + print_file(); + } + +"" | +"\n\n"); + fprintf(out,"\n"); + fprintf(out,"\t\n"); + print_all(out); + fprintf(out,"\t\n"); + fprintf(out,"\n"); + fclose(out); + } +} + +search(uri,first_child,position) +char *uri; +int first_child; +int position; +{ + if (first_child == HERE) + { + if (position == INHYP) + found = search_bucket(uri,MAINHYP); + else if (position == INCONCL) + found = search_bucket(uri,MAINCONCL); + /* if (found == NOTFOUND) + printf( "pos = %d, uri = %s\n", MAINCONCL, uri); */ + } + else found = search_bucket(uri,position); + /* if (found == NOTFOUND) + printf( "pos = %d, uri = %s\n", position, uri); */ + } + +int yywrap() { + return 1; + } diff --git a/helm/metadata/create_V7_mowgli/METADATA/sthandler.c b/helm/metadata/create_V7_mowgli/METADATA/sthandler.c new file mode 100644 index 000000000..963200038 --- /dev/null +++ b/helm/metadata/create_V7_mowgli/METADATA/sthandler.c @@ -0,0 +1,261 @@ +/*********************************************************************/ +/* 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 + +/****************************************************************/ +/* 2. Declarations */ +/****************************************************************/ + + +#define DICTSIZE 211 +#define HASH1 4 +#define HASH2 0xf0000000 +#define HASH3 24 +#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 st_bucket { + char *id; + /* identifier */ + 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. Definitions of functions to be exported. */ +/****************************************************************/ + +struct st_bucket *all; + + /* The following function initializes the symbol table to NULL */ +void init_symbol_table() +{ + struct st_bucket *st; + 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. */ + +search_bucket(id, where) + char *id; + /* identifier */ + int where; +{ + 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); + /* printf( "%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); + move_bucket(st,dict_index); + return NOTFOUND; + } + else + /* printf("uno=%s\n", id); + printf("st=%s\n", curr->id); */ + + /* 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 (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; + } +} + +print_all() +{ + int i; + struct st_bucket *curr; + curr = all; + + while (curr != NULL) + { + for (i = 0; i < 5; ++i) + if (curr->pos[i] == 1) + print_one(curr->id,i); + curr = curr->all_next; + } +} + + +/****************************************************************/ +/* 5. Definitions of functions local to the module. */ +/****************************************************************/ + + +// dome: cambiata per usare il modello con position +print_one(uri,pos) + char *uri; + int pos; +{ + printf("\t\t\n\t\t\t\n\t\t\t\t"); + if (pos == INBODY) + printf("InBody"); + else if (pos == MAINHYP) + printf("MainHypothesis"); + else if (pos == INHYP) + printf("InHypothesis"); + else if (pos == INCONCL) + printf("InConclusion"); + else if (pos == MAINCONCL) + printf("MainConclusion"); + printf("\n\t\t\t\t%s\n\t\t\t\n\t\t\n", uri); +} + + /* The following function allocates a bucket for an identifier. */ +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)->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. */ +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); +} + + + + + diff --git a/helm/metadata/create_V7_mowgli/METADATA/sthandler.h b/helm/metadata/create_V7_mowgli/METADATA/sthandler.h new file mode 100644 index 000000000..9c98992ce --- /dev/null +++ b/helm/metadata/create_V7_mowgli/METADATA/sthandler.h @@ -0,0 +1,8 @@ +/****************************************************************/ +/* STHANDLER.H */ +/****************************************************************/ + + +extern void init_symbol_table(); +extern void print_all(); +extern int search_bucket(char *, int); diff --git a/helm/metadata/create_V7_mowgli/METADATA/sthandler_ind.c b/helm/metadata/create_V7_mowgli/METADATA/sthandler_ind.c new file mode 100644 index 000000000..07612d6f8 --- /dev/null +++ b/helm/metadata/create_V7_mowgli/METADATA/sthandler_ind.c @@ -0,0 +1,263 @@ +/*********************************************************************/ +/* 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 + +/****************************************************************/ +/* 2. Declarations */ +/****************************************************************/ + + +#define DICTSIZE 211 +#define HASH1 4 +#define HASH2 0xf0000000 +#define HASH3 24 +#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 st_bucket { + char *id; + /* identifier */ + 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. Definitions of functions to be exported. */ +/****************************************************************/ + +struct st_bucket *all; + + /* The following function initializes the symbol table to NULL */ +void init_symbol_table() +{ + struct st_bucket *st; + 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. */ + +search_bucket(id, where) + char *id; + /* identifier */ + int where; +{ + 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); + /* printf( "%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); + move_bucket(st,dict_index); + return NOTFOUND; + } + else + /* printf("uno=%s\n", id); + printf("st=%s\n", curr->id); */ + + /* 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 (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; + } +} + +print_all(out) + FILE *out; +{ + int i; + struct st_bucket *curr; + curr = all; + + while (curr != NULL) + { + for (i = 0; i < 5; ++i) + if (curr->pos[i] == 1) + print_one(out,curr->id,i); + curr = curr->all_next; + } +} + + +/****************************************************************/ +/* 5. Definitions of functions local to the module. */ +/****************************************************************/ + + +// dome: cambiata per usare il modello con position +print_one(out,uri,pos) + FILE *out; + char *uri; + int pos; +{ + fprintf(out,"\t\t\n\t\t\t\n\t\t\t\t"); + if (pos == INBODY) + fprintf(out,"InBody"); + else if (pos == MAINHYP) + fprintf(out,"MainHypothesis"); + else if (pos == INHYP) + fprintf(out,"InHypothesis"); + else if (pos == INCONCL) + fprintf(out,"InConclusion"); + else if (pos == MAINCONCL) + fprintf(out,"MainConclusion"); + fprintf(out,"\n\t\t\t\t%s\n\t\t\t\n\t\t\n", uri); +} + + /* The following function allocates a bucket for an identifier. */ +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)->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. */ +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); +} + + + + + diff --git a/helm/metadata/create_V7_mowgli/METADATA/sthandler_ind.h b/helm/metadata/create_V7_mowgli/METADATA/sthandler_ind.h new file mode 100644 index 000000000..24d944706 --- /dev/null +++ b/helm/metadata/create_V7_mowgli/METADATA/sthandler_ind.h @@ -0,0 +1,8 @@ +/****************************************************************/ +/* STHANDLER.H */ +/****************************************************************/ + + +extern void init_symbol_table(); +extern void print_all(FILE *out); +extern int search_bucket(char *, int); diff --git a/helm/metadata/create_V7_mowgli/Makefile b/helm/metadata/create_V7_mowgli/Makefile new file mode 100644 index 000000000..b20dc2212 --- /dev/null +++ b/helm/metadata/create_V7_mowgli/Makefile @@ -0,0 +1,28 @@ +all: + @echo Available targets: + @echo " forward, backward, compress, clean-forward, clean-backward" + +forward: + time for i in `cat costanti_e_variabili.txt` ; do (cd tmp && wget -t 1 -O downloaded.xml.gz "http://mowgli.cs.unibo.it:58081/getxml?format=gz&uri=$$i" && wget -t 1 -O downloaded_body.xml.gz "http://mowgli.cs.unibo.it:58081/getxml?format=gz&uri=$$i.body") ; mkdir -p forward/`dirname $$i | sed "s/cic:\///"` && zcat tmp/downloaded.xml.gz > tmp/type.xml && zcat tmp/downloaded_body.xml.gz > tmp/body.xml ; METADATA/meta $$i > forward/`echo $$i | sed "s/cic:\///"`.xml && rm -f tmp/downloaded.xml.gz tmp/downloaded_body.xml.gz tmp/type.xml tmp/body.xml ; done > log 2>&1 + time for i in `cat tipi_induttivi.txt` ; do (cd tmp && wget -t 1 -O downloaded.xml.gz "http://mowgli.cs.unibo.it:58081/getxml?format=gz&uri=$$i") && mkdir -p forward/`dirname $$i | sed "s/cic:\///"` && zcat tmp/downloaded.xml.gz > tmp/inductive_type.xml && METADATA/meta_ind forward/`echo $$i | sed "s/cic:\///"` $$i && rm tmp/downloaded.xml.gz tmp/inductive_type.xml ; done >> log 2>&1 + (cd forward ; ../mkindex.sh forward) + +backward: + #time for i in `cat all_objects.txt` ; do touch/touch.opt $$i ; done + #find forward -type f -exec ./invert.pl {} \; + find backward -type f -exec ./fix_rdf.pl {} \; + (cd backward ; ../mkindex.sh backward) + +compress: + find forward -name "*.xml" -exec gzip {} \; + find backward -name "*.xml" -exec gzip {} \; + (cd forward ; ../mkindex.sh forward) + (cd backward ; ../mkindex.sh backward) + +clean-forward: + rm -rf forward/* + +clean-backward: + rm -rf backward/* + +.PHONY: all forward backward compress clean-forward clean-backward diff --git a/helm/metadata/create_V7_mowgli/fix_rdf.pl b/helm/metadata/create_V7_mowgli/fix_rdf.pl new file mode 100755 index 000000000..6d17383b3 --- /dev/null +++ b/helm/metadata/create_V7_mowgli/fix_rdf.pl @@ -0,0 +1,29 @@ +#!/usr/bin/perl + +$filename = $uri = $ARGV[0]; +$outputfile = $filename.".xml"; +$uri =~ s/^backward/cic:/; +$uri =~ s/(.*),([^,]*),([^,]*)/$1#xpointer(1\/$2\/$3)/; +$uri =~ s/(.*),([^,]*)/$1#xpointer(1\/$2)/; + +print "Now processing file $filename\n"; + +open(HEADER,">>$outputfile"); +print HEADER < + + + +EOT +close(HEADER); + +system("cat $filename >> $outputfile"); + +open(FOOTER,">>$outputfile"); +print FOOTER < + +EOT +close(FOOTER); + +unlink $filename; diff --git a/helm/metadata/create_V7_mowgli/invert.pl b/helm/metadata/create_V7_mowgli/invert.pl new file mode 100755 index 000000000..df3450649 --- /dev/null +++ b/helm/metadata/create_V7_mowgli/invert.pl @@ -0,0 +1,37 @@ +#!/usr/bin/perl + +my $inputfile = $ARGV[0]; + +print "Now splitting file $inputfile\n"; +open(IN, "<$inputfile") or die "Error opening file $inputfile"; +$dummy = ; # +$dummy = ; # +$dummy = ; # +$where = ; # +chomp($where); +$where =~ s/^[^"]*"([^"]*)">$/$1/; +while(($line1 = ) && not ($line1 =~ /<\/h:Object>/)) { + $line2 = ; # + $line3 = ; # value + $line4 = ; # value + $line5 = ; # + $line6 = ; # + $uri = $line4; + chomp($uri); + $uri =~ s/^[ \t]*([^<]*)<\/h:occurrence>$/$1/; + $who = $uri; + $who =~ s/^cic:/backward/; + $who =~ s/#xpointer\(1\/([^\/]*)\/([^\/]*)\)/,$1,$2/; + $who =~ s/#xpointer\(1\/([^\/]*)\)/,$1/; + $line4 =~ s/\Q$uri\E/$where/; + + open(OUT, ">>$who") or die "Error opening file $who"; + print OUT "\t\t\n"; + print OUT $line2; + print OUT $line3; + print OUT $line4; + print OUT $line5; + print OUT "\t\t\n"; + close(OUT); +} +close(IN); diff --git a/helm/metadata/create_V7_mowgli/mkindex.sh b/helm/metadata/create_V7_mowgli/mkindex.sh new file mode 100755 index 000000000..3a814ba17 --- /dev/null +++ b/helm/metadata/create_V7_mowgli/mkindex.sh @@ -0,0 +1,4 @@ +#!/bin/bash + +echo `find . -name "*.xml"` | ../uris_of_filenames.pl $1 > rdf_index.txt +echo `find . -name "*.xml.gz"` | ../uris_of_filenames.pl $1 -gz >> rdf_index.txt diff --git a/helm/metadata/create_V7_mowgli/touch/.cvsignore b/helm/metadata/create_V7_mowgli/touch/.cvsignore new file mode 100644 index 000000000..10bc8bd91 --- /dev/null +++ b/helm/metadata/create_V7_mowgli/touch/.cvsignore @@ -0,0 +1 @@ +*.cmi *.cmo *.cmx touch touch.opt diff --git a/helm/metadata/create_V7_mowgli/touch/Makefile b/helm/metadata/create_V7_mowgli/touch/Makefile new file mode 100644 index 000000000..636a804da --- /dev/null +++ b/helm/metadata/create_V7_mowgli/touch/Makefile @@ -0,0 +1,41 @@ +REQUIRES = helm-getter helm-cic str +PREDICATES = +OCAMLOPTIONS = -package "$(REQUIRES)" -predicates "$(PREDICATES)" +OCAMLDEP = ocamldep +OCAMLFIND = ocamlfind +OCAMLC = $(OCAMLFIND) ocamlc $(OCAMLOPTIONS) +OCAMLOPT = $(OCAMLFIND) ocamlopt $(OCAMLOPTIONS) + +LIBRARIES = $(shell ocamlfind query -recursive -predicates "byte $(PREDICATES)" -format "%d/%a" $(REQUIRES)) +LIBRARIES_OPT = $(shell ocamlfind query -recursive -predicates "native $(PREDICATES)" -format "%d/%a" $(REQUIRES)) + +all: touch +opt: touch.opt + +DEPOBJS = touch.ml + +TOUCHOBJS = touch.cmo + +depend: + $(OCAMLDEP) $(DEPOBJS) > .depend + +touch: $(TOUCHOBJS) $(LIBRARIES) + $(OCAMLC) -linkpkg -o touch $(TOUCHOBJS) + +touch.opt: $(TOUCHOBJS:.cmo=.cmx) $(LIBRARIES_OPT) + $(OCAMLOPT) -linkpkg -o touch.opt $(TOUCHOBJS:.cmo=.cmx) + +.SUFFIXES: .ml .mli .cmo .cmi .cmx +.ml.cmo: $(LIBRARIES) + $(OCAMLC) -c $< +.mli.cmi: $(LIBRARIES) + $(OCAMLC) -c $< +.ml.cmx: $(LIBRARIES_OPT) + $(OCAMLOPT) -c $< + +clean: + rm -f *.cm[iox] *.o touch touch.opt + +.PHONY: clean + +include .depend diff --git a/helm/metadata/create_V7_mowgli/touch/touch.ml b/helm/metadata/create_V7_mowgli/touch/touch.ml new file mode 100644 index 000000000..207750a6d --- /dev/null +++ b/helm/metadata/create_V7_mowgli/touch/touch.ml @@ -0,0 +1,132 @@ +(* 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/. + *) + +(******************************************************************************) +(* *) +(* PROJECT HELM *) +(* *) +(* Claudio Sacerdoti Coen *) +(* 03/04/2001 *) +(* *) +(* Missing description *) +(* *) +(******************************************************************************) + +let iteri foo = + let counter = ref 0 in + List.iter (function e -> incr counter ; foo e !counter) +;; + +let pathname_of_uri uristring = + "backward" ^ + Str.replace_first (Str.regexp "^cic:") "" uristring +;; + +let make_dirs dirpath = + ignore (Unix.system ("mkdir -p \"" ^ dirpath ^ "\"")) +;; + +let touch_file rdf_string_uri = + let module U = UriManager in + let rdf_uri = U.uri_of_string rdf_string_uri in + make_dirs (pathname_of_uri (U.buri_of_uri rdf_uri)) ; + ignore ( + Unix.system + ("touch \"" ^ (pathname_of_uri rdf_string_uri) ^ "\"") + ) +;; + +let get_obj uri = + let cicfilename = Getter.getxml uri in + let res = CicParser.obj_of_xml cicfilename None in + Unix.unlink cicfilename ; + res +;; + +let touch_obj string_uri = + let module U = UriManager in + let module C = Cic in + function + Some (C.InductiveDefinition (itys,_,_)) -> + iteri + (fun (_,_,_,cons) n -> + let sn = string_of_int n in + touch_file + (string_uri ^ "," ^ sn) ; + iteri + (fun (_,_) m -> + let sm = string_of_int m in + touch_file + (string_uri ^ "," ^ sn ^ "," ^ sm) + ) cons + ) itys + | Some _ -> assert false + | None -> + touch_file string_uri +;; + +let touch string_uri = + let module S = String in + let module U = UriManager in + print_endline ("Now touching metadata file for " ^ string_uri) ; + flush stdout ; + let uri = U.uri_of_string string_uri in + let obj = + if S.sub string_uri (S.length string_uri - 3) 3 = "ind" then + Some (get_obj uri) + else + None + in + touch_obj string_uri obj +;; + +let _ = + let usage_msg = "usage: touch[.opt] URI" in + let uri = ref "" in + Arg.parse [] + (fun x -> + if x = "" then + begin + prerr_string "No URI provided.\n" ; + Arg.usage [] usage_msg ; + exit (-1) + end + else if !uri = "" then + uri := x + else + begin + prerr_string "More than two arguments provided.\n" ; + Arg.usage [] usage_msg ; + exit (-1) + end + ) usage_msg ; + if !uri = "" then + begin + prerr_string "No URI provided.\n" ; + Arg.usage [] usage_msg ; + exit (-1) + end ; + touch !uri +;; diff --git a/helm/metadata/create_V7_mowgli/uris_of_filenames.pl b/helm/metadata/create_V7_mowgli/uris_of_filenames.pl new file mode 100755 index 000000000..db835bf9c --- /dev/null +++ b/helm/metadata/create_V7_mowgli/uris_of_filenames.pl @@ -0,0 +1,14 @@ +#!/usr/bin/perl + +while() { + chomp; + split / /; + for (@_) { + $GZSUFF = ""; + if (/.gz$/) + { s/.gz$//; $GZSUFF = " gz" if ($ARGV[1] == "-gz"); } + s/\./helm:rdf:www.cs.unibo.it\/helm\/rdf\/$ARGV[0]\/\/cic:/; + s/\.xml//; + print $_.$GZSUFF."\n"; + } +} -- 2.39.2