sctpred.h

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

#else /* then XMK_USE_STANDARD_DURATION */

  /*-- xPlus_SDL_Duration -------------------------------------------*/
  extern SDL_Duration xPlus_SDL_Duration  XPP((
    SDL_Duration D1,
    SDL_Duration D2 ));

  /*-- xMinus_SDL_Duration ------------------------------------------*/
  #define xMinus_SDL_Duration(P1, P2) \
    xPlus_SDL_Duration(P1, xMonMinus_SDL_Duration(P2))

  /*-- xMonMinus_SDL_Duration ---------------------------------------*/
  extern SDL_Duration xMonMinus_SDL_Duration  XPP((
    SDL_Duration D ));

  /*-- xMult_SDL_Duration -------------------------------------------*/
  #ifndef XNOUSEOFREAL
  extern SDL_Duration xMult_SDL_Duration  XPP((
    SDL_Duration D,
    SDL_Real     R ));
  #endif

  /*-- xMultRD_SDL_Duration -----------------------------------------*/
  #define xMultRD_SDL_Duration(R,D) xMult_SDL_Duration(D, R)

  /*-- xDiv_SDL_Duration --------------------------------------------*/
  #ifndef XNOUSEOFREAL
  extern SDL_Duration xDiv_SDL_Duration  XPP((
    SDL_Duration D,
    SDL_Real     R ));
  #endif

  #define xGT_SDL_Duration(P1, P2)  xLT_SDL_Time(P2, P1)
  #define xGE_SDL_Duration(P1, P2)  xLE_SDL_Time(P2, P1)
  #define xLT_SDL_Duration(P1, P2)  xLT_SDL_Time(P1, P2)
  #define xLE_SDL_Duration(P1, P2)  xLE_SDL_Time(P1, P2)

  /*-- xEq_SDL_Duration ---------------------------------------------*/
  extern SDL_Boolean xEq_SDL_Duration  XPP((
    SDL_Duration D1,
    SDL_Duration D2 ));

#endif /* ... XMK_USE_STANDARD_DURATION */

#endif /* ... defined(XSCT_CADVANCED) || defined(XSCT_CBASIC) */

/*---+---------------------------------------------------------------
     Integer
-------------------------------------------------------------------*/

#define xMonMinus_SDL_Integer(I)   (-(I))
#define xPlus_SDL_Integer(I1,I2)   ((I1)+(I2))
#define xMinus_SDL_Integer(I1,I2)  ((I1)-(I2))
#define xMult_SDL_Integer(I1,I2)   ((I1)*(I2))

/*-- xDiv_SDL_Integer ---------------------------------------------*/
#ifdef XEINTDIV
  extern SDL_Integer xDiv_SDL_Integer XPP(( SDL_Integer, SDL_Integer ));
#else
  #define xDiv_SDL_Integer(i,k) ((i)/(k))
#endif

/*-- xMod_SDL_Integer ---------------------------------------------*/
extern SDL_Integer xMod_SDL_Integer XPP((
  SDL_Integer,
  SDL_Integer ));

/*-- xRem_SDL_Integer ---------------------------------------------*/
#ifdef XEINTDIV
extern SDL_Integer xRem_SDL_Integer XPP((
  SDL_Integer,
  SDL_Integer ));
#else
#define xRem_SDL_Integer(i,k) ((i)%(k))
#endif

#define xLT_SDL_Integer(I1,I2)  ((I1)<(I2))
#define xLE_SDL_Integer(I1,I2)  ((I1)<=(I2))
#define xGT_SDL_Integer(I1,I2)  ((I1)>(I2))
#define xGE_SDL_Integer(I1,I2)  ((I1)>=(I2))

/*-- xFix_SDL_Integer ---------------------------------------------*/
#ifndef XNOUSEOFREAL
#ifdef XEFIXOF
extern SDL_Integer xFix_SDL_Integer XPP((
  SDL_Real ));
