/*
* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:   
* Author:       Frank Richichi
* Created:      Thu Apr 25 10:34:06 2002
* Modified:     Thu Apr 25 11:12:35 2002 (Frank Richichi) richichi@D5250215
* Language:     C
* Subsystem:    N/A
* RCS:          $Id$
*
*/

#include <stdio.h>
#include <io.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <time.h>


/* ----------------------------------------------------------------------- **
   The following strings are used to identify the beginning of a tag or 
   attribute list in the input file.
** ----------------------------------------------------------------------- **/

#define TAG_TABLE_HEADING   "TAGS_FOR_CODE_PAGE"
#define ATTR_TABLE_HEADING  "ATTRIBUTES_FOR_CODE_PAGE"
#define NO_STRINGS "NO_STRINGS"

/* ----------------------------------------------------------------------- **
   Types for various tables.
** ----------------------------------------------------------------------- **/
#define NAME_TABLE_T    "NW_Byte"
#define TOKEN_TABLE_T   "NW_WBXML_DictEntry_t"
#define CODEPAGE_TABLE_T  "NW_WBXML_Codepage_t"
#define DICTIONARY_TABLE_T  "NW_WBXML_Dictionary_t"
#define NAMES_T     "NW_String_UCS2Buff_t"
#define ELEMENT_T "NW_%s_Element"
#define ATTRIBUTE_T "NW_%s_Attribute"
#define ELEMENT_TOKEN_T "NW_%s_ElementToken"
#define ATTRIBUTE_TOKEN_T "NW_%s_AttributeToken"

/* ----------------------------------------------------------------------- **
   Misc array limits
** ----------------------------------------------------------------------- **/
#define TABLE_SIZE      255
#define MAX_LINE        255
#define MAX_NAME        255
#define MAX_TOKEN       4
#define MAX_DICT_NAME   255
#define MAX_PUBLIC_ID   255
#define MAX_DOC_TYPE    255
#define MAX_START_NAME  255
#define MAX_TYPE_NAME   255

/* ----------------------------------------------------------------------- **
  Names used in the generated tables
** ----------------------------------------------------------------------- **/
#define TAG_NAME    "tag"
#define ATTR_NAME   "attribute"


/* ----------------------------------------------------------------------- **
   Define a type for codepage storage
** ----------------------------------------------------------------------- **/
typedef struct codepage_s {
  int   num;    /* the code page number */
  int   size;   /* the number of entries in table */
} codepage_t;


/* ----------------------------------------------------------------------- **
   Header information
** ----------------------------------------------------------------------- **/
char dict_name[MAX_DICT_NAME];
char doc_type[MAX_DOC_TYPE];
char public_id[10];

/* ----------------------------------------------------------------------- **
   Scratch tables
** ----------------------------------------------------------------------- **/
char * tokens[TABLE_SIZE];
char * names[TABLE_SIZE];
int sorted_indexes[TABLE_SIZE];
codepage_t tag_codepages[TABLE_SIZE];
codepage_t attr_codepages[TABLE_SIZE];


/* ----------------------------------------------------------------------- **
   Records time of program execution and command line arguments
** ----------------------------------------------------------------------- **/
static time_t timestamp;
static int main_argc = 1;
static char** main_argv;

/* ----------------------------------------------------------------------- **
   Globals so error clean up is easy
** ----------------------------------------------------------------------- **/
static FILE* input_dict;
static FILE* output_c;
static FILE* output_h;

static void exit_error(int exit_code) {
  static char errmsg[]
  = "#error \"Bad input dictionary data cannot complete code generation\"\n";
  if (input_dict) fclose(input_dict);
  if (output_c) {
    fprintf(output_c, errmsg);
    fclose(output_c);
  }
  if (output_h) {
    fprintf(output_h, errmsg);
    fclose(output_h);
  }
  exit(exit_code);
}

