#include <stdio.h>
#include <string.h>

#define HZK_FILE      "hzk12.bin"
#define HZK_DOT_FIZE  12

#define HZCODE_DEFIND_FILE  "CONFIGHZ.H"

int  _iParseStatus ;
      #define   PARSE_NULL                              0
      #define   PARSE_MACRO_MASK                        1
      #define   PARSE_MACRO_IF_MASK                     2
      #define   PARSE_MACRO_IF_DEF_MASK              3
      #define   PARSE_MACRO_IF_DEF_CLOSE_MASK       4
      #define   PARSE_MACRO_IFDEF_WAIT_ENDIF_MASK  5
      #define   PARSE_MACRO_IFDEF_WAIT_ENDIF_WORD   6
      #define   PARSE_MACRO_DEFINE_MASK                 7
      #define   PARSE_MACRO_DEFINE_VALUE_MASK           8

FILE *configFile ;
char configBuffer[256] ;
int  leadOfconfigBuffer ;
int  sizeOfconfigBuffer ;
char wordBuffer[125] ;
int  sizeOfword ;
int  _iMacro_If_Counter ;
int  _iConfigFile_Line_Counter ;
int  _i_global_isNotFlag ;

struct  _IF_DEFINE_PAIR {
    char Name[128] ;
    int  isNot ;
} ;

struct _IF_DEFINE_STACK {
	struct _IF_DEFINE_PAIR   _if_define_pair[5] ;
	int  _sizeof_if_define_pair ;
} ;

struct _IF_DEFINE_STACK  _if_define_stack[20] ;
int  sizeof_if_define_stack ;

struct DefinedTok {
    char  Name[250]   ;
    int   Value       ;
} ;

struct DefinedTok  _defineToks[200] ;
int defineTokIndex;
int defineTokLast ;
struct DefinedTok *pLastDefineTok ;


int GetConfigFile()
{
     sizeOfconfigBuffer = fread(configBuffer,1,sizeof(configBuffer),configFile);
     leadOfconfigBuffer = 0 ;
     return sizeOfconfigBuffer ;
}

int IsNormalChar(char p)
{
    return     (p != ' ')  && (p != '!')   && (p != '(') && (p != '#')
	    && (p != ')')  && (p != '\r')  && (p != '\n');
}

void ReturnCharToConfigBuffer()
{
    leadOfconfigBuffer-- ;
}

char GetCharFromConfigBuffer()
{
      char c = 0 ;

loop:
      if( leadOfconfigBuffer < sizeOfconfigBuffer ) {
	  do {
	       c = configBuffer[leadOfconfigBuffer] ;
	       if( c == '\n' ) _iConfigFile_Line_Counter++ ;
	       leadOfconfigBuffer++ ;
	  } while ((c == '\n') || (c == '\r')) ;
      }
      else {
	   if( GetConfigFile() ) goto loop ;
      }
      return c ;
}

char _notCR_GetCharFromConfigBuffer()
{
      char c = 0 ;

loop:
      if( leadOfconfigBuffer < sizeOfconfigBuffer ) {
	       c = configBuffer[leadOfconfigBuffer] ;
	       if( c == '\n' ) _iConfigFile_Line_Counter++ ;
	       leadOfconfigBuffer++ ;
      }
      else {
	   if( GetConfigFile() ) goto loop ;
      }
      return c ;
}

void SkipCommitTok()
{
      char p ;

next_char_lp:
      p = GetCharFromConfigBuffer() ;
      if( p == '*' && p ) {
	    p = GetCharFromConfigBuffer() ;
	    if( p == '/' ) return ;
	    goto next_char_lp ;
      }
}

void SkipNewStyleCommitTok()
{
      char p ;

next_char_lp:
      p = _notCR_GetCharFromConfigBuffer() ;
      if( p == '\r' || p == '\n' ) return ;
      goto  next_char_lp ;
}

