%top {

/* Include this before everything else, for various large-file definitions */

#include "config.h"

#include <wireshark.h>

}

/*

* We want a reentrant scanner.

*/

%option reentrant

/*

* We don't use input, so don't generate code for it.

*/

%option noinput

/*

* We don't use unput, so don't generate code for it.

*/

%option nounput

/*

* We don't read interactively from the terminal.

*/

%option never-interactive

/*

* The language we're scanning is case-insensitive.

*/

%option caseless

/*

* We use start condition stacks.

*/

%option stack

/*

* We want to stop processing when we get to the end of the input.

*/

%option noyywrap

/*

* The type for the state we keep for a scanner.

*/

%option extra-type="DiamDict_scanner_state_t *"

/*

* Prefix scanner routines with "DiamDict_" rather than "yy", so this scanner

* can coexist with other scanners.

*/

%option prefix="DiamDict_"

/*

* We have to override the memory allocators so that we don't get

* "unused argument" warnings from the yyscanner argument (which

* we don't use, as we have a global memory allocator).

*

* We provide, as macros, our own versions of the routines generated by Flex,

* which just call malloc()/realloc()/free() (as the Flex versions do),

* discarding the extra argument.

*/

%option noyyalloc

%option noyyrealloc

%option noyyfree

%{

/*

** diam_dict.h

** Diameter Dictionary Import Routines

**

** (c) 2007, Luis E. Garcia Ontanon <luis@ontanon.org>

**

** This library is free software; you can redistribute it and/or

** modify it under the terms of the GNU Library General Public

** License as published by the Free Software Foundation; either

** version 2 of the License, or (at your option) any later version.

**

** This library 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

** Library General Public License for more details.

**

** You should have received a copy of the GNU Library General Public

** License along with this library; if not, write to the Free Software

** Foundation, Inc., 51 Franklin Street, Fifth Floor,

** Boston, MA 02110-1301, USA.

**

** See draft-frascone-xml-dictionary for the syntax of the

** dictionary.

*/

#include <glib.h>

#include <stdio.h>

#include <string.h>

#include <errno.h>

#include <stdlib.h>

#include <stdarg.h>

#include "diam_dict.h"

#include <epan/to_str.h>

#include <wsutil/file_util.h>

/*

* Disable diagnostics in the code generated by Flex.

*/

DIAG_OFF_FLEX()

typedef struct entity_t {

char* name;

char* file;

struct entity_t* next;

} entity_t;

#define ATTR_UINT(cont) do { D(("attr_uint " #cont "\t" )); yyextra->attr_uint = &(cont); yy_push_state(GET_UINT_ATTR, yyscanner); } while(0)

#define ATTR_STR(cont) do { D(("attr_str " #cont "\t" )); yyextra->attr_str = &(cont); yy_push_state(GET_ATTR, yyscanner); } while(0)

#define IGNORE() do { D(("ignore: %s\t",yytext)); yy_push_state(IGNORE_ATTR, yyscanner); } while(0)

#define D(args) ddict_debug args

#define MAX_INCLUDE_DEPTH 10

#define YY_INPUT(buf,result,max_size) { result = yyextra->current_yyinput(buf,max_size,yyscanner); }

#define YY_USER_INIT { \

DiamDict_scanner_state_t *scanner_state = DiamDict_get_extra(yyscanner); \

BEGIN(scanner_state->start_state); \

}

#define ECHO

#define APPEND(txt,len) append_to_buffer(txt,len,yyextra)

