sctpredg.h

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

        Prev->Suc = XCAT(yAvail_,SORT); \
        XCAT(yAvail_,SORT) = Prev; \
        Result.Length--; \
        return Result; \
      } \
      for (Temp=Prev->Suc; \
           Temp!=(XCAT(SORT,_yptr))0; \
           Temp=Temp->Suc) { \
        if ( XCAT(yEqF_,COMPONENTSORT)(Temp->Data, Item) ) {\
          Prev->Suc = Temp->Suc; \
          if (Result.Last == Temp) Result.Last = Prev; \
          Temp->Suc = XCAT(yAvail_,SORT); \
          XCAT(yAvail_,SORT) = Temp; \
          Result.Length--; \
          return Result; \
        } \
        Prev = Temp; \
      } \
    } \
    return Result; \
  }


/*-- yAnd_SORT (GPowerset)-----------------------------------------*/
#define GPowerset_And(SORT, COMPONENTSORT) \
  SORT XCAT(yAnd_,SORT) \
    XPP_PROTO( (SORT PS1, SORT PS2) ) \
    XPP_NOPROTO( (PS1, PS2)  SORT PS1; SORT PS2; ) \
  { \
    SORT Result; \
    XCAT(SORT,_yptr) Temp; \
    Result = XCAT(yEmpty_,SORT)(); \
    for (Temp=PS1.First; Temp!=(XCAT(SORT,_yptr))0; Temp=Temp->Suc) \
      if ( XCAT(yInInner_,SORT)(Temp->Data, PS2) ) { \
        if (Result.First == (XCAT(SORT,_yptr))0) { \
          Result.First = XCAT(yGetAvail_,SORT)(); \
          Result.Last = Result.First; \
        } else { \
          Result.Last->Suc = XCAT(yGetAvail_,SORT)(); \
          Result.Last = Result.Last->Suc; \
        } \
        XCAT(yAssF_,COMPONENTSORT)(Result.Last->Data, Temp->Data, XASS); \
        Result.Length++; \
      } \
    if (! PS1.IsAssigned) \
      XCAT(yFree_,SORT)((void **)&PS1); \
    if (! PS2.IsAssigned) \
      XCAT(yFree_,SORT)((void **)&PS2); \
    return Result; \
  }


/*-- yOr_SORT (GPowerset)------------------------------------------*/
#define GPowerset_Or(SORT, COMPONENTSORT) \
  SORT XCAT(yOr_,SORT) \
    XPP_PROTO( (SORT PS1, SORT PS2) ) \
    XPP_NOPROTO( (PS1, PS2)  SORT PS1; SORT PS2; ) \
  { \
    SORT Result; \
    XCAT(SORT,_yptr) Temp; \
    if (PS2.IsAssigned) \
      Result = XCAT(yCopyList_,SORT)(PS2); \
    else \
      Result = PS2; \
    for (Temp=PS1.First; Temp!=(XCAT(SORT,_yptr))0; Temp=Temp->Suc) \
      if ( ! XCAT(yInInner_,SORT)(Temp->Data, Result) ) { \
        if (Result.First == (XCAT(SORT,_yptr))0) { \
          Result.First = XCAT(yGetAvail_,SORT)(); \
          Result.Last = Result.First; \
        } else { \
          Result.Last->Suc = XCAT(yGetAvail_,SORT)(); \
          Result.Last = Result.Last->Suc; \
        } \
        XCAT(yAssF_,COMPONENTSORT)(Result.Last->Data, Temp->Data, XASS); \
        Result.Length++; \
      } \
    if (! PS1.IsAssigned) \
      XCAT(yFree_,SORT)((void **)&PS1); \
    return Result; \
  }


/*-- yLE_SORT (GPowerset)------------------------------------------*/
#define GPowerset_LE(SORT, COMPONENTSORT) \
  SDL_Boolean XCAT(yLE_,SORT) \
    XPP_PROTO( (SORT PS1, SORT PS2) ) \
    XPP_NOPROTO( (PS1, PS2)  SORT PS1; SORT PS2; ) \
  { \
    XCAT(SORT,_yptr) Temp; \
    SDL_Boolean Result; \
    Result = PS1.Length <= PS2.Length; \
    for (Temp=PS1.First; \
         Temp!=(XCAT(SORT,_yptr))0 && Result; \
         Temp=Temp->Suc) \
      if ( ! XCAT(yInInner_,SORT)(Temp->Data, PS2) ) \
        Result = SDL_False; \
    if (! PS1.IsAssigned) \
      XCAT(yFree_,SORT)((void **)&PS1); \
    if (! PS2.IsAssigned) \
      XCAT(yFree_,SORT)((void **)&PS2); \
    return Result; \
  }


