📄 easycics.ccs

📁 CICS简单入门例程 CICS环境构架 1 安装服务器 1）建立用户CICSTEST（要用超户权） 2）用CICSTEST用户登录 3）安装DB2指定CICSTEST为管理用户
💻 CCS
📖 第 1 页 / 共 2 页
字号:
上一页 12
}
else{
	EXEC CICS READQ TS QUEUE(TsqName) INTO(pComm) LENGTH(sn) ITEM(RsBlk) SYSID(SysId1) NOHANDLE;
}

	GetValue0( "_LONG", s );
if( !*s ){
 if(!*SysId1){
	EXEC CICS DELETEQ TS QUEUE(TsqName) NOHANDLE;
 }
 else{
	EXEC CICS DELETEQ TS QUEUE(TsqName) SYSID(SysId1) NOHANDLE;
 }
}

	SetValue0_( "_SYSID", SysId1 );
	strcpy(pCommArea,pComm);
	EXEC CICS RETURN;
}



/*
 */
void TsqRemove(char *SysId1){

if(!*SysId1){
	EXEC CICS DELETEQ TS QUEUE(TsqName) NOHANDLE;
}
else{
	EXEC CICS DELETEQ TS QUEUE(TsqName) SYSID(SysId1) NOHANDLE;
}

	EXEC CICS RETURN;
}



/*
 */
void TsqFetchBlock(char *SysId1){
char s[32];
short int sn, no;


	GetValue0( "_BNUM", s );
	BlockNum= atoi(s);

	GetValue0( "_BNO", s );
	no= atoi(s);

if(!no){
	EXEC CICS RETURN;
}

	*pComm =0;
	sn= BLOCK_SIZE;
if(!*SysId1){
	EXEC CICS READQ TS QUEUE(TsqName1) INTO(pComm) LENGTH(sn) ITEM(no) NOHANDLE;
}
else{
	EXEC CICS READQ TS QUEUE(TsqName1) INTO(pComm) LENGTH(sn) ITEM(no) SYSID(SysId1) NOHANDLE;
}

if( no==BlockNum ){
 if(!*SysId1){
	EXEC CICS DELETEQ TS QUEUE(TsqName1) NOHANDLE;
 }
 else{
	EXEC CICS DELETEQ TS QUEUE(TsqName1) SYSID(SysId1) NOHANDLE;
 }
}

	memcpy(pCommArea, pComm, BLOCK_SIZE);
	EXEC CICS RETURN;
}



/* Must follow InitEasyCics
 */
void _stdcall InitUpload(char *fpath, int maxlen){
char s[64], upfile[512], fullpath[1024];
int stn, len, err=0;
long l;
FILE *fp;


	GetValue0( "_UPF", upfile );
if( !*upfile ){
	err=1;
	goto EX;
}


	sprintf( fullpath, "%s%s", fpath, upfile );

	GetValue0( "_UPFC", s );

	if( *s == 'C' )
	fp= fopen( fullpath, "wb" );
	else
	fp= fopen( fullpath, "ab" );

if(!fp){
	err=-1;
	goto EX;
}

	GetValue0( "_UPFL", s );
	len= atoi( s );

	l= ftell(fp);
if( l>maxlen || l+len>maxlen || len<0 || len>BLOCK_SIZE ){
	fclose(fp);
	err=-2;
	goto EX;
}

	stn= strlen(pComm); 
	fwrite( pComm+stn+1, 1, len, fp );

	fclose(fp);
EX:
if(!err){
	SetValueX( "_UPOK", "Y", pCommArea );
}
else if(err==1){
	return;
}
else{
	sprintf( s, "%d", err );
	SetValueX( "_UPCODE", s, pCommArea );
}

	EXEC CICS RETURN;
}



/***
 ResultSet***/

/*
 */
void _stdcall RsCreate(int ColNum){

	RsColNum=ColNum;
	RsRow=RsRowNum=RsRowNum0=0;
	RsBlk=RsBlkCli=0;
	*TsqName = *TableLst = '\0';
}



/*
 */
void _stdcall RsNewTable(int ColNum){
char s[30];
int n_rows;


	n_rows= RsRowNum-RsRowNum0;
if(n_rows){
	sprintf( s, "%d:%d;", RsColNum, n_rows );
	RsRowNum0=RsRowNum;
	strcat( TableLst, s );
}

	if(ColNum)
	RsColNum=ColNum;
}



/*
 */
