path: root/epan/diam_dict.l

%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_"

%option outfile="diam_dict.c"

/*
 * 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;
	char* dname = NULL;
	char* fname;
	int i = 1;

	switch (argc) {
		case 3:
			dname = argv[i++];
		case 2:
			fname = argv[i];
			break;
		default:
			fprintf(stderr,"%s: usage [dictionary_dir] dictionary_filename\n",argv[0]);
			return 1;
	}

	d = ddict_scan(dname,fname,1);
	if (d == NULL) {
		fprintf(stderr, "Can't open dictionary\n");
		return 2;
	}

	ddict_print(stdout, d);

	return 0;
}
#endif