typedef struct {

const char* sys_dir;

char* write_ptr;

char* read_ptr;

char* strbuf;

unsigned size_strbuf;

unsigned len_strbuf;

ddict_t* dict;

ddict_application_t* appl;

ddict_avp_t* avp;

ddict_enum_t* enumitem;

ddict_gavp_t* gavp;

ddict_typedefn_t* typedefn;

ddict_cmd_t* cmd;

ddict_vendor_t* vnd;

ddict_xmlpi_t* xmlpi;

ddict_application_t* last_appl;

ddict_avp_t* last_avp;

ddict_enum_t* last_enumitem;

ddict_gavp_t* last_gavp;

ddict_typedefn_t* last_typedefn;

ddict_cmd_t* last_cmd;

ddict_vendor_t* last_vnd;

ddict_xmlpi_t* last_xmlpi;

entity_t *ents;

char** attr_str;

unsigned* attr_uint;

size_t (*current_yyinput)(char*,size_t,yyscan_t);

int (*current_close)(FILE *fh);

YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];

int include_stack_ptr;

int start_state;

} DiamDict_scanner_state_t;

static void ddict_debug(const char* fmt, ...) G_GNUC_PRINTF(1, 2);

static void append_to_buffer(const char* txt, unsigned len, DiamDict_scanner_state_t *statep);

static FILE* ddict_open(const char*, const char*);

/*

* Sleazy hack to suppress compiler warnings in yy_fatal_error().

*/

#define YY_EXIT_FAILURE ((void)yyscanner, 2)

/*

* Macros for the allocators, to discard the extra argument.

*/

#define DiamDict_alloc(size, yyscanner) (void *)malloc(size)

#define DiamDict_realloc(ptr, size, yyscanner) (void *)realloc((char *)(ptr), (size))

#define DiamDict_free(ptr, yyscanner) free((char *)ptr)

%}

xmlpi_start [[:blank:] \r\n]*<\?[[:blank:] \r\n]*

xmlpi_end [[:blank:] \r\n]*\?>[[:blank:] \r\n]*

xmlpi_key_attr [[:blank:] \r\n]*key[[:blank:] \r\n]*=[[:blank:] \r\n]*\042

xmlpi_value_attr [[:blank:] \r\n]*value[[:blank:] \r\n]*=[[:blank:] \r\n]*\042

comment_start [[:blank:] \r\n]*<!--[[:blank:] \r\n]*

comment_end [[:blank:] \r\n]*-->[[:blank:] \r\n]*

open_tag [[:blank:] \r\n]*<[[:blank:] \r\n]*

end_tag [[:blank:] \r\n]*\/>[[:blank:] \r\n]*

close_tag [[:blank:] \r\n]*>[[:blank:] \r\n]*

open_closetag [[:blank:] \r\n]*<\/[[:blank:] \r\n]*

equals [[:blank:] \r\n]*=[[:blank:] \r\n]*

whitespace [[:blank:] \r\n]*

dquoted \042[^\042]*\042