void _stdcall RsOpen(){
char s[10];

	GetValue0( "_RC", s );
	RsRowNum = atoi(s);
	RsRowNum0=0;
	/*-*/
	GetValue0( "_CC", s );
	RsColNum = atoi(s);

	RsRow=0;
	RsBlk=RsBlkCli=0;
	*TsqName = '\0';

	LongNum=RsRowNum;
        GetValue0( "_LONG", s );
	if(*s)
        LongNum= atoi(s);

	GetValue0( "_TL", TableLst );
}



/*
 */
void _stdcall RsAddRow(){
	RsRowNum++;

	*pRow=0;
}



/*
 */
void _stdcall RsSetCol(int Col, char *Vlu){
int i,n;
char *p, *p0, *p1;
char buf[BUF_SIZE]="";


/*Make sure (RsColNum-1) ","*/
	p0=pRow;
for( i=0; i<RsColNum; i++ ){
	p= strchr( p0, ',' );

	if(!p)break;
	p0= p+1;
}
	n= RsColNum-1-i;
if(n>0){
	for(i=0; i<n; i++)
	strcat( pRow, "," );
}


/*Find start-end*/
	p0=pRow;
	p1= pRow+ strlen(pRow);
	p=p1;
for( i=1; i<Col; i++ ){
	p= strchr( p0, ',' );

	if(!p)return;
	p0= p+1;
}

	p= strchr( p0, ',' );
	if(p)
	p1=p;

/*Set value*/
	strcpy( buf, p1 );

	EncodeStr_(Vlu,p0);
	strcat(p0,buf);	

}



/*
 */
void _stdcall RsGetCol(int Col, char *Vlu){
int i,n;
char *p, *p0, *p1;

/*Init*/
	*Vlu=0;

/*Find start-end*/
	p0=pRow;
	p1= pRow+ strlen(pRow);
	p=p1;
for( i=1; i<Col; i++ ){
	p= strchr( p0, ',' );

	if(!p)return;
	p0= p+1;
}

	p= strchr( p0, ',' );
	if(p)
	p1=p;

/*Get the value*/
	n= p1-p0;
	Decode_(p0,Vlu,n);

	if(ForPbUse)
	strcpy( Vlu, PbDecode(Vlu) );
}



/*
 */
void _stdcall RsSaveRow(){
char s[20];

	sprintf( s, "_%d", RsRowNum );
	SetValue_( s, pRow );

	LongNum=RsRowNum;

if( strlen(pComm) >WARN_SIZE ){
	sprintf( s, "%d", RsRowNum );
	SetValue0( "_LONG", s );

	if(!*TsqName)
	CreateTsqName();

	SaveBlk();

	RsBlk++;
	*pComm =0;

	SetValue0_( "_CA", CicsRegionTag );
}

}



/*
 */
int _stdcall RsFetchRow(){
char s[20], tsq[20], rcs[20];


	*pRow =0;

	RsRow++;

if(RsRow>LongNum){
        GetValue( "_TSQ", tsq );
        GetValue( "_RC", rcs );
        RsBlkCli= RsBlkCli+1;

	memset(pComm, 0, BUF_SIZE);
        SetValue( "_TSQ", tsq );
	sprintf( s, "%d", RsBlkCli );
        SetValue( "_BLK", s );

        _CallProgram0();
        
        LongNum=RsRowNum;
        GetValue( "_LONG", s );
        if(*s)
	LongNum= atoi(s);
        
        SetValue( "_TSQ", tsq );
        SetValue( "_RC", rcs );
}

	sprintf( s, "_%d", RsRow );
	GetValue( s, pRow );

	return 0;
}



/*
 */
void _stdcall RsClose(){
char s[20], tsq[20], rcs[20];

	if(LongNum==RsRowNum)
	return;

        GetValue( "_TSQ", tsq );
        GetValue( "_RC", rcs );
        RsBlkCli= RsBlkCli+1;

	memset(pComm, 0, BUF_SIZE);
        SetValue( "_TSQ", tsq );
	sprintf( s, "%d", RsBlkCli );
        SetValue( "_BLK", s );

	SetValue0( "_DELTSQ", "Y" );

        _CallProgram0();
}



/*
 */
int _stdcall RsGetRowNum(){
	return RsRowNum;
}



/*
 */
int _stdcall RsGetColNum(){
	return RsColNum;
}



/*
 */
