fml/fmltoken.c

   1 /*
   2  * FML interpreter. Europagate, 1995
   3  *
   4  * $Log: fmltoken.c,v $
   5  * Revision 1.4  1995/02/10 18:15:53  adam
   6  * FML function 'strcmp' implemented. This function can be used to
   7  * test for existence of MARC fields.
   8  *
   9  * Revision 1.3  1995/02/10  15:50:57  adam
  10  * MARC interface implemented. Minor bugs fixed. fmltest can
  11  * be used to format single MARC records. New function '\list'
  12  * implemented.
  13  *
  14  * Revision 1.2  1995/02/07  16:09:24  adam
  15  * The \ character is no longer INCLUDED when terminating a token.
  16  * Major changes in tokenization routines. Bug fixes in expressions
  17  * with lists (fml_sub0).
  18  *
  19  * Revision 1.1.1.1  1995/02/06  13:48:10  adam
  20  * First version of the FML interpreter. It's slow and memory isn't
  21  * freed properly. In particular, the FML nodes aren't released yet.
  22  *
  23  */
  24 #include <string.h>
  25 #include <assert.h>
  26 #include <stdio.h>
  27
  28 #include "fmlp.h"
  29
  30 static int look_char;
  31 static int look_type;
  32 static char lex_buf[FML_MAX_TOKEN];
  33
  34 static void lexer (Fml fml);
  35
  36 struct fml_node *fml_group (Fml fml);
  37
  38 struct fml_node *fml_tokenize (Fml fml)
  39 {
  40     struct fml_node *p;
  41
  42     look_char = (*fml->read_func)();
  43     p = fml_group (fml);
  44     if (fml->debug)
  45     {
  46         fml_pr_list (p);
  47         printf ("\n");
  48     }
  49     if (look_char != fml->eof_mark)
  50     {
  51         fprintf (stderr, "Ill formed parantheses");
  52         exit (1);
  53     }
  54     return p;
  55 }
  56
  57 void fml_pr_list (struct fml_node *p)
  58 {
  59     printf ("{");
  60
  61     while (p)
  62     {
  63         if (p->is_atom)
  64         {
  65             char buf[100];
  66             fml_atom_str (p->p[0], buf);
  67             printf (" %s", buf);
  68         }
  69         else
  70         {
  71             printf (" ");
  72             fml_pr_list (p->p[0]);
  73         }
  74         p = p->p[1];
  75     }
  76     printf (" }");
  77 }
  78
  79 struct fml_node *fml_group (Fml fml)
  80 {
  81     struct fml_node *ptr0 = NULL, *ptr1, *ptr2;
  82
  83     lexer (fml);
  84     if (look_type == 0)
  85         return NULL;
  86     while (1)
  87     {
  88         if (look_type == 'a')
  89         {
  90             ptr2 = fml_node_alloc (fml);
  91             if (!ptr0)
  92                 ptr0 = ptr2;
  93             else
  94                 ptr1->p[1] = ptr2;
  95             ptr2->p[0] = fml_atom_alloc (fml, lex_buf);
  96             ptr2->is_atom = 1;
  97         }
  98         else if (look_type == '{')
  99         {
 100             struct fml_node *sptr = fml_group (fml);
 101             if (sptr)
 102             {
 103                 ptr2 = fml_node_alloc (fml);
 104                 if (!ptr0)
 105                     ptr0 = ptr2;
 106                 else
 107                         ptr1->p[1] = ptr2;
 108                 ptr2->p[0] = sptr;
 109                 ptr2->is_atom = 0;
 110             }
 111             else
 112             {
 113                 ptr2 = fml_node_alloc (fml);
 114                 if (!ptr0)
 115                     ptr0 = ptr2;
 116                 else
 117                     ptr1->p[1] = ptr2;
 118                 ptr2->is_atom = 0;
 119             }
 120         }
 121         else
 122             break;
 123         lexer (fml);
 124         ptr1 = ptr2;
 125     }
 126     return ptr0;
 127 }
 128
 129 static void lexer (Fml fml)
 130 {
 131     int off;
 132     while (1)
 133     {
 134         if (look_char == fml->eof_mark)
 135         {
 136             look_type = 0;
 137             return;
 138         }
 139         else if (look_char == fml->comment_char)
 140         {
 141             do
 142                 look_char = (*fml->read_func)();
 143             while (look_char != '\n' && look_char != fml->eof_mark);
 144         }
 145         else
 146         {
 147             if (!strchr (fml->white_chars, look_char))
 148                 break;
 149             look_char = (*fml->read_func)();
 150         }
 151     }
 152     if (look_char == '{')
 153     {
 154         look_type = '{';
 155         look_char = (*fml->read_func)();
 156     }
 157     else if (look_char == '}')
 158     {
 159         look_type = '}';
 160         look_char = (*fml->read_func)();
 161     }
 162     else if (look_char == '\'')
 163     {
 164         off = 0;
 165         look_char = (*fml->read_func)();
 166         while (look_char != fml->eof_mark && look_char != '\'')
 167         {
 168             lex_buf[off++] = look_char;
 169             if (look_char == '\\')
 170             {
 171                 look_char = (*fml->read_func)();
 172                 switch (look_char)
 173                 {
 174                 case 'n':
 175                     lex_buf[off-1] = '\n';
 176                     break;
 177                 case 't':
 178                     lex_buf[off-1] = '\n';
 179                     break;
 180                 case '\'':
 181                     lex_buf[off-1] = '\'';
 182                     break;
 183                 default:
 184                     lex_buf[off-1] = look_char;
 185                 }
 186             }
 187             look_char = (*fml->read_func)();
 188         }
 189         lex_buf[off] = '\0';
 190         look_type = 'a';
 191         if (look_char == '\'')
 192             look_char = (*fml->read_func)();
 193     }
 194     else
 195     {
 196         off = 0;
 197         do
 198         {
 199             lex_buf[off++] = look_char;
 200             look_char = (*fml->read_func)();
 201         } while (look_char != fml->eof_mark
 202                  && !strchr (fml->white_chars, look_char)
 203                  && look_char != '{' && look_char != '}');
 204         lex_buf[off] = '\0';
 205         look_type = 'a';
 206     }
 207 #if 0
 208     if (fml->debug)
 209     {
 210         if (look_type == 'a')
 211             printf ("[%s]", lex_buf);
 212         else
 213             printf ("[%c]", look_type);
 214     }
 215 #endif
 216 }