sctpred.c

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

    }
  } else if (C2 == (SDL_Charstring)0) {
    if (C1[0] == 'T')
      return C1;
    else {
      Result = xAlloc_SDL_Charstring((xptrint)(strlen(C1)+1));
      (void)strcpy(Result, C1);
    }
  } else {
    Result = xAlloc_SDL_Charstring((xptrint)(strlen(C1)+strlen(C2)));
    (void)strcpy(Result, C1);
    (void)strcat(Result, C2+1);
    if (C1[0] == 'T')
      xFree_SDL_Charstring((void **)&C1);
    if (C2[0] == 'T')
      xFree_SDL_Charstring((void **)&C2);
  }

  Result[0] = 'T';
  return Result;
}


/*---+---------------------------------------------------------------
     xFirst_SDL_Charstring
-------------------------------------------------------------------*/
#ifndef XNOPROTO
SDL_Character xFirst_SDL_Charstring(
  SDL_Charstring  C )
#else
SDL_Character xFirst_SDL_Charstring( C )
  SDL_Charstring  C;
#endif
{
  char Result;
  if ( (C == (SDL_Charstring)0) || (strlen(C) <= (unsigned)1) ) {
#ifdef XECSOP
    xSDLOpError("First in sort Charstring",
                "Charstring length is zero." );
#endif
    Result = SDL_NUL;
  } else
    Result = C[1];
  if (C != (SDL_Charstring)0 && C[0] == 'T')
    xFree_SDL_Charstring((void **)&C);
  return Result;
}


/*---+---------------------------------------------------------------
     xLast_SDL_Charstring
-------------------------------------------------------------------*/
#ifndef XNOPROTO
SDL_Character xLast_SDL_Charstring(
  SDL_Charstring  C )
#else
SDL_Character xLast_SDL_Charstring( C )
  SDL_Charstring  C;
#endif
{
  char Result;
  if ( (C == (SDL_Charstring)0) || (strlen(C) <= (unsigned)1) ) {
#ifdef XECSOP
    xSDLOpError("Last in sort Charstring",
                "Charstring length is zero." );
#endif
    Result = SDL_NUL;
  } else
    Result = C[strlen(C) - 1];
  if (C != (SDL_Charstring)0 && C[0] == 'T')
    xFree_SDL_Charstring((void **)&C);
  return Result;
}


/*---+---------------------------------------------------------------
     xLength_SDL_Charstring
-------------------------------------------------------------------*/
#ifndef XNOPROTO
SDL_Integer xLength_SDL_Charstring(
  SDL_Charstring  C )
#else
SDL_Integer xLength_SDL_Charstring( C )
  SDL_Charstring  C;
#endif
{
  int Length;
  if (C == (SDL_Charstring)0)
    Length = 0;
  else {
    Length = strlen(C)-1;
    if (C[0] == 'T')
      xFree_SDL_Charstring((void **)&C);
  }
  return Length;
}


/*---+---------------------------------------------------------------
     xSubString_SDL_Charstring
-------------------------------------------------------------------*/
#ifndef XNOPROTO
SDL_Charstring xSubString_SDL_Charstring(
  SDL_Charstring  C,
  SDL_Integer     Start,
  SDL_Integer     SubLength )
#else
SDL_Charstring xSubString_SDL_Charstring( C, Start, SubLength )
  SDL_Charstring  C;
  SDL_Integer     Start;
  SDL_Integer     SubLength;
#endif
{
  SDL_Charstring Result;

  if ( (C == (SDL_Charstring)0) || (strlen(C) <= (unsigned)1) ) {
#ifdef XECSOP
    xSDLOpError("SubString in sort Charstring",
                "Charstring length is zero." );
#endif
    Result = (SDL_Charstring)0;
  } else if ( Start <= 0 ) {
#ifdef XECSOP
    xSDLOpError("SubString in sort Charstring",
                "Start is less than or equal to zero." );
#endif
    Result = (SDL_Charstring)0;
  } else if ( SubLength < 0 ) {
#ifdef XECSOP
    xSDLOpError("SubString in sort Charstring",
                "SubLength is less than zero." );
#endif
    Result = (SDL_Charstring)0;
  } else if ( SubLength == 0 ) {    /* No error if length is 0 */
    Result = (SDL_Charstring)0;
  } else if ( (unsigned)(Start+SubLength) > strlen(C)) { 
#ifdef XECSOP
    xSDLOpError("SubString in sort Charstring",
                "Start + Substring length is greater than string length." );
#endif
    Result = (SDL_Charstring)0;
  } else {
    Result = xAlloc_SDL_Charstring((xptrint)(SubLength + 2));
/*  Modified by GBU,000103  added cast since "SDL_Integer" and "size_t" may differ in size */
/*
    (void)strncpy(Result+1, (SDL_Charstring)((xptrint)C + Start), SubLength);
*/
    (void)strncpy(Result+1, (SDL_Charstring)((xptrint)C + Start), (size_t)SubLength);
    Result[0] = 'T';
    Result[SubLength+1] = '\0';
  }
  if (C != (SDL_Charstring)0 && C[0] == 'T')
    xFree_SDL_Charstring((void **)&C);
  return Result;
}

