sctpred.c

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

/*
# clearcase: CmicroPatchRel2.3.3
*/

/*
+------------------------------------------------------------------------------+
|                                                                              |
|  Copyright by Telelogic AB 1993 - 1998                                       |
|  Copyright by S&P Media GmbH Germany 1993 - 1998                             |
|                                                                              |
|  This Program is owned by Telelogic and is protected by national             |
|  copyright laws and international copyright treaties. Telelogic              |
|  grants you the right to use this Program on one computer or in              |
|  one local computer network at any one time.                                 |
|  Under this License you may only modify the source code for the purpose      |
|  of adapting it to your environment. You must reproduce and include          |
|  any copyright and trademark notices on all copies of the source code.       |
|  You may not use, copy, merge, modify or transfer the Program except as      |
|  provided in this License.                                                   |
|  Telelogic does not warrant that the Program will meet your                  |
|  requirements or that the operation of the Program will be                   |
|  uninterrupted and error free. You are solely responsible that the           |
|  selection of the Program and the modification of the source code            |
|  will achieve your intended results and that the results are actually        |
|  obtained.                                                                   |
|                                                                              |
+------------------------------------------------------------------------------+
*/

/*
$Id: sctpred.c,v 1.2 2004/08/13 03:17:52 chenlang Exp $ 
*/


/* This file contains implementation of operators and the read and
   write functions for the predefined data types except PId.
*/
/*
FILE INDEX
01   IdNodes for package Predefined (not relevant for Cmicro)
02   Operator implementations
03   Read and Write functions (not relevant for Cmicro)
*/

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

#include "scttypes.h"


/********  SDT VALIDATOR ********/
#ifdef XVALIDATOR_LIB
#ifndef XSYSD
#define XSYSD
#endif
SDL_Time xMaxTime = {2147483647,0};

#endif /* ... XVALIDATOR_LIB */

#else /* then XSCT_CMICRO */

#include "ml_typw.h"

#ifndef XSYSD
#define XSYSD
#endif

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


/****+***************************************************************
01   IdNodes for package Predefined
********************************************************************/

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

#ifndef XOPTSORT

/*---+---------------------------------------------------------------
     Package Predefined
-------------------------------------------------------------------*/

struct xPackageIdStruct yPacR_Predefined = {xPackageEC
  xSymbTLink((xIdNode)0, (xIdNode)0), xSymbolTableRoot xIdNames("Predefined")
  XCOMMON_EXTRAS xIdNames(0) XPAC_EXTRAS};

/*---+---------------------------------------------------------------
     Boolean
-------------------------------------------------------------------*/

XCONST struct xSortIdStruct xSrtR_SDL_Boolean = {xSortEC xSymbTLink((xIdNode)0,
  (xIdNode)0), (xIdNode)&yPacR_Predefined xIdNames("boolean")
  XCOMMON_EXTRAS xFreF(0) xAssF(0) xEqF(0) xRaWF(0) xRaWF(0) xTestF(0),
  (xptrint)sizeof(SDL_Boolean), xPredef, (xSortIdNode)0, (xSortIdNode)0, 0,
  0 XSRT_EXTRAS};
#ifndef XOPTLIT

#error "warning_static_in_use_DLH"
static XCONST struct xLiteralIdStruct yFalseR = {xLiteralEC xSymbTLink((xIdNode)0,
  (xIdNode)0), (xIdNode)&xSrtR_SDL_Boolean xIdNames("false")
  XCOMMON_EXTRAS XLIT_EXTRAS};

#error "warning_static_in_use_DLH"
static XCONST struct xLiteralIdStruct yTrueR = {xLiteralEC  xSymbTLink((xIdNode)0,
  (xIdNode)0), (xIdNode)&xSrtR_SDL_Boolean xIdNames("true")
  XCOMMON_EXTRAS XLIT_EXTRAS};
#endif

/*---+---------------------------------------------------------------
     Bit
-------------------------------------------------------------------*/

XCONST struct xSortIdStruct xSrtR_SDL_Bit = {xSortEC xSymbTLink((xIdNode)0,
  (xIdNode)0), (xIdNode)&yPacR_Predefined xIdNames("bit")
  XCOMMON_EXTRAS xFreF(0) xAssF(0) xEqF(0) xRaWF(xRead_SDL_Bit)
  xRaWF(xWri_SDL_Bit) xTestF(0), (xptrint)sizeof(SDL_Bit),
  xPredef, (xSortIdNode)0, (xSortIdNode)0, 0, 0 XSRT_EXTRAS};