#else
#define xFix_SDL_Integer(Re)   ((SDL_Integer)Re)
#endif
#endif

/* -- xFloat_SDL_Integer ------------------------------------------*/
#ifndef XNOUSEOFREAL
#define xFloat_SDL_Integer(I)   ((SDL_Real)I)
#endif

#define ANY_SDL_Integer      (SDL_Integer)(GETINTRAND - GETINTRAND_MAX/2)

/*---+---------------------------------------------------------------
     Null
-------------------------------------------------------------------*/

#define ANY_SDL_Null         (SDL_Null)0


/*---+---------------------------------------------------------------
     Natural
-------------------------------------------------------------------*/

/*-- xTest_SDL_Natural --------------------------------------------*/
#ifdef XTESTF
extern xbool xTest_SDL_Natural  XPP((
  void * ));
#endif

/*-- xTstA_SDL_Natural --------------------------------------------*/
#ifdef XERANGE
extern SDL_Natural xTstA_SDL_Natural XPP(( SDL_Natural ));
#define yTstA_SDL_Natural(N)  xTstA_SDL_Natural(N)
#else
#define xTstA_SDL_Natural(N)  N
#define yTstA_SDL_Natural(N)  N
#endif

/*-- xTstI_SDL_Natural --------------------------------------------*/
#ifdef XEINDEX
extern SDL_Natural xTstI_SDL_Natural XPP(( SDL_Natural ));
#define yTstI_SDL_Natural(N)  xTstI_SDL_Natural(N)
#else                                                                                          
#define xTstI_SDL_Natural(N)  N
#define yTstI_SDL_Natural(N)  N
#endif

#define ANY_SDL_Natural         (SDL_Natural)(GETINTRAND)

/*---+---------------------------------------------------------------
     PId
-------------------------------------------------------------------*/

#define ANY_SDL_PId             SDL_NULL


/*---+---------------------------------------------------------------
     Real
-------------------------------------------------------------------*/

#define xMonMinus_SDL_Real(R)   (-(R))
#define xPlus_SDL_Real(R1,R2)   ((R1)+(R2))
#define xMinus_SDL_Real(R1,R2)  ((R1)-(R2))
#define xMult_SDL_Real(R1,R2)   ((R1)*(R2))

/*-- xDiv_SDL_Real ------------------------------------------------*/
#ifndef XNOUSEOFREAL
#ifdef XEREALDIV
extern SDL_Real xDiv_SDL_Real XPP((
  SDL_Real,
  SDL_Real ));
#else
#define xDiv_SDL_Real(i,k) ((i)/(k))
#endif
#endif

#define xLT_SDL_Real(R1,R2)  ((R1)<(R2))
#define xLE_SDL_Real(R1,R2)  ((R1)<=(R2))
#define xGT_SDL_Real(R1,R2)  ((R1)>(R2))
#define xGE_SDL_Real(R1,R2)  ((R1)>=(R2))

#define ANY_SDL_Real         (SDL_Real)(GETINTRAND - GETINTRAND_MAX/2)


/*---+---------------------------------------------------------------
     Time
-------------------------------------------------------------------*/


#if defined(XSCT_CADVANCED) || defined(XSCT_CBASIC)

/*-- xPlus_SDL_Time -----------------------------------------------*/
#define xPlus_SDL_Time(P1, P2)  xPlus_SDL_Duration(P1, P2)

/*-- xPlusDT_SDL_Time ---------------------------------------------*/
#define xPlusDT_SDL_Time(P1, P2)  xPlus_SDL_Duration(P2, P1)

/*-- xMinusD_SDL_Time ---------------------------------------------*/
#define xMinusD_SDL_Time(P1, P2) \
  xPlus_SDL_Duration(P1, xMonMinus_SDL_Duration(P2))

/*-- xMinusT_SDL_Time ---------------------------------------------*/
#define xMinusT_SDL_Time(P1, P2) \
  xPlus_SDL_Duration(P1, xMonMinus_SDL_Duration(P2))