#endif /* ... defined(XSCT_CADVANCED) || defined(XSCT_CBASIC) && (defined(XSCT_CMICRO) && ! defined(XRESTUSEOFCHARSTRING)) */

#endif 
   /* XNOUSEOFCHARSTRING */

/*** Duration ******************************************************/

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

/*---+---------------------------------------------------------------
     xPlus_SDL_Duration
-------------------------------------------------------------------*/
#ifndef XNOPROTO
SDL_Duration xPlus_SDL_Duration(
  SDL_Duration D1,
  SDL_Duration D2 )
#else
SDL_Duration xPlus_SDL_Duration( D1, D2 )
  SDL_Duration D1;
  SDL_Duration D2;
#endif
{
  D1.s = D1.s + D2.s;
  D1.ns = D1.ns + D2.ns;
#ifdef X_XINT32_INT
  if ( ((D1.s >= 0) && (D1.ns >= 1000000000)) ||
       ((D1.s < 0) && (D1.ns > 0)) ) {
    D1.ns = D1.ns - 1000000000;
    D1.s = D1.s + 1;
  } else if
     ( ((D1.s > 0) && (D1.ns < 0)) ||
       ((D1.s <= 0) && (D1.ns <= -1000000000)) ) {
    D1.ns = D1.ns + 1000000000;
    D1.s = D1.s - 1;
  }
#else
  if ( ((D1.s >= 0L) && (D1.ns >= 1000000000L)) ||
       ((D1.s < 0L) && (D1.ns > 0L)) ) {
    D1.ns = D1.ns - 1000000000L;
    D1.s = D1.s + 1L;
  } else if
     ( ((D1.s > 0L) && (D1.ns < 0L)) ||
       ((D1.s <= 0L) && (D1.ns <= -1000000000L)) ) {
    D1.ns = D1.ns + 1000000000L;
    D1.s = D1.s - 1L;
  }
#endif
  return D1;
}


/*---+---------------------------------------------------------------
     xMonMinus_SDL_Duration
-------------------------------------------------------------------*/
#ifndef XNOPROTO
SDL_Duration xMonMinus_SDL_Duration(
  SDL_Duration D )
#else
SDL_Duration xMonMinus_SDL_Duration( D )
  SDL_Duration D;
#endif
{
  D.s = -D.s;
  D.ns = -D.ns;
  return D;
}


#ifndef XNOUSEOFREAL
/*---+---------------------------------------------------------------
     xMult_SDL_Duration
-------------------------------------------------------------------*/
#ifndef XNOPROTO
SDL_Duration xMult_SDL_Duration(
  SDL_Duration D,
  SDL_Real     R )
#else
SDL_Duration xMult_SDL_Duration( D, R )
  SDL_Duration D;
  SDL_Real     R;
#endif
{
  SDL_Real DTemp;
  DTemp = ( (SDL_Real)D.s + (SDL_Real)D.ns*(SDL_Real)1E-9 ) * R;
  if ( DTemp >= 2.147483647E9 ) {
    /* Overflow */
    D.s = 0;
    D.ns = 0;
  } else {
    D.s = (xint32)DTemp;
    D.ns = (xint32)((DTemp-(SDL_Real)D.s)*1E9);
  }
  return D;
}


/*---+---------------------------------------------------------------
     xDiv_SDL_Duration
-------------------------------------------------------------------*/
#ifndef XNOPROTO
SDL_Duration xDiv_SDL_Duration(
  SDL_Duration D,
  SDL_Real     R )
#else
SDL_Duration xDiv_SDL_Duration( D, R )
  SDL_Duration D;
  SDL_Real     R;
#endif
{
  SDL_Real DTemp;
  DTemp = ( (SDL_Real)D.s + (SDL_Real)D.ns*(SDL_Real)1E-9 ) / R;
  if ( DTemp >= 2.147483647E9 ) {
    /* Overflow */
    D.s = 0;
    D.ns = 0;
  } else {
    D.s = (xint32)DTemp;
    D.ns = (xint32)((DTemp-(SDL_Real)D.s)*1E9);
  }
  return D;
}