int RsGetTableColNum(int nt){
int i;
char *p0, *p1;

for(i=1, p0=TableLst; i<nt; i++, p0++){
	p0= strchr( p0, ';' );
	if(!p0)return 0;
}

	p1= strchr( p0, ':' );
	if(!p1)return 0;

	if( p0!=p1 )
	return atoi(p0);
	else
	return 0;
}



/*
 */
int RsGetTableRowNum(int nt){
int i;
char *p0, *p1, *p2;

for(i=1, p0=TableLst; i<nt; i++, p0++){
	p0= strchr( p0, ';' );
	if(!p0)return 0;
}

	p1= strchr( p0, ':' );
	if(!p1)return 0;

	p1++;
	p2= strchr( p1, ';' );
	if(!p2)return 0;

	if( p1!=p2 )
	return atoi(p1);
	else
	return 0;
}



/*
 */
void _stdcall RsSetColNameList(char *ColName){
	SetValue0( "_C_N", ColName );
}



/*
 */
void _stdcall BinaryToAscii(char *bs, char *as, int n){
int nn, i, bi;
char *p;


	memset( as, '\0', (n+2)/3*4 );

for( i=0, p=bs, bi=0; i<n; i++, p++, bi++ ){
	if(bi>=3)
	bi-=3;

	nn= i/3*4;
 switch(bi){
 case 0:
	as[nn] |= *p & 0x3f;
	as[nn] |= 0x40; 

	as[nn+1] |= (*p & 0xc0) >>6;
	as[nn+1] |= 0x40; 

	break;
 case 1:
	as[nn+1] |= (*p & 0xf) <<2; 
	as[nn+1] |= 0x40; 

	as[nn+2] |= (*p & 0xf0) >>4; 
	as[nn+2] |= 0x40; 

	break;
 case 2:
	as[nn+2] |= (*p & 0x3) <<4; 
	as[nn+2] |= 0x40; 

	as[nn+3] |= (*p & 0xfc) >>2; 
	as[nn+3] |= 0x40; 

	break;
 }

}

}



/*
 */
int _stdcall AsciiToBinary(char *as, char *bs){
int n, n1, nn, i, bi;
char *p;


	n= strlen(as);
	n1= n/4;
switch(n-n1*4){
case 0:
	n= n1*3;

	break;
case 1:
case 2:
	n= n1*3+1;

	break;
case 3:
	n= n1*3+2;
}

	memset( bs, '\0', n );

	nn=-1;
for( p=as, i=0, bi=0; *p; p++, i++, bi++ ){
	if(bi>=4)
	bi-=4;

	*p &= 0x3f;

	nn= i/4*3;
 switch(bi){
 case 0:
	bs[nn] |= *p;

	break;
 case 1:
	bs[nn] |= *p <<6;
	bs[nn+1] |= *p >>2;

	break;
 case 2:
	bs[nn+1] |= *p <<4;
	bs[nn+2] |= *p >>4;

	break;
 case 3:
	bs[nn+2] |= *p <<2;

	break;
 }
}

	return n;
}



/*
 */
int _stdcall CicsCommit(){

	EXEC CICS SYNCPOINT RESP(RetCode);

	if( RetCode != DFHRESP(NORMAL) )
	return -1;
	else
	return 0;
}



/*
 */
int _stdcall CicsRollBack(){

	EXEC CICS SYNCPOINT ROLLBACK RESP(RetCode);

	if( RetCode != DFHRESP(NORMAL) )
	return -1;
	else
	return 0;
}



/*
 */
void _stdcall CicsAbend(char *Abcode){

	if( strlen(Abcode) >4 )
	Abcode[4] = '\0';

	EXEC CICS ABEND ABCODE( Abcode );
}



/*
 */
void _stdcall GetValue1(char *Key, char *Value, int Num){
char s[BUF_SIZE];

	GetValue( Key, s );
	strncpy(Value,s,Num);
	Value[Num-1] = '\0';
}



/*
 */
void _stdcall RsGetCol1(int Col, char *Vlu, int Num){
char s[BUF_SIZE];

	RsGetCol( Col, s );
	strncpy(Vlu,s,Num);
	Vlu[Num-1] = '\0';
}



/*
 */
void SaveBlockUnit0(char *blku){
short int sn;

	sn= BLOCK_SIZE;

	EXEC CICS WRITEQ TS QUEUE(TsqName1) FROM(blku) LENGTH(sn) NOHANDLE;
}



/*
 */