/*-- yLT_SORT (GPowerset)------------------------------------------*/
#define GPowerset_LT(SORT, COMPONENTSORT) \
  SDL_Boolean XCAT(yLT_,SORT) \
    XPP_PROTO( (SORT PS1, SORT PS2) ) \
    XPP_NOPROTO( (PS1, PS2)  SORT PS1; SORT PS2; ) \
  { \
    XCAT(SORT,_yptr) Temp; \
    SDL_Boolean Result; \
    Result = PS1.Length < PS2.Length; \
    for (Temp=PS1.First; \
         Temp!=(XCAT(SORT,_yptr))0 && Result; \
         Temp=Temp->Suc) \
      if ( ! XCAT(yInInner_,SORT)(Temp->Data, PS2) ) \
        Result = SDL_False; \
    if (! PS1.IsAssigned) \
      XCAT(yFree_,SORT)((void **)&PS1); \
    if (! PS2.IsAssigned) \
      XCAT(yFree_,SORT)((void **)&PS2); \
    return Result; \
  }


/*-- yGE_SORT (GPowerset)------------------------------------------*/
#define GPowerset_GE(SORT, COMPONENTSORT) \
  SDL_Boolean XCAT(yGE_,SORT) \
    XPP_PROTO( (SORT PS1, SORT PS2) ) \
    XPP_NOPROTO( (PS1, PS2)  SORT PS1; SORT PS2; ) \
  { \
    return XCAT(yLE_,SORT)(PS2, PS1); \
  }


/*-- yGT_SORT (GPowerset)------------------------------------------*/
#define GPowerset_GT(SORT, COMPONENTSORT) \
  SDL_Boolean XCAT(yGT_,SORT) \
    XPP_PROTO( (SORT PS1, SORT PS2) ) \
    XPP_NOPROTO( (PS1, PS2)  SORT PS1; SORT PS2; ) \
  { \
    return XCAT(yLT_,SORT)(PS2, PS1); \
  }


/*-- yAss_SORT (GPowerset)-----------------------------------------*/
#define GPowerset_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; ) \
  { \
    if ((*SVar).First != (XCAT(SORT,_yptr))0 && (*SVar).First == SExpr.First) { \
      (*SVar).IsAssigned = (xbool)1; \
      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) { \
      *SVar = XCAT(yCopyList_,SORT)(SExpr); \
    } else { \
      (*SVar).First = SExpr.First; \
      (*SVar).Last = SExpr.Last; \
      (*SVar).Length = SExpr.Length; \
    } \
    (*SVar).IsAssigned = (xbool)1; \
  }


/*-- yEq_SORT (GPowerset)------------------------------------------*/
#define GPowerset_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) Temp; \
    SDL_Boolean Result; \
    Result = Expr1.Length == Expr2.Length; \
    for (Temp=Expr1.First; \
         Temp!=(XCAT(SORT,_yptr))0 && Result; \
         Temp=Temp->Suc) \
      if ( ! XCAT(yInInner_,SORT)(Temp->Data, Expr2) ) \
        Result = SDL_False; \
    if (! Expr1.IsAssigned) \
      XCAT(yFree_,SORT)((void **)&Expr1); \
    if (! Expr2.IsAssigned) \
      XCAT(yFree_,SORT)((void **)&Expr2); \
    return Result; \
  }


/*-- yDef_SORT (GPowerset)-----------------------------------------*/
#define GPowerset_Default(SORT, 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; \
    (*S).Length = 0; \
    (*S).IsAssigned = (xbool)1; \
  }


/*-- yFree_SORT (GPowerset)---------------------------------------*/
#define GPowerset_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))); \
    } \
  }


