src/ircd_parser.y

   1 /* This code is in the public domain.
   2  * $Nightmare: nightmare/src/main/parser.y,v 1.2.2.1.2.1 2002/07/02 03:42:10 ejb Exp $
   3  */
   4
   5 %{
   6 #include <sys/types.h>
   7 #include <sys/stat.h>
   8
   9 #include <netinet/in.h>
  10
  11 #include <string.h>
  12 #include <stdlib.h>
  13 #include <stdarg.h>
  14 #include <stdio.h>
  15 #define WE_ARE_MEMORY_C
  16 #include "stdinc.h"
  17 #include "setup.h"
  18 #include "common.h"
  19 #include "ircd_defs.h"
  20 #include "config.h"
  21 #include "client.h"
  22 #include "modules.h"
  23 #include "newconf.h"
  24
  25 #define YY_NO_UNPUT
  26
  27 int yyparse();
  28 int yyerror(const char *);
  29 int yylex();
  30
  31 static time_t conf_find_time(char*);
  32
  33 static struct {
  34         const char *    name;
  35         const char *    plural;
  36         time_t  val;
  37 } ircd_times[] = {
  38         {"second",     "seconds",    1},
  39         {"minute",     "minutes",    60},
  40         {"hour",       "hours",      60 * 60},
  41         {"day",        "days",       60 * 60 * 24},
  42         {"week",       "weeks",      60 * 60 * 24 * 7},
  43         {"fortnight",  "fortnights", 60 * 60 * 24 * 14},
  44         {"month",      "months",     60 * 60 * 24 * 7 * 4},
  45         {"year",       "years",      60 * 60 * 24 * 365},
  46         /* ok-- we now do sizes here too. they aren't times, but
  47            it's close enough */
  48         {"byte",        "bytes",        1},
  49         {"kb",          NULL,           1024},
  50         {"kbyte",       "kbytes",       1024},
  51         {"kilobyte",    "kilebytes",    1024},
  52         {"mb",          NULL,           1024 * 1024},
  53         {"mbyte",       "mbytes",       1024 * 1024},
  54         {"megabyte",    "megabytes",    1024 * 1024},
  55         {NULL, NULL, 0},
  56 };
  57
  58 time_t conf_find_time(char *name)
  59 {
  60   int i;
  61
  62   for (i = 0; ircd_times[i].name; i++)
  63     {
  64       if (strcasecmp(ircd_times[i].name, name) == 0 ||
  65           (ircd_times[i].plural && strcasecmp(ircd_times[i].plural, name) == 0))
  66         return ircd_times[i].val;
  67     }
  68
  69   return 0;
  70 }
  71
  72 static struct
  73 {
  74         const char *word;
  75         int yesno;
  76 } yesno[] = {
  77         {"yes",         1},
  78         {"no",          0},
  79         {"true",        1},
  80         {"false",       0},
  81         {"on",          1},
  82         {"off",         0},
  83         {NULL,          0}
  84 };
  85
  86 static int      conf_get_yesno_value(char *str)
  87 {
  88         int i;
  89
  90         for (i = 0; yesno[i].word; i++)
  91         {
  92                 if (strcasecmp(str, yesno[i].word) == 0)
  93                 {
  94                         return yesno[i].yesno;
  95                 }
  96         }
  97
  98         return -1;
  99 }
 100
 101 static void     free_cur_list(conf_parm_t* list)
 102 {
 103         switch (list->type & CF_MTYPE)
 104         {
 105                 case CF_STRING:
 106                 case CF_QSTRING:
 107                         MyFree(list->v.string);
 108                         break;
 109                 case CF_LIST:
 110                         free_cur_list(list->v.list);
 111                         break;
 112                 default: break;
 113         }
 114
 115         if (list->next)
 116                 free_cur_list(list->next);
 117 }
 118
 119
 120 conf_parm_t *   cur_list = NULL;
 121
 122 static void     add_cur_list_cpt(conf_parm_t *new)
 123 {
 124         if (cur_list == NULL)
 125         {
 126                 cur_list = MyMalloc(sizeof(conf_parm_t));
 127                 cur_list->type |= CF_FLIST;
 128                 cur_list->v.list = new;
 129         }
 130         else
 131         {
 132                 new->next = cur_list->v.list;
 133                 cur_list->v.list = new;
 134         }
 135 }
 136
 137 static void     add_cur_list(int type, char *str, int number)
 138 {
 139         conf_parm_t *new;
 140
 141         new = MyMalloc(sizeof(conf_parm_t));
 142         new->next = NULL;
 143         new->type = type;
 144
 145         switch(type)
 146         {
 147         case CF_INT:
 148         case CF_TIME:
 149         case CF_YESNO:
 150                 new->v.number = number;
 151                 break;
 152         case CF_STRING:
 153         case CF_QSTRING:
 154                 DupString(new->v.string, str);
 155                 break;
 156         }
 157
 158         add_cur_list_cpt(new);
 159 }
 160
 161
 162 %}
 163
 164 %union {
 165         int             number;
 166         char            string[IRCD_BUFSIZE + 1];
 167         conf_parm_t *   conf_parm;
 168 }
 169
 170 %token LOADMODULE TWODOTS
 171
 172 %token <string> QSTRING STRING
 173 %token <number> NUMBER
 174
 175 %type <string> qstring string
 176 %type <number> number timespec
 177 %type <conf_parm> oneitem single itemlist
 178
 179 %start conf
 180
 181 %%
 182
 183 conf:
 184         | conf conf_item
 185         | error
 186         ;
 187
 188 conf_item: block
 189          | loadmodule
 190          ;
 191
 192 block: string
 193          {
 194            conf_start_block($1, NULL);
 195          }
 196        '{' block_items '}' ';'
 197          {
 198            if (conf_cur_block)
 199                 conf_end_block(conf_cur_block);
 200          }
 201      | string qstring
 202          {
 203            conf_start_block($1, $2);
 204          }
 205        '{' block_items '}' ';'
 206          {
 207            if (conf_cur_block)
 208                 conf_end_block(conf_cur_block);
 209          }
 210      ;
 211
 212 block_items: block_items block_item
 213            | block_item
 214            ;
 215
 216 block_item:     string '=' itemlist ';'
 217                 {
 218                         conf_call_set(conf_cur_block, $1, cur_list, CF_LIST);
 219                         free_cur_list(cur_list);
 220                         cur_list = NULL;
 221                 }
 222                 ;
 223
 224 itemlist: itemlist ',' single
 225         | single
 226         ;
 227
 228 single: oneitem
 229         {
 230                 add_cur_list_cpt($1);
 231         }
 232         | oneitem TWODOTS oneitem
 233         {
 234                 /* "1 .. 5" meaning 1,2,3,4,5 - only valid for integers */
 235                 if (($1->type & CF_MTYPE) != CF_INT ||
 236                     ($3->type & CF_MTYPE) != CF_INT)
 237                 {
 238                         conf_report_error("Both arguments in '..' notation must be integers.");
 239                         break;
 240                 }
 241                 else
 242                 {
 243                         int i;
 244
 245                         for (i = $1->v.number; i <= $3->v.number; i++)
 246                         {
 247                                 add_cur_list(CF_INT, 0, i);
 248                         }
 249                 }
 250         }
 251         ;
 252
 253 oneitem: qstring
 254             {
 255                 $$ = MyMalloc(sizeof(conf_parm_t));
 256                 $$->type = CF_QSTRING;
 257                 DupString($$->v.string, $1);
 258             }
 259           | timespec
 260             {
 261                 $$ = MyMalloc(sizeof(conf_parm_t));
 262                 $$->type = CF_TIME;
 263                 $$->v.number = $1;
 264             }
 265           | number
 266             {
 267                 $$ = MyMalloc(sizeof(conf_parm_t));
 268                 $$->type = CF_INT;
 269                 $$->v.number = $1;
 270             }
 271           | string
 272             {
 273                 /* a 'string' could also be a yes/no value ..
 274                    so pass it as that, if so */
 275                 int val = conf_get_yesno_value($1);
 276
 277                 $$ = MyMalloc(sizeof(conf_parm_t));
 278
 279                 if (val != -1)
 280                 {
 281                         $$->type = CF_YESNO;
 282                         $$->v.number = val;
 283                 }
 284                 else
 285                 {
 286                         $$->type = CF_STRING;
 287                         DupString($$->v.string, $1);
 288                 }
 289             }
 290           ;
 291
 292 loadmodule:
 293           LOADMODULE QSTRING
 294             {
 295 #ifndef STATIC_MODULES
 296               char *m_bn;
 297
 298               m_bn = irc_basename((char *) $2);
 299
 300               if (findmodule_byname(m_bn) == -1)
 301                   load_one_module($2, 0);
 302 #endif
 303             }
 304           ';'
 305           ;
 306
 307 qstring: QSTRING { strcpy($$, $1); } ;
 308 string: STRING { strcpy($$, $1); } ;
 309 number: NUMBER { $$ = $1; } ;
 310
 311 timespec:       number string
 312                 {
 313                         time_t t;
 314
 315                         if ((t = conf_find_time($2)) == 0)
 316                         {
 317                                 conf_report_error("Unrecognised time type/size '%s'", $2);
 318                                 t = 1;
 319                         }
 320
 321                         $$ = $1 * t;
 322                 }
 323                 | timespec timespec
 324                 {
 325                         $$ = $1 + $2;
 326                 }
 327                 | timespec number
 328                 {
 329                         $$ = $1 + $2;
 330                 }
 331                 ;