/*
*******************************************************************************
*
*   Copyright (C) 1998-2000, International Business Machines
*   Corporation and others.  All Rights Reserved.
*
*******************************************************************************
*
* File parse.c
*
* Modification History:
*
*   Date        Name        Description
*   05/26/99    stephen     Creation.
*   02/25/00    weiv        Overhaul to write udata
*******************************************************************************
*/

#include "parse.h"
#include "error.h"
#include "uhash.h"
#include "cmemory.h"
#include "read.h"
#include "unicode/ustdio.h"
#include "ustr.h"
#include "reslist.h"
#include "unicode/ustring.h"
#include "unicode/ucol.h"

U_CAPI const UChar * U_EXPORT2 ucol_getDefaultRulesArray(uint32_t *size);

U_STRING_DECL(k_start_string, "string", 6);
U_STRING_DECL(k_start_binary, "binary", 6);
U_STRING_DECL(k_start_table, "table", 5);
U_STRING_DECL(k_start_int, "int", 3);
U_STRING_DECL(k_start_array, "array", 5);
U_STRING_DECL(k_start_intvector, "intvector", 9);
U_STRING_DECL(k_start_reserved, "reserved", 8);
U_STRING_DECL(rootName, "root", 4);

static UBool didInit=FALSE;
static UBool didInitRoot=FALSE;

/* Node IDs for the state transition table. */
enum ENode {
  eError,
  eInitial,   /* Next: Locale name */
  eGotLoc,    /* Next: { */
  eIdle,      /* Next: Tag name | } */
  eGotTag,    /* Next: { | : */
  eNode5,     /* Next: Data | Subtag */
  eNode6,     /* Next: } | { | , */
  eList,      /* Next: List data */
  eNode8,     /* Next: , */
  eTagList,   /* Next: Subtag data */
  eNode10,    /* Next: } */
  eNode11,    /* Next: Subtag */
  eNode12,    /* Next: { */
  e2dArray,   /* Next: Data | } */
  eNode14,    /* Next: , | } */
  eNode15,    /* Next: , | } */
  eNode16,     /* Next: { | } */
  eTypeStart, /* Next: Type name */
  eGotType	  /* Next: { */
};

/* Action codes for the state transtiion table. */
enum EAction {
  /* Generic actions */
  eNOP       = 0x0100, /* Do nothing */
  eOpen      = 0x0200, /* Open a new locale data block with the data
			  string as the locale name */
  eClose     = 0x0300, /* Close a locale data block */
  eSetTag    = 0x0400, /* Record the last string as the tag name */
  
  /* Comma-delimited lists */
  eBegList   = 0x1100, /* Start a new string list with the last string
			  as the first element */
  eEndList   = 0x1200, /* Close a string list being built */
  eListStr   = 0x1300, /* Record the last string as a data string and
			  increment the index */
  eStr       = 0x1400, /* Record the last string as a singleton string */
  
  /* 2-d lists */
  eBeg2dList = 0x2100, /* Start a new 2d string list with no elements as yet */
  eEnd2dList = 0x2200, /* Close a 2d string list being built */
  e2dStr     = 0x2300, /* Record the last string as a 2d string */
  eNewRow    = 0x2400, /* Start a new row */
  
  /* Tagged lists */
  eBegTagged = 0x3100, /* Start a new tagged list with the last
			  string as the first subtag */
  eEndTagged = 0x3200, /* Close a tagged list being build */
  eSubtag    = 0x3300, /* Record the last string as the subtag */
  eTaggedStr = 0x3400,  /* Record the last string as a tagged string */

  /* Type support */
  eBegType = 0x4100, /* Start getting a type */
  eSetType = 0x4200 /* Record and init type */
};

/* A struct which encapsulates a node ID and an action. */
struct STransition {
  enum ENode fNext;
  enum EAction fAction;
};

/* This table describes an ATM (state machine) which parses resource
   bundle text files rather strictly. Each row represents a node. The
   columns of that row represent transitions into other nodes. Most
   transitions are "eError" because most transitions are
   disallowed. For example, if the parser has just seen a tag name, it
   enters node 4 ("eGotTag"). The state table then marks only one
   valid transition, which is into node 5, upon seeing an eOpenBrace
   token. We allow an extra comma after the last element in a
   comma-delimited list (transition from eList to eIdle on
   kCloseBrace). */
