sctpredg.h

是一个手机功能的模拟程序

      } \
      return Temp->Data; \
    } \
  }


/*-- yAss_SORT (String)--------------------------------------------*/
#define String_Assign(SORT, COMPONENTSORT) \
  static XCAT(SORT,_yptr)  XCAT(yAvail_,SORT) = (XCAT(SORT,_yptr))0; \
  void XCAT(yAss_,SORT) \
    XPP_PROTO( (SORT * SVar, SORT SExpr, int AssType) ) \
    XPP_NOPROTO( (SVar, SExpr, AssType)  SORT * SVar; SORT SExpr; int AssType; ) \
  { \
    XCAT(SORT,_yptr)  TempSVar, TempExpr; \
    \
    if ((*SVar).First != (XCAT(SORT,_yptr))0 && (*SVar).First == SExpr.First) \
      return; \
    if (AssType == XASS && (*SVar).First != (XCAT(SORT,_yptr))0) { \
      XCAT(yFree_,SORT)((void **)SVar); \
    } \
    if ( (SExpr.IsAssigned || AssType == XASS2MAKE) && \
         SExpr.First != (XCAT(SORT,_yptr))0) { \
      TempExpr = SExpr.First; \
      TempSVar = XCAT(yGetAvail_,SORT)(); \
      (*SVar).First = TempSVar; \
      XCAT(yAssF_,COMPONENTSORT)(TempSVar->Data, TempExpr->Data, XASS); \
      \
      TempExpr = TempExpr->Suc; \
      while (TempExpr != (XCAT(SORT,_yptr))0) { \
        TempSVar->Suc = XCAT(yGetAvail_,SORT)(); \
        TempSVar = TempSVar->Suc; \
        XCAT(yAssF_,COMPONENTSORT)(TempSVar->Data, TempExpr->Data, XASS); \
        TempExpr = TempExpr->Suc; \
      } \
      (*SVar).Last = TempSVar; \
    } else { \
      (*SVar).First = SExpr.First; \
      (*SVar).Last = SExpr.Last; \
    } \
    (*SVar).Length = SExpr.Length; \
    (*SVar).IsAssigned = (xbool)1; \
  }


/*-- yEq_SORT (String)---------------------------------------------*/
#define String_Equal(SORT, COMPONENTSORT) \
  SDL_Boolean XCAT(yEq_,SORT) \
    XPP_PROTO( (SORT Expr1, SORT Expr2) ) \
    XPP_NOPROTO( (Expr1, Expr2) SORT Expr1; SORT Expr2; ) \
  { \
    XCAT(SORT,_yptr)  Temp1, Temp2; \
    SDL_Boolean  Result; \
    \
    Result = SDL_True; \
    if (Expr1.Length != Expr2.Length) \
      Result = SDL_False; \
    Temp1 = Expr1.First; \
    Temp2 = Expr2.First; \
    while (Result && Temp1 != (XCAT(SORT,_yptr))0) { \
      if (XCAT(yNEqF_,COMPONENTSORT)(Temp1->Data, Temp2->Data) ) \
        Result = SDL_False; \
      Temp1 = Temp1->Suc; \
      Temp2 = Temp2->Suc; \
    } \
    if (! Expr1.IsAssigned && Expr1.First != (XCAT(SORT,_yptr))0) { \
      XCAT(yFree_,SORT)((void **)&Expr1); \
    } \
    if (! Expr2.IsAssigned && Expr2.First != (XCAT(SORT,_yptr))0) { \
      XCAT(yFree_,SORT)((void **)&Expr2); \
    } \
    return Result; \
  }

/*-- yDef_SORT (String)--------------------------------------------*/
#define String_Default(SORT, COMPONENTSORT) \
  void XCAT(yDef_,SORT) \
    XPP_PROTO( (SORT *SIn) ) \
    XPP_NOPROTO( (SIn) SORT *SIn; ) \
  { \
    (*SIn).First = (XCAT(SORT,_yptr))0; \
    (*SIn).Last = (XCAT(SORT,_yptr))0; \
    (*SIn).Length = 0; \
    (*SIn).IsAssigned = (xbool)1; \
  }