void print_usage(char* progname)
{
  fprintf(stderr,
  "Dictionary creator - creates a .c and .h source file for a\n"
  "NW_Wbxml_Dictionary_t structure from a dictionary data file.\n"
  "\n"
  "Usage: %s data_input_file dot_c_output_file dot_h_output_file\n"
  "\n"
  " - all args are required\n"
  "\n"
  "Comments are defined to be:\n"
  "\n"
  " - A line whose first non-whitespace char is '#'\n"
  " - A blank line or line with only whitespace\n"
  " Note: Comments are NOT permitted at the end of other lines.\n"
  "\n"
  "Input format:\n"
  "\n"
  " - Dictionary name = the first non-comment line.  The dictionary\n"
  "   that will be created will use this string in the dictionary \n"
  "   name.  For example, if the dictionary name is \"wml\", the\n"
  "   following dictionary will be created:\n"
  "\n"
  "     NW_Wbxml_Dictionary_t NW_wml_dictionary = { ... }\n"
  "\n"
  " - Public id = the second non-comment line.  This is the Public \n"
  "   Identifier as specified in section 7.2 of the WBML spec.  If\n"
  "   a public id has not been defined, use \"1\".\n"
  "\n"
  " - Doc Type = the third non-comment line.  This is the source\n"
  "   document's Document Type Declaration.\n"
  "\n"
  " - The beginning of a Tag table has the following syntax:\n"
  "\n"
  "     TAGS_FOR_CODE_PAGE <codepage_number> [NO_STRINGS]\n"
  "\n"
  "     <codepage_number> is required and is a base 10 number\n"
  "\n"
  "     [NO_STRINGS] is an optional keyword which means output only\n"
  "     the token structures, treat all token names as empty strings\n"
  "\n"
  " - The beginning of an Attribute table has the following syntax:\n"
  "\n"
  "     ATTRIBUTES_FOR_CODE_PAGE <codepage_number> [NO_STRINGS]\n"
  "     \n"
  "     <codepage_number> is required and is a base 10 number\n"
  "\n"
  "     [NO_STRINGS] is an optional keyword which means output only\n"
  "     the token structures, treat all token names as empty strings\n"
  "\n"
  " - The syntax for an entry is the same for both Tag and Attribute \n"
  "   tables\n"
  "\n"
  "     <token> <name>\n"
  "\n"
  "     <token> must be a hexadecimal number written as 0x?? (e.g., 0x07)\n"
  "     NOTE: Tokens are sorted as strings so 0x7 MUST be entered as 0x07\n"
  "           or the sorting won't work!  It is ok to mix case as all hex\n"
  "           digits are converted to lower case before the sort.\n"
  "\n"
  "     <name> is any sequence of printable characters without whitespace\n"
  "\n"
  " - The input tables do NOT have to be sorted \n"
  "\n"
  " - If a language has \"Attribute Value Tokens\", they should be included\n"
  "   in the Attribute table\n"
  "\n"
  "Example input file (example.dict):\n"
  "\n"
  "  #\n"
  "  # Sample dictionary for the WML language\n"
  "  #\n"
  "  wml\n"
  "  #\n"
  "  # WML version 1.2 has a public id of 9\n"
  "  #\n"
  "  9\n"
  "  #\n"
  "  # WML 1.2 doc type\n"
  "  #\n"
  "  -//WAPFORUM//DTD WML 1.1//EN\n"
  "  #\n"
  "  # Tags\n"
  "  #\n"
  "  TAGS_FOR_CODE_PAGE 0\n"
  "  0x2b go\n"
  "  0x1d td\n"
  "  #\n"
  "  # Attributes\n"
  "  #\n"
  "  ATTRIBUTES_FOR_CODE_PAGE 0\n"
  "  0x12 format\n"
  "  0xA0 wrap\n"
  "  0x23 newcontext=true\n"
  "  0x8F http://www.\n"
  "\n"
  "Example run command:\n"
  "\n"
  "  %s example.dict example.c example.h\n",
  progname, progname);
}