static struct STransition gTransitionTable [] = {
  /*                kString           kOpenBrace            kCloseBrace         kComma            
  /*eError*/    {eError,eNOP},       {eError,eNOP},        {eError,eNOP},      {eError,eNOP},	
  
  /*eInitial*/  {eGotLoc,eOpen},     {eError,eNOP},        {eError,eNOP},      {eError,eNOP},	
  /*eGotLoc*/   {eError,eNOP},       {eIdle,eNOP},         {eError,eNOP},      {eError,eNOP},	
 
  /*eIdle*/     {eGotTag,eSetTag},   {eError,eNOP},        {eInitial,eClose},  {eError,eNOP},	
  /*eGotTag*/   {eError,eNOP},       {eNode5,eNOP},        {eError,eNOP},      {eError,eNOP},	
  /*eNode5*/    {eNode6,eNOP},       {e2dArray,eBeg2dList},{eError,eNOP},      {eError,eNOP},	
  /*eNode6*/    {eError,eNOP},       {eTagList,eBegTagged},{eIdle,eStr},       {eList,eBegList},
  
  /*eList*/     {eNode8,eListStr},   {eError,eNOP},         {eIdle,eEndList},  {eError,eNOP},	
  /*eNode8*/    {eError,eNOP},       {eError,eNOP},         {eIdle,eEndList},  {eList,eNOP},	
 
  /*eTagList*/  {eNode10,eTaggedStr},{eError,eNOP},         {eError,eNOP},     {eError,eNOP},	
  /*eNode10*/   {eError,eNOP},       {eError,eNOP},         {eNode11,eNOP},    {eError,eNOP},	
  /*eNode11*/   {eNode12,eNOP},      {eError,eNOP},         {eIdle,eEndTagged},{eError,eNOP},	
  /*eNode12*/   {eError,eNOP},       {eTagList,eSubtag},    {eError,eNOP},     {eError,eNOP},	

  /*e2dArray*/  {eNode14,e2dStr},    {eError,eNOP},         {eNode15,eNOP},    {eError,eNOP},	
  /*eNode14*/   {eError,eNOP},       {eError,eNOP},         {eNode15,eNOP},    {e2dArray,eNOP},	
  /*eNode15*/   {eError,eNOP},       {e2dArray,eNewRow},    {eIdle,eEnd2dList},{eNode16,eNOP},	
  /*eNode16*/   {eError,eNOP},       {e2dArray,eNewRow},    {eIdle,eEnd2dList},{eError,eNOP},	
  /*eTypeStart*/{eGotType,eSetType}, {eError,eNOP},         {eError,eNOP},     {eError,eNOP},	
  /*eGotType*/	{eError,eNOP},       {eError,eNOP},         {eError,eNOP},     {eError,eNOP}	
};

/* Row length is 4 */
#define GETTRANSITION(row,col) (gTransitionTable[col + (row<<2)])
/* Not anymore, it is 5 now */
/*#define GETTRANSITION(row,col) (gTransitionTable[col + (row*5)])*/

/*********************************************************************
 * Hashtable glue
 ********************************************************************/

static UBool get(UHashtable *hash, const struct UString* tag) {
    return uhash_get(hash, tag) != NULL;
}

static void put(UHashtable *hash, const struct UString *tag,
                UErrorCode* status) {
    struct UString* key = uprv_malloc(sizeof(struct UString));
    ustr_init(key);
    ustr_cpy(key, tag, status);
    uhash_put(hash, key, (void*)1, status);
}

static void freeUString(void* ustr) {
    ustr_deinit(ustr);
    uprv_free(ustr);
}

static int32_t hashUString(const void* ustr) {
    return uhash_hashUChars(((struct UString*)ustr)->fChars);
}

static UBool compareUString(const void* ustr1, const void* ustr2) {
    return uhash_compareUChars(((struct UString*)ustr1)->fChars,
                               ((struct UString*)ustr2)->fChars);
}

char *getModificationData(struct UFILE *file, UErrorCode *status) {
  enum ETokenType modType;
  struct UString modToken;
  char *retValue = NULL;
  ustr_init(&modToken);
  modType = getNextToken(file, &modToken, status);
  if(U_SUCCESS(*status) && modType == tok_open_brace) {
    modType = getNextToken(file, &modToken, status);
    if(U_SUCCESS(*status) && modType == tok_string) {
      retValue = uprv_malloc(u_strlen(modToken.fChars)+1);
      u_UCharsToChars(modToken.fChars, retValue, u_strlen(modToken.fChars)+1);
      modType = getNextToken(file, &modToken, status);
      if(U_SUCCESS(*status) && modType == tok_close_brace) {
	return retValue;
      } else {
	uprv_free(retValue);
      }
    }
  } 
  setErrorText("Invalid modificator directive");
  *status = U_INVALID_FORMAT_ERROR;
  return NULL;
}