/*---+---------------------------------------------------------------
     Bit_String
-------------------------------------------------------------------*/

#ifndef XNOUSEOFOCTETBITSTRING
XCONST struct xSortIdStruct xSrtR_SDL_Bit_String = {xSortEC xSymbTLink((xIdNode)0,
  (xIdNode)0), (xIdNode)&yPacR_Predefined xIdNames("bit_string")
  XCOMMON_EXTRAS xFreF(xFree_SDL_Bit_String) xAssF(xAss_SDL_Bit_String)
  xEqF(xEq_SDL_Bit_String) xRaWF(xRead_SDL_Bit_String)
  xRaWF(xWri_SDL_Bit_String) xTestF(0), (xptrint)sizeof(SDL_Bit_String),
  xPredef, (xSortIdNode)0, (xSortIdNode)0, 0, 0 XSRT_EXTRAS};
#endif
       /* XNOUSEOFOCTETBITSTRING */

/*---+---------------------------------------------------------------
     Octet
-------------------------------------------------------------------*/

#ifndef XNOUSEOFOCTETBITSTRING
XCONST struct xSortIdStruct xSrtR_SDL_Octet = {xSortEC xSymbTLink((xIdNode)0,
  (xIdNode)0), (xIdNode)&yPacR_Predefined xIdNames("octet")
  XCOMMON_EXTRAS xFreF(0) xAssF(0) xEqF(0) xRaWF(xRead_SDL_Octet)
  xRaWF(xWri_SDL_Octet) xTestF(0), (xptrint)sizeof(SDL_Octet),
  xPredef, (xSortIdNode)0, (xSortIdNode)0, 0, 0 XSRT_EXTRAS};
#endif
       /* XNOUSEOFOCTETBITSTRING */

/*---+---------------------------------------------------------------
     Octet_String
-------------------------------------------------------------------*/

#ifndef XNOUSEOFOCTETBITSTRING
XCONST struct xSortIdStruct xSrtR_SDL_Octet_String = {xSortEC xSymbTLink((xIdNode)0,
  (xIdNode)0), (xIdNode)&yPacR_Predefined xIdNames("octet_string")
  XCOMMON_EXTRAS xFreF(xFree_SDL_Bit_String) xAssF(xAss_SDL_Bit_String)
  xEqF(xEq_SDL_Bit_String) xRaWF(xRead_SDL_Octet_String)
  xRaWF(xWri_SDL_Octet_String) xTestF(0), (xptrint)sizeof(SDL_Octet_String),
  xPredef, (xSortIdNode)0, (xSortIdNode)0, 0, 0 XSRT_EXTRAS};
#endif
       /* XNOUSEOFOCTETBITSTRING */

/*---+---------------------------------------------------------------
     Character
-------------------------------------------------------------------*/

XCONST struct xSortIdStruct xSrtR_SDL_Character = {xSortEC xSymbTLink((xIdNode)0,
  (xIdNode)0), (xIdNode)&yPacR_Predefined xIdNames("character")
  XCOMMON_EXTRAS xFreF(0) xAssF(0) xEqF(0) xRaWF(xRead_SDL_Character)
  xRaWF(xWri_SDL_Character) xTestF(0), (xptrint)sizeof(SDL_Character),
  xPredef, (xSortIdNode)0, (xSortIdNode)0, 0, 0 XSRT_EXTRAS};

/*---+---------------------------------------------------------------
     Charstring
-------------------------------------------------------------------*/

XCONST struct xSortIdStruct xSrtR_SDL_Charstring = {xSortEC xSymbTLink((xIdNode)0,
  (xIdNode)0), (xIdNode)&yPacR_Predefined xIdNames("charstring")
  XCOMMON_EXTRAS xFreF(xFree_SDL_Charstring) xAssF(xAss_SDL_Charstring)
  xEqF(xEq_SDL_Charstring) xRaWF(xRead_SDL_Charstring)
  xRaWF(xWri_SDL_Charstring) xTestF(0), (xptrint)sizeof(SDL_Charstring),
  xPredef, (xSortIdNode)0, (xSortIdNode)0, 0, 0 XSRT_EXTRAS};

/*---+---------------------------------------------------------------
     IA5String
-------------------------------------------------------------------*/