/*-- xEq_SDL_Time -------------------------------------------------*/
#define xEq_SDL_Time(P1, P2)  xEq_SDL_Duration(P1, P2)

/*-- xLT_SDL_Time -------------------------------------------------*/
extern SDL_Boolean xLT_SDL_Time  XPP((
  SDL_Time,
  SDL_Time ));

/*-- xLE_SDL_Time -------------------------------------------------*/
extern SDL_Boolean xLE_SDL_Time  XPP((
  SDL_Time,
  SDL_Time ));

/*-- xGT_SDL_Time -------------------------------------------------*/
#define xGT_SDL_Time(P1, P2)  xLT_SDL_Time(P2, P1)

/*-- xGE_SDL_Time -------------------------------------------------*/
#define xGE_SDL_Time(P1, P2)  xLE_SDL_Time(P2, P1)

#define ANY_SDL_Time \
   SDL_Time_Lit(GETINTRAND, GETINTRAND % 1000000000)

#else /* then XSCT_CMICRO */

#ifndef XMK_USE_STANDARD_TIME

  #define xPlus_SDL_Time(P1, P2)     (P1 + P2)
  #define xPlusDT_SDL_Time(P1, P2)   (P1 + P2)
  #define xMinusD_SDL_Time(P1, P2)   (P1 - P2)
  #define xMinusT_SDL_Time(P1, P2)   (P1 - P2)
  #define xEq_SDL_Time(P1, P2)       (P1 == P2)
  #define xLT_SDL_Time(P1, P2)       (P1 < P2)
  #define xGT_SDL_Time(P1, P2)       (P1 > P2)
  #define xGE_SDL_Time(P1, P2)       (P1 >= P2)

#else /* then XMK_USE_STANDARD_TIME */

  /*-- xPlus_SDL_Time -----------------------------------------------*/
  #define xPlus_SDL_Time(P1, P2)  xPlus_SDL_Duration(P1, P2)

  /*-- xPlusDT_SDL_Time ---------------------------------------------*/
  #define xPlusDT_SDL_Time(P1, P2)  xPlus_SDL_Duration(P2, P1)

  /*-- xMinusD_SDL_Time ---------------------------------------------*/
  #define xMinusD_SDL_Time(P1, P2) \
    xPlus_SDL_Duration(P1, xMonMinus_SDL_Duration(P2))

  /*-- xMinusT_SDL_Time ---------------------------------------------*/
  #define xMinusT_SDL_Time(P1, P2) \
    xPlus_SDL_Duration(P1, xMonMinus_SDL_Duration(P2))

  /*-- xEq_SDL_Time -------------------------------------------------*/
  #define xEq_SDL_Time(P1, P2)  xEq_SDL_Duration(P1, P2)

  /*-- xLT_SDL_Time -------------------------------------------------*/
  extern SDL_Boolean xLT_SDL_Time  XPP((
    SDL_Time T1,
    SDL_Time T2 ));

  /*-- xLE_SDL_Time -------------------------------------------------*/
  extern SDL_Boolean xLE_SDL_Time  XPP((
    SDL_Time T1,
    SDL_Time T2 ));

  /*-- xGT_SDL_Time -------------------------------------------------*/
  #define xGT_SDL_Time(P1, P2)  xLT_SDL_Time(P2, P1)

  /*-- xGE_SDL_Time -------------------------------------------------*/
  #define xGE_SDL_Time(P1, P2)  xLE_SDL_Time(P2, P1)

  #define ANY_SDL_Time ERROR_ANY_SDL_Time_IsNotImplemented

#endif /* ... XMK_USE_STANDARD_TIME */

#endif /* ... defined(XSCT_CADVANCED) || defined(XSCT_CBASIC) */


/*---+---------------------------------------------------------------
     own/oref
-------------------------------------------------------------------*/
extern void * xPassOwn XPP((void **P));


/****+***************************************************************
03   Read and Write functions
********************************************************************/