static void print_automaticallyGeneratedCodeWarning(FILE *f)
{
  int i;
  static char automaticallyGeneratedCodeWarning[] =
  "/*\n"
  "** WARNING\n"
  "**\n"
  "** DO NOT EDIT - THIS CODE IS AUTOMATICALLY GENERATED\n"
  "**               FROM A DATA FILE BY THE DICTIONARY CREATION PROGRAM";

  fprintf(f, "%s\n", automaticallyGeneratedCodeWarning);
  fprintf(f,
          "**\n"
          "** This file generated on %s"
          "**                        (coordinated universal time)\n"
          "**\n"
          "** Command line: ",
          asctime(gmtime(&timestamp))); /* asctime() generates a newline at the end */
  fprintf(f, "%s", main_argv[0]);
  for (i = 1; i < main_argc; i++) {
    fprintf(f, " %s", main_argv[i]);
  }
  fprintf(f, "\n*/");
}

static void print_copyright(FILE *f)
{
  struct tm* tm_time;
  static const char copyright[] =
  "/* ****************************************************************\n"
  "**          Copyright %d - Nokia Corporation  All rights reserved.\n"
  "**          Nokia Americas\n"
  "**          6000 Connection Drive\n"
  "**          Irving, Texas 75039\n"
  "**\n"
  "**          Restricted Rights: Use, duplication, or disclosure by the\n"
  "**          U.S. Government is subject to restrictions as set forth in\n"
  "**          subparagraph (c)(1)(ii) of DFARS 252.227-7013, or in FAR\n"
  "**          52.227-19, or in FAR 52.227-14 Alt. III, as applicable.\n"
  "**\n"
  "**          This software is proprietary to and embodies the confidential\n"
  "**          technology of Nokia  Possession, use, or copying of this software\n"
  "**          and media is authorized only pursuant to a valid written license\n"
  "**          from Nokia or an authorized sublicensor.\n"
  "**\n"
  "**          Nokia  - Wireless Software Solutions\n"
  "*****************************************************************/";

  tm_time = gmtime(&timestamp);
  fprintf(f, copyright,
          tm_time->tm_year + 1900);
}

static FILE * open_file(char* fn, char *perms){
  FILE* f;
  
  if ((fn == 0)||((f = fopen(fn, perms)) == 0)){    
    return 0;
  }else{    
    return f;
  }
  
}

static init() {
  int i;

  for (i=0; i < TABLE_SIZE; i++) {
    tag_codepages[i].num = -1;
    attr_codepages[i].num = -1;
  }
}


/* ----------------------------------------------------------------------- **
  Read the next line of input and store it in s.  
 
  NOTE: s will have the new-line character stripped
 
  RETURN: 1 for success and 0 for EOF or failure 
** ----------------------------------------------------------------------- **/
static int get_line(FILE *f, char s[], int n){
  int i = 0, j, indx, len;
  char line[MAX_LINE];

  for(;;) {
    if ((fgets(line, n, f)) == 0) {
      /* Either EOF or an error occurred */
      return 0;
    }
    len = (int) strlen(line);
    /* Skip any preceeding whitespace */
    for (i=0; i < len; i++) {
      if (isspace(line[i]))
      continue;
      break;
    }
    if (i >= len || line[i] == '#')
      continue;
    break;
  }

  /* Fill in s */
  for (j=i, indx = 0; j < (int) strlen(line); i++, j++, indx++) {
    if (line[j] == '\n') {
      break;
    }
    if (line[j] == '\t') {
      /* convert tab to space for isprint() test */
      line[j] = ' ';
    }
    if (!isprint(line[j])) {
      /* stops on bogus char */
      fprintf(stderr,
              "ERROR: Illegal character (may be control char) in input text "
              "near file byte offset %ld\n",
              ftell(f));
      exit_error(1);
    }
    s[indx] = line[j];
    if (indx + 1 == MAX_LINE) break;
  }

  if (indx > 0)
    s[indx] = '\000';

  return 1;
}


/* ----------------------------------------------------------------------- **
   Read the a line of input and break it into three items:
   For table header
      1. Table type name
      2. Code page number
      3. Optional "NO_STRINGS"
   For table entry
      1. 0x?? token value
      2. token string (optional, extends from first nonspace to eol)
      3. null
 
  RETURN: 1 for success and 0 for EOF or failure
 ** ----------------------------------------------------------------------- **/