char *GetWordFromConfigFile()
{
      char p ;

head_LP:
      p = GetCharFromConfigBuffer() ;
      while(p == ' ' && p ) {
	  p = GetCharFromConfigBuffer() ;
      }

      if( p == '#' || p == '!' || p == ')' ) {
	  wordBuffer[0] = p ;
	  wordBuffer[1] = 0x00 ;
	  sizeOfword = 1 ;
	  return &wordBuffer[0];
      }

      if( p == '/' && p ) {
	  p = GetCharFromConfigBuffer() ;
	  if( p == '/'  && p ) {  // skip to new line
	       SkipNewStyleCommitTok() ;
	       goto head_LP ;
	  }
	  if( p == '*'  && p ) {
	       SkipCommitTok() ;
	       goto head_LP ;
	  }
      }

      sizeOfword = 0 ;
      while( p && IsNormalChar(p) ) {
	     wordBuffer[sizeOfword++] = p ;
	     p = GetCharFromConfigBuffer() ;
      }
      if( p == ')' || p == '#' ) ReturnCharToConfigBuffer() ;
      wordBuffer[sizeOfword] = 0x00 ;

      return &wordBuffer[0] ;
}

int findDefineTok(char *pDef)
{
     int i ;

     for(i = 0 ; i < defineTokLast ; i++) {
	   if( strcmp(_defineToks[i].Name,pDef) == 0 ) {
	       pLastDefineTok = &_defineToks[i] ;
	       return  1 ;
	   }
     }
     return 0 ;
}

int ProcessIfMacro()
{
      struct  _IF_DEFINE_PAIR  *p_if_define_pair ;
      struct  _IF_DEFINE_STACK *p_if_define_stack ;
      int     i ;

      p_if_define_stack = &_if_define_stack[sizeof_if_define_stack] ;

      for(i=0;i<p_if_define_stack->_sizeof_if_define_pair;i++) {
	   p_if_define_pair = &p_if_define_stack->_if_define_pair[i] ;
	   if( findDefineTok(p_if_define_pair->Name) ) {
	       return !p_if_define_pair->isNot ;
	   }
	   else {
	       return p_if_define_pair->isNot ;
	   }
      }
      return 0 ;
}