void _stdcall SaveBlockUnit(char *blku){

	if(!*TsqName1)
	CreateTsqName1();

	SaveBlockUnit0(blku);
}



/*
 */
void _stdcall SetBlockSize(int size){
char s[32];

	BlockSize=size;
	sprintf( s, "%d", BlockSize );
	SetValue( "_BSIZE", s );

	BlockNum = (BlockSize+BLOCK_SIZE-1) /BLOCK_SIZE;
	sprintf( s, "%d", BlockNum );
	SetValue( "_BNUM", s );

if(BlockNum==1){
	EXEC CICS DELETEQ TS QUEUE(TsqName1) NOHANDLE;
}

}



/*
 */
void _stdcall SaveBlock(char *blk, int size){
int i, n;
char *p, buf[BLOCK_SIZE];


	if(!*TsqName1)
	CreateTsqName1();

	SetBlockSize(size);

for( i=0, n=BlockSize, p=blk; i<BlockNum; i++, n-=BLOCK_SIZE, p+=BLOCK_SIZE ){

 if( n>=BLOCK_SIZE ){
	SaveBlockUnit0( p );
 }
 else{
	memset( buf, 0, BLOCK_SIZE );
	memcpy( buf, p, n );

	SaveBlockUnit0( buf );
 }

}

}



/*
 */
void _stdcall GetUniqueId6(char *UniqueId){
unsigned char *pc;
int i;

	pc= (unsigned char *)dfheiptr->eibtaskn;
	UniqueId[0]= pc[0] & 0x3F;
	UniqueId[1]= pc[1] & 0x3F;
	UniqueId[2]= pc[2] & 0x3F;
	UniqueId[3]= pc[3] & 0x3F;
	UniqueId[4]= (pc[0] >>6 <<2) | (pc[1] >>6);
	UniqueId[5]= (pc[2] >>6 <<2) | (pc[3] >>6);

	for(i=0; i<6; i++)
	UniqueId[i] |= 0x40;

	UniqueId[6] =0;
}



/*
 */
unsigned long _stdcall GetUniqueNum(){
unsigned char *pc;
unsigned long ln;

	pc= (unsigned char *)dfheiptr->eibtaskn;
	return ( (unsigned long )pc[0] <<24 ) + ( (unsigned long )pc[1] <<16 ) + ( (unsigned long )pc[2] <<8 ) + (unsigned long )pc[3];
}



/*
 */
void _stdcall GetUniqueId(char *UniqueId){
unsigned char *pc;
unsigned long ln;


	ln= GetUniqueNum();
	sprintf( UniqueId, "%08lX", ln );
	UniqueId[8] =0;
}



/*
 */
int _stdcall CicsLock(char *LockPtr, int IfPtr, int IfDsync){
short n;

if( !IfPtr ){
	n= strlen(LockPtr);
 if( !IfDsync ){
	EXEC CICS ENQ RESOURCE(LockPtr) LENGTH(n) RESP(RetCode);
 }
 else{
	EXEC CICS ENQ RESOURCE(LockPtr) LENGTH(n) NOSUSPEND RESP(RetCode);
 }
}
else{
 if( !IfDsync ){
	EXEC CICS ENQ RESOURCE(LockPtr) RESP(RetCode);
 }
 else{
	EXEC CICS ENQ RESOURCE(LockPtr) NOSUSPEND RESP(RetCode);
 }
}

	if( RetCode != DFHRESP(NORMAL) )
	return -1;
	else
	return 0;
}



/*
 */
int _stdcall CicsUnLock(char *LockPtr, int IfPtr){
short n;

if( !IfPtr ){
	n= strlen(LockPtr);
	EXEC CICS DEQ RESOURCE(LockPtr) LENGTH(n) RESP(RetCode);
}
else{
	EXEC CICS DEQ RESOURCE(LockPtr) RESP(RetCode);
}

	if( RetCode != DFHRESP(NORMAL) )
	return -1;
	else
	return 0;
}



/*
 */
int _stdcall CicsLockTest(char *LockPtr, int IfPtr){	/* 0: means NO lock */
short n;

if( !IfPtr ){
	n= strlen(LockPtr);
	EXEC CICS ENQ RESOURCE(LockPtr) LENGTH(n) NOSUSPEND RESP(RetCode);
}
else{
	EXEC CICS ENQ RESOURCE(LockPtr) NOSUSPEND RESP(RetCode);
}

if( RetCode != DFHRESP(NORMAL) ){
	return 1;
}
else{
	CicsUnLock(LockPtr, IfPtr);
	return 0;
}

}