doctype [[:blank:] \r\n]*<!DOCTYPE[^\[]*\[[[:blank:] \r\n]*

doctype_end [[:blank:] \r\n]*\][[:blank:] \r\n]*>[[:blank:] \r\n]*

start_entity [[:blank:] \r\n]*<\!ENTITY[[:blank:] \r\n]*

system [[:blank:] \r\n]*SYSTEM[[:blank:] \r\n]*\042

entityname [a-z0-9-]+

ndquot [^\042]+

end_entity \042[[:blank:] \r\n]*>[[:blank:] \r\n]*

entity \&[a-z0-9-]+;

any .

stop >

stop_end \/>

dquot \042

number [-]?[0-9]*

dictionary_start <dictionary>

dictionary_end <\/dictionary>

base_start <base[^>*]*>

base_end <\/base>

application_start <application

application_end<\/application>

command_start <command

command_end<\/command>

typedefn_start <typedefn

avp_start <avp

avp_end <\/avp>

type_start <type

enum_start <enum

grouped_start <grouped>

grouped_end <\/grouped>

vendor_start <vendor

vendor_end<\/vendor>

gavp_start <gavp

ignored_attr [a-z0-9-]+=

ignored_quoted \042[^\042]*\042

name_attr name=\042

id_attr id=\042

code_attr code=\042

vendor_attr vendor-id=\042

typename_attr type-name=\042

typeparent_attr type-parent=\042

description_attr description=\042

%S LOADING LOADING_COMMENT LOADING_XMLPI ENTITY GET_SYSTEM GET_FILE END_ENTITY

%S GET_ATTR GET_UINT_ATTR END_ATTR OUTSIDE IN_DICT IN_APPL IN_AVP APPL_ATTRS IGNORE_ATTR

%S TYPE_ATTRS GAVP_ATTRS ENUM_ATTRS AVP_ATTRS VENDOR_ATTRS COMMAND_ATTRS TYPEDEFN_ATTRS

%S XMLPI_ATTRS XMLPI_GETKEY XMLPI_GETVAL XMLPI_ENDATTR

%%

<LOADING>{doctype} ;

<LOADING>{doctype_end} ;

<LOADING>{comment_start} BEGIN LOADING_COMMENT;

<LOADING_COMMENT>. ;

<LOADING_COMMENT>{comment_end} BEGIN LOADING;

<LOADING>{xmlpi_start} BEGIN LOADING_XMLPI;

<LOADING_XMLPI>{whitespace} ;

<LOADING_XMLPI>{entityname} {

yyextra->xmlpi = g_new(ddict_xmlpi_t,1);

yyextra->xmlpi->name = g_strdup(yytext);

yyextra->xmlpi->key = NULL;

yyextra->xmlpi->value = NULL;

yyextra->xmlpi->next = NULL;

if (!yyextra->dict->xmlpis)

yyextra->last_xmlpi = yyextra->dict->xmlpis = yyextra->xmlpi;

else

yyextra->last_xmlpi = yyextra->last_xmlpi->next = yyextra->xmlpi;

BEGIN XMLPI_ATTRS;

}

<XMLPI_ATTRS>{xmlpi_key_attr} BEGIN XMLPI_GETKEY;

<XMLPI_GETKEY>{ndquot} { yyextra->xmlpi->key = g_strdup(yytext); BEGIN XMLPI_ATTRS; }

<XMLPI_ATTRS>{xmlpi_value_attr} BEGIN XMLPI_GETVAL;

<XMLPI_GETVAL>{ndquot} { yyextra->xmlpi->value = g_strdup(yytext); BEGIN XMLPI_ATTRS; }

<XMLPI_ATTRS>.

<XMLPI_ATTRS>{xmlpi_end} BEGIN LOADING;

<LOADING>{start_entity} BEGIN ENTITY;

<ENTITY>{entityname} {

entity_t* e = g_new(entity_t,1);

e->name = g_strdup(yytext);

e->next = yyextra->ents;

yyextra->ents = e;

BEGIN GET_SYSTEM;

};

<GET_SYSTEM>{system} BEGIN GET_FILE;

<GET_FILE>{ndquot} {

yyextra->ents->file = g_strdup(yytext);

BEGIN END_ENTITY;

}

<END_ENTITY>{end_entity} BEGIN LOADING;

<LOADING>{open_tag} APPEND("<",1);

<LOADING>{close_tag} APPEND(">",1);

<LOADING>{end_tag} APPEND("/>",2);

<LOADING>{open_closetag} APPEND("</",2);

<LOADING>{whitespace} APPEND(" ",1);

<LOADING>{dquoted} APPEND(yytext, (unsigned) yyleng);

<LOADING>{equals} APPEND("=",1);

<LOADING>{any} APPEND(yytext, (unsigned) yyleng);

<LOADING>{entity} {

char* p = ++yytext;

entity_t* e;

while(*p != ';') p++;

*p = '\0';

D(("looking for entity: %s\n",yytext));

if ( yyextra->include_stack_ptr >= MAX_INCLUDE_DEPTH ) {

fprintf(stderr, "included files nested to deeply\n");

yyterminate();

}

for (e = yyextra->ents; e; e = e->next) {

if (strcmp(e->name,yytext) == 0) {

yyin = ddict_open(yyextra->sys_dir,e->file);

D(("entity: %s filename: %s yyin: %p\n",e->name,e->file,(void*)yyin));

if (!yyin) {

if (errno)

fprintf(stderr, "Could not open file: '%s', error: %s\n", e->file, g_strerror(errno) );

else

fprintf(stderr, "Could not open file: '%s', error unknown (errno == 0)\n", e->file );

yyterminate();

} else {

yyextra->include_stack[yyextra->include_stack_ptr++] = YY_CURRENT_BUFFER;

yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE, yyscanner), yyscanner);

BEGIN LOADING;

}

break;

}

}