XCONST struct xSortIdStruct xSrtR_SDL_IA5String = {xSortEC xSymbTLink((xIdNode)0,
  (xIdNode)0), (xIdNode)&yPacR_Predefined xIdNames("IA5String")
  XCOMMON_EXTRAS xFreF(xFree_SDL_Charstring) xAssF(xAss_SDL_Charstring)
  xEqF(xEq_SDL_Charstring) xRaWF(xRead_SDL_Charstring)
  xRaWF(xWri_SDL_Charstring) xTestF(0), (xptrint)sizeof(SDL_Charstring),
  xSyntype, &xSrtR_SDL_Charstring, (xSortIdNode)0, 0, 0 XSRT_EXTRAS};

/*---+---------------------------------------------------------------
     NumericString
-------------------------------------------------------------------*/

XCONST struct xSortIdStruct xSrtR_SDL_NumericString = {xSortEC
  xSymbTLink((xIdNode)0, (xIdNode)0), (xIdNode)&yPacR_Predefined
  xIdNames("NumericString") XCOMMON_EXTRAS xFreF(xFree_SDL_Charstring)
  xAssF(xAss_SDL_Charstring) xEqF(xEq_SDL_Charstring)
  xRaWF(xRead_SDL_NumericString)
  xRaWF(xWri_SDL_NumericString) xTestF(xTest_SDL_NumericString),
  (xptrint)sizeof(SDL_Charstring), xSyntype, &xSrtR_SDL_Charstring,
  (xSortIdNode)0, 0, 0 XSRT_EXTRAS};

/*---+---------------------------------------------------------------
     PrintableString
-------------------------------------------------------------------*/

XCONST struct xSortIdStruct xSrtR_SDL_PrintableString = {xSortEC
  xSymbTLink((xIdNode)0, (xIdNode)0), (xIdNode)&yPacR_Predefined
  xIdNames("PrintableString") XCOMMON_EXTRAS xFreF(xFree_SDL_Charstring)
  xAssF(xAss_SDL_Charstring) xEqF(xEq_SDL_Charstring)
  xRaWF(xRead_SDL_PrintableString)
  xRaWF(xWri_SDL_PrintableString) xTestF(xTest_SDL_PrintableString),
  (xptrint)sizeof(SDL_Charstring), xSyntype, &xSrtR_SDL_Charstring,
  (xSortIdNode)0, 0, 0 XSRT_EXTRAS};

/*---+---------------------------------------------------------------
     VisibleString
-------------------------------------------------------------------*/

XCONST struct xSortIdStruct xSrtR_SDL_VisibleString = {xSortEC
  xSymbTLink((xIdNode)0, (xIdNode)0), (xIdNode)&yPacR_Predefined
  xIdNames("VisibleString") XCOMMON_EXTRAS xFreF(xFree_SDL_Charstring)
  xAssF(xAss_SDL_Charstring) xEqF(xEq_SDL_Charstring)
  xRaWF(xRead_SDL_VisibleString)
  xRaWF(xWri_SDL_VisibleString) xTestF(xTest_SDL_PrintableString),
  (xptrint)sizeof(SDL_Charstring), xSyntype, &xSrtR_SDL_Charstring,
  (xSortIdNode)0, 0, 0 XSRT_EXTRAS};

/*---+---------------------------------------------------------------
     Duration
-------------------------------------------------------------------*/

XCONST struct xSortIdStruct xSrtR_SDL_Duration = {xSortEC xSymbTLink((xIdNode)0,
  (xIdNode)0), (xIdNode)&yPacR_Predefined xIdNames("duration")
  XCOMMON_EXTRAS xFreF(0) xAssF(0) xEqF(xEq_SDL_Duration)
  xRaWF(xRead_SDL_Duration) xRaWF(xWri_SDL_Duration) xTestF(0),
  (xptrint)sizeof(SDL_Duration), xPredef, (xSortIdNode)0, (xSortIdNode)0,
  0, 0 XSRT_EXTRAS};

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

XCONST struct xSortIdStruct xSrtR_SDL_Integer = {xSortEC xSymbTLink((xIdNode)0,
  (xIdNode)0), (xIdNode)&yPacR_Predefined xIdNames("integer")
  XCOMMON_EXTRAS xFreF(0) xAssF(0) xEqF(0) xRaWF(xRead_SDL_Integer)
  xRaWF(xWri_SDL_Integer) xTestF(0), (xptrint)sizeof(SDL_Integer),
  xPredef, (xSortIdNode)0, (xSortIdNode)0, 0, 0 XSRT_EXTRAS};

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