static int get_tuple(FILE *f, char item1[], char item2[], char item3[])
{
  char line[MAX_LINE];
  int i;
  int j;
  int len;

  if ((get_line(f, line, MAX_LINE)) != 1) {
    return 0;
  }

  len = (int)strlen(line);

  /* tablename or token hex value */
  j = 0;
  for (i = 0; i < len; i++) {
    if (isspace(line[i])) break;
    if (item1[0] == '0' && j == MAX_TOKEN) {
      /* have to check for leading '0' because this func is called to process
      TAG_TABLE_HEADING lines too where length could be longer than MAX_TOKEN */
      fprintf(stderr, "ERROR: token value too long near input file byte offset %ld\n",
              ftell(f));
      exit_error(1);
      break;
    }
    item1[j++] = line[i];
  }
  item1[j] = '\0';

  /* whitespace */
  for (; i < len; i++) {
    if (!isspace(line[i])) break;
  }

  /* codepage or token string */
  j = 0;
  for (/* continue with i */; i < len; i++) {
    if (item1[0] != '0' && isspace(line[i])) break;
    if (j == MAX_NAME) {
      fprintf(stderr, "ERROR: token string too long near input file byte offset %ld\n",
              ftell(f));
      exit_error(1);
      break;
    }
    item2[j++] = line[i];
  }
  item2[j] = '\0';

  /* whitespace */
  for (; i < len; i++) {
    if (!isspace(line[i])) break;
  }

  /* nostrings or nothing */
  j = 0;
  for (/* continue with i */; i < len; i++) {
    item3[j++] = line[i];
  }
  item3[j] = '\0';

  return 1;
}

static void process_header(FILE *f)
{
  if ((get_line(f, dict_name, MAX_DICT_NAME)) != 1) {
    fprintf(stderr, "ERROR: reading dictionary name\n");
    exit_error(1);
  }

  if ((get_line(f, public_id, MAX_PUBLIC_ID)) != 1) {
    fprintf(stderr, "ERROR: reading public id\n");
    exit_error(1);
  }

  if ((get_line(f, doc_type, MAX_DOC_TYPE)) != 1) {
    fprintf(stderr, "ERROR: reading doc type\n");
    exit_error(1);
  }
}

static void print_file_header(FILE *output, FILE *outputHeader)
{
  fprintf(output, "/*\n");
  fprintf(output, " * Dictionary = %s\n", dict_name);
  fprintf(output, " * Public id = %s\n", public_id);
  fprintf(output, " * Doc Type = %s\n", doc_type);
  fprintf(output, " */\n");
  fprintf(output, "\n");

  fprintf(output, "#include \"%s\"\n", main_argv[3]);
  fprintf(output, "#include \"nw_wbxml_dictionary.h\"\n");

  fprintf(output, "\n");

  /* Including the typedef for public id */
  fprintf(outputHeader, "#define NW_%s_PublicId %s\n", dict_name, public_id);
}

static void print_table_header(FILE *output, char * table_type, char *type, char *key, char *code_page, int n)
{
  print_automaticallyGeneratedCodeWarning(output);
  fprintf(output, "\n\n");
  fprintf(output, "/*\n");
  fprintf(output, " * %s entries - sorted by %s\n", type, key);
  fprintf(output, " */\n");
  fprintf(output, "static const\n");
  fprintf(output, "%s NW_%s_%s_%s_%s[%d] = {\n", table_type, dict_name, type, key, code_page, n);
}

static void process_entry(int i, char *token, char *name) 
{
  tokens[i] = strdup(token);
  names[i] = strdup(name);
  sorted_indexes[i] = i;
}


/* ----------------------------------------------------------------------- **
   Print the table of tokens and names - sorted by token
   Also create a list of the items, sorted by name 
 ** ----------------------------------------------------------------------- **/