if (!e) {

fprintf(stderr, "Could not find entity: '%s'\n", yytext );

yyterminate();

}

}

<<EOF>> {

if (!yyin) yyterminate();

yyextra->current_close(yyin);

D(("closing: %p %i\n",(void*)yyin,yyextra->include_stack_ptr));

if ( --yyextra->include_stack_ptr < 0 ) {

D(("DONE READING\n"));

yyin = NULL;

yyterminate();

} else {

yy_delete_buffer( YY_CURRENT_BUFFER, yyscanner);

yy_switch_to_buffer(yyextra->include_stack[yyextra->include_stack_ptr], yyscanner);

BEGIN LOADING;

}

}

<GET_ATTR>{ndquot} {

*(yyextra->attr_str) = g_strdup(yytext);

D(("%s\n",yytext));

yyextra->attr_str = NULL;

BEGIN END_ATTR;

}

<GET_UINT_ATTR>{number} {

*(yyextra->attr_uint) = (unsigned) strtoul(yytext,NULL,10);

D(("%s\n",yytext););

yyextra->attr_uint = NULL;

BEGIN END_ATTR;

}

<END_ATTR>{dquot} { yy_pop_state(yyscanner); }

<IGNORE_ATTR>. {

/* XXX: should go?*/

D(("{%s}",yytext));

}

<IGNORE_ATTR>{ignored_quoted} {

D(("=>%s<=\n",yytext));

yy_pop_state(yyscanner);

}

<OUTSIDE>{dictionary_start} {

D(("dictionary_start\n"));

BEGIN IN_DICT;

}

<IN_DICT>{base_start} {

D(("base_start\n"));

BEGIN IN_APPL;

}

<IN_DICT>{application_start} {

D(("application_start\n"));

yyextra->appl = g_new(ddict_application_t,1);

yyextra->appl->name = NULL;

yyextra->appl->code = 0;

yyextra->appl->next = NULL;

if (!yyextra->dict->applications)

yyextra->last_appl = yyextra->dict->applications = yyextra->appl;

else

yyextra->last_appl = yyextra->last_appl->next = yyextra->appl;

BEGIN APPL_ATTRS;

}

<APPL_ATTRS>{name_attr} { ATTR_STR(yyextra->appl->name); }

<APPL_ATTRS>{id_attr} { ATTR_UINT(yyextra->appl->code); }

<APPL_ATTRS>{stop} BEGIN IN_APPL;

<APPL_ATTRS>{stop_end} BEGIN IN_DICT;

<IN_APPL>{command_end} ;

<IN_APPL>{command_start} {

D(("command_start\n"));

yyextra->cmd = g_new(ddict_cmd_t,1);

yyextra->cmd->name = NULL;

yyextra->cmd->vendor = NULL;

yyextra->cmd->code = 0;

yyextra->cmd->next = NULL;

if (!yyextra->dict->cmds)

yyextra->last_cmd = yyextra->dict->cmds = yyextra->cmd;

else

yyextra->last_cmd = yyextra->last_cmd->next = yyextra->cmd;

BEGIN COMMAND_ATTRS;

}

<COMMAND_ATTRS>{name_attr} { ATTR_STR(yyextra->cmd->name); }