XCONST struct xSortIdStruct xSrtR_SDL_Natural = {xSortEC xSymbTLink((xIdNode)0,
  (xIdNode)0), (xIdNode)&yPacR_Predefined xIdNames("natural")
  XCOMMON_EXTRAS xFreF(0) xAssF(0) xEqF(0) xRaWF(xRead_SDL_Integer)
  xRaWF(xWri_SDL_Integer) xTestF(xTest_SDL_Natural),
  (xptrint)sizeof(SDL_Integer), xSyntype, &xSrtR_SDL_Integer,
  (xSortIdNode)0, 0, 0 XSRT_EXTRAS};

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

XCONST struct xSortIdStruct xSrtR_SDL_Null = {xSortEC xSymbTLink((xIdNode)0,
  (xIdNode)0), (xIdNode)&yPacR_Predefined xIdNames("null")
  XCOMMON_EXTRAS xFreF(0) xAssF(0) xEqF(0) xRaWF(xRead_SDL_Null)
  xRaWF(xWri_SDL_Null) xTestF(0), (xptrint)sizeof(SDL_Null),
  xPredef, (xSortIdNode)0, (xSortIdNode)0, 0, 0 XSRT_EXTRAS};

/*---+---------------------------------------------------------------
     Object_Identifier
-------------------------------------------------------------------*/

#ifndef XNOUSEOFOBJECTIDENTIFIER
XCONST struct xSortIdStruct xSrtR_SDL_Object_Identifier = {xSortEC
  xSymbTLink((xIdNode)0, (xIdNode)0), (xIdNode)&yPacR_Predefined
  xIdNames("object_identifier") XCOMMON_EXTRAS xFreF(yFree_SDL_Object_Identifier)
  xAssF(yAss_SDL_Object_Identifier) xEqF(yEq_SDL_Object_Identifier)
  xRaWF(yRead_SDL_Object_Identifier) xRaWF(yWri_SDL_Object_Identifier)
  xTestF(0), (xptrint)sizeof(SDL_Object_Identifier), xString, &xSrtR_SDL_Natural,
  (xSortIdNode)0, 0, 0 XSRT_EXTRAS};
#endif
       /* XNOUSEOFOBJECTIDENTIFIER */

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

XCONST struct xSortIdStruct xSrtR_SDL_PId = {xSortEC xSymbTLink((xIdNode)0,
  (xIdNode)0), (xIdNode)&yPacR_Predefined xIdNames("pid")
  XCOMMON_EXTRAS xFreF(0) xAssF(0) xEqF(yEq_SDL_PId) xRaWF(xRead_SDL_PId)
  xRaWF(xWri_SDL_PId) xTestF(0), (xptrint)sizeof(SDL_PId), xPredef,
  (xSortIdNode)0, (xSortIdNode)0, 0, 0 XSRT_EXTRAS};

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

#ifndef XNOUSEOFREAL
XCONST struct xSortIdStruct xSrtR_SDL_Real = {xSortEC xSymbTLink((xIdNode)0,
  (xIdNode)0), (xIdNode)&yPacR_Predefined xIdNames("real") XCOMMON_EXTRAS
  xFreF(0) xAssF(0) xEqF(0) xRaWF(xRead_SDL_Real) xRaWF(xWri_SDL_Real)
  xTestF(0), (xptrint)sizeof(SDL_Real), xPredef, (xSortIdNode)0,
  (xSortIdNode)0, 0, 0 XSRT_EXTRAS};
#endif

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

XCONST struct xSortIdStruct xSrtR_SDL_Time = {xSortEC xSymbTLink((xIdNode)0,
  (xIdNode)0), (xIdNode)&yPacR_Predefined xIdNames("time") XCOMMON_EXTRAS
  xFreF(0) xAssF(0) xEqF(xEq_SDL_Duration) xRaWF(xRead_SDL_Time)
  xRaWF(xWri_SDL_Time) xTestF(0), (xptrint)sizeof(SDL_Time), xPredef,
  (xSortIdNode)0, (xSortIdNode)0, 0, 0 XSRT_EXTRAS};
#endif


/*---+---------------------------------------------------------------
     yInit_Predefined
-------------------------------------------------------------------*/