static void print_token_table(FILE *output, FILE* outputHeader,
                              char *type, char *key, char *code_page, int n,
                              int use_strings)
{
  static char tagTypeString[MAX_TYPE_NAME];
  static char tokenTypeString[MAX_TYPE_NAME];

  /* Must first sort by token */
  int i, j;
  char *tmp_token;
  char *tmp_name;
  char *tagType = &tagTypeString[0];

  if (strcmp("tag", type) == 0)
  {
    (void)sprintf(tagTypeString, ELEMENT_T, dict_name);
    (void)sprintf(tokenTypeString, ELEMENT_TOKEN_T, dict_name);
  }
  else if (strcmp("attribute", type) == 0)
  {
    (void)sprintf(tagTypeString, ATTRIBUTE_T, dict_name);
    (void)sprintf(tokenTypeString, ATTRIBUTE_TOKEN_T, dict_name);
  }
  else {
    fprintf(stderr, "ERROR: internal error\n");
    exit_error(1);
  }

  /* make all the tokens lower case */
  for (i=0; i < n; i++) {
    int l = (int)strlen(tokens[i]);
    if (l != 4) {
      fprintf(stderr, 
              "ERROR: Badly formatted token %s\n"
              "All token values must be in the form 0x?? (e.g., 0x07) "
              "or the sorting algorithm won't work.\n"
              , tokens[i]);
      exit_error(1);
    }
    for (j=0; j < l; j++) {
      if (isupper(tokens[i][j])) {
        tokens[i][j] = (char)tolower(tokens[i][j]);
      }
      if ((tokens[i][j] != 'x') && isalpha(tokens[i][j])) {
        if ((tokens[i][j] < 'a') || (tokens[i][j] > 'f')) {
          fprintf(stderr, 
                  "ERROR: Illegal hex digit in token %s\n"
                  , tokens[i]);
          exit_error(1);
        }
      }
    }
  }

  for (i=0; i < n-1; i++) {
    for (j=0; j < n-1; j++) {
      /* 
       * Sort by token 
       */
      if ((strcmp(tokens[j], tokens[j+1])) > 0) {
        /* Swap the two elements */
        tmp_token = tokens[j];
        tmp_name = names[j];
        tokens[j] = tokens[j+1];
        names[j] = names[j+1];
        tokens[j+1] = tmp_token;
        names[j+1] = tmp_name;
      }
    }
  }

  /*
   * print variables
   */
  fprintf(output, "\n");
  for (i=0; i < n; i++) {
    char tempName[MAX_NAME+1];
    int l;
    if (isdigit(names[i][0])) {
      tempName[0] = '_';
      strcpy(tempName+1, names[i]);
    } else {
      strcpy(tempName, names[i]);
    }
    l = (int)strlen(tempName);
    for (j = 0; j < l; j++) {
      if (isdigit(tempName[j])
          || isalpha(tempName[j])
          || (tempName[j] == '_')) {
        continue;
      }
      tempName[j] = '_';
    }
    if (use_strings) {
      fprintf(output, 
              "static const NW_Ucs2 %sTag_%s[] = {"
              , tagType, tempName);
      for (j=0; j < (int) strlen(names[i]); j++) {
        if (names[i][j] == '\\') {
          fprintf(output, "\'\\\\\',");
        } else {
          fprintf(output, "\'%c\',", names[i][j]);
        }
      }
      fprintf(output, "\'\\0\'};\n");
    }
  }
  if (!use_strings) {
    fprintf(output,
            "static const NW_Ucs2 %sTag_emptyString_%s[] = { \'\\0\' };\n"
            , tagType, code_page);
  }
  fprintf(output, "\n");

  print_table_header(output, TOKEN_TABLE_T, type, key, code_page, n);
  if (use_strings) {
    fprintf(outputHeader, 
            "\ntypedef enum %sToken_%s_e{\n", 
            tagType, code_page);
  }
 /*
  * Print the table
  */
  for (i=0; i < n; i++) {
    char tempName[MAX_NAME+1] ;
    char tempToken[6] ;
    char *token;
    int l;
    if (isdigit(names[i][0])) {
      tempName[0] = '_';
      strcpy(tempName+1, names[i]);
    } else {
      strcpy(tempName, names[i]);
    }
    l = (int)strlen(tempName);
    for (j = 0; j < l; j++) {
      if (isdigit(tempName[j])
          || isalpha(tempName[j])
          || (tempName[j] == '_')) {
        continue;
      }
      tempName[j] = '_';
    }
    strcpy(tempToken, tokens[i]);
    token = strchr(tempToken, 'x');
    token++;
    if (use_strings) {
      fprintf(output, "\t{%s, (%s *) %sTag_%s", tokens[i], NAMES_T, tagType, tempName);
      fprintf(outputHeader, "\t%s_%s = 0x0%s%s", tokenTypeString, tempName, code_page, token);
    } else {
      fprintf(output, "\t{%s, &%sTag_emptyString_%s", tokens[i], tagType, code_page);
    }
    
    if (i == (n-1))
    {
      fprintf(output, "}\n");
      if (use_strings) {
        fprintf(outputHeader, "\n");
      }
    }
    else
    {
      fprintf(output, "},\n");
      if (use_strings) {
        fprintf(outputHeader, ",\n");
      }
    }
  }
  fprintf(output, "};\n\n");
  if (use_strings) {
    fprintf(outputHeader, "}%sToken_%s_t;\n\n", tagType, code_page);
  }

  if (use_strings) {
    /*
    * Create an array of the names sorted by index
    */
    for (i=0; i < n-1; i++) {
      for (j=0; j < n-1; j++) {
        /*
        * Since we will need an array of the names sorted by index,
        * generate that arrary now.
        */
        if ((strcmp(names[j], names[j+1])) > 0) {
          /* Swap the two names */
          int tmp_token;
          tmp_name = names[j];
          tmp_token = sorted_indexes[j];
          names[j] = names[j+1];
          names[j+1] = tmp_name;
          sorted_indexes[j] = sorted_indexes[j+1];
          sorted_indexes[j+1] = tmp_token;
        }
      }
    }
  }
}