#endif
       /* ! XNOUSEOFREAL */


/*---+---------------------------------------------------------------
     xEq_SDL_Duration
-------------------------------------------------------------------*/
#ifndef XNOPROTO
SDL_Boolean xEq_SDL_Duration(
  SDL_Duration D1,
  SDL_Duration D2 )
#else
SDL_Boolean xEq_SDL_Duration( D1, D2 )
  SDL_Duration D1;
  SDL_Duration D2;
#endif
{
  if ( (D1.s == D2.s) && (D1.ns == D2.ns) ) return SDL_True;
  return SDL_False;
}


/*---+---------------------------------------------------------------
     SDL_Duration_Lit
-------------------------------------------------------------------*/
#ifndef XNOPROTO
SDL_Duration SDL_Duration_Lit(
  xint32 s,
  xint32 ns )
#else
SDL_Duration SDL_Duration_Lit( s, ns )
  xint32 s;
  xint32 ns;
#endif
{
  SDL_Duration D;
  D.s = s;
  D.ns = ns;
  return D;
}

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

/*** Integer *******************************************************/

#if !defined(XNOUSEOFREAL) && defined(XEFIXOF)
/*---+---------------------------------------------------------------
     xFix_SDL_Integer
-------------------------------------------------------------------*/
#ifndef XNOPROTO
SDL_Integer xFix_SDL_Integer(
  SDL_Real     Re )
#else
SDL_Integer xFix_SDL_Integer( Re )
  SDL_Real     Re;
#endif
{
  if ( Re >= (SDL_Real)(XSYSD xMax_SDL_Integer)) {
#if defined(XSCT_CADVANCED) || defined(XSCT_CBASIC)
    xSDLOpError("Fix in sort Integer", "Integer overflow.");
#else
    ErrorHandler (ERR_N_SDL_RANGE);
#endif
    return 0;
  } else
    return (SDL_Integer)Re;
}
#else
/* See sctpred.h #define xFix_SDL_Integer() */
#endif
       /* !XNOUSEOFREAL && XEFIXOF */


/*---+---------------------------------------------------------------
     xDiv_SDL_Integer
-------------------------------------------------------------------*/
#ifdef XEINTDIV
#ifndef XNOPROTO
SDL_Integer xDiv_SDL_Integer(
  SDL_Integer  i,
  SDL_Integer  k )
#else
SDL_Integer xDiv_SDL_Integer( i, k )
  SDL_Integer  i;
  SDL_Integer  k;
#endif
{
  if ( k == 0 ) {
#if defined(XSCT_CADVANCED) || defined(XSCT_CBASIC)
    xSDLOpError("Division in sort Integer", "Integer division with 0" );
#else
    ErrorHandler (ERR_N_DIVIDE_BY_ZERO);
#endif
    return 0;
  } else
    return i/k;
}
/* #else
   See scttypes.h #define xDiv_SDL_Integer ... */
#endif
       /* XEINTDIV */


/*---+---------------------------------------------------------------
     xRem_SDL_Integer
-------------------------------------------------------------------*/
#ifdef XEINTDIV
#ifndef XNOPROTO
SDL_Integer xRem_SDL_Integer(
  SDL_Integer  i,
  SDL_Integer  k )
#else
SDL_Integer xRem_SDL_Integer( i, k )
  SDL_Integer  i;
  SDL_Integer  k;
#endif
{
  if ( k == 0 ) {
#if defined(XSCT_CADVANCED) || defined(XSCT_CBASIC)
    xSDLOpError("Rem in sort Integer", "Second operand is 0" );
#else
    ErrorHandler (ERR_N_DIVIDE_BY_ZERO);
#endif
    return 0;
  } else
    return i%k;
}
/* #else
   See scttypes.h #define xRem_SDL_Integer ... */
#endif
       /* XEINTDIV */


/*---+---------------------------------------------------------------
     xMod_SDL_Integer
-------------------------------------------------------------------*/
#ifndef XNOPROTO
SDL_Integer xMod_SDL_Integer(
  SDL_Integer  i,
  SDL_Integer  k )
#else
SDL_Integer xMod_SDL_Integer( i, k )
  SDL_Integer  i;
  SDL_Integer  k;
#endif
{
  SDL_Integer result;
  if ( k == 0 ) {
#if defined(XEINTDIV) || defined(XMK_USE_MAX_ERR