------------------------SDT2ÿÿÿÿA BufferInterface----------------------------------------------------ObjectName----------------------------------------ObjectType----------------------------------------!%()HeaderText------------------------------------!%()HeadingText-----------------------------------  ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿBufferInterface------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ÿÿÿÿ11-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ÿÿÿÿ()[8(!> ; /* ******************************************************************************* Copyright by Telelogic AB 2000 - 2002. 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. *******************************************************************************/ /* # clearcase CoderBuf.sdl@@/main/29 : 2002/05/03 kab */ /* SDL representations of fundamenal C/C++ types */ /*#INCLUDE 'BasicCTypes.pr'*/ /*#INCLUDE 'CPointer.pr'*/ /* Inclusion of the original C/C++ header files */ /*#CODE #TYPE #ifndef _SDLCODERPACKAGE_SDL_H #define _SDLCODERPACKAGE_SDL_H #include "cucf.h" #endif #ifndef XNO_VERSION_CHECK #if defined(XSCT_CBASIC) || defined(XSCT_CADVANCED) #ifndef SCT_VERSION_4_4 Version_of_code_g enerator_and_bufferinterface_does_not_match force_error; #endif #endif #endif */)]}----------------------------------------------------------------------------------------------------------------------------------------------------------------------------Tÿÿÿÿ()[8(! package BufferInterface)]}-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------/ÿÿÿÿ()[w(!GSDL)]}-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ÿÿÿÿ!%()HeaderText------------------------------------!%()HeadingText-----------------------------------!%()PageOrder------------------------------------DefinitionPage------------------------------------  Aÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ!%&()LinkEndpoints----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------ ------------ ------------ÿÿÿÿ()[(! H ! 22!(d)[h(! 6––!  è)[k(! 6¯¯)[n(! 6¯ú! )]][Bq(! 6¯! )][ t(! 6R ¯)][9w(! 6âÈ! !S)[8(!Ø0 newtype global_namespace /*#NOTYPE*/ operators BufInitBuf : CoderBuf, tBMSBufType -> int; BufInitBuf : CoderBuf, tBMSBufType; BufCloseBuf : CoderBuf -> int; BufCloseBuf : CoderBuf; BufInitBufWithMemory : CoderBuf, tBMSBufType, ptr_tBMSUserMemory -> int; BufInitBufWithMemory : CoderBuf, tBMSBufType, ptr_tBMSUserMemory; BufCloseBufToMemory : CoderBuf, ptr_tBMSUserMemory -> int; BufCloseBufToMemory : CoderBuf, ptr_tBMSUserMemory; BufCopyBuf : CoderBuf, CoderBuf -> int; BufCopyBuf : CoderBuf, CoderBuf; BufInitWriteMode : CoderBuf -> int; BufInitWriteMode : CoderBuf; BufCloseWriteMode : CoderBuf -> int; BufCloseWriteMode : CoderBuf; BufInitReadMode : CoderBuf -> int; BufInitReadMode : CoderBuf; BufCloseReadMode : CoderBuf -> int; BufCloseReadMode : CoderBuf; BufCloseDeleteReadMode : CoderBuf -> int; BufCloseDeleteReadMode : CoderBuf; BufGetDataLen : CoderBuf -> tBMSLength; BufGetReadDataLen : CoderBuf -> tBMSLength; BufGetRule : CoderBuf -> tERRule; BufSetRule : CoderBuf, tERRule; BufGetByte : CoderBuf -> unsigned_char; BufPeekByte : CoderBuf -> unsigned_char; BufPutByte : CoderBuf, unsigned_char; /*#ADT(A(S) E(S) K(H))*/ endnewtype global_namespace;external 'C'; newtype global_namespace_need_wrapper operators BufGetSeg /*#NAME 'SDL_BufGetSeg' */ : CoderBuf, int -> Octet_string; BufPeekSeg /*#NAME 'SDL_BufPeekSeg' */ : CoderBuf, int -> Octet_string; BufPutSeg /*#NAME 'SDL_BufPutSeg' */ : CoderBuf, Octet_string, int; "or" /*#NAME '|'*/: tERRule, tERRule -> tERRule; /*#OP(HI)*/ "and" /*#NAME '&'*/: tERRule, tERRule -> tERRule; /*#OP(HI)*/ /*#ADT ( A(S) E(S) H) #HEADING extern SDL_Octet_String *SDL_BufGetSeg(tCoder *b, int length, SDL_Octet_String *res); extern SDL_Octet_String *SDL_BufPeekSeg(tCoder *b, int length, SDL_Octet_String *res); extern void SDL_BufPutSeg(tCoder *b, SDL_Octet_String *Seg, int length); #BODY SDL_Octet_String *SDL_BufGetSeg(tCoder *b, int length, SDL_Octet_String *res) { char *tmp; tmp = (char *)BufGetSeg(b, length); if (tmp != NULL) { res->Length = length;  res->IsAssigned = (xbool)0; res->Bits = (unsigned char *)XALLOC((xptrint)(length*8), xSrtN_SDL_Octet_String); memcpy( (unsigned char*)(res->Bits), tmp, length); } else { res->Length = 0; res->IsAssigned = (xbool)0; res->Bits = (unsigned char *)0; } return res; } SDL_Octet_String *SDL_BufPeekSeg(tCoder *b, int length, SDL_Octet_String *res) { char *tmp; tmp = (char *)BufPeekSeg(b, length); if (tmp != NULL) { res->Length = length; res->IsAssigned = (xbool)0; res->Bits = (unsigned char *)XALLOC((xptrint)(length*8), xSrtN_SDL_Octet_String); memcpy( (unsigned char*)(res->Bits), tmp, length); } else { res->Length = 0; res->IsAssigned = (xbool)0; res->Bits = (unsigned char *)0; } return res; } void SDL_BufPutSeg(tCoder *b, SDL_Octet_String *Seg, int length) { BufPutSeg( b, (unsigned char*)Seg->Bits, Seg->Length); } */ endnewtype global_namespace_need_wrapper; newtype CoderBuf /*#NAME 'CoderBuf'*/ Ref( tCoder); /*#ADT(A(S) E(S) W R F(H)) #TYPE #ifdef XVALIDATOR ERROR__data_type_cannot_be_used_by_SDT_Validator #endif #HEADING extern void yFree_CoderBuf(void **yVar); #BODY #ifdef XREADANDWRITEF #define MAX_WRITE_LEN (100) static char CTmp_CoderBuf[ 2*MAX_WRITE_LEN + 40]; static const char HexStr[] = "0123456789ABCDEF"; char * yWri_CoderBuf (void * value) { CoderBuf cb; tBMSLength length; static unsigned char * segPtr = 0; char * p; unsigned char * ptr; char temp[20]; SDL_Octet_String Temp2; cb = *(CoderBuf *)value; if (cb == 0) { return "Buffer not initialized"; } if (BufGetBufType(cb) == bms_SmallBuffer) { strcpy(CTmp_CoderBuf,"bms_SmallBuffer"); } else if (BufGetBufType(cb) == bms_UserBuffer) { strcpy(CTmp_CoderBuf,"bms_UserBuffer"); } else { strcpy(CTmp_CoderBuf,"BufferType"); } if (BufInNoMode(cb)) { tBMSLength rlen; strcat(CTmp_CoderBuf,"(NM)"); BufInitReadMode(cb); l ength = BufGetDataLen(cb); if ( length > 128*1024*1024 ) length = 0; rlen = BufGetReadDataLen(cb); if ( length > rlen ) { length -= rlen; segPtr = BufPeekSeg(cb,length); } else { length = 0; } BufCloseRea!dMode(cb); } else if (BufInReadMode(cb)) { tBMSLength rlen; strcat(CTmp_CoderBuf,"(RM)"); length = BufGetDataLen(cb); if ( length > 128*1024*1024 ) length = 0; rlen = BufGetReadDataLen(cb); if ( length > rlen ) { lengt"h -= rlen; segPtr = BufPeekSeg(cb,length); } else { length = 0; } } else { strcat(CTmp_CoderBuf,"(WM) Reading from Buffer not possible"); return CTmp_CoderBuf; } sprintf(temp,"%lu",length); strcat(CTmp_CoderBuf,temp)#; p = CTmp_CoderBuf; while (*p) { ++p; } *p = '\''; ++p; if ( length > MAX_WRITE_LEN ) length = MAX_WRITE_LEN; while ( length-- ) { *p = HexStr[ (*segPtr)>>4 ]; ++p; *p = HexStr[ (*segPtr) & 0x0f ]; ++p; ++segPtr; $ } *p = '\''; ++p; *p = 'H'; ++p; *p = '\0'; if (BufGetBufType(cb) != bms_SmallBuffer && BufGetBufType(cb) != bms_UserBuffer) { strcat(CTmp_CoderBuf,"\nif the user has defined new coder buffer\n"); strcat(CTmp_CoderBuf,"modification of% function yWri_CoderBuf might be needed\nto display the Buffer Type"); } return CTmp_CoderBuf; } static int xChooseAlternative(char * Prompt, char ** alternatives) { int i; xxToken Token; char strVar[256]; Token = xScanToken(strVar); & if (Token == xxEoln) { xPrintString(Prompt); } else if (Token == xxQuestionMark) { xSkipLine(); for (i = 0; alternatives[i]; i++) { xWriteBuf_Fmt("%s ",alternatives[i]); } xPrintString(": "); } else if (Token==xxMinus) { 'return -1; } else if (Token==xxLBracket) { return -3; } else if (strVar[0] != '\0') { for (i = 0; alternatives[i]; i++) { if (xfEqualIdString(strVar, alternatives[i])) { return i; } } return -2; } else { return( -2; } for (;;) { Token = xScanToken(strVar); if (Token == xxEoln) { for (i = 0; alternatives[i]; i++) { xWriteBuf_Fmt("%s ",alternatives[i]); } xPrintString(": "); } else if (Token == xxQuestionMark) { xSki)pLine(); for (i = 0; alternatives[i]; i++) { xWriteBuf_Fmt("%s ",alternatives[i]); } xPrintString(": "); } else if (Token==xxMinus) { return -1; } else if (Token==xxLBracket) { return -3; } else if (strVar[*0] != '\0') { for (i = 0; alternatives[i]; i++) { if (xfEqualIdString(strVar, alternatives[i])) { return i; } } return -2; } else { return -2; } } } int yRead_CoderBuf (void * Result_Addr) { Co+derBuf cb; int i; unsigned long length ; unsigned long length2 ; xxToken Token; SDL_Octet_String Temp; unsigned char * segPtr; int mChoice; char *modeChoices[] = { "ReadMode(RM)", "WriteMode(WM)", "NoMode(NM)", 0 }; SDL_,Integer result; Token = xPromptQuestionMark(" (CoderBuf) : "," (CoderBuf) : ", CTmp_CoderBuf); if (Token != xxId || sscanf(CTmp_CoderBuf,"%lu",&length) == 0) { xPrintString("CoderBuffer length should be unsigned long\n"); return 0; } mems-et(&Temp,0,sizeof(Temp)); if (!xReadSort(&Temp,xSrtN_SDL_Octet_String)) { xPrintString("CoderBuffer value should be an Octet_String\n"); GenericFreeSort((void **)&Temp,&ySDL_SDL_Octet_String); return 0; } length2 = Temp.Length; segPtr =. Temp.Bits; cb = NULL; result = BufInitBuf(cb,bms_SmallBuffer); if ( result != ec_SUCCESS) { cb = NULL; result = BufInitBuf(cb,bms_UserBuffer); if ( result != ec_SUCCESS) { xPrintString("Error in Buffer initialization(yRead_CoderBu/f)\n"); xPrintString("If the user has defined new coderbuffer,\nmodification of function yRead_CoderBuf might be needed\n"); GenericFreeSort((void **)&Temp,&ySDL_SDL_Octet_String); return 0; } } BufInitWriteMode(cb); if (length20 < length) { BufPutSeg(cb,segPtr,length2); for (i=1; i<=(length-length2); i++) { BufPutByte(cb,'\0'); } } else if (length2 > length) { BufPutSeg(cb,segPtr,length); } else { BufPutSeg(cb,segPtr,length2); } mChoice = xChoose1Alternative( "Choose Buffer Mode(Read/Write/No) : ", modeChoices ); if (mChoice == 0) { BufCloseWriteMode(cb); BufInitReadMode(cb); } else if (mChoice == 1) {} else if (mChoice == 2 || mChoice == -1) { BufCloseWriteMode(cb); } else if2 (mChoice == -2 || mChoice == -3) { xPrintString("Invalid Buffer Mode\n"); GenericFreeSort((void **)&Temp,&ySDL_SDL_Octet_String); BufCloseWriteMode(cb); BufCloseBuf(cb); return 0; } *(CoderBuf *)Result_Addr = cb; GenericFreeSort(3(void **)&Temp,&ySDL_SDL_Octet_String); return 1; } #endif void yFree_CoderBuf (void * * yVar) { CoderBuf cb; cb = *(CoderBuf *)yVar; if (cb) { if (BufInNoMode(cb)){ BufCloseBuf(cb); } else if (BufInWriteMode(cb)) { BufCloseWri4teMode(cb); BufCloseBuf(cb); } else if (BufInReadMode(cb)) { BufCloseReadMode(cb); BufCloseBuf(cb); } else { #ifdef XREADANDWRITEF xPrintString("Can't Close Buffer(in function yFree_CoderBuf)"); #endif } } *(CoderBuf5 *)yVar = (CoderBuf)0; } */ endnewtype CoderBuf; newtype tBMSUserMemory /*#REFNAME 'struct tBMSUserMemory'*/ struct DataLength tBMSLength; MemPtr ptr_void; MemSize tBMSLength; /*#ADT(A(S) E(S) K(H))*/ endnewtype tBMSUserMemory;external 'C';6 newtype ptr_tBMSUserMemory Ref( tBMSUserMemory); /*#ADT(A(S) E(S))*/ endnewtype ptr_tBMSUserMemory;external 'C'; newtype tBMSBufType /*#REFNAME 'enum tBMSBufType'*/ literals bms_SmallBuffer, bms_UserBuffer; /*#ADT(A(S) E(S) K(H))*/ endnewtype tBMSBufT7ype;external 'C'; syntype tERRule = unsigned_long_int endsyntype;external 'C'; synonym er_BER tERRule= external 'C'; synonym er_Definite tERRule= external 'C'; synonym er_Indefinite tERRule= external 'C'; synonym er_PER tERRule = external 'C'; synonym8 er_Aligned tERRule = external 'C'; synonym er_Unaligned tERRule = external 'C'; synonym er_NoEndPad tERRule = external 'C'; synonym er_UER tERRule = external 'C'; syntype tCoder = sCoder /*#ADT(A(S) E(S) K(H))*/ endsyntype tCoder;external 'C'; newtype s9Coder /*#REFNAME 'struct sCoder'*/ struct IsAssigned unsigned_char; /*#ADT(A(S) E(S) K(H))*/ endnewtype sCoder;external 'C'; syntype tBMSLength = unsigned_long_int /*#ADT(A(S) E(S) K(H))*/ endsyntype tBMSLength;external 'C'; /* encode and decode: operators for predefined sorts */ newtype CodingOperators operators encode : in/out CoderBuf, in Boolean -> Integer; decode : in CoderBuf, out Boolean -> Integer; encode : in/out CoderBuf, in Character -> Integer; decode : in CoderBuf, o;ut Character -> Integer; encode : in/out CoderBuf, in Charstring -> Integer; decode : in CoderBuf, out Charstring -> Integer; encode : in/out CoderBuf, in Integer -> Integer; decode : in CoderBuf, out Integer -> Integer; encode : in/out< CoderBuf, in Real -> Integer; decode : in CoderBuf, out Real -> Integer; encode : in/out CoderBuf, in Pid -> Integer; decode : in CoderBuf, out Pid -> Integer; encode : in/out CoderBuf, in Duration -> Integer; decode : in CoderBuf, out= Duration -> Integer; encode : in/out CoderBuf, in Time -> Integer; decode : in CoderBuf, out Time -> Integer; encode : in/out CoderBuf, in Bit -> Integer; decode : in CoderBuf, out Bit -> Integer; encode : in/out CoderBuf, in Bit_strin>g -> Integer; decode : in CoderBuf, out Bit_string -> Integer; encode : in/out CoderBuf, in Octet -> Integer; decode : in CoderBuf, out Octet -> Integer; encode : in/out CoderBuf, in Octet_string -> Integer; decode : in CoderBuf, out Oc?tet_string -> Integer; encode : in/out CoderBuf, in Object_identifier -> Integer; decode : in CoderBuf, out Object_identifier -> Integer; encode : in/out CoderBuf, in NULL -> Integer; decode : in CoderBuf, out NULL -> Integer; endnewtype Co@dingOperators; )]]]]}------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ÿÿÿÿ(!4w!5!W!7)[!(! DefinitionPage! )]}-------------------------------------------------------------------------------------------------------------------------------------------------------------------]ÿÿÿÿ