/*********************************************************************
 * parse
 ********************************************************************/
int32_t lineCount = 0;
char lastTag[200] = "";

struct SRBRoot*
parse(FileStream *f, const char *cp, const char *inputDir,
      UErrorCode *status)
{
  struct UFILE *file;
  enum ETokenType type;
  enum ENode node;
  struct STransition t;

  struct UString token;
  struct UString tag;

    char cTag[1024];
    char cSubTag[1024];
    struct SRBRoot *bundle = NULL;
    struct SResource *rootTable = NULL;
    struct SResource *temp = NULL;
    struct SResource *temp1 = NULL;
    struct SResource *temp2 = NULL;
    UBool colEl = FALSE, colOverride = FALSE;
    UChar trueValue[] = {0x0054, 0x0052, 0x0055, 0x0045, 0x0000}; /* Just to store "TRUE" and "FALSE" */
    UChar falseValue[] = {0x0046, 0x0041, 0x004C, 0x0053, 0x0045, 0x0000}; 

    /* Hashtable for keeping track of seen tag names */
    struct UHashtable *data;

    strcpy(lastTag, "<none>");

    if(U_FAILURE(*status)) return NULL;

    /* setup */

  ustr_init(&token);
  ustr_init(&tag);
/*  
    cTag = uprv_malloc(1024);
    if(cTag == NULL) {
        *status = U_MEMORY_ALLOCATION_ERROR;
        return NULL;
    }
    cSubTag = uprv_malloc(1024);
    if(cSubTag == NULL) {
        *status = U_MEMORY_ALLOCATION_ERROR;
        return NULL;
    }
*/

  node = eInitial;
  data = 0;

  file = u_finit((FILE *)f, 0, cp);
  lineCount = 1;
/*  file = u_finit(f, cp, status); */
  if(file == NULL) {
      setErrorText("Could not initialize input file - most probably because of wrong converter\n");
      *status = U_INVALID_FORMAT_ERROR;
      goto finish;
  }

    bundle = bundle_open(status);
    rootTable = bundle -> fRoot;

    if(U_FAILURE(*status) || file == NULL) {
        goto finish;
    }
  
  /* iterate through the stream */
  for(;;) {

    /* get next token from stream */
    type = getNextToken(file, &token, status);
    if(U_FAILURE(*status)) {
        goto finish;
    }

    switch(type) {
    case tok_EOF:
      *status = (node == eInitial) ? U_ZERO_ERROR : U_INVALID_FORMAT_ERROR;
      if(U_FAILURE(*status)) {
        setErrorText("Unexpected EOF encountered");
      }
      goto finish;
      /*break;*/

    case tok_error:
      *status = U_INVALID_FORMAT_ERROR;
      goto finish;
      /*break;*/
      
    default:
      break;
    }
    
    t = GETTRANSITION(node, type);
    node = t.fNext;
    
    if(node == eError) {
        *status = U_INVALID_FORMAT_ERROR;
        goto finish;
    }
    
    switch(t.fAction) {
    case eNOP:
        break;
      
      /* Record the last string as the tag name */
    case eSetTag:
        ustr_cpy(&tag, &token, status);
        u_UCharsToChars(tag.fChars, cTag, u_strlen(tag.fChars)+1);
        if(U_FAILURE(*status)) {
            goto finish;
        }
         strcpy(lastTag, cTag);
       /*  fprintf(stderr, "%d: %s\n", lineCount,  lastTag); //[prints all tags]
        */

      if(get(data, &tag)) {
	  char *s;
	  *status = U_INVALID_FORMAT_ERROR;
	  s = uprv_malloc(1024);
	  strcpy(s, "Duplicate tag name detected: ");
	  u_austrcpy(s+strlen(s), tag.fChars);
	  setErrorText(s);
	  goto finish;
        }
	{
	  char *modificator = NULL;
	  if((modificator = uprv_strchr(cTag, ':'))!=NULL) {
	    /* type modificator - do the type modification*/
	    *modificator = '\0';
	    ustr_deinit(&tag);
	    ustr_setlen(&tag, uprv_strlen(cTag), status);
	    u_charsToUChars(cTag, tag.fChars, uprv_strlen(cTag));
	    /* we need to test whether we have the same name, different type here */
	    if(get(data, &tag)) {
	      char *s;
	      *status = U_INVALID_FORMAT_ERROR;
	      s = uprv_malloc(1024);
	      strcpy(s, "Duplicate tag name detected: ");
	      u_austrcpy(s+strlen(s), tag.fChars);
	      setErrorText(s);
	      goto finish;
	    }
	    modificator++;
	    /* including streams of binary data */
	    if(uprv_strcmp(modificator, "bin") == 0) {
	      char *binaryValue;
	      char toConv[3];
	      uint32_t i = 0, bytesConverted = 0;
	      uint8_t val = 0;
	      uint8_t *newValue;
	      fprintf(stderr, "bin\n");
	      binaryValue = getModificationData(file, status);
	      if(U_SUCCESS(*status) && binaryValue != NULL) {
		/* do the parsing & outputing of the data */
		fprintf(stderr, "Will parse binary value  %s and store it in tag: %s\n", binaryValue, cTag);
		newValue = uprv_malloc(sizeof(uint8_t)*uprv_strlen(binaryValue));
		for(i = 0; i<uprv_strlen(binaryValue); i+=2) {
		  toConv[0] = *(binaryValue+i);
		  toConv[1] = *(binaryValue+i+1);
		  toConv[2] = '\0';
		  val = (uint8_t)uprv_strtoul(toConv, NULL, 16);
		  newValue[bytesConverted] = val;
		  bytesConverted++;
		}
		temp1 = bin_open(bundle, cTag, bytesConverted, newValue, status);
		table_add(rootTable, temp1, status);
		  
		uprv_free(newValue);
		uprv_free(binaryValue);
		node = eIdle;
	      } else {
		if(binaryValue != NULL) {
		  uprv_free(binaryValue);
		}
		node = eError;
	      }
	    }
	    /* including integers */
	    else if(uprv_strcmp(modificator, "int") == 0) {
	      char *intValue;
	      int32_t val;
	      fprintf(stderr, "int\n");
	      intValue = getModificationData(file, status);
	      if(U_SUCCESS(*status) && intValue != NULL) {
		/* do the parsing & outputing of the data */
		fprintf(stderr, "Will parse integer value  %s and store it in tag: %s\n", intValue, cTag);
		val = uprv_strtol(intValue, NULL, 10);
		uprv_free(intValue);
		temp1 = int_open(bundle, cTag, val, status);
		fprintf(stderr, "Added integer %s, value %d -> %s\n", cTag, val,
			  u_errorName(*status) );
		table_add(rootTable, temp1, status);
		
		put(data, &tag, status);
		node = eIdle;
	      } else {
		if(intValue != NULL) {
		  uprv_free(intValue);
		}
		node = eError;
	      }
	    } 
	    /* importing a file and storing it in a binary object */
	    else if(uprv_strcmp(modificator, "import") == 0) {
	      FileStream *importFile;
	      int32_t len; 
	      uint8_t *binData;
	      char *fileName;
	      fprintf(stderr, "import\n");
	      fileName = getModificationData(file, status);
	      if(U_SUCCESS(*status) && fileName != NULL) {
		/* do the reading & outputing of the file */
		fprintf(stderr, "Will read %s and store it in tag:  %s\n", fileName, cTag);
		  /* Open the input file for reading */
		if(inputDir == NULL) {
		  importFile = T_FileStream_open(fileName, "rb");
		} else {
		  char *openFileName = NULL;
		  int32_t dirlen = uprv_strlen(inputDir);
		  int32_t filelen = uprv_strlen(fileName);
		  if(inputDir[dirlen-1] != U_FILE_SEP_CHAR) {
		    openFileName = (char *) uprv_malloc(dirlen+filelen+2);
		    uprv_strcpy(openFileName, inputDir);
		    openFileName[dirlen] = U_FILE_SEP_CHAR;
		    openFileName[dirlen+1] = '\0';
		    uprv_strcat(openFileName, fileName);
		  } else {
		    openFileName = (char *) uprv_malloc(dirlen+filelen+1);
		    uprv_strcpy(openFileName, inputDir);
		    uprv_strcat(openFileName, fileName);
		  }
		  importFile = T_FileStream_open(openFileName, "rb");
		  uprv_free(openFileName);
		}
		len = T_FileStream_size(importFile);
		binData = uprv_malloc(len);
		T_FileStream_read(importFile,binData,len);
		T_FileStream_close(importFile);
 
		temp1 = bin_open(bundle, cTag, len, binData, status);
		fprintf(stderr, "Added %s, len %d -> %s\n", cTag, len,
			  u_errorName(*status) );
		table_add(rootTable, temp1, status);
		uprv_free(binData);
		uprv_free(fileName);
		put(data, &tag, status);
		node = eIdle;
	      } else {
		if(fileName != NULL) {
		  uprv_free(fileName);
		}
		node = eError;
	      }
	    } 
	    /* array of integers, still unimplemented */
	    else if(uprv_strcmp(modificator, "intarray") == 0) {
		  fprintf(stderr, "intarray\n");
	    } 
	    /* unknown tupe - an error */
	    else {
		  fprintf(stderr, "Unknown\n");
	    }

	  } else if(uprv_strcmp(cTag, "CollationElements") == 0) {
	    colEl = TRUE;
	  } 
	}


        break;

      /* Record a singleton string */
    case eStr:
        if(temp != NULL) {
	        *status = U_INTERNAL_PROGRAM_ERROR;
	        goto finish;
        }
        temp = string_open(bundle, cTag, token.fChars, token.fLength, status);
        table_add(rootTable, temp, status);
#if 0
		if(colEl == TRUE) {
			const UChar * defaultRulesArray;
            UErrorCode intStatus = U_ZERO_ERROR;
			uint32_t defaultRulesArrayLength = 0;
			/* do the collation elements */
			int32_t len = 0;
			uint8_t *binColData = NULL;
			UCollator *coll = NULL; 
			UChar *rules = NULL;
			defaultRulesArray = ucol_getDefaultRulesArray(&defaultRulesArrayLength);
			rules = uprv_malloc(sizeof(defaultRulesArray[0])*(defaultRulesArrayLength + token.fLength));
			uprv_memcpy(rules, defaultRulesArray, defaultRulesArrayLength*sizeof(defaultRulesArray[0]));
			uprv_memcpy(rules + defaultRulesArrayLength, token.fChars, token.fLength*sizeof(token.fChars[0]));
			
			coll = ucol_openRules(rules, defaultRulesArrayLength + token.fLength, UCOL_DECOMP_CAN, 0, &intStatus);
			ucol_setNormalization(coll, UCOL_NO_NORMALIZATION);

			if(U_SUCCESS(intStatus) && coll !=NULL) {
				binColData = ucol_cloneRuleData(coll, &len, &intStatus);
				if(U_SUCCESS(*status) && data != NULL) {
					temp1 = bin_open(bundle, "%%Collation", len, binColData, status);
					table_add(rootTable, temp1, status);
					uprv_free(binColData);
				}
				ucol_close(coll);
            } else {
                setErrorText("Warning: %%Collation could not be constructed from CollationElements - check context!");
            }
			uprv_free(rules);
			colEl = FALSE;
		} 
#endif
 
        /*uhash_put(data, tag.fChars, status);*/
        put(data, &tag, status);
        if(U_FAILURE(*status)) {
            goto finish;
        }
        temp = NULL;
        break;
      /* Begin a string list */
    case eBegList:
        if(temp != NULL) {
	        *status = U_INTERNAL_PROGRAM_ERROR;
	        goto finish;
        }
        temp = array_open(bundle, cTag, status);
        temp1 = string_open(bundle, NULL, token.fChars, token.fLength, status);
        array_add(temp, temp1, status);
        temp1 = NULL;
        if(U_FAILURE(*status)) {
            goto finish;
        }
        break;
      
      /* Record a comma-delimited list string */      
    case eListStr:
        temp1 = string_open(bundle, NULL, token.fChars, token.fLength, status);
        array_add(temp, temp1, status);
        temp1 = NULL;
        if(U_FAILURE(*status)) {
            goto finish;
        }
        break;
      
      /* End a string list */
    case eEndList:
        /*uhash_put(data, tag.fChars, status);*/
        put(data, &tag, status);
        table_add(rootTable, temp, status);
        temp = NULL;
        if(U_FAILURE(*status)) {
            goto finish;
        }
        break;
      
    case eBeg2dList:
        if(temp != NULL) {
	        *status = U_INTERNAL_PROGRAM_ERROR;
	        goto finish;
        }
        temp = array_open(bundle, cTag, status);
        temp1 = array_open(bundle, NULL, status);
        if(U_FAILURE(*status)) {
            goto finish;
        }
        break;
      
    case eEnd2dList:
        /*uhash_put(data, tag.fChars, status);*/
        put(data, &tag, status);
        array_add(temp, temp1, status);
        table_add(rootTable, temp, status);
        temp1 = NULL;
        temp = NULL;
        if(U_FAILURE(*status)) {
            goto finish;
        }
        break;
      
    case e2dStr:
        temp2 = string_open(bundle, NULL, token.fChars, token.fLength, status);
        array_add(temp1, temp2, status);
        temp2 = NULL;
        if(U_FAILURE(*status)) {
            goto finish;
        }
        break;
      
    case eNewRow:
        array_add(temp, temp1, status);
        temp1 = array_open(bundle, NULL, status);
        if(U_FAILURE(*status)) {
            goto finish;
        }
        break;
      
    case eBegTagged:
        if(temp != NULL) {
	        *status = U_INTERNAL_PROGRAM_ERROR;
	        goto finish;
        }
        temp = table_open(bundle, cTag, status);
        u_UCharsToChars(token.fChars, cSubTag, u_strlen(token.fChars)+1);
        if(U_FAILURE(*status)) {
            goto finish;
        }
        break;
      
    case eEndTagged:
        /*uhash_put(data, tag.fChars, status);*/
        put(data, &tag, status);
        table_add(rootTable, temp, status);
        temp = NULL;
        if(U_FAILURE(*status)) {
            goto finish;
        }
        break;
      
    case eTaggedStr:
        temp1 = string_open(bundle, cSubTag, token.fChars, token.fLength, status);
        table_add(temp, temp1, status);
        temp1 = NULL;
        if(U_FAILURE(*status)) {
            goto finish;
        }
        /* We have seen the Override tag aleady, now checks if the value is "TRUE" or "FALSE". */
        if (uprv_strcmp(cSubTag, "Override") == 0) 
        {
            if (u_strncmp(token.fChars, trueValue, u_strlen(trueValue)) == 0)
            {
                colOverride = TRUE;
            } else {
                colOverride = FALSE;
            }
        }
        if (colEl && (uprv_strcmp(cSubTag, "Sequence") == 0))
        {
			const UChar * defaultRulesArray;
            UErrorCode intStatus = U_ZERO_ERROR;
			uint32_t defaultRulesArrayLength = 0;
			/* do the collation elements */
			int32_t len = 0;
			uint8_t *binColData = NULL;
			UCollator *coll = NULL; 
			UChar *rules = NULL;
            struct UString newTag;

            if (colOverride == FALSE)
            {
			    defaultRulesArray = ucol_getDefaultRulesArray(&defaultRulesArrayLength);
			    rules = uprv_malloc(sizeof(defaultRulesArray[0])*(defaultRulesArrayLength + token.fLength));
			    uprv_memcpy(rules, defaultRulesArray, defaultRulesArrayLength*sizeof(defaultRulesArray[0]));
			    uprv_memcpy(rules + defaultRulesArrayLength, token.fChars, token.fLength*sizeof(token.fChars[0]));
			    
			    coll = ucol_openRules(rules, defaultRulesArrayLength + token.fLength, UCOL_DECOMP_CAN, 0, &intStatus);
            } else {
                coll = ucol_openRules(token.fChars, token.fLength, UCOL_DECOMP_CAN, 0, &intStatus);
            }
			
			ucol_setNormalization(coll, UCOL_NO_NORMALIZATION);

			if(U_SUCCESS(intStatus) && coll !=NULL) {
				binColData = ucol_cloneRuleData(coll, &len, &intStatus);
				if(U_SUCCESS(*status) && data != NULL) {
					temp1 = bin_open(bundle, "%%Collation", len, binColData, status);
					table_add(rootTable, temp1, status);
					uprv_free(binColData);
				}
				ucol_close(coll);
            } else {
                setErrorText("Warning: %%Collation could not be constructed from CollationElements - check context!");
            }
			uprv_free(rules);
			colEl = FALSE;
            colOverride = FALSE;
            intStatus = U_ZERO_ERROR;
            ustr_initChars(&newTag, "CollationElements", -1, &intStatus);
            if(U_FAILURE(intStatus)) {
                goto finish;
		    } 
            put(data, &newTag, &intStatus);
            ustr_deinit(&newTag);
            if(U_FAILURE(intStatus)) {
                goto finish;
            }
        }
        break;
      
      /* Record the last string as the subtag */
    case eSubtag:
        u_UCharsToChars(token.fChars, cSubTag, u_strlen(token.fChars)+1);
        if(U_FAILURE(*status)) {
            goto finish;
        }
        if(table_get(temp, cSubTag, status) != 0) {
	        *status = U_INVALID_FORMAT_ERROR;
	        setErrorText("Duplicate subtag found in tagged list");
	        goto finish;
        }
        break;
      
    case eOpen:
      if(data != 0) {
	        *status = U_INTERNAL_PROGRAM_ERROR;
	        goto finish;
        }
        bundle_setlocale(bundle, token.fChars, status);
	if(didInitRoot == FALSE) {
	  U_STRING_INIT(rootName, "root", 4);
	  didInitRoot = TRUE;
	}

	if(u_strcmp(token.fChars, rootName) == 0) {
			const UChar * defaultRulesArray;
			uint32_t defaultRulesArrayLength = 0;
			/* do the collation elements */
			int32_t len = 0;
			uint8_t *data = NULL;
			uint8_t *data2 = NULL;
			UCollator *coll = NULL; 

			UChar *rules = NULL;
			defaultRulesArray = ucol_getDefaultRulesArray(&defaultRulesArrayLength);
			rules = uprv_malloc(sizeof(defaultRulesArray[0])*(defaultRulesArrayLength));
			uprv_memcpy(rules, defaultRulesArray, defaultRulesArrayLength*sizeof(defaultRulesArray[0]));
			
			coll = ucol_openRules(rules, defaultRulesArrayLength, UCOL_DECOMP_CAN, 0, status);
			ucol_setNormalization(coll, UCOL_DEFAULT_NORMALIZATION);

			if(U_SUCCESS(*status) && coll !=NULL) {
				data = ucol_cloneRuleData(coll, &len, status);
				if(U_SUCCESS(*status) && data != NULL) {
					temp1 = bin_open(bundle, "%%Collation", len, data, status);
					table_add(rootTable, temp1, status);
					uprv_free(data);
				}
				ucol_close(coll);
			}
			uprv_free(rules);
	}
    if(U_FAILURE(*status)) {
        goto finish;
    }
        data = uhash_open(hashUString, compareUString, status);
        uhash_setKeyDeleter(data, freeUString);
        break;
      
    case eClose:
        if(data == 0) {
	        *status = U_INTERNAL_PROGRAM_ERROR;
	        goto finish;
        }
        break;
	case eSetType:
		/* type recognition */
		if(!didInit) {
			U_STRING_INIT(k_start_string, "string", 6);
			U_STRING_INIT(k_start_binary, "binary", 6);
			U_STRING_INIT(k_start_table, "table", 5);
			U_STRING_INIT(k_start_int, "int", 3);
			U_STRING_INIT(k_start_array, "array", 5);
			U_STRING_INIT(k_start_intvector, "intvector", 9);
			U_STRING_INIT(k_start_reserved, "reserved", 8);
			didInit=TRUE;
		}
		if(u_strcmp(token.fChars, k_start_string) == 0) {
			node = eGotTag;
		} else if(u_strcmp(token.fChars, k_start_array) == 0) {
			node = eGotTag;
		} else if(u_strcmp(token.fChars, k_start_table) == 0) {
			node = eGotTag;
		} else if(u_strcmp(token.fChars, k_start_binary) == 0) {
			/* start of binary */
		} else if(u_strcmp(token.fChars, k_start_int) == 0) {
			/* start of integer */
		} else if(u_strcmp(token.fChars, k_start_intvector) == 0) {
			/* start of intvector */
		} else if(u_strcmp(token.fChars, k_start_reserved) == 0) {
			/* start of reserved */
		} else {
	        *status = U_INTERNAL_PROGRAM_ERROR;
	        goto finish;
		}
		break;
    }
  }

 finish:

  /* clean  up */
  
  if(data != 0)
    uhash_close(data);

  ustr_deinit(&token);
  ustr_deinit(&tag);

    /*uprv_free(cTag);*/
    /*uprv_free(cSubTag);*/

  if(file != 0)
    u_fclose(file);

  return bundle;
}