#if defined(XSCT_CADVANCED) || defined(XSCT_CBASIC)

#ifdef XREADANDWRITEF

/*-- xRead_SDL_Boolean --------------------------------------------*/
#define xRead_SDL_Boolean(Addr)  xReadSort(Addr, xSrtN_SDL_Boolean)

/*-- xWri_SDL_Boolean ---------------------------------------------*/
#define xWri_SDL_Boolean(Value)  xWriteSort(Value, xSrtN_SDL_Boolean)

/*-- xRead_SDL_Bit ------------------------------------------------*/
extern int xRead_SDL_Bit XPP((void *));

/*-- xWri_SDL_Bit -------------------------------------------------*/
extern char * xWri_SDL_Bit XPP((void *));

/*-- xRead_SDL_Bit_String -----------------------------------------*/
extern int xRead_SDL_Bit_String XPP((void *));

/*-- xWri_SDL_Bit_String ------------------------------------------*/
extern char * xWri_SDL_Bit_String XPP((void *));

/*-- xRead_SDL_Octet ----------------------------------------------*/
extern int xRead_SDL_Octet XPP((void *));

/*-- xWri_SDL_Octet -----------------------------------------------*/
extern char * xWri_SDL_Octet XPP((void *));

/*-- xRead_SDL_Octet_String ---------------------------------------*/
extern int xRead_SDL_Octet_String XPP((void *));

/*-- xWri_SDL_Octet_String ----------------------------------------*/
extern char * xWri_SDL_Octet_String XPP((void *));

/*-- xRead_SDL_Character ------------------------------------------*/
extern int xRead_SDL_Character XPP((void *));

/*-- xWri_SDL_Character -------------------------------------------*/
extern char * xWri_SDL_Character XPP((void *));

/*-- xRead_SDL_Charstring -----------------------------------------*/
extern int xRead_SDL_Charstring XPP((void *));

/*-- xWri_SDL_Charstring ------------------------------------------*/
extern char * xWri_SDL_Charstring XPP((void *));

/*-- xRead_SDL_Duration -------------------------------------------*/
extern int xRead_SDL_Duration XPP((void *));

/*-- xWri_SDL_Duration --------------------------------------------*/
extern char * xWri_SDL_Duration XPP((void *));

/*-- xRead_SDL_Integer --------------------------------------------*/
extern int xRead_SDL_Integer XPP((void *));

/*-- xWri_SDL_Integer ---------------------------------------------*/
extern char * xWri_SDL_Integer XPP((void *));

/*-- xRead_SDL_Null -----------------------------------------------*/
extern int xRead_SDL_Null XPP((void *));

/*-- xWri_SDL_Null ------------------------------------------------*/
extern char * xWri_SDL_Null XPP((void *));

/*-- xRead_SDL_Real -----------------------------------------------*/
extern int xRead_SDL_Real XPP((void *));

/*-- xWri_SDL_Real ------------------------------------------------*/
extern char * xWri_SDL_Real XPP((void *));

/*-- xRead_SDL_Time -----------------------------------------------*/
extern int xRead_SDL_Time XPP((void *));

/*-- xWri_SDL_Time ------------------------------------------------*/
extern char * xWri_SDL_Time XPP((void *));



/* Help functions, also used by sctutil.c and sctmon.c */
/*-- xReadSDL_Time ------------------------------------------------*/
extern int xReadSDL_Time XPP((SDL_Time *));

/*-- xWriteSDL_Time -----------------------------------------------*/
extern char * xWriteSDL_Time XPP((SDL_Time, int));

#endif /* ... defined(XSCT_CADVANCED) || defined(XSCT_CBASIC) */ 

#endif
   /* XREADANDWRITEF */


#ifndef XNO_LONG_MACROS
/*
** Generators are in an extra file because
** some C compilers cannot preprocess correctly
*/
#include "sctpredg.h"
#endif

#endif
   /* X_SCTPRED_H */