crypto/kerberosIV/lib/sl/parse.y

   1 %{
   2 /*
   3  * Copyright (c) 1998, 1999 Kungliga Tekniska Högskolan
   4  * (Royal Institute of Technology, Stockholm, Sweden).
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  *
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * 3. Neither the name of the Institute nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include "make_cmds.h"
  36 RCSID("$Id: parse.y,v 1.5 1999/12/02 16:58:55 joda Exp $");
  37
  38 void yyerror (char *s);
  39 long name2number(const char *str);
  40 void error_message(char *, ...);
  41
  42 struct string_list* append_string(struct string_list*, char*);
  43 void free_string_list(struct string_list *list);
  44 unsigned string_to_flag(const char *);
  45
  46 /* This is for bison */
  47
  48 #if !defined(alloca) && !defined(HAVE_ALLOCA)
  49 #define alloca(x) malloc(x)
  50 #endif
  51
  52 %}
  53
  54 %union {
  55   char *string;
  56   unsigned number;
  57   struct string_list *list;
  58 }
  59
  60 %token TABLE REQUEST UNKNOWN UNIMPLEMENTED END
  61 %token <string> STRING
  62 %type <number> flag flags
  63 %type <list> aliases
  64
  65 %%
  66
  67 file            : /* */
  68                 | statements
  69                 ;
  70
  71 statements      : statement
  72                 | statements statement
  73                 ;
  74
  75 statement       : TABLE STRING ';'
  76                 {
  77                     table_name = $2;
  78                 }
  79                 | REQUEST STRING ',' STRING ',' aliases ',' '(' flags ')' ';'
  80                 {
  81                     add_command($2, $4, $6, $9);
  82                 }
  83                 | REQUEST STRING ',' STRING ',' aliases ';'
  84                 {
  85                     add_command($2, $4, $6, 0);
  86                 }
  87                 | UNIMPLEMENTED STRING ',' STRING ',' aliases ';'
  88                 {
  89                     free($2);
  90                     free($4);
  91                     free_string_list($6);
  92                 }
  93                 | UNKNOWN aliases ';'
  94                 {
  95                     free_string_list($2);
  96                 }
  97                 | END ';'
  98                 {
  99                     YYACCEPT;
 100                 }
 101                 ;
 102
 103 aliases         : STRING
 104                 {
 105                     $$ = append_string(NULL, $1);
 106                 }
 107                 | aliases ',' STRING
 108                 {
 109                     $$ = append_string($1, $3);
 110                 }
 111                 ;
 112
 113 flags           : flag
 114                 {
 115                     $$ = $1;
 116                 }
 117                 | flags ',' flag
 118                 {
 119                     $$ = $1 | $3;
 120                 }
 121                 ;
 122 flag            : STRING
 123                 {
 124                     $$ = string_to_flag($1);
 125                     free($1);
 126                 }
 127                 ;
 128
 129
 130
 131 %%
 132
 133 long
 134 name2number(const char *str)
 135 {
 136     const char *p;
 137     long base = 0;
 138     const char *x = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 139         "abcdefghijklmnopqrstuvwxyz0123456789_";
 140     if(strlen(str) > 4) {
 141         yyerror("table name too long");
 142         return 0;
 143     }
 144     for(p = str; *p; p++){
 145         char *q = strchr(x, *p);
 146         if(q == NULL) {
 147             yyerror("invalid character in table name");
 148             return 0;
 149         }
 150         base = (base << 6) + (q - x) + 1;
 151     }
 152     base <<= 8;
 153     if(base > 0x7fffffff)
 154         base = -(0xffffffff - base + 1);
 155     return base;
 156 }
 157
 158 void
 159 yyerror (char *s)
 160 {
 161     error_message ("%s\n", s);
 162 }
 163
 164 struct string_list*
 165 append_string(struct string_list *list, char *str)
 166 {
 167     struct string_list *sl = malloc(sizeof(*sl));
 168     sl->string = str;
 169     sl->next = NULL;
 170     if(list) {
 171         *list->tail = sl;
 172         list->tail = &sl->next;
 173         return list;
 174     }
 175     sl->tail = &sl->next;
 176     return sl;
 177 }
 178
 179 void
 180 free_string_list(struct string_list *list)
 181 {
 182     while(list) {
 183         struct string_list *sl = list->next;
 184         free(list->string);
 185         free(list);
 186         list = sl;
 187     }
 188 }
 189
 190 unsigned
 191 string_to_flag(const char *string)
 192 {
 193     return 0;
 194 }