sctpredg.h

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

      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_,INDEXSORT)(TempSVar->Index, TempExpr->Index, XASS); \
        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_,INDEXSORT)(TempSVar->Index, TempExpr->Index, XASS); \
          XCAT(yAssF_,COMPONENTSORT)(TempSVar->Data, TempExpr->Data, XASS); \
          TempExpr = TempExpr->Suc; \
        } \
        (*SVar).Last = TempSVar; \
      } else { \
        (*SVar).First = SExpr.First; \
        (*SVar).Last = SExpr.Last; \
      } \
    } \
    XCAT(yAssF_,COMPONENTSORT)((*SVar).Data, SExpr.Data, XASS); \
    (*SVar).IsAssigned = (xbool)1; \
    \
    PrevExpr = (*SVar).First; \
    while ( PrevExpr != (XCAT(SORT,_yptr))0 && \
            XCAT(yEqF_,COMPONENTSORT)(PrevExpr->Data, (*SVar).Data) ) { \
      (*SVar).First = PrevExpr->Suc; \
      PrevExpr->Suc = XCAT(yAvail_,SORT); \
      XCAT(yAvail_,SORT) = PrevExpr; \
      PrevExpr = (*SVar).First; \
    } \
    if ( PrevExpr != (XCAT(SORT,_yptr))0 ) { \
      while ( PrevExpr->Suc != (XCAT(SORT,_yptr))0 ) { \
        TempExpr = PrevExpr->Suc; \
        if ( XCAT(yEqF_,COMPONENTSORT)(TempExpr->Data, (*SVar).Data) ) { \
          PrevExpr->Suc = TempExpr->Suc; \
          TempExpr->Suc = XCAT(yAvail_,SORT); \
          XCAT(yAvail_,SORT) = TempExpr; \
        } else { \
          PrevExpr = TempExpr; \
        } \
      } \
    } \
    (*SVar).Last = PrevExpr; \
  }
#else
#define Array_Assign(SORT, INDEXSORT, 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, PrevExpr; \
    \
    if ((*SVar).First != SExpr.First) {\
      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_,INDEXSORT)(TempSVar->Index, TempExpr->Index, XASS); \
        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_,INDEXSORT)(TempSVar->Index, TempExpr->Index, XASS); \
          XCAT(yAssF_,COMPONENTSORT)(TempSVar->Data, TempExpr->Data, XASS); \
          TempExpr = TempExpr->Suc; \
        } \
        (*SVar).Last = TempSVar; \
      } else { \
        (*SVar).First = SExpr.First; \
        (*SVar).Last = SExpr.Last; \
      } \
    } \
    XCAT(yAssF_,COMPONENTSORT)((*SVar).Data, SExpr.Data, XASS); \
    (*SVar).IsAssigned = (xbool)1; \
    \
    PrevExpr = (*SVar).First; \
    while ( PrevExpr != (XCAT(SORT,_yptr))0 && \
            XCAT(yEqF_,COMPONENTSORT)(PrevExpr->Data, (*SVar).Data) ) { \
      (*SVar).First = PrevExpr->Suc; \
      PrevExpr->Suc = XCAT(yAvail_,SORT); \
      XCAT(yAvail_,SORT) = PrevExpr; \
      PrevExpr = (*SVar).First; \
    } \
    if ( PrevExpr != (XCAT(SORT,_yptr))0 ) { \
      while ( PrevExpr->Suc != (XCAT(SORT,_yptr))0 ) { \
        TempExpr = PrevExpr->Suc; \
        if ( XCAT(yEqF_,COMPONENTSORT)(TempExpr->Data, (*SVar).Data) ) { \
          PrevExpr->Suc = TempExpr->Suc; \
          TempExpr->Suc = XCAT(yAvail_,SORT); \
          XCAT(yAvail_,SORT) = TempExpr; \
        } else { \
          PrevExpr = TempExpr; \
        } \
      } \
    } \
    (*SVar).Last = PrevExpr; \
  }
#endif