<COMMAND_ATTRS>{vendor_attr} { ATTR_STR(yyextra->cmd->vendor); }

<COMMAND_ATTRS>{code_attr} { ATTR_UINT(yyextra->cmd->code); }

<COMMAND_ATTRS>{stop} |

<COMMAND_ATTRS>{stop_end} { BEGIN IN_APPL; }

<IN_DICT>{vendor_start} {

D(("vendor_start\n"));

yyextra->vnd = g_new(ddict_vendor_t,1);

yyextra->vnd->name = NULL;

yyextra->vnd->code = 0;

yyextra->vnd->next = NULL;

if (!yyextra->dict->vendors)

yyextra->last_vnd = yyextra->dict->vendors = yyextra->vnd;

else

yyextra->last_vnd = yyextra->last_vnd->next = yyextra->vnd;

BEGIN VENDOR_ATTRS;

}

<VENDOR_ATTRS>{name_attr} { ATTR_STR(yyextra->vnd->desc); }

<VENDOR_ATTRS>{vendor_attr} { ATTR_STR(yyextra->vnd->name); }

<VENDOR_ATTRS>{code_attr} { ATTR_UINT(yyextra->vnd->code); }

<VENDOR_ATTRS>{stop} { BEGIN IN_APPL; }

<VENDOR_ATTRS>{stop_end} { BEGIN IN_DICT; }

<IN_APPL>{typedefn_start} {

D(("typedefn_start\n"));

yyextra->typedefn = g_new(ddict_typedefn_t,1);

yyextra->typedefn->name = NULL;

yyextra->typedefn->parent = NULL;

yyextra->typedefn->next = NULL;

if (!yyextra->dict->typedefns)

yyextra->last_typedefn = yyextra->dict->typedefns = yyextra->typedefn;

else

yyextra->last_typedefn = yyextra->last_typedefn->next = yyextra->typedefn;

BEGIN TYPEDEFN_ATTRS;

}

<TYPEDEFN_ATTRS>{typename_attr} { ATTR_STR(yyextra->typedefn->name); }

<TYPEDEFN_ATTRS>{typeparent_attr} { ATTR_STR(yyextra->typedefn->parent); }

<TYPEDEFN_ATTRS>{stop} |

<TYPEDEFN_ATTRS>{stop_end} { BEGIN IN_APPL; }

<IN_APPL>{avp_start} {

D(("avp_start\n"));

yyextra->avp = g_new(ddict_avp_t,1);

yyextra->avp->name = NULL;

yyextra->avp->description = NULL;

yyextra->avp->vendor = NULL;

yyextra->avp->code = 0;

yyextra->avp->type = NULL;

yyextra->avp->enums = NULL;

yyextra->avp->gavps = NULL;

yyextra->avp->next = NULL;

if (! yyextra->dict->avps )

yyextra->last_avp = yyextra->dict->avps = yyextra->avp;

else

yyextra->last_avp = yyextra->last_avp->next = yyextra->avp;

BEGIN AVP_ATTRS;

}

<AVP_ATTRS>{name_attr} { ATTR_STR(yyextra->avp->name); }

<AVP_ATTRS>{description_attr} { ATTR_STR(yyextra->avp->description); }

<AVP_ATTRS>{vendor_attr} { ATTR_STR(yyextra->avp->vendor); }

<AVP_ATTRS>{code_attr} { ATTR_UINT(yyextra->avp->code); }

<AVP_ATTRS>{stop} { BEGIN IN_AVP; }

<AVP_ATTRS>{stop_end} { BEGIN IN_APPL; }

<IN_AVP>{grouped_start} { yyextra->avp->type = g_strdup("Grouped"); };

<IN_AVP>{grouped_end} ;

<IN_AVP>{type_start} { BEGIN TYPE_ATTRS; }

<TYPE_ATTRS>{typename_attr} { ATTR_STR(yyextra->avp->type); }