int ParseConfigFile()
{
      struct  _IF_DEFINE_PAIR *p_if_define_pair ;
      struct _IF_DEFINE_STACK *p_if_define_stack ;

      if( leadOfconfigBuffer >= sizeOfconfigBuffer ) {
	   if( !GetConfigFile() ) return 0 ;
      }
      if( !GetWordFromConfigFile() ) {
	    return 0 ;
      }

      switch( _iParseStatus ) {
	 case PARSE_NULL :
		   if( strncmp(wordBuffer,"#",1)==0) {
		       _iParseStatus = PARSE_MACRO_MASK ;
		   }
		   break ;
	 case PARSE_MACRO_MASK :
		   if( strncmp(wordBuffer,"if",2)==0) {
			_iMacro_If_Counter++ ;
			sizeof_if_define_stack++ ;
			p_if_define_stack = &_if_define_stack[sizeof_if_define_stack] ;
			p_if_define_stack->_sizeof_if_define_pair = 0 ;
			_iParseStatus = PARSE_MACRO_IF_MASK ;
		   } else
		   if( strncmp(wordBuffer,"define",6)==0) {
			_iParseStatus = PARSE_MACRO_DEFINE_MASK ;
		   }
		   else
		   {
			printf(" Error at %d\n",_iConfigFile_Line_Counter) ;
			return 0 ;
		   }
		   break ;
	 case PARSE_MACRO_DEFINE_MASK :
		   if( !findDefineTok(wordBuffer) ) {
			 _defineToks[defineTokLast].Value = -1 ;
			 strcpy(_defineToks[defineTokLast].Name,wordBuffer) ;
			 pLastDefineTok = &_defineToks[defineTokLast] ;
			 defineTokLast++ ;
		   }
		   _iParseStatus = PARSE_MACRO_DEFINE_VALUE_MASK ;
		   break ;
	 case PARSE_MACRO_DEFINE_VALUE_MASK :
		   if( strncmp(wordBuffer,"#",1)==0) {
		       _iParseStatus = PARSE_MACRO_MASK ;
		       break ;
		   }
		   else if( wordBuffer[0] != 0 ) {
			pLastDefineTok->Value = atoi(wordBuffer) ;
			_iParseStatus = PARSE_NULL ;
		   }
		   break ;
	 case PARSE_MACRO_IF_MASK :
		   if( strncmp(wordBuffer,"!",1)==0) {
			  _i_global_isNotFlag = 1 ;
		   }
		   else if( strncmp(wordBuffer,"defined",7)==0) {
			_iParseStatus = PARSE_MACRO_IF_DEF_MASK  ;
		   }
		   break ;
	 case PARSE_MACRO_IF_DEF_MASK  :
		   p_if_define_stack = &_if_define_stack[sizeof_if_define_stack] ;
		   p_if_define_pair  = &p_if_define_stack->_if_define_pair[p_if_define_stack->_sizeof_if_define_pair] ;
		   strcpy(p_if_define_pair->Name,wordBuffer) ;
		   p_if_define_stack->_sizeof_if_define_pair++ ;
		   p_if_define_pair->isNot = _i_global_isNotFlag;
		   _i_global_isNotFlag = 0 ;
		   _iParseStatus = PARSE_MACRO_IF_DEF_CLOSE_MASK ;
		   break ;
	 case PARSE_MACRO_IF_DEF_CLOSE_MASK :
		   if( strncmp(wordBuffer,")",1)==0) {
			  //if( p_if_define_pair->isNot ) {
			  //    if( !findDefineTok(p_if_define_pair->Name) ) {
			  //	  _iParseStatus = PARSE_MACRO_DEFINE_MASK ;
			   //   }
			  //}
		   }
		   else if( strncmp(wordBuffer,"#",1)==0) {
		       _iParseStatus = PARSE_MACRO_MASK ;
		       if( !ProcessIfMacro() ) {
			   _iParseStatus = PARSE_MACRO_IFDEF_WAIT_ENDIF_MASK;
		       }
		   }
		   break ;
	 case PARSE_MACRO_IFDEF_WAIT_ENDIF_MASK :
		   if( strncmp(wordBuffer,"#",1)==0) {
		       _iParseStatus = PARSE_MACRO_IFDEF_WAIT_ENDIF_WORD  ;
		   }
		   break ;
	 case PARSE_MACRO_IFDEF_WAIT_ENDIF_WORD  :
		   if( strncmp(wordBuffer,"if",2)==0) {
		       _iMacro_If_Counter++ ;
		       _iParseStatus = PARSE_MACRO_IFDEF_WAIT_ENDIF_MASK ;
		   }
		   else if( strncmp(wordBuffer,"endif",5)==0) {
		       _iMacro_If_Counter-- ;
		       if( _iMacro_If_Counter == 0 ) {
			   _iParseStatus = PARSE_NULL ;
			   break ;
		       }
		       _iParseStatus = PARSE_MACRO_IFDEF_WAIT_ENDIF_MASK ;
		   }
		   else if( strncmp(wordBuffer,"else",4)==0) {
			_iParseStatus = PARSE_MACRO_IFDEF_WAIT_ENDIF_MASK ;
		   }
	   break ;
      }
      return 1 ;
}

int main()
{
     sizeOfconfigBuffer = 0 ;
     _iMacro_If_Counter = 0 ;
     _iConfigFile_Line_Counter = 1 ;
     sizeof_if_define_stack = -1 ;
     _i_global_isNotFlag = 0 ;
     defineTokIndex = 0 ;
     defineTokLast  = 0 ;

     configFile = fopen(HZCODE_DEFIND_FILE,"r");
     while(ParseConfigFile()) ;
     fclose(configFile) ;
     return 0 ;
}