compiler.h

mgcp协议源代码和测试程序,还有一个编译器

/******************************************************************************
*      Copyright (C), 2005-2005 
*      All rights reserved
*
*      Authors                   :  Frank ZHANG
*      Description               :  
*
*
*      Date of creation          :  04/15/2005
*
*
*      History                   :
*      2005/04/15 Frank ZHANG    : - Creation
******************************************************************************/
#ifndef __ABNFTYPE_H__
#define __ABNFTYPE_H__

#include <stdio.h>

#include "typedef.h"
#include "list.h"
#include "debg.h"

/* Context stack deepth */
#define STACK_SIZE  64


/* Raw element types before element is processed, they are defined in RFC2234;
 * after processed, the GROUP/OPTION element and the compound element are
 * transformed into the new created element types */
#define ELEMENT_RULE           100  /* Element is a rule name: Rule */
#define ELEMENT_STRING         101  /* Element is a string: "abcd" */
#define ELEMENT_CHAR           102  /* Element is a char: %d12 or %x2A */
#define ELEMENT_TOKEN          103  /* Element is a rule name, but is capital */

#define ELEMENT_GROUP          104  /* Element is a group: (Elements) */
#define ELEMENT_OPTION         105  /* Element is a option: [Elements] */


/* New created element types after element is processed */
#define ELEMENT_GRP_RULE       201  /* Element is a group, but contain only one
                                     * rule element in it: *(Rule "abcd" %x2F) */

#define ELEMENT_OPT_RULE       202  /* Element is a option, but contain only one
                                     * rule element in it: : [*WSP Rule] */

#define ELEMENT_OPT_STR        203  /* Element is a option and contain only one
                                     * sting: ["abcd"] */

/* 1)First element is a Rule and its repetition is 1;
 * 2)The second element is a GRP_RULE and its name is same as the first RULE element
 * Meet above two conditions, the first RULE element is ELEMENT_RULE_LST_RULE type,
 * the second GRP_RULE element is ELEMENT_RULE_LST_GRP type */
#define ELEMENT_RULE_LST_RULE  204
#define ELEMENT_RULE_LST_GRP   205

#define ELEMENT_OPT_LST        206  /* Element is a option, but contain one RULE_LST 
                                     * in it: [Rule *("/" Rule)] */
                                     
/* Concatenation type in choice rule */
#define CHOICE_STR             300  /* Concatenation is string: "CRCX"/"EPCF" */
#define CHOICE_RULE            301  /* Concatenation is rule: Rule1/Rule2 */
#define CHOICE_TOKEN           302  /* Concatenation is token: ALPHA/HEXDIG */
#define CHOICE_CHAR            303  /* Concatenation is char: %d23/%x1D */


/* Rule type */
#define RULE_SEQUENCE          400  /* Rule is sequence type (not ONE_ELEM tpye)
                                     * and contains at least one rule name:
                                     * Rule = Rule1 Rule2 *"abcd"* %x2F */

#define RULE_ONE_ELEM          401  /* Rule contains one and only rule name and its
                                     * repetition is 1 */
                                     
#define RULE_STRING            402  /* Rule is sequence type and only contains
                                     * STRING/TOKEN/CHAR type repetitions:
                                     * Rule = *"abcd" *%x2F  *TOKEN */

#define RULE_CHOICE            403  /* Rule contains at least one ELEMENT_RULE
                                     * and no contain ELEMENT_CHAR,
                                     * Rule = Rule1/"abcd"/DIGIT */


#define RULE_STRING_CHOICE     404  /* Rule contains only STRING/CHAR/TOKEN type,
                                     * Rule = "abcd"/TOKEN/%d12-46 */


struct TConcatenation;

typedef struct TRule_tag {
  char *pRuleName;                /* Rule name */
  int iType;                      /* Rule type, such as Sequence,Choice... */
  int iCount;                     /* Concatenation number in this rule */
  struct TConcatenation* pConcat; /* Concatenation table */
}TRule;


typedef struct TGroupOption_tag {
  TRule Rule;                      /* Concatenation table */
}TGroupOption;