/*-- yEq_SORT (Array)----------------------------------------------*/
#define Array_Equal(SORT, INDEXSORT, COMPONENTSORT) \
  SDL_Boolean XCAT(yEq_,SORT) \
    XPP_PROTO( (SORT Expr1, SORT Expr2) ) \
    XPP_NOPROTO( (Expr1, Expr2) SORT Expr1; SORT Expr2; ) \
  { \
    XCAT(SORT,_yptr)  Temp; \
    SDL_Boolean  Result; \
    \
    Result = XCAT(yEqF_,COMPONENTSORT)(Expr1.Data, Expr2.Data); \
    if (Result) { \
      Temp = Expr1.First; \
      while (Result && Temp != (XCAT(SORT,_yptr))0) { \
        if (XCAT(yNEqF_,COMPONENTSORT) \
             (Temp->Data, XCAT(yExtrInner_,SORT)(Expr2, Temp->Index)) ) \
          Result = SDL_False; \
        Temp = Temp->Suc; \
      } \
      Temp = Expr2.First; \
      while (Result && Temp != (XCAT(SORT,_yptr))0) { \
        if (XCAT(yNEqF_,COMPONENTSORT) \
             (Temp->Data, XCAT(yExtrInner_,SORT)(Expr1, Temp->Index)) ) \
          Result = SDL_False; \
        Temp = Temp->Suc; \
      } \
    } \
    \
    if (! Expr1.IsAssigned) \
      XCAT(yFree_,SORT)((void **)&Expr1); \
    if (! Expr2.IsAssigned) \
      XCAT(yFree_,SORT)((void **)&Expr2); \
    return Result; \
  }

/*-- yDef_SORT (Array)---------------------------------------------*/
#define Array_Default(SORT, INDEXSORT, COMPONENTSORT) \
  void XCAT(yDef_,SORT) \
    XPP_PROTO( (SORT *S) ) \
    XPP_NOPROTO( (S) SORT *S; ) \
  { \
    (*S).First = (XCAT(SORT,_yptr))0; \
    (*S).Last = (XCAT(SORT,_yptr))0; \
    XCAT(yDef_,COMPONENTSORT)(&(*S).Data); \
    (*S).IsAssigned = (xbool)1; \
  } 


/*-- yFree_SORT (Array)--------------------------------------------*/
#define Array_Free(SORT, INDEXSORT, FREEINDEX, COMPONENTSORT, FREECOMP) \
  void XCAT(yFree_,SORT) \
    XPP_PROTO( (void ** C) ) \
    XPP_NOPROTO( (C) void ** C; ) \
  { \
    XCAT(SORT,_yptr)  Temp, TempSuc; \
    if (FREECOMP != XXFREE || FREEINDEX != XXFREE) { \
      for (Temp =  (*(SORT *)C).First; \
           Temp != (XCAT(SORT,_yptr))0; \
           Temp =  TempSuc) { \
        if (FREECOMP != XXFREE)  FREECOMP((void **)&Temp->Data); \
        if (FREEINDEX != XXFREE) FREEINDEX((void **)&Temp->Index); \
        TempSuc =  Temp->Suc; \
        XFREE((void **)&Temp, sizeof(XCAT(SORT,_yrec))); \
      } \
      if (FREECOMP != XXFREE) \
        FREECOMP((void **)&(*(SORT *)C).Data); \
    } \
    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; \
    for (Temp = XCAT(yAvail_,SORT); \
         Temp; \
         Temp = XCAT(yAvail_,SORT)) { \
      XCAT(yAvail_,SORT)  = Temp->Suc; \
      if (FREECOMP != XXFREE)  FREECOMP((void **)&Temp->Data); \
      if (FREEINDEX != XXFREE) FREEINDEX((void **)&Temp->Index); \
      XFREE((void **)&Temp, sizeof(XCAT(SORT,_yrec))); \
    } \
  }