/* System will abend with "AKCS" if the TD property DeadLockTimeout is too small.
 */
void _stdcall CicsSleep(int nSeconds){
	EXEC CICS DELAY FOR SECONDS(nSeconds);
}



/*
 */
void * _stdcall CicsMalloc(int nBytes, int IfShared){
void *pMem;

if(!IfShared){
	EXEC CICS GETMAIN SET(pMem) FLENGTH(nBytes) RESP(RetCode);
}
else{
	EXEC CICS GETMAIN SET(pMem) FLENGTH(nBytes) SHARED RESP(RetCode);
}

	if( RetCode != DFHRESP(NORMAL) )
	return 0;	/* It means error !!! */
	else
	return pMem;
}



/*
 */
void _stdcall CicsFree(char *pMem){
	EXEC CICS FREEMAIN DATA(pMem);
}



/*
 */
void _stdcall SaveToCwa(int nPos, void *pMem, int len){
int i;
char *p;

	p= pMem;
	for( i=0; i<len; i++,p++ )
	pCwa[nPos+i] = *p;
}



/*
 */
void _stdcall LoadFromCwa(int nPos, void *pMem, int len){
int i;
char *p;

	p= pMem;
	for( i=0; i<len; i++,p++ )
	*p = pCwa[nPos+i];
}



/*
 */
int _stdcall WriteTdq( char *name, char *data, short len ){

	EXEC CICS WRITEQ TD QUEUE(name) FROM(data) LENGTH(len) RESP(RetCode) NOHANDLE;


	if( RetCode!= DFHRESP(NORMAL) )
	return -1;

	return 0;
}



/*
 */
int _stdcall ReadTdq( char *name, char *data, short len, int seconds ){
int i;


	memset( data, '\0', len );
for( i=0; i<=seconds; i++ ){
	EXEC CICS READQ TD QUEUE(name) INTO(data) LENGTH(len) NOSUSPEND RESP(RetCode) NOHANDLE;

	if( RetCode== DFHRESP(NORMAL) )
	return 0;

	if( ( RetCode!= DFHRESP(NORMAL) ) && ( RetCode!= DFHRESP(QZERO) ) )
	return -1;

	if(seconds)
	CicsSleep(1);
}

	return 1;
}



/*
 */
int _stdcall DelTdq( char *name ){

	EXEC CICS DELETEQ TD QUEUE(name) RESP(RetCode) NOHANDLE;
	if( RetCode!= DFHRESP(NORMAL) )
	return -1;
	return 0;
}



/*
 */
int _stdcall WriteTsq( char *name, char *data, short len ){

	EXEC CICS WRITEQ TS QUEUE(name) FROM(data) LENGTH(len) RESP(RetCode) NOHANDLE;

	if( RetCode!= DFHRESP(NORMAL) )
	return -1;

	return 0;
}



/*
 */
int _stdcall WriteTsqInMem( char *name, char *data, short len ){

	EXEC CICS WRITEQ TS QUEUE(name) FROM(data) LENGTH(len) MAIN RESP(RetCode) NOHANDLE;

	if( RetCode!= DFHRESP(NORMAL) )
	return -1;

	return 0;
}



/*
 */
int _stdcall ReadTsq( char *name, char *data, short len, short item_num ){

	memset( data, '\0', len );
	EXEC CICS READQ TS QUEUE(name) INTO(data) LENGTH(len) ITEM(item_num) RESP(RetCode) NOHANDLE;

	if( RetCode!= DFHRESP(NORMAL) )
	return -1;

	return 0;
}



/*
 */
int _stdcall DelTsq( char *name ){

	EXEC CICS DELETEQ TS QUEUE(name) RESP(RetCode) NOHANDLE;
	if( RetCode!= DFHRESP(NORMAL) )
	return -1;
	return 0;
}



/*
 */
int _stdcall ModifyTsq( char *name, char *data, short len, short item_num ){

	EXEC CICS WRITEQ TS QUEUE(name) FROM(data) LENGTH(len) ITEM(item_num) REWRITE RESP(RetCode) NOHANDLE;

	if( RetCode!= DFHRESP(NORMAL) )
	return -1;

	return 0;
}



/******************************************************************************/
#ifdef  __cplusplus
}
#endif
/******************************************************************************/
上一页 12
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -