/*

 * parser-sming.y --

 *

 *      Syntax rules for parsing the SMIng MIB module language.

 *

 * Copyright (c) 1999 Frank Strauss, Technical University of Braunschweig.

 *

 * See the file "COPYING" for information on usage and redistribution

 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.

 *

 * @(#) $Id: parser-sming.y 7966 2008-03-27 21:25:52Z schoenw $

 */

%{

#include <config.h>

#ifdef BACKEND_SMING

#define _ISOC99_SOURCE

#include <stdio.h>

#include <errno.h>

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include <time.h>

#include <limits.h>

#include <float.h>

#if defined(_MSC_VER)

#include <malloc.h>

#endif

#ifdef HAVE_WIN_H

#include "win.h"

#endif

#include "smi.h"

#include "error.h"

#include "parser-sming.h"

#include "scanner-sming.h"

#include "data.h"

#include "check.h"

#include "util.h"

#ifdef HAVE_DMALLOC_H

#include <dmalloc.h>

#endif

/*

 * These arguments are passed to yyparse() and yylex().

 */

#define YYPARSE_PARAM parserPtr

#define YYLEX_PARAM   parserPtr

#define thisParserPtr      ((Parser *)parserPtr)

#define thisModulePtr     (((Parser *)parserPtr)->modulePtr)

/*

 * NOTE: The argument lvalp ist not really a void pointer. Unfortunately,

 * we don't know it better at this point. bison generated C code declares

 * YYSTYPE just a few lines below based on the `%union' declaration.

 */

extern int yylex(void *lvalp, Parser *parserPtr);

static char *typeIdentifier, *macroIdentifier, *identityIdentifier, 

	    *classIdentifier, *attributeIdentifier;

static char *importModulename = NULL;

static Type *typePtr = NULL;

static Macro *macroPtr = NULL;

static Identity *identityPtr = NULL;

static Class	*classPtr = NULL;

static Attribute *attributePtr = NULL;

static Event *eventPtr = NULL;

static SmiBasetype defaultBasetype = SMI_BASETYPE_UNKNOWN;

static NamedNumber *namedNumberPtr = NULL;

static int bitsFlag = 0; /* used to differentiate bits definition from enum*/

static int attributeFlag = 0; /* 

							   *Used to differentiate between attribute and

							   *and typedef to tie the type statement

							   *respectively to class or module.

							   */

#define SMI_EPOCH	631152000	/* 01 Jan 1990 00:00:00 */ 

static Type *

findType(char *spec, Parser *parserPtr, Module *modulePtr)

{

    Type *typePtr;

    Import *importPtr;

    char *module, *type;

    type = strstr(spec, "::");

    if (!type) {

	typePtr = findTypeByModuleAndName(modulePtr, spec);

	if (!typePtr) {

	    importPtr = findImportByName(spec, modulePtr);

	    if (importPtr) {

		typePtr = findTypeByModulenameAndName(importPtr->export.module,

						      spec);

	    }

	}

    } else {

	module = strtok(spec, ":");

	type = &type[2];

	typePtr = findTypeByModulenameAndName(module, type);

    }

    return typePtr;

}

static Identity *

findIdentity(char *spec, Parser *parserPtr, Module *modulePtr)

{

    Identity *identityPtr;

    Import *importPtr;

    char *module, *identity;

    identity = strstr(spec, "::");

    if (!identity) {

	identityPtr = findIdentityByModuleAndName(modulePtr, spec);

	if (!identityPtr) {

	    importPtr = findImportByName(spec, modulePtr);

	    if (importPtr) {

		identityPtr = findIdentityByModulenameAndName(importPtr->export.module,

						      spec);

	    }

	}

    } else {

	module = strtok(spec, ":");

	identity = &identity[2];

	identityPtr = findIdentityByModulenameAndName(module, identity);

    }

    return identityPtr;

}

static Class *

findClass(char *spec, Parser *parserPtr, Module *modulePtr)

{

    Class *classPtr;

    Import *importPtr;

    char *module, *class;

    class = strstr(spec, "::");

    if (!class) {

	classPtr = findClassByModuleAndName(modulePtr, spec);

	if (!classPtr) {

	    importPtr = findImportByName(spec, modulePtr);

	    if (importPtr) {

		classPtr = findClassByModulenameAndName(importPtr->export.module,

						      spec);

	    }

	}

    } else {

	module = strtok(spec, ":");

	class = &class[2];

	classPtr = findClassByModulenameAndName(module, class);

    }

    return classPtr;

}

static void

checkTypes(Parser *parserPtr, Module *modulePtr)

{

    Type *typePtr;

    for(typePtr = modulePtr->firstTypePtr;

	typePtr; typePtr = typePtr->nextPtr) {

	/*

	 * Complain about empty description clauses.

	 */

	if (! parserPtr->flags & SMI_FLAG_NODESCR

	    && (! typePtr->export.description

		|| ! typePtr->export.description[0])) {

	    smiPrintErrorAtLine(parserPtr, ERR_EMPTY_DESCRIPTION,

				typePtr->line, typePtr->export.name);

	}

	smiCheckNamedNumberRedefinition(parserPtr, typePtr);

	smiCheckNamedNumberSubtyping(parserPtr, typePtr);

    }

}

static time_t

checkDate(Parser *parserPtr, char *date)

{

    struct tm	tm;

    time_t	anytime;

    int		i, len;

    char	*p;

    memset(&tm, 0, sizeof(tm));

    anytime = 0;

    len = strlen(date);

    if (len == 10 || len == 16) {

	for (i = 0; i < len; i++) {

	    if (((i < 4 || i == 5 || i == 6 || i == 8 || i == 9 || i == 11

		  || i == 12 || i == 14 || i == 15) && ! isdigit((int)date[i]))

		|| ((i == 4 || i == 7) && date[i] != '-')

		|| (i == 10 && date[i] != ' ')

		|| (i == 13 && date[i] != ':')) {

		smiPrintError(parserPtr, ERR_DATE_CHARACTER, date);

		anytime = (time_t) -1;

		break;

	    }

	}

    } else {

	smiPrintError(parserPtr, ERR_DATE_LENGTH, date);

	anytime = (time_t) -1;

    }

    if (anytime == 0) {

	for (i = 0, p = date, tm.tm_year = 0; i < 4; i++, p++) {

	    tm.tm_year = tm.tm_year * 10 + (*p - '0');

	}

	p++;

	tm.tm_mon = (p[0]-'0') * 10 + (p[1]-'0');

	p += 3;

	tm.tm_mday = (p[0]-'0') * 10 + (p[1]-'0');

	p += 2;

	if (len == 16) {

	    p++;

	    tm.tm_hour = (p[0]-'0') * 10 + (p[1]-'0');

	    p += 3;

	    tm.tm_min = (p[0]-'0') * 10 + (p[1]-'0');

	}

	if (tm.tm_mon < 1 || tm.tm_mon > 12) {

	    smiPrintError(parserPtr, ERR_DATE_MONTH, date);

	}

	if (tm.tm_mday < 1 || tm.tm_mday > 31) {

	    smiPrintError(parserPtr, ERR_DATE_DAY, date);

	}

	if (tm.tm_hour < 0 || tm.tm_hour > 23) {

	    smiPrintError(parserPtr, ERR_DATE_HOUR, date);

	}

	if (tm.tm_min < 0 || tm.tm_min > 59) {

	    smiPrintError(parserPtr, ERR_DATE_MINUTES, date);

	}

	tm.tm_year -= 1900;

	tm.tm_mon -= 1;

	tm.tm_isdst = 0;

	anytime = timegm(&tm;;

	if (anytime == (time_t) -1) {

	    smiPrintError(parserPtr, ERR_DATE_VALUE, date);

	} else {

	    if (anytime < SMI_EPOCH) {

		smiPrintError(parserPtr, ERR_DATE_IN_PAST, date);

	    }

	    if (anytime > time(NULL)) {

		smiPrintError(parserPtr, ERR_DATE_IN_FUTURE, date);

	    }

	}

    }

    return (anytime == (time_t) -1) ? 0 : anytime;

}

static char *hexToStr(char *hexStr, int len)

{

   union{

   	char ch;

   	long l;

   } hex2char;

   char* res =(char*)malloc(sizeof(char)*len/2+1);

   char* tmp =(char*)malloc(sizeof(char)*3);

   int i,j = 0;

   tmp[2]=0;

   for(i=2; i+1

   {

   	tmp[0]= hexStr[i];

   	tmp[1]= hexStr[i+1];

   	hex2char.l = strtol(tmp,NULL,16);

   	res[j] = hex2char.ch;

   	j++;

   }

   smiFree(tmp);

   res[j]=0;

   return res;

}

static void createBitsValue(SmiValue *valuePtr, Type *typePtr)

{

    List *bitsListPtr, *valueListPtr, *p, *pp, *nextPtr;

    int nBits, bit;

    if (valuePtr->basetype != SMI_BASETYPE_BITS)

	return;

	bitsListPtr = typePtr->listPtr;

	valueListPtr = (void *)valuePtr->value.ptr;

	for (nBits = 0, p = bitsListPtr; p; p = p->nextPtr) {

	    if (nBits < 1+((NamedNumber *)(p->ptr))->export.value.value.unsigned64) {

		nBits = 1+((NamedNumber *)(p->ptr))->export.value.value.unsigned64;

	    }

	}

	valuePtr->value.ptr = smiMalloc((nBits+7)/8);

	memset(valuePtr->value.ptr, 0, (nBits+7)/8);

	valuePtr->len = (nBits+7)/8;

	for (p = valueListPtr; p;) {

	    for (pp = bitsListPtr; pp; pp = pp->nextPtr) {

		if (!strcmp(p->ptr,

			    ((NamedNumber *)(pp->ptr))->export.name)) {

		    bit = (int)(((NamedNumber *)(pp->ptr))->export.value.value.unsigned64);

		    valuePtr->value.ptr[bit/8] |=

			1 << (7-(bit%8));

		}

	    }

	    smiFree(p->ptr);

	    nextPtr = p->nextPtr;

	    smiFree(p);

	    p = nextPtr;

	}

}

%}

/*

 * The grammars start symbol.

 */

%start smingFile

/*

 * We call the parser from within the parser when IMPORTing modules,

 * hence we need reentrant parser code. This is a bison feature.

 */

%pure_parser

/*

 * The attributes.

 */

%union {

    char           *id;				/* identifier name           */

    int            rc;				/* >=0: ok, <0: error        */

    time_t	   date;			/* a date value		     */

    char	   *text;

    Module	   *modulePtr;

    Node	   *nodePtr;

    Object	   *objectPtr;

    Identity   *identityPtr;

    Macro	   *macroPtr;

    Type	   *typePtr;

    Class	   *classPtr;

    Attribute  *attributePtr;

    Event	   *eventPtr;

    Index	   index;

    Option	   *optionPtr;

    Refinement	   *refinementPtr;

    SmiStatus	   status;

    SmiAccess	   access;

    NamedNumber    *namedNumberPtr;

    Range	   *rangePtr;

    SmiValue	   *valuePtr;

    List	   *listPtr;

    Revision	   *revisionPtr;

}

/*

 * Tokens and their attributes.

 */

%token DOT

%token DOT_DOT

%token COLON_COLON

%token <text>ucIdentifier

%token <text>lcIdentifier

%token <text>floatValue

%token <text>textSegment

%token <text>decimalNumber

%token <text>hexadecimalNumber

%token <text>OID

%token <rc>moduleKeyword

%token <rc>importKeyword

%token <rc>revisionKeyword

%token <rc>identityKeyword

%token <rc>oidKeyword

%token <rc>dateKeyword

%token <rc>organizationKeyword

%token <rc>contactKeyword

%token <rc>descriptionKeyword

%token <rc>referenceKeyword

%token <rc>extensionKeyword

%token <rc>typedefKeyword

%token <rc>typeKeyword

%token <rc>formatKeyword

%token <rc>unitsKeyword

%token <rc>statusKeyword

%token <rc>accessKeyword

%token <rc>defaultKeyword

%token <rc>impliedKeyword

%token <rc>indexKeyword

%token <rc>augmentsKeyword

%token <rc>reordersKeyword

%token <rc>sparseKeyword

%token <rc>expandsKeyword

%token <rc>createKeyword

%token <rc>membersKeyword

%token <rc>objectsKeyword

%token <rc>mandatoryKeyword

%token <rc>optionalKeyword

%token <rc>refineKeyword

%token <rc>abnfKeyword

%token <rc>OctetStringKeyword

%token <rc>ObjectIdentifierKeyword

%token <rc>Integer32Keyword

%token <rc>Unsigned32Keyword

%token <rc>Integer64Keyword

%token <rc>Unsigned64Keyword

%token <rc>Float32Keyword

%token <rc>Float64Keyword

%token <rc>Float128Keyword

%token <rc>BitsKeyword

%token <rc>EnumerationKeyword

%token <rc>currentKeyword

%token <rc>deprecatedKeyword

%token <rc>obsoleteKeyword

%token <rc>readonlyKeyword

%token <rc>readwriteKeyword

%token <rc>parentKeyword

%token <rc>classKeyword

%token <rc>extendsKeyword

%token <rc>attributeKeyword

%token <rc>uniqueKeyword

%token <rc>eventKeyword

%token <rc>PointerKeyword

%token <rc>eventonlyKeyword

%token <rc>neginfKeyword

%token <rc>posinfKeyword

%token <rc>snanKeyword

%token <rc>qnanKeyword

/*

 * Types of non-terminal symbols.

 */

%type <rc>smingFile

%type <rc>moduleStatement_optsep_0n

%type <rc>moduleStatement_optsep_1n

%type <rc>moduleStatement_optsep

%type <modulePtr>moduleStatement

%type <rc>extensionStatement_stmtsep_0n

%type <rc>extensionStatement_stmtsep_1n

%type <rc>extensionStatement_stmtsep

%type <macroPtr>extensionStatement

%type <rc>identityStatement_stmtsep_0n

%type <rc>identityStatement_stmtsep_1n

%type <rc>identityStatement_stmtsep

%type <identityPtr>identityStatement

%type <identityPtr>parentStatement_stmtsep_01

%type <identityPtr>parentStatement

%type <rc>typedefStatement_stmtsep_0n

%type <rc>typedefStatement_stmtsep_1n

%type <rc>typedefStatement_stmtsep

%type <typePtr>typedefStatement

%type <rc>attributeStatement_stmtsep_0n

%type <rc>attributeStatement_stmtsep_1n

%type <rc>attributeStatement_stmtsep

%type <attributePtr>attributeStatement

%type <rc>eventStatement_stmtsep_0n

%type <rc>eventStatement_stmtsep_1n

%type <rc>eventStatement_stmtsep

%type <eventPtr>eventStatement

%type <rc>classStatement_stmtsep_0n

%type <rc>classStatement_stmtsep_1n

%type <rc>classStatement_stmtsep

%type <classPtr>classStatement

%type <classPtr>extendsStatement_stmtsep_01

%type <classPtr>extendsStatement

%type <rc>importStatement_stmtsep_0n

%type <rc>importStatement_stmtsep_1n

%type <rc>importStatement_stmtsep

%type <listPtr>importStatement

%type <rc>revisionStatement_stmtsep_0n

%type <rc>revisionStatement_stmtsep_1n

%type <rc>revisionStatement_stmtsep

%type <revisionPtr>revisionStatement

%type <typePtr>typedefTypeStatement

%type <attributePtr>attributeTypeStatement

%type <date>dateStatement

%type <text>organizationStatement

%type <text>contactStatement

%type <text>formatStatement_stmtsep_01

%type <text>formatStatement

%type <text>unitsStatement_stmtsep_01

%type <text>unitsStatement

%type <status>statusStatement_stmtsep_01

%type <status>statusStatement

%type <valuePtr>defaultStatement_stmtsep_01

%type <valuePtr>defaultStatement

%type <access>accessStatement_stmtsep_01

%type <access>accessStatement

%type <access>access

%type <text>descriptionStatement_stmtsep_01

%type <text>descriptionStatement

%type <text>referenceStatement_stmtsep_01

%type <text>referenceStatement

%type <text>abnfStatement_stmtsep_01

%type <text>abnfStatement

%type <typePtr>refinedBaseType_refinedType

%type <typePtr>refinedBaseType

%type <typePtr>refinedType

%type <attributePtr>attribute_refinedBaseType_refinedType

%type <attributePtr>attribute_refinedBaseType

%type <attributePtr>attribute_refinedType

%type <listPtr>optsep_anySpec_01

%type <listPtr>anySpec

%type <listPtr>optsep_numberSpec_01

%type <listPtr>numberSpec

%type <listPtr>furtherNumberElement_0n

%type <listPtr>furtherNumberElement_1n

%type <rangePtr>furtherNumberElement

%type <rangePtr>numberElement

%type <valuePtr>numberUpperLimit_01

%type <valuePtr>numberUpperLimit

%type <listPtr>optsep_floatSpec_01

%type <listPtr>floatSpec

%type <listPtr>furtherFloatElement_0n

%type <listPtr>furtherFloatElement_1n

%type <rangePtr>furtherFloatElement

%type <rangePtr>floatElement

%type <text>floatUpperLimit_01

%type <text>floatUpperLimit

%type <text>specialFloatValue

%type <listPtr>optsep_pointerRestr_01

%type <text>pointerRestr

%type <listPtr>bitsOrEnumerationSpec

%type <listPtr>bitsOrEnumerationList

%type <listPtr>furtherBitsOrEnumerationItem_0n

%type <listPtr>furtherBitsOrEnumerationItem_1n

%type <namedNumberPtr>furtherBitsOrEnumerationItem

%type <namedNumberPtr>bitsOrEnumerationItem

%type <listPtr>identifierList

%type <listPtr>furtherIdentifier_0n

%type <listPtr>furtherIdentifier_1n

%type <text>furtherIdentifier

%type <listPtr>uniqueStatement_stmtsep_01

%type <listPtr>uniqueStatement

%type <listPtr>uniqueSpec

%type <listPtr>bitsValue

%type <listPtr>bitsList

%type <listPtr>furtherLcIdentifier_0n

%type <listPtr>furtherLcIdentifier_1n

%type <text>furtherLcIdentifier

%type <text>identifier

%type <text>qucIdentifier

%type <text>qlcIdentifier

%type <text>text

%type <text>optsep_textSegment_0n

%type <text>optsep_textSegment_1n

%type <text>optsep_textSegment

%type <date>date

%type <text>format

%type <text>units

%type <valuePtr>anyValue

%type <status>status

%type <valuePtr>number

%type <valuePtr>negativeNumber

%type <valuePtr>signedNumber

%type <rc>optsep_comma_01

%type <rc>sep

%type <rc>optsep

%type <rc>stmtsep

%type <text>qOID

%%

/*

 * Yacc rules.

 *

 */

/*

 * One mibFile may contain multiple MIB modules.

 * It's also possible that there's no module in a file.

 */

smingFile:		optsep moduleStatement_optsep_0n

			{

			    /*

			     * Return the number of successfully

			     * parsed modules.

			     */

			    $$ = $2;

			}

	;

moduleStatement_optsep_0n:	/* empty */

			{

			    $$ = 0;

			}

	|		moduleStatement_optsep_1n

			{

			    $$ = $1;

			}

	;

moduleStatement_optsep_1n:	moduleStatement_optsep

			{

			    $$ = $1;

			}

	|		moduleStatement_optsep_1n moduleStatement_optsep

			{

			    /*

			     * Sum up the number of successfully parsed

			     * modules or return -1, if at least one

			     * module failed.

			     */

			    if (($1 >= 0) && ($2 >= 0)) {

				$$ = $1 + $2;

			    } else {

				$$ = -1;

			    }

			}

        ;

moduleStatement_optsep:	moduleStatement optsep

			{

			    /*

			     * If we got a (Module *) return rc == 1,

			     * otherwise parsing failed (rc == -1).

			     */

			    if ($1 != NULL) {

				$$ = 1;

			    } else {

				$$ = -1;

			    }

			}

        ;

moduleStatement:	moduleKeyword sep ucIdentifier

			{

			    thisParserPtr->modulePtr = findModuleByName($3);

			    if (!thisParserPtr->modulePtr) {

				thisParserPtr->modulePtr =

				    addModule($3,

					      smiStrdup(thisParserPtr->path),

					      0,

					      thisParserPtr);

			    } else {

			        smiPrintError(thisParserPtr,

					      ERR_MODULE_ALREADY_LOADED,

					      $3);

				free($3);

				/*

				 * this aborts parsing the whole file,

				 * not only the current module.

				 */

				YYABORT;

			    }

			    thisModulePtr->export.language = SMI_LANGUAGE_SMING;

			    thisParserPtr->modulePtr->numImportedIdentifiers

				                                           = 0;

			    thisParserPtr->modulePtr->numStatements = 0;

			    thisParserPtr->modulePtr->numModuleIdentities = 0;

			    thisParserPtr->firstIndexlabelPtr = NULL;

			    thisParserPtr->identityObjectName = NULL;

			}

			optsep '{' stmtsep

			importStatement_stmtsep_0n

			organizationStatement stmtsep

			{

			    if ($9) {

				setModuleOrganization(thisParserPtr->modulePtr,

						      $9);

			    }

			}

			contactStatement stmtsep

			{

			    if ($12) {

				setModuleContactInfo(thisParserPtr->modulePtr,

						     $12);

			    }

			}

			descriptionStatement stmtsep

			{

			    if ($15) {

				setModuleDescription(thisParserPtr->modulePtr,

						     $15, thisParserPtr);

			    }

			}

			referenceStatement_stmtsep_01

			{

			    if ($18) {

				setModuleReference(thisParserPtr->modulePtr,

						   $18, thisParserPtr);

			    }

			}

			revisionStatement_stmtsep_0n

			extensionStatement_stmtsep_0n

			identityStatement_stmtsep_0n

			typedefStatement_stmtsep_0n

			classStatement_stmtsep_0n			

			'}' optsep ';'

			{

			    checkTypes(thisParserPtr, thisModulePtr);

			    $$ = thisModulePtr;

			}

	;

extensionStatement_stmtsep_0n: /* empty */

			{

			    $$ = 0;

			}

        |		extensionStatement_stmtsep_1n

			{

			    /*

			     * Return the number of successfully

			     * parsed extension statements.

			     */

			    $$ = $1;

			}

	;

extensionStatement_stmtsep_1n: extensionStatement_stmtsep

			{

			    $$ = $1;

			}

        |		extensionStatement_stmtsep_1n

			extensionStatement_stmtsep

			{

			    /*

			     * Sum up the number of successfully parsed

			     * extensions or return -1, if at least one

			     * failed.

			     */

			    if (($1 >= 0) && ($2 >= 0)) {

				$$ = $1 + $2;

			    } else {

				$$ = -1;

			    }

			}

        ;

extensionStatement_stmtsep: extensionStatement stmtsep

			{

			    /*

			     * If we got a (Type *) return rc == 1,

			     * otherwise parsing failed (rc == -1).

			     */

			    if ($1) {

				$$ = 1;

			    } else {

				$$ = -1;

			    }

			}

        ;

extensionStatement:	extensionKeyword sep lcIdentifier

			{

			    macroIdentifier = $3;

			    macroPtr = addMacro(macroIdentifier,

						0,

						thisParserPtr);

			    setMacroDecl(macroPtr, SMI_DECL_EXTENSION);

			}

			optsep '{' stmtsep

			statusStatement_stmtsep_01

			{

			    if (macroPtr && $8) {

				setMacroStatus(macroPtr, $8);

			    }

			}

			descriptionStatement_stmtsep_01

			{

			    if (macroPtr && $10) {

				setMacroDescription(macroPtr, $10,

						    thisParserPtr);

			    }

			}

			referenceStatement_stmtsep_01

			{

			    if (macroPtr && $12) {

				setMacroReference(macroPtr, $12,

						  thisParserPtr);

			    }

			}

			abnfStatement_stmtsep_01

			{

			   if (macroPtr && $14) {

				setMacroAbnf(macroPtr, $14,

						  thisParserPtr);

			   }

			}

			'}' optsep ';'

			{

			    $$ = 0;

			    macroPtr = NULL;

			}

	;

typedefStatement_stmtsep_0n: /* empty */

			{

			    $$ = 0;

			}

        |		typedefStatement_stmtsep_1n

			{

			    /*

			     * Return the number of successfully

			     * parsed typedef statements.

			     */

			    $$ = $1;

			}

	;

typedefStatement_stmtsep_1n: typedefStatement_stmtsep

			{

			    $$ = $1;

			}

        |		typedefStatement_stmtsep_1n

			typedefStatement_stmtsep

			{

			    /*

			     * Sum up the number of successfully parsed

			     * typedefs or return -1, if at least one

			     * failed.

			     */

			    if (($1 >= 0) && ($2 >= 0)) {

				$$ = $1 + $2;

			    } else {

				$$ = -1;

			    }

			}

        ;

typedefStatement_stmtsep: typedefStatement stmtsep

			{

			    /*

			     * If we got a (Type *) return rc == 1,

			     * otherwise parsing failed (rc == -1).

			     */

			    if ($1) {

				$$ = 1;

			    } else {

				$$ = -1;

			    }

			}

        ;

typedefStatement:	typedefKeyword sep ucIdentifier

			{

			    typeIdentifier = $3;

			    /* 

			     *check for duplicate names in the module 

			     */

			    if(typePtr =