/*-- yWri_SORT (Array)---------------------------------------------*/
#define Array_Write(SORT, INDEXSORT, COMPONENTSORT) \
  char * XCAT(yWri_,SORT) \
    XPP_PROTO( (void * S) ) \
    XPP_NOPROTO( (S) void * S; ) \
  { \
    XCAT(SORT,_yptr) ArrPtr; \
  static  char       CTemp[MAX_WRI_LENGTH]; \
    \
    (void)strcpy(CTemp, "(: (others:"); \
    xSafeStrcat(CTemp, \
       xWriteSort((void *)(&(*(SORT *)S).Data), XCAT(ySrtN_,COMPONENTSORT))); \
    xSafeStrcat(CTemp, ")"); \
    for (ArrPtr =  (*(SORT *)S).First; \
         ArrPtr != (XCAT(SORT,_yptr))0; \
         ArrPtr =  ArrPtr->Suc) { \
      xSafeStrcat(CTemp, ", ("); \
      xSafeStrcat(CTemp, \
               xWriteSort((void *)(&ArrPtr->Index), XCAT(ySrtN_,INDEXSORT))); \
      xSafeStrcat(CTemp, ":"); \
      xSafeStrcat(CTemp, \
            xWriteSort((void *)(&ArrPtr->Data), XCAT(ySrtN_,COMPONENTSORT))); \
      xSafeStrcat(CTemp, ")"); \
    } \
    xSafeStrcat(CTemp, " :)"); \
    return CTemp; \
  }


/*-- yRead_SORT (Array)--------------------------------------------*/
#define Array_Read(SORT, INDEXSORT, COMPONENTSORT) \
  int XCAT(yRead_,SORT) \
    XPP_PROTO( (void * Result) ) \
    XPP_NOPROTO( (Result) void * Result; ) \
  { \
    INDEXSORT     Index; \
    COMPONENTSORT Item; \
    xxToken       Token; \
    char          strVar[256]; \
    xbool         IsOthers; \
    int           Res; \
    \
    XCAT(yDef_,SORT)((SORT *)Result); \
    Token = xScanToken(strVar); \
    if (XVALUE_SYNTAX && \
        Token != xxLParColon && Token != xxQuestionMark && Token != xxEoln) { \
      xPrintString("Array value should start with (:\n"); \
      return 0; \
    } \
    if (Token != xxLParColon) xUngetToken(Token, strVar); \
    \
    IsOthers = (xbool)1; \
    while (Token != xxRParColon) { \
      Token = xScanToken(strVar); \
      if (Token == xxLPar) Token = xScanToken(strVar); \
      if (! IsOthers) { \
        if (Token == xxEoln || Token == xxQuestionMark) { \
          (void)sprintf(strVar, " Index (%s) : ", XCAT(ySrtN_,INDEXSORT)->Name); \
          xPrintString(strVar); \
          Token = xScanToken(strVar); \
        } \
        if (Token == xxRParColon) break; \
        xUngetToken(Token, strVar); \
        (void)memset((void *)(&Index), 0, sizeof(INDEXSORT)); \
        if ( ! xReadSort((void *)&Index, XCAT(ySrtN_,INDEXSORT))) { \
          xPrintString("Illegal index value\n"); \
          return 0; \
        } \
        Token = xScanToken(strVar); \
      } else { \
        if (Token == xxEoln || Token == xxQuestionMark) { \
          xPrintString(" others"); \
        } else if (Token == xxId) { \
          if (xfEqualIdString(strVar, "others") != 2) { \
            xPrintString("others expected\n"); \
            return 0; \
          } \
          Token = xScanToken(strVar); \
        } else { \
          xPrintString("others expected\n"); \
          return 0; \
        } \
      } \
      if (Token != xxColon) xUngetToken(Token, strVar); \
      if (IsOthers) \
        (void)sprintf(strVar, " Others component (%s) : ", XCAT(ySrtN_,COMPONENTSORT)->Name); \
      else \
        (void)sprintf(strVar, " Component (%s) : ", XCAT(ySrtN_,COMPONENTSORT)->Name); \
      (void)memset((void *)(&Item), 0, sizeof(COMPONENTSORT)); \
      Res = xReadOneParameter(XCAT(ySrtN_,COMPONENTSORT), strVar, (void *)&Item); \
      if (Res == 0) { \
        xPrintString("Illegal component value\n"); \
        return 0; \
      } \
      if (IsOthers) \
        XCAT(yAss_,SORT)((SORT *)Result, XCAT(yMake_,SORT)(Item), XASS); \
      else \
        XCAT(yAssF_,COMPONENTSORT)( \
            (* XCAT(yAddr_,SORT)((SORT *)Result, Index)) , Item, XASS); \
      \
      Token = xScanToken(strVar); \
      if (Token == xxRPar) Token = xScanToken(strVar); \
      if (Token == xxComma) Token = xScanToken(strVar); \
      if (Token != xxRParColon) xUngetToken(Token, strVar); \
      IsOthers = (xbool)0; \
    } \
    (*(SORT *)Result).IsAssigned = (int)1; \
    return 1; \
  }