/*-- yFree_SORT (String)-------------------------------------------*/
#define String_Free(SORT, COMPONENTSORT, FREEFUNC) \
  void XCAT(yFree_,SORT) \
    XPP_PROTO( (void ** C) ) \
    XPP_NOPROTO( (C) void ** C; ) \
  { \
    XCAT(SORT,_yptr)  Temp, TempSuc; \
    if (FREEFUNC != XXFREE) { \
      for (Temp =  (*(SORT *)C).First; \
           Temp != (XCAT(SORT,_yptr))0; \
           Temp =  TempSuc) { \
        FREEFUNC((void **)&Temp->Data); \
        TempSuc =  Temp->Suc; \
        XFREE((void **)&Temp, sizeof(XCAT(SORT,_yrec))); \
      } \
    } \
    else if ((*(SORT *)C).First != (XCAT(SORT,_yptr))0) { \
      (*(SORT *)C).Last->Suc = XCAT(yAvail_,SORT); \
      XCAT(yAvail_,SORT) = (*(SORT *)C).First; \
    } \
    (*(SORT *)C).First = (XCAT(SORT,_yptr))0; \
    (*(SORT *)C).Last = (XCAT(SORT,_yptr))0; \
    (*(SORT *)C).Length = 0; \
    (*(SORT *)C).IsAssigned = (xbool)0; \
    for (Temp = XCAT(yAvail_,SORT); \
         Temp; \
         Temp = XCAT(yAvail_,SORT)) { \
      XCAT(yAvail_,SORT)  = Temp->Suc; \
      if (FREEFUNC != XXFREE)  FREEFUNC((void **)&Temp->Data); \
      XFREE((void **)&Temp, sizeof(XCAT(SORT,_yrec))); \
    } \
  }

/*-- yWri_SORT (String)-------------------------------------------*/
#ifdef XITEXCOMM
#define String_Write_Start \
  if (XSYSD xUse_Itex_Syntax) \
    (void)strcpy(CTemp, "(: "); \
  else
#define String_Write_End \
  if (XSYSD xUse_Itex_Syntax) \
    xSafeStrcat(CTemp, " :)"); \
  else
#else
#define String_Write_Start
#define String_Write_End
#endif

#define String_Write(SORT, COMPONENTSORT) \
  char * XCAT(yWri_,SORT) \
    XPP_PROTO( (void * SIn) ) \
    XPP_NOPROTO( (SIn) void * SIn; ) \
  { \
    XCAT(SORT,_yptr) Temp, TempLast; \
  static  char       CTemp[MAX_WRI_LENGTH]; \
    \
    String_Write_Start \
    if (XASN1_SYNTAX) \
      (void)strcpy(CTemp, "{ "); \
    else \
      (void)strcpy(CTemp, "(. "); \
    TempLast = (*(SORT *)SIn).Last; \
    for (Temp = (*(SORT *)SIn).First; \
         Temp != (XCAT(SORT,_yptr))0; \
         Temp = Temp->Suc) { \
      xSafeStrcat(CTemp, \
             xWriteSort((void *)(&Temp->Data), XCAT(ySrtN_,COMPONENTSORT))); \
      if (strlen(CTemp) == MAX_WRI_LENGTH - 1) \
        return CTemp; \
      if (Temp != TempLast) \
        xSafeStrcat(CTemp, ", "); \
    } \
    String_Write_End \
    if (XASN1_SYNTAX) \
      xSafeStrcat(CTemp, " }"); \
    else \
      xSafeStrcat(CTemp, " .)"); \
    return CTemp; \
  }


/*-- yRead_SORT (String)------------------------------------------*/
#ifdef XITEXCOMM
#define String_Read_StartToken (Token != xxLParColon) &&
#define String_Read_EndToken   (Token != xxRParColon) &&
#define String_Read_EndTokenOr (Token == xxRParColon) ||
#else
#define String_Read_StartToken
#define String_Read_EndToken
#define String_Read_EndTokenOr
#endif