static void cache_codepage(codepage_t table[], char *cp_num, int n)
{
  int num = atoi(cp_num);

  if (num >= TABLE_SIZE) {
    fprintf(stderr, "ERROR: Codepage '%d' is too large!\n", num);
    exit(1);
  }

  table[num].num = num; 
  table[num].size = n; 
}

/*
 * Print a table of the names 
 */
static void print_name_table(FILE *output, char *type, char *key, char *code_page, int n,
                             int use_strings)
{
  int i;

  print_table_header(output, NAME_TABLE_T, type, key, code_page, n);

  for (i=0; i < n; i++) {
    if (use_strings) {
      fprintf(output, "\t%d,\n", sorted_indexes[i]);
    } else {
      fprintf(output, "\t0,\n");
    }
  }

  fprintf(output, "};\n");
}

static process_content(FILE *f, FILE *output, FILE* outputHeader)
{
  char token[MAX_START_NAME+1]; /* Must be big enough to hold a 
                                   tag/attr start string */
  char name[MAX_NAME+1];
  char optional[MAX_LINE+1];
  char *tag_code_page = "";
  char *attr_code_page = "";
  char processing_tag = 2;  /* processing state: 1 = tag, 0 = attribute, 2 = init */
  int n = 0;
  int use_strings = 1;

  for(;;) {

    if ((get_tuple(f, token, name, optional)) != 1) {
      break;
    }

    if (!strcmp(token, TAG_TABLE_HEADING)) {
      use_strings = strcmp(optional, NO_STRINGS);
      if (processing_tag == 1) {
        /* Process the current tag table */
        print_token_table(output, outputHeader, TAG_NAME, "token", tag_code_page, n, use_strings);
        print_name_table(output, TAG_NAME, "name", tag_code_page, n, use_strings);
        cache_codepage(tag_codepages, tag_code_page, n);
        n = 0;
      } else if (processing_tag == 0) {
        /* Process the current attribute table */
        print_token_table(output, outputHeader, ATTR_NAME, "token", attr_code_page, n, use_strings);
        print_name_table(output, ATTR_NAME, "name", attr_code_page, n, use_strings);
        cache_codepage(attr_codepages, attr_code_page, n);
        n = 0;
      }
      tag_code_page = strdup(name);
      processing_tag = 1;
    }
    else if (!strcmp(token, ATTR_TABLE_HEADING)) {
      use_strings = strcmp(optional, NO_STRINGS);
      if (processing_tag == 1) {
        /* Process the current tag table */
        print_token_table(output, outputHeader, TAG_NAME, "token", tag_code_page, n, use_strings);
        print_name_table(output, TAG_NAME, "name", tag_code_page, n, use_strings);
        cache_codepage(tag_codepages, tag_code_page, n);
        n = 0;
      } else if (processing_tag == 0) {
        /* Process the current attribute table */
        print_token_table(output, outputHeader, ATTR_NAME, "token", attr_code_page, n, use_strings);
        print_name_table(output, ATTR_NAME, "name", attr_code_page, n, use_strings);
        cache_codepage(attr_codepages, attr_code_page, n);
        n = 0;
      }
      attr_code_page = strdup(name);
      processing_tag = 0;
    } else {
      process_entry(n, token, name);
      n++;
    }
  }

  if (processing_tag == 2) {
    fprintf(stderr, 
            "ERROR: Could not find tag or attribute table starts in file.\n"
            "       Input file syntax has changed.\n"
            "       See usage by executing this program with no arguments.\n");
    exit_error(1);
  }

  /*
   * If anything is left, process it
   */
  if (n > 0) {
    if (processing_tag == 1) {
      print_token_table(output, outputHeader, TAG_NAME, "token", tag_code_page, n, use_strings);
      print_name_table(output, TAG_NAME, "name", tag_code_page, n, use_strings);
      cache_codepage(tag_codepages, tag_code_page, n);
    } else if (processing_tag == 0) {
      print_token_table(output, outputHeader, ATTR_NAME, "token", attr_code_page, n, use_strings);
      print_name_table(output, ATTR_NAME, "name", attr_code_page, n, use_strings);
      cache_codepage(attr_codepages, attr_code_page, n);
    }
  }
}