/****+***************************************************************
06   Generator Powerset  (limited and discrete component type)
********************************************************************/

/* typedef for Powerset type --------------------------------------*/

#define Powerset_Type(SORT, COMPONENTSORT, LOW, HIGH) \
  typedef struct { \
    unsigned long A[(HIGH-LOW)/32+1]; \
  } SORT;

  /* unsigned long is assumed to be 32 bits */


#define Powerset_prototypes(SORT, COMPONENTSORT, LOW, HIGH) \
  extern SORT XCAT(yEmpty_,SORT) XPP((void)); \
  extern SDL_Boolean XCAT(yIn_,SORT) XPP((COMPONENTSORT, SORT)); \
  extern SORT XCAT(yIncl_,SORT) XPP((COMPONENTSORT, SORT)); \
  extern SORT XCAT(yDel_,SORT) XPP((COMPONENTSORT, SORT)); \
  extern SDL_Boolean XCAT(yLT_,SORT) XPP((SORT, SORT)); \
  extern SDL_Boolean XCAT(yGT_,SORT) XPP((SORT, SORT)); \
  extern SDL_Boolean XCAT(yLE_,SORT) XPP((SORT, SORT)); \
  extern SDL_Boolean XCAT(yGE_,SORT) XPP((SORT, SORT)); \
  extern SORT XCAT(yAnd_,SORT) XPP((SORT, SORT)); \
  extern SORT XCAT(yOr_,SORT) XPP((SORT, SORT)); \
  extern SDL_Integer XCAT(yLength_,SORT) XPP((SORT)); \
  extern COMPONENTSORT XCAT(yTake_,SORT) XPP((SORT)); \
  extern COMPONENTSORT XCAT(yTake2_,SORT) XPP((SORT, SDL_Integer));


/*-- yEmpty_SORT (Powerset)----------------------------------------*/
#define Powerset_Empty(SORT, COMPONENTSORT, LOW, HIGH) \
  SORT XCAT(yEmpty_,SORT) XPP((void)) \
  { \
    SORT PS; \
    int Item; \
    for (Item=0; Item<=(HIGH-LOW)/32; Item++) \
      PS.A[Item] = 0; \
    return PS; \
  }  


/*-- yIn_SORT (Powerset)-------------------------------------------*/
#define Powerset_In(SORT, COMPONENTSORT, LOW, HIGH) \
  SDL_Boolean XCAT(yIn_,SORT) \
    XPP_PROTO( (COMPONENTSORT Item, SORT PS) ) \
    XPP_NOPROTO( (Item, PS)  COMPONENTSORT Item; SORT PS; ) \
  { \
/*  Modified by GBU,000103  in WIP only unsigned [0..HIGH] is used */ \
/*    if (Item < LOW || Item > HIGH) return SDL_False;*/ \
/*    Item = Item - LOW;*/ \
    if (Item > HIGH) return SDL_False; \
    if ( ((unsigned long)1 << Item%32) & PS.A[Item/32] ) \
      return SDL_True; \
    return SDL_False; \
  }  


/*-- yIncl_SORT (Powerset)-----------------------------------------*/
#define Powerset_Incl(SORT, COMPONENTSORT, LOW, HIGH) \
  SORT XCAT(yIncl_,SORT) \
    XPP_PROTO( (COMPONENTSORT Item, SORT PS) ) \
    XPP_NOPROTO( (Item, PS)  COMPONENTSORT Item; SORT PS; ) \
  { \
/*  Modified by GBU,000103  in WIP only unsigned [0..HIGH] is used */ \
/*    if (Item < LOW || Item > HIGH) return PS;*/ \
/*    Item = Item - LOW;*/ \
    if (Item > HIGH) return PS; \
    PS.A[Item/32] = ((unsigned long)1 << Item%32) | PS.A[Item/32]; \
    return PS; \
  }