<IN_AVP>{gavp_start} {

D(("gavp_start\n"));

yyextra->gavp = g_new(ddict_gavp_t,1);

yyextra->gavp->name = NULL;

yyextra->gavp->code = 0;

yyextra->gavp->next = NULL;

if (!yyextra->avp->gavps)

yyextra->last_gavp = yyextra->avp->gavps = yyextra->gavp;

else

yyextra->last_gavp = yyextra->last_gavp->next = yyextra->gavp;

BEGIN GAVP_ATTRS;

}

<GAVP_ATTRS>{name_attr} { ATTR_STR(yyextra->gavp->name); }

<IN_AVP>{enum_start} {

D(("enum_start\n"));

yyextra->enumitem = g_new(ddict_enum_t,1);

yyextra->enumitem->name = NULL;

yyextra->enumitem->code = 0;

yyextra->enumitem->next = NULL;

if (!yyextra->avp->enums)

yyextra->last_enumitem = yyextra->avp->enums = yyextra->enumitem;

else

yyextra->last_enumitem = yyextra->last_enumitem->next = yyextra->enumitem;

BEGIN ENUM_ATTRS;

}

<ENUM_ATTRS>{name_attr} { ATTR_STR(yyextra->enumitem->name); }

<ENUM_ATTRS>{code_attr} { ATTR_UINT(yyextra->enumitem->code); }

<TYPE_ATTRS,GAVP_ATTRS,ENUM_ATTRS>{stop} { BEGIN IN_AVP; }

<TYPE_ATTRS,GAVP_ATTRS,ENUM_ATTRS>{stop_end} { BEGIN IN_AVP; }

<IN_AVP>{avp_end} { D(("avp_end\n")); BEGIN IN_APPL; }

<IN_APPL>{application_end} {

D(("application_end\n")); BEGIN IN_DICT;

}

<IN_APPL>{stop_end} {

D(("application_stop_end\n")); BEGIN IN_DICT;

}

<IN_APPL>{vendor_end} {

D(("vendor_end\n")); BEGIN IN_DICT;

}

<IN_APPL>{base_end} {

D(("base_end\n")); BEGIN IN_DICT;

}

<IN_DICT>{dictionary_end} {

yyterminate();

}

<AVP_ATTRS,ENUM_ATTRS,GAVP_ATTRS,TYPE_ATTRS,TYPEDEFN_ATTRS,VENDOR_ATTRS,APPL_ATTRS,COMMAND_ATTRS>{ignored_attr} IGNORE();

<OUTSIDE>. ;

%%

/*

* Turn diagnostics back on, so we check the code that we've written.

*/

DIAG_ON_FLEX()

static int debugging = 0;

static void ddict_debug(const char* fmt, ...) {

va_list ap;

va_start(ap, fmt);

if (debugging) vfprintf(stderr, fmt, ap);

va_end(ap);

fflush(stderr);

}

/*

* Sleazy hack to avoid unused function warnings for yy_top_state.

*/

extern void ddict_unused(yyscan_t yyscanner);

void

ddict_unused(yyscan_t yyscanner)

{

yy_top_state(yyscanner);

}

static void

append_to_buffer(const char* txt, unsigned len, DiamDict_scanner_state_t *statep)

{

if (statep->strbuf == NULL) {

statep->strbuf = (char*)g_malloc(statep->size_strbuf);

statep->read_ptr = statep->strbuf;

statep->write_ptr = statep->strbuf;

}

if (statep->len_strbuf + len >= statep->size_strbuf) {

statep->strbuf = (char*)g_realloc(statep->strbuf,statep->size_strbuf *= 2);

statep->read_ptr = statep->strbuf;

}

statep->write_ptr = statep->strbuf + statep->len_strbuf;

memcpy(statep->write_ptr, txt, len + 1);

statep->len_strbuf += len;

}

static size_t

file_input(char* buf, size_t max, yyscan_t scanner)