/*-- yLength_SORT (GPowerset)---------------------------------------*/
#define GPowerset_Length(SORT, COMPONENTSORT) \
  SDL_Integer XCAT(yLength_,SORT) \
    XPP_PROTO( (SORT PS) ) \
    XPP_NOPROTO( (PS)  SORT PS; ) \
  { \
    return PS.Length; \
  }


/*-- yTake_SORT (GPowerset)------------------------------------*/
#define GPowerset_Take(SORT, COMPONENTSORT) \
  COMPONENTSORT XCAT(yTake_,SORT) \
    XPP_PROTO( (SORT PS) ) \
    XPP_NOPROTO( (PS)  SORT PS; ) \
  { \
    COMPONENTSORT Result; \
    if (PS.First != (XCAT(SORT,_yptr))0) \
      return PS.First->Data; \
    xReportStringError("Take in Powerset sort", "Empty powerset") \
    (void)memset((void *)(&Result), 0, sizeof(COMPONENTSORT)); \
    XCAT(yDef_,COMPONENTSORT)(&Result); \
    return Result; \
  }


/*-- yTake2_SORT (GPowerset)------------------------------------*/
#define GPowerset_Take2(SORT, COMPONENTSORT) \
  COMPONENTSORT XCAT(yTake2_,SORT) \
    XPP_PROTO( (SORT PS, SDL_Integer Index) ) \
    XPP_NOPROTO( (PS, Index)  SORT PS; SDL_Integer Index; ) \
  { \
    XCAT(SORT,_yptr) Temp; \
    int Number = 0; \
    COMPONENTSORT Result; \
    for (Temp=PS.First; \
         Temp!=(XCAT(SORT,_yptr))0 && ++Number<Index; \
         Temp=Temp->Suc) ; \
    if (Number == Index && Temp != (XCAT(SORT,_yptr))0) \
      return Temp->Data; \
    xReportStringError("Take in Powerset sort", "Index out of range") \
    (void)memset((void *)(&Result), 0, sizeof(COMPONENTSORT)); \
    XCAT(yDef_,COMPONENTSORT)(&Result); \
    return Result; \
  }


/*-- yWri_SORT (GPowerset)----------------------------------------*/
#define GPowerset_Write(SORT, COMPONENTSORT) \
  char * XCAT(yWri_,SORT) \
    XPP_PROTO( (void * PS) ) \
    XPP_NOPROTO( (PS) void * PS; ) \
  { \
    XCAT(SORT,_yptr) Temp, TempLast; \
    static  char     CTemp[MAX_WRI_LENGTH]; \
    \
    (void)strcpy(CTemp, "[ "); \
    TempLast = (*(SORT *)PS).Last; \
    for (Temp = (*(SORT *)PS).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, ", "); \
    } \
    xSafeStrcat(CTemp, " ]"); \
    return CTemp; \
  }


/*-- yRead_SORT (GPowerset)---------------------------------------*/
#define GPowerset_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 && \
        Token != xxLBracket && Token != xxQuestionMark && Token != xxEoln) { \
      xPrintString("Powerset value should start with [\n"); \
      return 0; \
    } \
    if (Token != xxLBracket) xUngetToken(Token, strVar); \
    \
    while (Token != xxRBracket) { \
      (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 (Token == xxRBracket) break; \
        return 0; \
      } \
      *(SORT *)Result = XCAT(yIncl_,SORT)(Item, *(SORT *)Result); \
      Token = xScanToken(strVar); \
      if (Token != xxRBracket) xUngetToken(Token, strVar); \
    } \
    (*(SORT *)Result).IsAssigned = (int)1; \
    return 1; \
  }


/****+***************************************************************
08   Generator Bag
********************************************************************/

/* typedef for Bag type -------------------------------------------*/

#if defined(ALPHACC) && defined(XVALIDATOR_LIB)
#define Bag_Type(SORT, COMPONENTSORT) \
   typedef struct XCAT(SORT,_ystruct)  * XCAT(SORT,_yptr); \
   typedef struct XCAT(SORT,_ystruct) { \
     XCAT(SORT,_yptr)   Suc; \
     long               NoOfItems; \
     COMPONENTSORT      Data; \
   } XCAT(SORT,_yrec); \
   typedef struct { \
     XCAT(SO