typedef struct TRepetition_tag {
  int iType;                       /* Element type, such as Rule type */

  char *pName;                     /* Repetition name, If rule type, store 
                                    * rule name, If string type, store string */

  int iRepMin;                     /* Min repeat of element */
  int iRepMax;                     /* Max repeat of element */
  int iNumbValueStart;             /* If char type, store the lower range */
  int iNumbValueEnd;               /* If char type, store the upper range */
  TGroupOption GroupOption;        /* Uesed only for Group or Option type */

  
  char *pVaribleName;              /* Used only for repetition in Choice rule,
                                    * to create Choice Enum macro, the repet 
                                    * name must be diffrent and cannot contain
                                    * special char, used this to store the 
                                    * Enum macro name. */


  char *pRuleName;                 /* If GrpRule/OptRule/OptLst, store the New
                                    * created rule name */
                                        
  TRule *pRuleLink;                /* Store the corresponding rule pointer */
  TRule *pGrpRuleLink;             /* Only used for GrpRule/OptRule/OptLst repetiton
                                    * store the corresponding rule pointer */                                   
}TRepetition;


typedef struct TConcatenation_tag {
  int iType;                       /* Only used for Choice Rule */
  int iCount;                      /* Repetition number in this concatenation */
  TRepetition* pRepetition;        /* Repetition table */
}TConcatenation;


typedef struct TRuleList_tag {
	int iCount;                      /* Rule number in this rule list */
	TRule* pRule;                    /* Rule table */
  
  TSList RulePntLst;               /* List store the rule pointer, the rules in
                                    * the rule list will be reordered according
                                    * their association, this list store the
                                    * rule pointer after reordered */
}TRuleList;


typedef struct TStack_tag {
  int iCount;
  void* pItem[STACK_SIZE];
}TStack;


typedef struct TElementCount_tag {
  int iTokenCount;
  int iCharCount;
  int iStringCount;
  int iRuleCount;
  int iGrpCount;
  int iOptCount;
  int iRuleLstRule;
  int iRuleLstGrp;
  int iRuleGrpCount;
  int iCharGrpCount;
  int iOptCharCount;
  int iOptRuleCount;
  int iOptLstCount;  

  int iTotalCount;
}TElementCount;


TRule* AddNewRule(TRuleList* pRuleList, char* pRuleName);
TConcatenation* AddNewConcatenation(TRule* pRule);
TRepetition* AddNewRepetition(TConcatenation* pConcat);
void FreeGroupOption(TGroupOption* pGroupOption);
void FreeRepetition(TRepetition* pRepetition);
void FreeConcatenation(TConcatenation* pConcatenation);
void FreeRule(TRule* pRule);
void InitRuleList(TRuleList *pRuleList);
void FreeRuleList(TRuleList* pRuleList);
void InitStack(TStack *pStack);
int PushStack(TStack *pStack, void* pItem);
void* PopStack(TStack *pStack);
TRule* CreateNewRule(char *pOrigName,TRepetition *pGrpOptRep, TRuleList *pOriRuleList, TRuleList *pNewRuleList);
void ConvertName(char *des, char *src);
char* ConvetName(char *Str);
BOOL ProcessRuleList(TRuleList *pRuleList);
BOOL ProcessRule(TRule *pRule, TRuleList *pRuleList, TRuleList *pNewRuleList);
void CountRepNumInConcat(TConcatenation *pConcat, TElementCount *count);
BOOL ProcessLstOpt(TRepetition *pRep, TRuleList *pRuleList, TRuleList *pNewRuleList);
BOOL ProcessRuleOpt(TRepetition *pRep, TRuleList *g_pRuleList, TRuleList *g_pNewRuleList);
BOOL ProcessLstOpt(TRepetition *pRep, TRuleList *pRuleList, TRuleList *pNewRuleList);
BOOL ProcessOpt(TRepetition *pRep, TRuleList *pRuleList, TRuleList *pNewRuleList);
BOOL ProcessGroup(TRepetition *pRep, TRuleList *pRuleList, TRuleList *pNewRuleList);
BOOL ProcessRep(TRepetition *pRep, TRuleList *pRuleList, TRuleList *pNewRuleList);
void PreProcessRepet(TRepetition *pRep);
BOOL IsOneElement(TGroupOption *pGrp);
void MergeRules(TRuleList *pDes, TRuleList *pSrc);
BOOL SortRule(TRuleList *pRuleList, TSList *pArray);
TRule* FindRule(TRuleList *pRuleList, char *RuleName);
TRule *CheckDupRuleName(TRuleList *pRuleList);
BOOL LinkRule(TRuleList *pRuleList);
BOOL FindRulePntInList(TRule *pRule, TSList *pArray);