#ifndef XOPTSORT
void yInit_Predefined XPP((void))
{
  xInsertIdNode((xIdNode)&yPacR_Predefined);
  xInsertIdNode((xIdNode)&xSrtR_SDL_Boolean);
#ifndef XOPTLIT
  xInsertIdNode((xIdNode)&yFalseR);
  xInsertIdNode((xIdNode)&yTrueR);
#endif
  xInsertIdNode((xIdNode)&xSrtR_SDL_Bit);
#ifndef XNOUSEOFOCTETBITSTRING
  xInsertIdNode((xIdNode)&xSrtR_SDL_Bit_String);
#endif
  xInsertIdNode((xIdNode)&xSrtR_SDL_Character);
  xInsertIdNode((xIdNode)&xSrtR_SDL_Charstring);
  xInsertIdNode((xIdNode)&xSrtR_SDL_Duration);
  xInsertIdNode((xIdNode)&xSrtR_SDL_IA5String);
  xInsertIdNode((xIdNode)&xSrtR_SDL_Integer);
  xInsertIdNode((xIdNode)&xSrtR_SDL_Natural);
  xInsertIdNode((xIdNode)&xSrtR_SDL_Null);
  xInsertIdNode((xIdNode)&xSrtR_SDL_NumericString);
#ifndef XNOUSEOFOBJECTIDENTIFIER
  xInsertIdNode((xIdNode)&xSrtR_SDL_Object_Identifier);
#endif
#ifndef XNOUSEOFOCTETBITSTRING
  xInsertIdNode((xIdNode)&xSrtR_SDL_Octet);
  xInsertIdNode((xIdNode)&xSrtR_SDL_Octet_String);
#endif
  xInsertIdNode((xIdNode)&xSrtR_SDL_PId);
  xInsertIdNode((xIdNode)&xSrtR_SDL_PrintableString);
#ifndef XNOUSEOFREAL
  xInsertIdNode((xIdNode)&xSrtR_SDL_Real);
#endif
  xInsertIdNode((xIdNode)&xSrtR_SDL_Time);
  xInsertIdNode((xIdNode)&xSrtR_SDL_VisibleString);
}
#endif

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


/****+***************************************************************
02   Operator implementations
********************************************************************/

/*** Bit_String ***************************************************/

#ifndef XNOUSEOFOCTETBITSTRING

/*---+---------------------------------------------------------------
     xAss_SDL_Bit_String
-------------------------------------------------------------------*/
#ifndef XNOPROTO
void xAss_SDL_Bit_String (
  SDL_Bit_String *BVar,
  SDL_Bit_String  BExpr,
  int             AssType )
#else
void xAss_SDL_Bit_String (BVar, BExpr, AssType)
  SDL_Bit_String *BVar;
  SDL_Bit_String  BExpr;
  int             AssType;
#endif
{
  int IsXASSPARA = XMK_FALSE ;
  /* Needed because *BVar equals BExpr in XASSCOPY case : */
  SDL_Bit_String tmpv; /* only needed for XASSCOPY case */
  PRINTF((" XASSPARA = %d", AssType));
  if (AssType == XASSPARA)
  {
      PRINTF((" XASSPARA = %d", AssType));
    /*
    ** Default setting of octet_string variable - used in the
    ** case of output only (corrected by fbi)
    */
    (*BVar).Bits = 0;
    (*BVar).Length = 0;
    (*BVar).IsAssigned = (xbool)1;
    IsXASSPARA = XMK_TRUE ;
    AssType = XASS ;
  }
  else if (AssType == XASSCOPY)
  {
    /* 
    ** When a PRD with FPAR IN is called, the incoming variable must
    ** be duplicated. This concerns the dynamic memory as well.
    ** In the case of Bit_String / Octet_String, a C struct value
    ** is passed into the PRD C function, which is already a copy
    ** of the incoming variable. So, only the dynamic memory must be
    ** allocated newly (if there was some allocated in the incoming variable).
    */
    if ( (*BVar).Bits != (SDL_Bit *)0 )
    {
      if ( ! ( (*BVar).IsAssigned ) && ( (*BVar).Length != 0) )
      {
        (*BVar).IsAssigned = (xbool)1;
      }
      else
      {
        tmpv.IsUsedInSignal = (xbool)0;
        /* Incoming Variable FPAR IN contains a value */
        tmpv.Bits = xAlloc_SDL_Bit_String((xptrint)(BExpr.Length));
        (void)memcpy((void *)(tmpv).Bits, (void *)BExpr.Bits, BExpr.Length);
        (*BVar).Bits = tmpv.Bits;
        (*BVar).IsAssigned = (xbool)1; /* FBI */
      }
    }