#define String_Read(SORT, COMPONENTSORT) \
  int XCAT(yRead_,SORT) \
    XPP_PROTO( (void * Result) ) \
    XPP_NOPROTO( (Result) void * Result; ) \
  { \
    COMPONENTSORT Item; \
    xxToken       Token; \
    char          strVar[256]; \
    int           Res; \
    \
    (*(SORT *)Result).First = (XCAT(SORT,_yptr))0; \
    (*(SORT *)Result).Last = (XCAT(SORT,_yptr))0; \
    (*(SORT *)Result).Length = 0; \
    (*(SORT *)Result).IsAssigned = (int)0; \
    Token = xScanToken(strVar); \
    if (XVALUE_SYNTAX && \
        String_Read_StartToken \
        Token != xxLParDot && Token != xxLCurlyBracket && \
        Token != xxQuestionMark && Token != xxEoln) { \
      xPrintString("String value should start with (. or {\n"); \
      return 0; \
    } \
    if (String_Read_StartToken \
      Token != xxLParDot && Token != xxLCurlyBracket) \
      xUngetToken(Token, strVar); \
    \
    while (String_Read_EndToken \
           Token != xxRParDot && Token != xxRCurlyBracket) { \
      (void)sprintf(strVar, " (%s) : ", XCAT(ySrtN_,COMPONENTSORT)->Name); \
      (void)memset((void *)(&Item), 0, sizeof(COMPONENTSORT)); \
      Res = xReadOneParameter(XCAT(ySrtN_,COMPONENTSORT), strVar, (void *)&Item); \
      if (Res == 0) return 0; \
      if (Res == 2) { \
        Token = xScanToken(strVar); \
        if (String_Read_EndTokenOr \
            Token == xxRParDot || Token == xxRCurlyBracket) break; \
        return 0; \
      } \
      XCAT(yAppend_,SORT)((SORT *)Result, XCAT(yMkString_,SORT)(Item)); \
      Token = xScanToken(strVar); \
      if (String_Read_EndToken \
          Token != xxRParDot && Token != xxRCurlyBracket) \
        xUngetToken(Token, strVar); \
    } \
    (*(SORT *)Result).IsAssigned = (int)1; \
    return 1; \
  }

/****+***************************************************************
05   Generator Array  (array that cannot become array in C)
********************************************************************/

/* typedef for Array type -----------------------------------------*/

#ifdef ALPHACC
#define Array_Type(SORT, INDEXSORT, COMPONENTSORT) \
   typedef struct XCAT(SORT,_ystruct)  * XCAT(SORT,_yptr); \
   typedef struct XCAT(SORT,_ystruct) { \
     XCAT(SORT,_yptr)   Suc; \
     INDEXSORT          Index; \
     COMPONENTSORT      Data; \
   } XCAT(SORT,_yrec); \
   typedef struct { \
     XCAT(SORT,_yptr) First; \
     XCAT(SORT,_yptr) Last; \
     long             IsAssigned; \
     COMPONENTSORT    Data; \
   } SORT;
#else
#define Array_Type(SORT, INDEXSORT, COMPONENTSORT) \
   typedef struct XCAT(SORT,_ystruct)  * XCAT(SORT,_yptr); \
   typedef struct XCAT(SORT,_ystruct) { \
     XCAT(SORT,_yptr)   Suc; \
     INDEXSORT          Index; \
     COMPONENTSORT      Data; \
   } XCAT(SORT,_yrec); \
   typedef struct { \
     XCAT(SORT,_yptr) First; \
     XCAT(SORT,_yptr) Last; \
     xbool            IsAssigned; \
     COMPONENTSORT    Data; \
   } SORT;
#endif


/* Array operator prototypes --------------------------------------*/

#define Array_prototypes(SORT, INDEXSORT, COMPONENTSORT) \
  extern SORT XCAT(yMake_,SORT) XPP((COMPONENTSORT)); \
  extern COMPONENTSORT XCAT(yExtr_,SORT) XPP((SORT, INDEXSORT)); \
  extern COMPONENTSORT *XCAT(yAddr_,SORT) XPP((SORT *, INDEXSORT)); \
  \
  extern XCAT(SORT,_yptr) XCAT(yGetAvail_,SORT) XPP((void)); \
  extern COMPONENTSORT XCAT(yExtrInner_,SORT) \
         XPP((SORT S, INDEXSORT Index)); \
  \
  extern char * XCAT(yWri_,SORT) XPP((void * S)); \
  extern int XCAT(yRead_,SORT) XPP((void * Result));


/* Array operator implementations ---------------------------------*/

/*-- yMake_SORT (Array)--------------------------------------------*/
#define Array_Make(SORT, INDEXSORT, COMPONENTSORT) \
  SORT XCAT(yMake_,SORT) \
    XPP_PROTO( (COMPONENTSORT Component) ) \
    XPP_NOPROTO( (Component) COMPONENTSORT Component; ) \
  { \
    SORT Result; \
    (void)memset((void *)&Result, 0, sizeof(SORT)); \
    Result.First = (XCAT(SORT,_yptr))0; \
    Result.Last = (XCAT(SORT,_yptr))0; \
    Result.IsAssigned = (xbool)0; \
    XCAT(yAssF_,COMPONENTSORT)(Result.Data, Component, XASS); \
    return Result; \
  }