{

FILE *in = yyget_in(scanner);

size_t read_cnt;

read_cnt = fread(buf,1,max,in);

if ( read_cnt == max ) {

return max;

} else if (read_cnt > 0) {

return read_cnt;

} else {

return YY_NULL;

}

}

static size_t

string_input(char* buf, size_t max, yyscan_t scanner)

{

DiamDict_scanner_state_t *statep = yyget_extra(scanner);

if (statep->read_ptr >= statep->write_ptr ) {

return YY_NULL;

} else if ( statep->read_ptr + max > statep->write_ptr ) {

max = statep->write_ptr - statep->read_ptr;

}

memcpy(buf,statep->read_ptr,max);

statep->read_ptr += max;

return max;

}

/*

* If we're reading from a string, yyin is set to stdin, and we don't

* want to close that.

*/

static int

string_close(FILE *fh _U_)

{

return 0;

}

static FILE *

ddict_open(const char* system_directory, const char* filename)

{

FILE* fh;

char* fname;

if (system_directory) {

fname = ws_strdup_printf("%s" G_DIR_SEPARATOR_S "%s",

system_directory,filename);

} else {

fname = g_strdup(filename);

}

fh = ws_fopen(fname,"r");

D(("fname: %s fh: %p\n",fname,(void*)fh));

g_free(fname);

return fh;

}

ddict_t *

ddict_scan(const char* system_directory, const char* filename, int dbg)

{

DiamDict_scanner_state_t state;

FILE *in;

yyscan_t scanner;

debugging = dbg;

state.sys_dir = system_directory;

state.write_ptr = NULL;

state.read_ptr = NULL;

state.strbuf = NULL;

state.size_strbuf = 8192;

state.len_strbuf = 0;

state.dict = g_new(ddict_t,1);

state.dict->applications = NULL;

state.dict->vendors = NULL;

state.dict->cmds = NULL;

state.dict->typedefns = NULL;

state.dict->avps = NULL;

state.dict->xmlpis = NULL;

state.appl = NULL;

state.avp = NULL;

state.enumitem = NULL;

state.gavp = NULL;

state.typedefn = NULL;

state.cmd = NULL;

state.vnd = NULL;

state.xmlpi = NULL;

state.last_appl = NULL;

state.last_avp = NULL;

state.last_enumitem = NULL;

state.last_gavp = NULL;

state.last_typedefn = NULL;

state.last_cmd = NULL;

state.last_vnd = NULL;

state.last_xmlpi = NULL;

state.ents = NULL;

state.attr_str = NULL;

state.attr_uint = NULL;

/*

* Pass 1.

*

* Reads the file, does some work, and stores a modified version

* of the file contents in memory.

*/

state.current_yyinput = file_input;

state.current_close = fclose;

state.include_stack_ptr = 0;

in = ddict_open(system_directory,filename);

if (in == NULL) {

D(("unable to open %s: %s\n", filename, g_strerror(errno)));

g_free(state.dict);

return NULL;

}

if (DiamDict_lex_init(&scanner) != 0) {

/* Note: cannot be reached since memory allocation failure terminates early */

D(("Can't initialize scanner: %s\n", g_strerror(errno)));

fclose(in);

g_free(state.dict);

return NULL;

}

DiamDict_set_in(in, scanner);

/* Associate the state with the scanner */

DiamDict_set_extra(&state, scanner);

state.start_state = LOADING;

DiamDict_lex(scanner);

DiamDict_lex_destroy(scanner);

/*

* XXX - can the lexical analyzer terminate without closing

* all open input files?

*/

D(("\n---------------\n%s\n------- %u -------\n",state.strbuf,state.len_strbuf));

/*

* Pass 2.

*

* Reads the modified version of the file contents and does the

* rest of the work.

*/

state.current_yyinput = string_input;

state.current_close = string_close;

if (DiamDict_lex_init(&scanner) != 0) {

/* Note: cannot be reached since memory allocation failure terminates early */

D(("Can't initialize scanner: %s\n", g_strerror(errno)));

g_free(state.dict);

g_free(state.strbuf);

return NULL;

}

/* Associate the state with the scanner */

DiamDict_set_extra(&state, scanner);

state.start_state = OUTSIDE;

DiamDict_lex(scanner);

DiamDict_lex_destroy(scanner);

{

entity_t *e, *en;

for (e = state.ents; e; e = en) {

en = e->next;

g_free(e->name);

g_free(e->file);

g_free(e);

}

}

g_free(state.strbuf);

return state.dict;

}

