epan/diam_dict.l

   1 /*
   2  * We don't use input, so don't generate code for it.
   3  */
   4 %option noinput
   5
   6 /*
   7  * We don't use unput, so don't generate code for it.
   8  */
   9 %option nounput
  10
  11 /*
  12  * We don't read interactively from the terminal.
  13  */
  14 %option never-interactive
  15
  16 /*
  17  * The language we're scanning is case-insensitive.
  18  */
  19 %option caseless
  20
  21 /*
  22  * We use start condition stacks.
  23  */
  24 %option stack
  25
  26 /*
  27  * Prefix scanner routines with "DiamDict" rather than "yy", so this scanner
  28  * can coexist with other scanners.
  29  */
  30 %option prefix="DiamDict"
  31
  32 %option outfile="diam_dict.c"
  33
  34 %{
  35         /*
  36          ** diam_dict.h
  37          ** Diameter Dictionary Import Routines
  38          **
  39          ** (c) 2007, Luis E. Garcia Ontanon <luis@ontanon.org>
  40          **
  41          ** This library is free software; you can redistribute it and/or
  42          ** modify it under the terms of the GNU Library General Public
  43          ** License as published by the Free Software Foundation; either
  44          ** version 2 of the License, or (at your option) any later version.
  45          **
  46          ** This library is distributed in the hope that it will be useful,
  47          ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  48          ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  49          ** Library General Public License for more details.
  50          **
  51          ** You should have received a copy of the GNU Library General Public
  52          ** License along with this library; if not, write to the Free Software
  53          ** Foundation, Inc., 51 Franklin Street, Fifth Floor,
  54          ** Boston, MA  02110-1301, USA.
  55          */
  56
  57 #include "config.h"
  58
  59 #include <glib.h>
  60 #include <stdio.h>
  61 #include <string.h>
  62 #include <errno.h>
  63 #include <stdlib.h>
  64 #include <stdarg.h>
  65 #include "diam_dict.h"
  66 #include "diam_dict_lex.h"
  67 #include <epan/to_str.h>
  68 #include <wsutil/file_util.h>
  69
  70 typedef struct entity_t {
  71         char* name;
  72         char* file;
  73         struct entity_t* next;
  74 } entity_t;
  75
  76 #define ATTR_UINT(cont) do { D(("attr_uint " #cont "\t" )); attr_uint = &(cont); yy_push_state(GET_UINT_ATTR); } while(0)
  77 #define ATTR_STR(cont) do { D(("attr_str " #cont "\t" )); attr_str = &(cont); yy_push_state(GET_ATTR); } while(0)
  78 #define IGNORE() do { D(("ignore: %s\t",yytext)); yy_push_state(IGNORE_ATTR); } while(0)
  79
  80 #define D(args) ddict_debug args
  81
  82 #define MAX_INCLUDE_DEPTH 10
  83 #define YY_INPUT(buf,result,max_size) { result = current_yyinput(buf,max_size); }
  84 #define ECHO
  85 #define APPEND(txt,len) append_to_buffer(txt,len)
  86
  87 static entity_t ents;
  88 static YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];
  89 static int include_stack_ptr = 0;
  90 static size_t (*current_yyinput)(char*,size_t);
  91 static const char* sys_dir;
  92 static ddict_t* dict;
  93 static ddict_application_t* appl;
  94 static ddict_avp_t* avp;
  95 static ddict_enum_t* enumitem;
  96 static ddict_gavp_t* gavp;
  97 static ddict_typedefn_t* typedefn;
  98 static ddict_cmd_t* cmd;
  99 static ddict_vendor_t* vnd;
 100 static ddict_xmlpi_t* xmlpi;
 101
 102 static ddict_application_t* last_appl;
 103 static ddict_avp_t* last_avp;
 104 static ddict_enum_t* last_enumitem;
 105 static ddict_gavp_t* last_gavp;
 106 static ddict_typedefn_t* last_typedefn;
 107 static ddict_cmd_t* last_cmd;
 108 static ddict_vendor_t* last_vnd;
 109 static ddict_xmlpi_t* last_xmlpi;
 110
 111 static char** attr_str;
 112 static unsigned* attr_uint;
 113
 114 static void ddict_debug(const char* fmt, ...) G_GNUC_PRINTF(1, 2);
 115 static void append_to_buffer(const char* txt, unsigned len);
 116 static FILE* ddict_open(const char*, const char*);
 117
 118 %}
 119
 120
 121 xmlpi_start [[:blank:] \r\n]*<\?[[:blank:] \r\n]*
 122 xmlpi_end [[:blank:] \r\n]*\?>[[:blank:] \r\n]*
 123 xmlpi_key_attr [[:blank:] \r\n]*key[[:blank:] \r\n]*=[[:blank:] \r\n]*\042
 124 xmlpi_value_attr [[:blank:] \r\n]*value[[:blank:] \r\n]*=[[:blank:] \r\n]*\042
 125
 126 comment_start [[:blank:] \r\n]*<!--[[:blank:] \r\n]*
 127 comment_end [[:blank:] \r\n]*-->[[:blank:] \r\n]*
 128 open_tag [[:blank:] \r\n]*<[[:blank:] \r\n]*
 129 end_tag [[:blank:] \r\n]*\/>[[:blank:] \r\n]*
 130 close_tag [[:blank:] \r\n]*>[[:blank:] \r\n]*
 131 open_closetag [[:blank:] \r\n]*<\/[[:blank:] \r\n]*
 132 equals [[:blank:] \r\n]*=[[:blank:] \r\n]*
 133 whitespace [[:blank:] \r\n]*
 134 dquoted \042[^\042]*\042
 135
 136 doctype [[:blank:] \r\n]*<!DOCTYPE[^\[]*\[[[:blank:] \r\n]*
 137 doctype_end [[:blank:] \r\n]*\][[:blank:] \r\n]*>[[:blank:] \r\n]*
 138
 139 start_entity [[:blank:] \r\n]*<\!ENTITY[[:blank:] \r\n]*
 140 system [[:blank:] \r\n]*SYSTEM[[:blank:] \r\n]*\042
 141 entityname [a-z0-9-]+
 142 ndquot [^\042]+
 143 end_entity \042[[:blank:] \r\n]*>[[:blank:] \r\n]*
 144
 145 entity \&[a-z0-9-]+;
 146
 147 any .
 148
 149
 150
 151
 152 stop >
 153 stop_end \/>
 154 dquot \042
 155 number [-]?[0-9]*
 156
 157 dictionary_start <dictionary>
 158 dictionary_end <\/dictionary>
 159
 160 base_start <base[^>*]*>
 161 base_end <\/base>
 162
 163 application_start <application
 164 application_end<\/application>
 165
 166 command_start <command
 167 command_end<\/command>
 168
 169 typedefn_start <typedefn
 170
 171 avp_start <avp
 172 avp_end <\/avp>
 173
 174 type_start <type
 175 enum_start <enum
 176
 177 grouped_start <grouped>
 178 grouped_end <\/grouped>
 179
 180 vendor_start <vendor
 181 vendor_end<\/vendor>
 182
 183 gavp_start <gavp
 184
 185 ignored_attr [a-z0-9-]+=
 186 ignored_quoted \042[^\042]*\042
 187
 188 name_attr name=\042
 189 id_attr id=\042
 190 code_attr code=\042
 191 vendor_attr vendor-id=\042
 192 typename_attr type-name=\042
 193 typeparent_attr type-parent=\042
 194 description_attr description=\042
 195
 196
 197
 198 %S LOADING LOADING_COMMENT LOADING_XMLPI ENTITY GET_SYSTEM GET_FILE END_ENTITY
 199 %S GET_ATTR GET_UINT_ATTR END_ATTR OUTSIDE IN_DICT IN_APPL IN_AVP APPL_ATTRS IGNORE_ATTR
 200 %S TYPE_ATTRS GAVP_ATTRS ENUM_ATTRS AVP_ATTRS VENDOR_ATTRS COMMAND_ATTRS TYPEDEFN_ATTRS
 201 %S XMLPI_ATTRS XMLPI_GETKEY XMLPI_GETVAL XMLPI_ENDATTR
 202 %%
 203 <LOADING>{doctype} ;
 204 <LOADING>{doctype_end} ;
 205
 206 <LOADING>{comment_start} BEGIN LOADING_COMMENT;
 207 <LOADING_COMMENT>. ;
 208 <LOADING_COMMENT>{comment_end} BEGIN LOADING;
 209
 210 <LOADING>{xmlpi_start} BEGIN LOADING_XMLPI;
 211 <LOADING_XMLPI>{whitespace} ;
 212 <LOADING_XMLPI>{entityname} {
 213         xmlpi = g_new(ddict_xmlpi_t,1);
 214         xmlpi->name = g_strdup(yytext);
 215         xmlpi->key = NULL;
 216         xmlpi->value = NULL;
 217         xmlpi->next = NULL;
 218
 219         if (!dict->xmlpis) last_xmlpi = dict->xmlpis = xmlpi;
 220         else last_xmlpi = last_xmlpi->next = xmlpi;
 221
 222         BEGIN XMLPI_ATTRS;
 223 }
 224
 225 <XMLPI_ATTRS>{xmlpi_key_attr} BEGIN XMLPI_GETKEY;
 226 <XMLPI_GETKEY>{ndquot} { xmlpi->key = strdup(yytext); BEGIN XMLPI_ATTRS; }
 227
 228 <XMLPI_ATTRS>{xmlpi_value_attr} BEGIN XMLPI_GETVAL;
 229 <XMLPI_GETVAL>{ndquot} { xmlpi->value = strdup(yytext); BEGIN XMLPI_ATTRS; }
 230
 231 <XMLPI_ATTRS>.
 232 <XMLPI_ATTRS>{xmlpi_end} BEGIN LOADING;
 233
 234
 235 <LOADING>{start_entity} BEGIN ENTITY;
 236 <ENTITY>{entityname} {
 237         entity_t* e = g_new(entity_t,1);
 238         e->name = strdup(yytext);
 239         e->next = ents.next;
 240         ents.next = e;
 241         BEGIN GET_SYSTEM;
 242         };
 243 <GET_SYSTEM>{system} BEGIN GET_FILE;
 244 <GET_FILE>{ndquot} {
 245                 ents.next->file = strdup(yytext);
 246                 BEGIN END_ENTITY;
 247         }
 248 <END_ENTITY>{end_entity} BEGIN LOADING;
 249
 250 <LOADING>{open_tag} APPEND("<",1);
 251
 252 <LOADING>{close_tag} APPEND(">",1);
 253
 254 <LOADING>{end_tag} APPEND("/>",2);
 255
 256 <LOADING>{open_closetag} APPEND("</",2);
 257
 258 <LOADING>{whitespace} APPEND(" ",1);
 259
 260 <LOADING>{dquoted} APPEND(yytext, (unsigned) yyleng);
 261
 262 <LOADING>{equals} APPEND("=",1);
 263
 264 <LOADING>{any} APPEND(yytext, (unsigned) yyleng);
 265
 266 <LOADING>{entity} {
 267         char* p = ++yytext;
 268         entity_t* e;
 269
 270         while(*p != ';') p++;
 271
 272         *p = '\0';
 273
 274         D(("looking for entity: %s\n",yytext));
 275
 276         if ( include_stack_ptr >= MAX_INCLUDE_DEPTH ) {
 277                 fprintf(stderr, "included files nested to deeply\n");
 278                 yyterminate();
 279         }
 280
 281         for (e = ents.next; e; e = e->next) {
 282                 if (strcmp(e->name,yytext) == 0) {
 283                         yyin = ddict_open(sys_dir,e->file);
 284                         D(("entity: %s filename: %s yyin: %p\n",e->name,e->file,yyin));
 285                         if (!yyin) {
 286                                 if (errno)
 287                                         fprintf(stderr, "Could not open file: '%s', error: %s\n", e->file, g_strerror(errno) );
 288                                 else
 289                                         fprintf(stderr, "Could not open file: '%s', error unknown (errno == 0)\n", e->file );
 290                                 yyterminate();
 291                         } else {
 292                                 include_stack[include_stack_ptr++] = YY_CURRENT_BUFFER;
 293                                 yy_switch_to_buffer(yy_create_buffer( yyin, YY_BUF_SIZE ) );
 294                                 BEGIN LOADING;
 295                         }
 296                         break;
 297                 }
 298         }
 299
 300         if (!e) {
 301                 fprintf(stderr, "Could not find entity: '%s'\n", yytext );
 302                 yyterminate();
 303         }
 304
 305 }
 306
 307 <<EOF>> {
 308         if (!yyin) yyterminate();
 309
 310         fclose(yyin);
 311         D(("closing: %p %i\n",yyin,include_stack_ptr));
 312
 313         if ( --include_stack_ptr < 0 ) {
 314                 D(("DONE READING\n"));
 315                 yyin = NULL;
 316                 yyterminate();
 317         } else {
 318                 yy_delete_buffer( YY_CURRENT_BUFFER );
 319                 yy_switch_to_buffer(include_stack[include_stack_ptr]);
 320                 BEGIN LOADING;
 321         }
 322 }
 323
 324
 325 <GET_ATTR>{ndquot} {
 326         *attr_str = strdup(yytext);
 327         D(("%s\n",yytext));
 328         attr_str = NULL;
 329         BEGIN END_ATTR;
 330 }
 331
 332 <GET_UINT_ATTR>{number} {
 333         *attr_uint = (unsigned) strtoul(yytext,NULL,10);
 334         D(("%s\n",yytext););
 335         attr_uint = NULL;
 336         BEGIN END_ATTR;
 337 }
 338
 339 <END_ATTR>{dquot} {     yy_pop_state(); }
 340
 341 <IGNORE_ATTR>. {
 342         /* XXX: should go?*/
 343         D(("{%s}",yytext));
 344 }
 345
 346 <IGNORE_ATTR>{ignored_quoted} {
 347         D(("=>%s<=\n",yytext));
 348         yy_pop_state();
 349 }
 350
 351 <OUTSIDE>{dictionary_start} {
 352         D(("dictionary_start\n"));
 353
 354         BEGIN IN_DICT;
 355 }
 356
 357 <IN_DICT>{base_start} {
 358         D(("base_start\n"));
 359         BEGIN IN_APPL;
 360 }
 361
 362 <IN_DICT>{application_start} {
 363         D(("application_start\n"));
 364
 365         appl = g_new(ddict_application_t,1);
 366         appl->name = NULL;
 367         appl->code = 0;
 368         appl->next = NULL;
 369
 370         if (!dict->applications) last_appl = dict->applications = appl;
 371         else last_appl = last_appl->next = appl;
 372
 373         BEGIN APPL_ATTRS;
 374 }
 375
 376 <APPL_ATTRS>{name_attr} { ATTR_STR(appl->name); }
 377 <APPL_ATTRS>{id_attr} { ATTR_UINT(appl->code); }
 378
 379 <APPL_ATTRS>{stop} BEGIN IN_APPL;
 380 <APPL_ATTRS>{stop_end} BEGIN IN_DICT;
 381
 382 <IN_APPL>{command_end}                  ;
 383
 384 <IN_APPL>{command_start}                {
 385         D(("command_start\n"));
 386
 387         cmd = g_new(ddict_cmd_t,1);
 388         cmd->name = NULL;
 389         cmd->vendor = NULL;
 390         cmd->code = 0;
 391         cmd->next = NULL;
 392
 393         if (!dict->cmds) last_cmd = dict->cmds = cmd;
 394         else last_cmd = last_cmd->next = cmd;
 395
 396         BEGIN COMMAND_ATTRS;
 397 }
 398
 399 <COMMAND_ATTRS>{name_attr}              { ATTR_STR(cmd->name); }
 400 <COMMAND_ATTRS>{vendor_attr}            { ATTR_STR(cmd->vendor); }
 401 <COMMAND_ATTRS>{code_attr}              { ATTR_UINT(cmd->code); }
 402 <COMMAND_ATTRS>{stop}                   |
 403 <COMMAND_ATTRS>{stop_end}               { BEGIN IN_APPL; }
 404
 405 <IN_DICT>{vendor_start} {
 406         D(("vendor_start\n"));
 407
 408         vnd = g_new(ddict_vendor_t,1);
 409         vnd->name = NULL;
 410         vnd->code = 0;
 411         vnd->next = NULL;
 412
 413         if (!dict->vendors) last_vnd = dict->vendors = vnd;
 414         else last_vnd = last_vnd->next = vnd;
 415
 416         BEGIN VENDOR_ATTRS;
 417 }
 418
 419 <VENDOR_ATTRS>{name_attr}               { ATTR_STR(vnd->desc); }
 420 <VENDOR_ATTRS>{vendor_attr}             { ATTR_STR(vnd->name); }
 421 <VENDOR_ATTRS>{code_attr}               { ATTR_UINT(vnd->code); }
 422 <VENDOR_ATTRS>{stop}                    { BEGIN IN_APPL; }
 423 <VENDOR_ATTRS>{stop_end}                { BEGIN IN_DICT; }
 424
 425 <IN_APPL>{typedefn_start} {
 426         D(("typedefn_start\n"));
 427
 428         typedefn = g_new(ddict_typedefn_t,1);
 429         typedefn->name = NULL;
 430         typedefn->parent = NULL;
 431         typedefn->next = NULL;
 432
 433         if (!dict->typedefns) last_typedefn = dict->typedefns = typedefn;
 434         else last_typedefn = last_typedefn->next = typedefn;
 435
 436         BEGIN TYPEDEFN_ATTRS;
 437 }
 438
 439 <TYPEDEFN_ATTRS>{typename_attr}         { ATTR_STR(typedefn->name); }
 440 <TYPEDEFN_ATTRS>{typeparent_attr}       { ATTR_STR(typedefn->parent); }
 441 <TYPEDEFN_ATTRS>{stop}                  |
 442 <TYPEDEFN_ATTRS>{stop_end}              { BEGIN IN_APPL; }
 443
 444
 445 <IN_APPL>{avp_start}    {
 446         D(("avp_start\n"));
 447
 448         avp = g_new(ddict_avp_t,1);
 449         avp->name = NULL;
 450         avp->description = NULL;
 451         avp->vendor = NULL;
 452         avp->code = 0;
 453         avp->type = NULL;
 454         avp->enums = NULL;
 455         avp->gavps = NULL;
 456         avp->next = NULL;
 457
 458         if (! dict->avps ) last_avp = dict->avps = avp;
 459         else last_avp = last_avp->next = avp;
 460
 461         BEGIN AVP_ATTRS;
 462 }
 463
 464 <AVP_ATTRS>{name_attr}                  { ATTR_STR(avp->name); }
 465 <AVP_ATTRS>{description_attr}           { ATTR_STR(avp->description); }
 466 <AVP_ATTRS>{vendor_attr}                { ATTR_STR(avp->vendor); }
 467 <AVP_ATTRS>{code_attr}                  { ATTR_UINT(avp->code); }
 468 <AVP_ATTRS>{stop}                       { BEGIN IN_AVP;  }
 469 <AVP_ATTRS>{stop_end}                   { BEGIN IN_APPL; }
 470
 471
 472 <IN_AVP>{grouped_start} { avp->type = strdup("Grouped"); };
 473 <IN_AVP>{grouped_end} ;
 474
 475 <IN_AVP>{type_start} { BEGIN TYPE_ATTRS; }
 476 <TYPE_ATTRS>{typename_attr}                     { ATTR_STR(avp->type); }
 477
 478 <IN_AVP>{gavp_start} {
 479         D(("gavp_start\n"));
 480
 481         gavp = g_new(ddict_gavp_t,1);
 482         gavp->name = NULL;
 483         gavp->code = 0;
 484         gavp->next = NULL;
 485
 486         if (!avp->gavps) last_gavp = avp->gavps = gavp;
 487         else last_gavp = last_gavp->next = gavp;
 488
 489         BEGIN GAVP_ATTRS;
 490 }
 491
 492
 493 <GAVP_ATTRS>{name_attr}                 { ATTR_STR(gavp->name); }
 494
 495
 496 <IN_AVP>{enum_start} {
 497         D(("enum_start\n"));
 498
 499         enumitem = g_new(ddict_enum_t,1);
 500         enumitem->name = NULL;
 501         enumitem->code = 0;
 502         enumitem->next = NULL;
 503
 504         if (!avp->enums) last_enumitem = avp->enums = enumitem;
 505         else last_enumitem = last_enumitem->next = enumitem;
 506
 507         BEGIN ENUM_ATTRS;
 508 }
 509
 510
 511 <ENUM_ATTRS>{name_attr}                 { ATTR_STR(enumitem->name); }
 512 <ENUM_ATTRS>{code_attr}                 { ATTR_UINT(enumitem->code); }
 513
 514 <TYPE_ATTRS,GAVP_ATTRS,ENUM_ATTRS>{stop}                { BEGIN IN_AVP; }
 515 <TYPE_ATTRS,GAVP_ATTRS,ENUM_ATTRS>{stop_end}            { BEGIN IN_AVP; }
 516
 517 <IN_AVP>{avp_end} { D(("avp_end\n")); BEGIN IN_APPL; }
 518
 519 <IN_APPL>{application_end} {
 520         D(("application_end\n")); BEGIN IN_DICT;
 521 }
 522 <IN_APPL>{stop_end} {
 523         D(("application_stop_end\n")); BEGIN IN_DICT;
 524 }
 525 <IN_APPL>{vendor_end} {
 526         D(("vendor_end\n")); BEGIN IN_DICT;
 527 }
 528 <IN_APPL>{base_end} {
 529         D(("base_end\n")); BEGIN IN_DICT;
 530 }
 531
 532 <IN_DICT>{dictionary_end} {
 533         yyterminate();
 534 }
 535
 536 <AVP_ATTRS,ENUM_ATTRS,GAVP_ATTRS,TYPE_ATTRS,TYPEDEFN_ATTRS,VENDOR_ATTRS,APPL_ATTRS,COMMAND_ATTRS>{ignored_attr} IGNORE();
 537
 538 <OUTSIDE>. ;
 539
 540
 541
 542
 543
 544
 545 %%
 546
 547 static int debugging  = 0;
 548
 549 static void ddict_debug(const char* fmt, ...) {
 550         va_list ap;
 551
 552         va_start(ap, fmt);
 553         if (debugging) vfprintf(stderr, fmt, ap);
 554         va_end(ap);
 555
 556         fflush(stderr);
 557 }
 558
 559
 560 static char* strbuf = NULL;
 561 static char* write_ptr = NULL;
 562 static char* read_ptr = NULL;
 563
 564 static unsigned size_strbuf = 8192;
 565 static unsigned len_strbuf = 0;
 566
 567 extern void ddict_unused(void);
 568 void
 569 ddict_unused(void)
 570 {
 571         yy_top_state();
 572 }
 573
 574 static void
 575 append_to_buffer(const char* txt, unsigned len)
 576 {
 577
 578         if (strbuf == NULL) {
 579                 read_ptr = write_ptr = strbuf = (char*)g_malloc(size_strbuf);
 580         }
 581
 582         if ( (len_strbuf + len) >= size_strbuf ) {
 583                 read_ptr = strbuf = (char*)g_realloc(strbuf,size_strbuf *= 2);
 584         }
 585
 586         write_ptr = strbuf + len_strbuf;
 587         strncpy(write_ptr,txt,len);
 588         len_strbuf += len;
 589
 590 }
 591
 592 static size_t
 593 file_input(char* buf, size_t max)
 594 {
 595         size_t read_cnt;
 596
 597         read_cnt = fread(buf,1,max,yyin);
 598
 599         if ( read_cnt == max ) {
 600                 return max;
 601         } else if (read_cnt > 0) {
 602                 return read_cnt;
 603         } else {
 604                 return YY_NULL;
 605         }
 606 }
 607
 608
 609 static size_t
 610 string_input(char* buf, size_t max)
 611 {
 612         if (read_ptr >= write_ptr ) {
 613                 return YY_NULL;
 614         } else if ( read_ptr + max > write_ptr ) {
 615                 max = write_ptr - read_ptr;
 616         }
 617
 618         memcpy(buf,read_ptr,max);
 619         read_ptr += max;
 620
 621         return max;
 622 }
 623
 624 static FILE *
 625 ddict_open(const char* system_directory, const char* filename)
 626 {
 627         FILE* fh;
 628         char* fname;
 629         if (system_directory) {
 630                 fname = g_strdup_printf("%s" G_DIR_SEPARATOR_S "%s",
 631                     system_directory,filename);
 632         } else {
 633                 fname = g_strdup(filename);
 634         }
 635
 636         fh = ws_fopen(fname,"r");
 637
 638         D(("fname: %s fh: %p\n",fname,fh));
 639
 640         g_free(fname);
 641
 642
 643         return fh;
 644 }
 645
 646 ddict_t *
 647 ddict_scan(const char* system_directory, const char* filename, int dbg)
 648 {
 649
 650         debugging = dbg;
 651
 652         sys_dir = system_directory;
 653
 654         yyin = ddict_open(sys_dir,filename);
 655
 656         if (yyin == NULL) {
 657                 D(("unable to open %s\n", filename));
 658                 return NULL;
 659         }
 660
 661         write_ptr = NULL;
 662         read_ptr = NULL;
 663
 664         dict = g_new(ddict_t,1);
 665         dict->applications = NULL;
 666         dict->cmds = NULL;
 667         dict->vendors = NULL;
 668         dict->typedefns = NULL;
 669         dict->avps = NULL;
 670         dict->xmlpis = NULL;
 671
 672         appl = NULL;
 673         avp = NULL;
 674         enumitem = NULL;
 675         gavp = NULL;
 676         typedefn = NULL;
 677         cmd = NULL;
 678         vnd = NULL;
 679         xmlpi = NULL;
 680
 681         last_appl = NULL;
 682         last_avp = NULL;
 683         last_enumitem = NULL;
 684         last_gavp = NULL;
 685         last_typedefn = NULL;
 686         last_cmd = NULL;
 687         last_vnd = NULL;
 688         last_xmlpi = NULL;
 689
 690         ents.next = NULL;
 691         current_yyinput = file_input;
 692         BEGIN LOADING;
 693         yylex();
 694
 695         D(("\n---------------\n%s\n------- %u -------\n",strbuf,len_strbuf));
 696
 697         current_yyinput = string_input;
 698
 699         BEGIN OUTSIDE;
 700         yylex();
 701
 702         g_free(strbuf);
 703         strbuf = NULL;
 704         size_strbuf = 8192;
 705
 706         return dict;
 707 }
 708
 709 void
 710 ddict_free(ddict_t* d)
 711 {
 712         ddict_application_t *p, *pn;
 713         ddict_vendor_t *v, *vn;
 714         ddict_cmd_t *c, *cn;
 715         ddict_typedefn_t *t, *tn;
 716         ddict_avp_t *a, *an;
 717
 718 #define FREE_NAMEANDOBJ(n) do { if(n->name) g_free(n->name); g_free(n); } while(0)
 719
 720         for (p = d->applications; p; p = pn ) {
 721                 pn = p->next;
 722                 FREE_NAMEANDOBJ(p);
 723         }
 724
 725         for (v = d->vendors; v; v = vn) {
 726                 vn = v->next;
 727                 if (!v->desc)  g_free(v->desc);
 728                 FREE_NAMEANDOBJ(v);
 729         }
 730
 731         for (c = d->cmds; c; c = cn ) {
 732                 cn = c->next;
 733                 FREE_NAMEANDOBJ(c);
 734         }
 735
 736         for (t = d->typedefns; t; t = tn) {
 737                 tn = t->next;
 738                 if (!t->parent)  g_free(t->parent);
 739                 FREE_NAMEANDOBJ(t);
 740         }
 741
 742         for (a = d->avps; a; a = an) {
 743                 ddict_gavp_t* g, *gn;
 744                 ddict_enum_t* e, *en;
 745                 an = a->next;
 746
 747                 for (g = a->gavps; g; g = gn) {
 748                         gn = g->next;
 749                         FREE_NAMEANDOBJ(g);
 750                 }
 751
 752                 for (e = a->enums; e; e = en) {
 753                         en = e->next;
 754                         FREE_NAMEANDOBJ(e);
 755                 }
 756
 757                 if (!a->vendor)  g_free(a->vendor);
 758                 if (!a->type)  g_free(a->type);
 759                 if (!a->description)  g_free(a->description);
 760                 FREE_NAMEANDOBJ(a);
 761         }
 762
 763         g_free(d);
 764 }
 765
 766 void
 767 ddict_print(FILE* fh, ddict_t* d)
 768 {
 769         ddict_application_t* p;
 770         ddict_vendor_t* v;
 771         ddict_cmd_t* c;
 772         ddict_typedefn_t* t;
 773         ddict_avp_t* a;
 774
 775
 776         for (p = d->applications; p; p = p->next) {
 777                 fprintf(fh,"Application: %s[%u]:\n",
 778                                 p->name ? p->name : "-",
 779                                 p->code);
 780         }
 781
 782         for (v = d->vendors; v; v = v->next) {
 783                 fprintf(fh,"Vendor: %s[%u]:\n",
 784                                 v->name ? v->name : "-",
 785                                 v->code);
 786         }
 787
 788         for (c = d->cmds; c; c = c->next) {
 789                 fprintf(fh,"Command: %s[%u] \n",
 790                                 c->name ? c->name : "-",
 791                                 c->code);
 792         }
 793
 794         for (t = d->typedefns; t; t = t->next) {
 795                 fprintf(fh,"Type: %s -> %s \n",
 796                                 t->name ? t->name : "-",
 797                                 t->parent ? t->parent : "" );
 798         }
 799
 800         for (a = d->avps; a; a = a->next) {
 801                 ddict_gavp_t* g;
 802                 ddict_enum_t* e;
 803                 fprintf(fh,"AVP: %s[%u:%s] %s %s\n",
 804                                 a->name ? a->name : "-",
 805                                 a->code,
 806                                 a->vendor ? a->vendor : "None",
 807                                 a->type ? a->type : "-",
 808                                 a->description ? a->description : "");
 809
 810                 for (g = a->gavps; g; g = g->next) {
 811                         fprintf(fh,"\tGAVP: %s\n",
 812                                         g->name ? g->name : "-" );
 813                 }
 814
 815                 for (e = a->enums; e; e = e->next) {
 816                         fprintf(fh,"\tEnum: %s[%u]\n",
 817                                         e->name ? e->name : "-",
 818                                         e->code);
 819                 }
 820         }
 821 }
 822
 823 /*
 824  * We want to stop processing when we get to the end of the input.
 825  * (%option noyywrap is not used because if used then
 826  * some flex versions (eg: 2.5.35) generate code which causes
 827  * warnings by the Windows VC compiler).
 828  */
 829
 830 int
 831 yywrap(void)
 832 {
 833     return 1;
 834 }
 835
 836 #ifdef TEST_DIAM_DICT_STANDALONE
 837 int
 838 main(int argc, char** argv)
 839 {
 840         ddict_t* d;
 841         char* dname = NULL;
 842         char* fname;
 843         int i = 1;
 844
 845         switch (argc) {
 846                 case 3:
 847                         dname = argv[i++];
 848                 case 2:
 849                         fname = argv[i];
 850                         break;
 851                 default:
 852                         fprintf(stderr,"%s: usage [dictionary_dir] dictionary_filename\n",argv[0]);
 853                         return 1;
 854         }
 855
 856         d = ddict_scan(dname,fname,1);
 857         if (d == NULL) {
 858                 fprintf(stderr, "Can't open dictionary\n");
 859                 return 2;
 860         }
 861
 862         ddict_print(stdout, d);
 863
 864         return 0;
 865 }
 866 #endif