/*-- yModify_SORT (Array)------------------------------------------*/
#define Array_Modify(SORT, INDEXSORT, COMPONENTSORT) \
  XCAT(SORT,_yptr) XCAT(yGetAvail_,SORT) XPP((void)) \
  { \
    XCAT(SORT,_yptr) Item; \
    if (XCAT(yAvail_,SORT) != (XCAT(SORT,_yptr))0) { \
      Item = XCAT(yAvail_,SORT); \
      XCAT(yAvail_,SORT) = XCAT(yAvail_,SORT)->Suc; \
      Item->Suc = (XCAT(SORT,_yptr))0; \
    } else { \
      Item = (XCAT(SORT,_yptr))xAlloc((unsigned)sizeof(XCAT(SORT,_yrec))); \
    } \
    return Item; \
  } \
  \
  COMPONENTSORT *XCAT(yAddr_,SORT) \
    XPP_PROTO( (SORT *S, INDEXSORT Index) ) \
    XPP_NOPROTO( (S, Index) SORT *S; INDEXSORT Index; ) \
  { \
    XCAT(SORT,_yptr) Temp; \
    Temp = (*S).First; \
    while ( Temp != (XCAT(SORT,_yptr))0  && \
            XCAT(yNEqF_,INDEXSORT)(Temp->Index, Index) ) \
      Temp = Temp->Suc; \
    if (Temp != (XCAT(SORT,_yptr))0) \
      return &Temp->Data; \
    if ((*S).First == (XCAT(SORT,_yptr))0) { \
      (*S).First = XCAT(yGetAvail_,SORT)(); \
      (*S).Last = (*S).First; \
    } else { \
      (*S).Last->Suc = XCAT(yGetAvail_,SORT)(); \
      (*S).Last = (*S).Last->Suc; \
    } \
    XCAT(yAssF_,INDEXSORT)((*S).Last->Index, Index, XASS); \
    XCAT(yAssF_,COMPONENTSORT)((*S).Last->Data, (*S).Data, XASS); \
    return &(*S).Last->Data; \
  }


/*-- yExtr_SORT (Array)---------------------------------------------*/
#define Array_Extract(SORT, INDEXSORT, COMPONENTSORT) \
  \
  COMPONENTSORT XCAT(yExtrInner_,SORT) \
    XPP_PROTO( (SORT S, INDEXSORT Index) ) \
    XPP_NOPROTO( (S, Index) SORT S; INDEXSORT Index; ) \
  { \
    XCAT(SORT,_yptr) Temp; \
    Temp = S.First; \
    while ( Temp != (XCAT(SORT,_yptr))0  && \
            XCAT(yNEqF_,INDEXSORT)(Temp->Index, Index) ) \
      Temp = Temp->Suc; \
    if (Temp != (XCAT(SORT,_yptr))0) \
      return Temp->Data; \
    else \
      return S.Data; \
  } \
  \
  COMPONENTSORT XCAT(yExtr_,SORT) \
    XPP_PROTO( (SORT S, INDEXSORT Index) ) \
    XPP_NOPROTO( (S, Index) SORT S; INDEXSORT Index; ) \
  { \
    COMPONENTSORT result; \
    result = XCAT(yExtrInner_,SORT)(S, Index); \
    if (! S.IsAssigned && S.First != (XCAT(SORT,_yptr))0) \
      XCAT(yFree_,SORT)((void **)&S); \
    return result; \
  }


/*-- yAss_SORT (Array)---------------------------------------------*/
#ifdef NO_GLOBAL_VARS
#define Array_Assign(SORT, INDEXSORT, COMPONENTSORT) \
  void XCAT(yAss_,SORT) \
    XPP_PROTO( (SORT * SVar, SORT SExpr, int AssType) ) \
    XPP_NOPROTO( (SVar, SExpr, AssType)  SORT * SVar; SORT SExpr; int AssType; ) \
  { \
    XCAT(SORT,_yptr)  TempSVar, TempExpr, PrevExpr; \
    \
    if ((*SVar).First != SExpr.First) {\