void

ddict_free(ddict_t* d)

{

ddict_application_t *p, *pn;

ddict_vendor_t *v, *vn;

ddict_cmd_t *c, *cn;

ddict_typedefn_t *t, *tn;

ddict_avp_t *a, *an;

ddict_xmlpi_t *x, *xn;

#define FREE_NAMEANDOBJ(n) do { g_free(n->name); g_free(n); } while(0)

for (p = d->applications; p; p = pn ) {

pn = p->next;

FREE_NAMEANDOBJ(p);

}

for (v = d->vendors; v; v = vn) {

vn = v->next;

g_free(v->desc);

FREE_NAMEANDOBJ(v);

}

for (c = d->cmds; c; c = cn ) {

cn = c->next;

g_free(c->vendor);

FREE_NAMEANDOBJ(c);

}

for (t = d->typedefns; t; t = tn) {

tn = t->next;

g_free(t->parent);

FREE_NAMEANDOBJ(t);

}

for (a = d->avps; a; a = an) {

ddict_gavp_t* g, *gn;

ddict_enum_t* e, *en;

an = a->next;

for (g = a->gavps; g; g = gn) {

gn = g->next;

FREE_NAMEANDOBJ(g);

}

for (e = a->enums; e; e = en) {

en = e->next;

FREE_NAMEANDOBJ(e);

}

g_free(a->vendor);

g_free(a->type);

g_free(a->description);

FREE_NAMEANDOBJ(a);

}

for (x = d->xmlpis; x; x = xn) {

xn = x->next;

g_free(x->key);

g_free(x->value);

FREE_NAMEANDOBJ(x);

}

g_free(d);

}

void

ddict_print(FILE* fh, ddict_t* d)

{

ddict_application_t* p;

ddict_vendor_t* v;

ddict_cmd_t* c;

ddict_typedefn_t* t;

ddict_avp_t* a;

for (p = d->applications; p; p = p->next) {

fprintf(fh,"Application: %s[%u]:\n",

p->name ? p->name : "-",

p->code);

}

for (v = d->vendors; v; v = v->next) {

fprintf(fh,"Vendor: %s[%u]:\n",

v->name ? v->name : "-",

v->code);

}

for (c = d->cmds; c; c = c->next) {

fprintf(fh,"Command: %s[%u] \n",

c->name ? c->name : "-",

c->code);

}

for (t = d->typedefns; t; t = t->next) {

fprintf(fh,"Type: %s -> %s \n",

t->name ? t->name : "-",

t->parent ? t->parent : "" );

}

for (a = d->avps; a; a = a->next) {

ddict_gavp_t* g;

ddict_enum_t* e;

fprintf(fh,"AVP: %s[%u:%s] %s %s\n",

a->name ? a->name : "-",

a->code,

a->vendor ? a->vendor : "None",

a->type ? a->type : "-",

a->description ? a->description : "");

for (g = a->gavps; g; g = g->next) {

fprintf(fh,"\tGAVP: %s\n",

g->name ? g->name : "-" );

}

for (e = a->enums; e; e = e->next) {

fprintf(fh,"\tEnum: %s[%u]\n",

e->name ? e->name : "-",

e->code);

}

}

}

#ifdef TEST_DIAM_DICT_STANDALONE

int

main(int argc, char** argv)

{

ddict_t* d;