static void get_num_codepages(codepage_t cp[], int *n, int *max)
{
  int i;
  /* Determine the number of codepages */
  for (i=0; i < TABLE_SIZE; i++) {
    if (cp[i].num != -1) {
      *max = i;
      (*n)++;
    }
  }
}

static void print_codepage_table(FILE *output, codepage_t cp[], int n, int max, char *type)
{
  int i;

  if (n == 0)
  return;

  fprintf(output, "static const\n");
  fprintf(output, "%s NW_%s_%s_codepages[%d] = {\n", CODEPAGE_TABLE_T, 
      dict_name, type, max + 1);

  for (i=0; i <= max && i < TABLE_SIZE; i++) {
    if (cp[i].num == -1) {
      fprintf(output, "\t{0, 0, 0},\n");
    } else {
      fprintf(output, "\t{%d, (%s*)&NW_%s_%s_token_%d[0], ", 
      cp[i].size, TOKEN_TABLE_T, dict_name, type, cp[i].num);
      fprintf(output, "(NW_Byte *)&NW_%s_%s_name_%d[0]},\n", 
      dict_name, type, cp[i].num);
    }
  }
  fprintf(output, "};\n");
}

static void print_codepage_tables(FILE *output) 
{
  int n=0, max=0;

  /* Tag tables */
  fprintf(output, 
          "\n"
          "/*\n"
          " * Tag codepage table\n"
          " */\n"
          );

  get_num_codepages(tag_codepages, &n, &max);
  print_codepage_table(output, tag_codepages, n, max, TAG_NAME);

  /* Attr tables */
  fprintf(output, 
          "\n"
          "/*\n"
          " * Attribute codepage table\n"
          " */\n"
          );

  n = max = 0;
  get_num_codepages(attr_codepages, &n, &max);
  print_codepage_table(output, attr_codepages, n, max, ATTR_NAME);
}

static void add_codepage(FILE *output, codepage_t cp[], char *type)
{
  int n=0, max=0;

  get_num_codepages(cp, &n, &max);

  if (n == 0)
    fprintf(output, "\t0, 0,\n");
  else
    fprintf(output, "\t%d, (%s*)&NW_%s_%s_codepages[0],\n", max + 1, CODEPAGE_TABLE_T, dict_name, type);
}