void PrintRuleStruct(TRule *pRule, FILE *f);
void PrintRuleFuncPrototype(TRule *pRuleList, FILE *file);
void PrintChoiceRuleStruct(TRule *pRule, FILE *f);
void PrintSeqRuleStruct(TRule *pRule, FILE *f);
void PrintDeFuncOfTokenElemInSeq(TRepetition *pRept, FILE *file);
void PrintDeFuncOfGrpRuleInOptLst(char *pRuleName, TRepetition *pRept, FILE *file);
void PrintDeFuncOfGrpRule(char *pRuleName, TRepetition *pRept, FILE *file);
void PrintDeFuncOfOptRule(char *pRuleName, TRepetition *pRept, FILE *file);
void PrintDeFuncOfOptLst(char *pRuleName, TRepetition *pRept, FILE *file);
void PrintDeFuncOfRuleElemInSeq(char *pRuleName, TRepetition *pRept, FILE *file);
void PrintDeFuncOfRuleElemInChoice(char *pRuleName, TRepetition *pRept, FILE *file);
void PrintDeFuncOfStrRule(TRule *pRule, FILE *file);
void PrintDeFuncOfStrChoiceRule(TRule *pRule, FILE *file);
void PrintDeFuncOfRuleLst(char *pRuleName, TRepetition *pRept, FILE *file);
void PrintDeSegOfRuleLst(char *pRuleName, TRepetition *pRept, FILE *file);
void PrintDeFuncOfChoiceRule(TRule *pRule, FILE *file);
void PrintDeFuncOfSeqRule(TRule *pRule, FILE *file);
void PrintEnFuncOfTokenElemInSeq(TRepetition *pRept, FILE *file);
void PrintEnFuncOfGrpRule(char *pRuleName, TRepetition *pRept, FILE *file);
void PrintEnFuncOfGrpRuleInRuleLst(char *pRuleName, TRepetition *pRept, FILE *file);
void PrintEnFuncOfOptRule(char *pRuleName, TRepetition *pRept, FILE *file);
void PrintEnFuncOfOptLst(char *pRuleName, TRepetition *pRept, FILE *file);
void PrintEnSegOfRuleLst(char *pRuleName, TRepetition *pRept, FILE *file);
void PrintEnFuncOfRuleElemInSeq(char *pRuleName, TRepetition *pRept, FILE *file);
void PrintEnFuncOfRuleElemInChoice(char *pRuleName, TRepetition *pRept, FILE *file);
void PrintEnFuncOfStrRule(TRule *pRule, FILE *file);
void PrintEnFuncOfRuleLst(char *pRuleName, TRepetition *pRept, FILE *file);
void PrintEnFuncOfChoiceRule(TRule *pRule, FILE *file);
void PrintEnFuncOfSeqRule(TRule *pRule, FILE *file);
void PrintRuleDecEncFunc(TRule *pRule, FILE *file);
void PrintCFile(TRuleList *pRuleList, FILE *Headerfile, FILE *Deffile);
void PrintFreeFuncOfListRule(TRule *pRule, TRepetition *pRep, FILE *file);
void PrintFreeFuncOfOptRule(TRule *pRule, TRepetition *pRep, FILE *file);
void PrintFreeFuncOfSeqRule(TRule *pRule, FILE *file);
void PrintFreeFuncOfChoiceRule(TRule *pRule, FILE *file);
void PrintRuleFreeFunc(TRule *pRule, FILE *file);

#endif