static void print_dictionary_table(FILE *output, FILE *outputHeader)
{
  int i;
  if (strlen(doc_type) > 0)
  {
    fprintf(output, "\nstatic const NW_Ucs2 NW_%s_docType[] = {", dict_name);
    for (i=0; i < (int) strlen(doc_type); i++)
      fprintf(output, "\'%c\',", doc_type[i]);
    fprintf(output, "\'\\0\'};\n");
  }

  fprintf(output, 
          "\n"
          "/*\n"
          " * Dictionary\n"
          " */\n"
          );

  fprintf(outputHeader, "extern const %s NW_%s_WBXMLDictionary\n",
          DICTIONARY_TABLE_T, dict_name);
  fprintf(output, "%s NW_%s_WBXMLDictionary = {\n", DICTIONARY_TABLE_T, dict_name);
  fprintf(output, "\tNW_%s_PublicId,\n", dict_name);

  /* Print the doc type as a UCS2 string */
  fprintf(output, "\t(%s *)NW_%s_docType,\n", "NW_Ucs2", dict_name);

  /* Add the tag and attribute code page */
  add_codepage(output, tag_codepages, TAG_NAME);
  add_codepage(output, attr_codepages, ATTR_NAME);

  fprintf(output, "};\n");
}

static void process_file(FILE *f, FILE *output, FILE* outputHeader)
{
  process_header(f);

  print_file_header(output, outputHeader);

  process_content(f, output, outputHeader);

  print_codepage_tables(output);

  print_dictionary_table(output, outputHeader);
}

int main(int argc, char ** argv){
  if (argc < 4) {
    print_usage(argv[0]);
    exit_error(1);
  }

  init();

  input_dict = NULL;
  output_c = NULL;
  output_h = NULL;

  /* ----------------------------------------------------------------------- **
     Save info used in print_automaticallyGeneratedCodeWarning()   
  ** ----------------------------------------------------------------------- **/
  (void)time(&timestamp);
  main_argc = argc;
  main_argv = argv;


  /* ----------------------------------------------------------------------- **
     Work on files in text mode to ease end-of-line processing in DOS.  
  ** ----------------------------------------------------------------------- **/
  if ((input_dict = open_file(argv[1], "rt")) == NULL) {
    fprintf(stderr, "ERROR: Input File '%s' could NOT be opened!\n", argv[1]);
    exit_error(1);
  }

  if ((output_c = open_file(argv[2], "wt")) == NULL) {
    fprintf(stderr, "ERROR: Output .c File '%s' could NOT be opened!\n", argv[2]);
    exit_error(1);
  }

  if ((output_h = open_file(argv[3], "wt")) == NULL) {
    fprintf(stderr, "ERROR: Output .h File '%s' could NOT be opened!\n", argv[3]);
    exit_error(1);
  }

  print_copyright(output_c);
  fprintf(output_c, "\n\n");
  print_automaticallyGeneratedCodeWarning(output_c);
  fprintf(output_c, "\n\n");

  print_copyright(output_h);
  fprintf(output_h, "\n\n");
  print_automaticallyGeneratedCodeWarning(output_h);
  fprintf(output_h, "\n\n");

  {
    int l;
    char* p = strrchr(argv[3], '.');
    l = (p == NULL) ? (int)strlen(argv[3]) : p - argv[3];

    fprintf(output_h, "#ifndef HEADER_GUARD_%.*s", l, argv[3]);
    if (p != NULL) fprintf(output_h, "_%s", p+1);
    fprintf(output_h,
            "\n"
            "#define HEADER_GUARD_%.*s"
            , l, argv[3]);
    if (p != NULL) fprintf(output_h, "_%s", p+1);
    fprintf(output_h, 
            "\n"
            "\n"
            "#ifdef __cplusplus\n"
            "extern \"C\"\n"
            "{\n"
            "#endif\n"
            "\n"
            "\n"
            );
  }

  /* process input */
  process_file(input_dict, output_c, output_h);

  fprintf(output_c, "\n");
  print_automaticallyGeneratedCodeWarning(output_c);

  fprintf(output_c, "\n");
  fprintf(output_h, "\n");
  print_automaticallyGeneratedCodeWarning(output_h);

  fprintf(output_h,
          "\n"
          "\n"
          "#ifdef __cplusplus\n"
          "} /* extern \"C\" */\n"
          "#endif\n"
          "\n"
          "#endif\n"
          );
  
  /* close files */
  fclose(input_dict);
  fclose(output_c);
  fclose(output_h);

  return 0;
}
