/*
* Manual page at process.def
*/
INT16 CGEN_PUBLIC CProcess::Status()
{
CData* d;
char s[L_INPUTLINE];
INT32 i;
printf("\n"); dlp_fprint_x_line(stdout,'-',dlp_maxprintcols()); // Protocol
printf("\n Status of instance"); // Protocol
printf("\n process %s",BASEINST(_this)->m_lpInstanceName); // Protocol
printf("\n"); dlp_fprint_x_line(stdout,'-',dlp_maxprintcols()); // Protocol
printf("\n State : 0x%04X",m_nState); // Protocol
if (m_nState!=0) // In any but the maiden state
{ // >>
BOOL b = 0; // Comma flag
printf(" ("); // Protocol
if (m_nState&PRC_DATASENT ) { if(b) printf(", "); printf("data sent" ); b=1; }//...
if (m_nState&PRC_RUNNING ) { if(b) printf(", "); printf("running" ); b=1; }//...
if (m_nState&PRC_COMPLETE ) { if(b) printf(", "); printf("complete" ); b=1; }//...
if (m_nState&PRC_KILLED ) { if(b) printf(", "); printf("killed" ); b=1; }//...
if (m_nState&PRC_DATARECEIVED) { if(b) printf(", "); printf("data received"); b=1; }//...
printf(")"); // Protocol
} // <<
printf("\n Return value: %ld",(long)m_nRetVal ); // Protocol
if (dlp_strlen(m_psTmpFile)) printf("\n Temp. files : %s*",m_psTmpFile); // Protocol
dlp_strcpy(s,m_psCmdLine); dlp_strreplace(s,m_psTmpFile,"<tmpfile>"); // Abbreviate command line
if (dlp_strlen(m_psCmdLine)) printf("\n Command line: %s" ,s); // Protocol
// Show transferred data // ------------------------------------
if (m_iDto) // Have data transfer object
{ // >>
printf("\n"); dlp_fprint_x_line(stdout,'-',dlp_maxprintcols()); // Protocol
printf("\n Transferred data"); // Protocol
d = (CData*)CDlpObject_FindInstanceWord(m_iDto,PRC_S_IDSIGN,NULL); // Get signature table
printf("\n - function : %s",(char*)CData_XAddr(d,0,0)); // Protocol (job function name)
for (i=1; i<CData_GetNRecs(d); i++) // Loop over function arguemnts
printf("\n %13s %s",i==1?"- arguments :":"",(char*)CData_XAddr(d,i,0)); // Protocol (job function arg.)
d = (CData*)CDlpObject_FindInstanceWord(m_iDto,PRC_S_IDGLOB,NULL); // Get list of global instances
if (d) // Have one
for (i=0; i<CData_GetNRecs(d); i++) // Loop over entries
printf("\n %13s %-8s %s",i==0?"- globals :":"", // Protocol (global instance)
(char*)CData_XAddr(d,i,0),(char*)CData_XAddr(d,i,1)); // |
printf("\n"); dlp_fprint_x_line(stdout,'-',dlp_maxprintcols()); // Protocol
printf("\n Transferred program"); // Protocol
for (i=0; dlp_strlen(__sSlaveScript[i]); i++) // Loop over slave script lines
{ // >>
dlp_strcpy(s,__sSlaveScript[i]); // Get a line
if (strstr(s,"##"))*(strstr(s,"##"))='\0'; // Truncate at comment
printf("\n (%02ld) %s",i,dlp_strtrimright(s)); // Protocol (script line)
} // <<
} // <<
printf("\n"); dlp_fprint_x_line(stdout,'-',dlp_maxprintcols()); printf("\n"); // Protocol
return O_K; // All done
}
/**
* Prints the instance in text mode (exactly one component of type 1).
*/
INT16 CGEN_PRIVATE CData_PrintText(CData* _this)
{
INT32 nR = 0; /* Current record */
INT32 nXR = 0; /* Number of records */
char* tx = NULL; /* Auxilary char pointer #1 */
char* tx0 = NULL; /* Pointer to string */
char* ty = NULL; /* Auxilary char pointer #2 */
char* ty0 = NULL; /* Pointer to last white space */
INT32 nCtr = 0; /* Line counter */
char sBuf[255]; /* Printing buffer */
/* Initialize */ /* --------------------------------- */
nXR = CData_GetNRecs(_this); /* Get number of records */
/* Print data contents as text */ /* --------------------------------- */
DLPASSERT(FMSG("ALPHA: String mode not tested yet")); /* TODO: Remove after debugging */
printf("\n String Mode"); dlp_inc_printlines(1); /* Protocol */
tx0=tx=(char*)CData_XAddr(_this,0,0); /* Initialize char pointers */
if (!*tx) /* Empty string */
{ /* >> */
printf("\n [empty]"); /* Protocol */
dlp_inc_printlines(1); /* Adjust no. of printed lines */
} /* << */
else while (*tx) /* Loop over characters */
{ /* >> */
/* Make line breaks */ /* - - - - - - - - - - - - - - - - */
for (ty=tx,ty0=NULL; *ty && ty<tx0+nXR; ) /* Do until end of string */
{ /* >> */
while (*ty && ty<tx0+nXR && !iswspace(*ty)) ty++; /* Seek next white space */
while (*ty && ty<tx0+nXR && iswspace(*ty)) ty++; /* Skip following white spaces */
ty0=ty; /* Remember previous white spc. */
if (ty>tx+dlp_maxprintcols()-16) break; /* Line full */
} /* << */
if (ty0) ty=ty0; /* Go back to last white space */
/* Print one line */ /* - - - - - - - - - - - - - - - - */
dlp_memset(sBuf,0,255); /* Clear printing buffer */
dlp_memmove(sBuf,tx,ty-tx); /* Copy characters in */
printf("\n %4d(%06d): %s",(int)nCtr,(int)(tx-tx0),sBuf); /* Print 'em */
dlp_inc_printlines(1); /* Adjust no. of printed lines */
if (dlp_if_printstop()) break; /* Break listing */
/* End-of-line actions */ /* - - - - - - - - - - - - - - - - */
DLPASSERT(ty>tx); /* Should have made some progress */
tx=ty; /* Move to end of printed line */
nCtr++; /* Increment line counter */
} /* << */
if (nR>=nXR) printf("\n No more data - Stop."); /* Protocol */
else printf("\n Cancelled - Stop."); /* Protocol */
return O_K; /* Ok */
}
/**
* Prints the instance in vector mode (standard).
* @param _this
* Pointer to data instance
* @return <code>O_K</code> if successfull, a (negative) errorcode otherwise
*/
INT16 CGEN_PUBLIC CData_PrintVectors(CData* _this)
{
INT32 i = 0; /* Universal loop counter */
INT32 nB = 0; /* Current block index */
INT32 nL = 0; /* Number of recently printed lines */
INT32 nXL = 0; /* Total number of printed lines */
char sBuf[L_SSTR+1]; /* String buffer */
if (CData_GetNBlocks(_this)<=1) /* No blocks */
return (INT16)CData_PrintVectors_Block(_this,-1); /* Print all records at once */
else for (nB=0; nB<CData_GetNBlocks(_this); ) /* Else loop over blocks */
{ /* >> */
nL = CData_PrintVectors_Block(_this,nB); /* Print blocks separately */
if (nL<0) { printf("\n Cancelled"); return O_K; } /* Cancelled by user */
if (nB<CData_GetNBlocks(_this)-1) /* Not the last block */
{ printf("\n"); for (i=0; i<dlp_maxprintcols(); i+=2) printf(" -"); } /* Print a nice separator */
nXL += nL; /* Count printed lines */
if /* Next block won't fit on screen */
( /* | */
nXL+nL>dlp_maxprintlines() || /* | if it is as long as the last */
CData_GetNRecsPerBlock(_this)>dlp_maxprintlines() /* | because it has too many recs. */
) /* | */
{ /* >> */
if (nB==CData_GetNBlocks(_this)) /* This was the last block */
{ printf("\n"); for (i=0; i<dlp_maxprintcols(); i+=2) printf(" -"); } /* Separator not yet printed */
dlp_inc_printlines(dlp_maxprintlines()); /* Do stop right here */
sprintf(sBuf,"block (0..%ld)",(long)CData_GetNBlocks(_this)-1); /* Make user hint */
if ((nB=dlp_printstop_nix(nB,sBuf,NULL))==-1) break; /* Break listing */
if (nB< -2 ) nB=0; /* Bad user reply -> start over */
if (nB>=CData_GetNBlocks(_this)) break; /* No more blocks -> break */
nXL=0; /* Reset line counter */
} /* << */
else nB++; /* No list break -> next block */
} /* << */
return O_K; /* Ok */
}
/*
* Manual page at statistics.def
*/
INT16 CGEN_PUBLIC CStatistics_Pool
(
CStatistics* _this,
CStatistics* iSrc,
CData* idMap
)
{
INT32 i = 0; /* Current component index */
INT32 nC = 0; /* Current pooled statistics class */
INT32 nCs = 0; /* Current source class index */
INT32 nXC = 0; /* Number of pooled classes */
INT32 nRpb = 0; /* Statistics raw data block size */
INT16 nCheckSave = 0; /* Saved check level */
CData* idAux = NULL; /* Auxilary data instance #1 */
CData* idPmp = NULL; /* Pooling map */
CData* idPcd = NULL; /* Pooled class raw data buffer */
/* Initialize */ /* --------------------------------- */
CHECK_THIS_RV(0); /* Check this instance */
IF_NOK(CStatistics_Check(iSrc)) /* Check source statistics */
return IERROR(_this,ERR_INVALARG,"iSrc",0,0); /* ... */
nCheckSave = _this->m_nCheck; /* Save check level */
CStatistics_Reset(BASEINST(_this),TRUE); /* Reset destination */
_this->m_nCheck = nCheckSave; /* Restore check level */
IFIELD_RESET(CData,"dat"); /* Create pool raw stats. data inst. */
/* Protocol */ /* --------------------------------- */
IFCHECK /* On verbose level 1 */
{ /* >> */
printf("\n"); dlp_fprint_x_line(stdout,'-',dlp_maxprintcols()); /* Print protocol header */
printf("\n statistics -pool"); /* ... */
printf("\n"); dlp_fprint_x_line(stdout,'-',dlp_maxprintcols());printf("\n");/* ... */
} /* << */
/* No map --> pool all classes */ /* --------------------------------- */
if (CData_IsEmpty(idMap)) /* NULL or empty map instance */
{ /* >> */
IFCHECK printf("\n Empty pooling map --> pool all classes"); /* Protocol (verbose level 1) */
CStatistics_PoolInt(_this->m_idDat,iSrc->m_idDat,0); /* Pool sum data */
CStatistics_PoolInt(_this->m_idDat,iSrc->m_idDat,1); /* Pool min data */
CStatistics_PoolInt(_this->m_idDat,iSrc->m_idDat,2); /* Pool max data */
STA_PROTOCOL_FOOTER(1,"done"); /* Print protocol footer */
return O_K; /* That's it */
}
IFCHECK printf("\n Pooling by map"); /* Protocol (verbose level 1) */
ICREATEEX(CData,idAux,"CStatistics_Pool.~idAux",NULL); /* Create auxilary data instance #1 */
ICREATEEX(CData,idPmp,"CStatistics_Pool.~idPmp",NULL); /* Create pooling map */
ICREATEEX(CData,idPcd,"CStatistics_Pool.~idPcs",NULL); /* Create pooled raw stats.data inst.*/
/* Find and copy map component (pooled class) */ /* --------------------------------- */
for (i=0; i<CData_GetNComps(idMap); i++) /* Loop over components of idMap */
if (dlp_is_numeric_type_code(CData_GetCompType(idMap,i))) /* Is current component numeric? */
{ /* >> (Yes) */
CData_SelectComps(idPmp,idMap,i,1); /* Copy component */
break; /* Have ready :) */
} /* << */
if (CData_IsEmpty(idPmp)) /* Have not got map component */
{ /* >> */
IERROR(_this,STA_BADCOMP,"map",BASEINST(idMap)->m_lpInstanceName,"numeric");/* Error message */
DLPTHROW(STA_BADCOMP); /* Throw exception */
} /* << */
/* Create source class component */ /* --------------------------------- */
CData_AddComp(idPmp,"srcc",T_LONG); /* Add source class index component */
for (i=0; i<CData_GetNRecs(idPmp); i++) CData_Dstore(idPmp,i,i,1); /* Fill it */
/* Finish pooling map and initialize pooling */ /* --------------------------------- */
CData_Sortup(idPmp,idPmp,0); /* Sort map by pooled class index */
nXC = (INT32)CData_Dfetch(idPmp,CData_GetNRecs(idPmp)-1,0)+1; /* Get greatest pooled class index */
IFCHECK printf("\n Pooling %ld statistics classes",(long)nXC); /* Protocol (verbose level 1) */
IFCHECKEX(3) CData_Print(idPmp); /* Print pooling map (verbose lvl.3) */
nRpb = CData_GetNRecsPerBlock(iSrc->m_idDat); /* Get block size */
/* Prepare pooled statistics */ /* --------------------------------- */
CData_Scopy(_this->m_idDat,iSrc->m_idDat); /* Create target raw data components */
CData_Allocate(_this->m_idDat,nRpb*nXC); /* Allocate target raw data */
CData_SetNBlocks(_this->m_idDat,nXC); /* Set target statistics block number*/
/* Pooling loop */ /* --------------------------------- */
for (i=0; i<CData_GetNRecs(idPmp); ) /* Loop over pooling map */
{ /* >> */
/* - Copy raw statistics data of one pooled class */ /* - - - - - - - - - - - - - - - - */
nC = (INT32)CData_Dfetch(idPmp,0,0); /* Get pooled class index */
IFCHECK printf("\n Pooled class %3ld"); /* Protocol (verbose level 1) */
for (i=0; i<CData_GetNRecs(idPmp); i++) /* Loop over partition of pool.map */
{ /* >> */
if (nC != (INT32)CData_Dfetch(idPmp,0,0)) break; /* Not the current class anymore */
nCs = (INT32)CData_Dfetch(idPmp,i,1); /* Get source class index */
IFCHECK printf("\n - Source class %3ld",nCs); /* Protocol (verbose level 1) */
CData_SelectBlocks(idAux,iSrc->m_idDat,nCs,1); /* Copy raw stats. data block */
CData_Cat(idPcd,idAux); /* Append to buffer */
} /* << */
/* - Pool data */ /* - - - - - - - - - - - - - - - - */
CData_SetNBlocks(idPcd,CData_GetNRecs(idPcd)/nRpb); /* Set block count of aggr. buffer */
IFCHECK /* Protocol (verbose level 1) */
printf("\n - Aggregating %ld statistics classes", /* | */
(long)CData_GetNBlocks(idPcd)); /* | */
CStatistics_PoolInt(idAux,idPcd,0); /* Pool sum data */
CStatistics_PoolInt(idAux,idPcd,1); /* Pool min data */
CStatistics_PoolInt(idAux,idPcd,2); /* Pool max data */
/* - Store pooled raw statistics data block */ /* - - - - - - - - - - - - - - - - */
dlp_memmove /* Copy pooled raw stats. data */
( /* | */
CData_XAddr(_this->m_idDat,nC*nRpb,0), /* | To target statistics block */
CData_XAddr(idAux,0,0), /* | From aggregation buffer */
CData_GetNRecs(idAux)*CData_GetRecLen(idAux) /* | Length of aggregation buffer */
); /* | */
/* - Clean up auxilary instances */ /* - - - - - - - - - - - - - - - - */
CData_Reset(idPcd,TRUE); /* Clear aggregation buffer */
}
/* Clean up */ /* --------------------------------- */
IDESTROY(idAux); /* Destroy auxilary data instance #1 */
IDESTROY(idPmp); /* Destroy pooling map */
IDESTROY(idPcd); /* Destroy pooled cls. raw data inst.*/
STA_PROTOCOL_FOOTER(1,"done"); /* Print protocol footer */
return O_K; /* Ok */
DLPCATCH(STA_BADCOMP) /* == Catch STA_BADCOMP exception */
IDESTROY(idAux); /* Destroy auxilary data instance #1 */
IDESTROY(idPmp); /* Destroy pooling map */
IDESTROY(idPcd); /* Destroy pooled cls. raw data inst.*/
STA_PROTOCOL_FOOTER(1,"FAILED"); /* Print protocol footer */
return NOT_EXEC; /* Not ok */
}
/**
* Prints one block of the instance in vector mode (standard).
*/
INT32 CGEN_PRIVATE CData_PrintVectors_Block
(
CData* _this, /* Pointer to data instance */
INT32 nBlock /* Block index (<0: ignore blocks) */
) /* Returns number of lines printed */
{
INT32 i = 0; /* Universal loop counter */
INT32 nR = 0; /* Current record */
INT32 nR_ = 0; /* First record to be printed */
INT32 nR0 = 0; /* First record of current page */
INT32 nSR = 0; /* Number of records of currenr page */
INT32 nXR = 0; /* Last record to print plus one */
INT32 nC = 0; /* Current component */
INT32 nXC = 0; /* Number of components */
INT32 nWI = 0; /* Component index column width */
INT32 nW0 = 0; /* Head column width */
INT32 nW = 0; /* Column width */
INT32 nP = 0; /* Current page */
INT32 nPps = 0; /* Pages per screen */
INT32 nL = 0; /* Line counter */
BOOL bPur = FALSE; /* Print physical record unit flag */
BOOL bPuc = FALSE; /* Print physical component unit flg.*/
FLOAT64 nBuf = 0.; /* Double buffer */
char sBuf[L_SSTR+1]; /* String buffer */
/* Validate */ /* --------------------------------- */
if (nBlock>=CData_GetNBlocks(_this)) return 0; /* Requested block does not exist */
/* Initialize */ /* --------------------------------- */
nR_ = nBlock>=0 ? CData_GetNRecsPerBlock(_this)*nBlock : 0; /* Get first record to print */
nXR = nBlock>=0 ? nR_+CData_GetNRecsPerBlock(_this) : CData_GetNRecs(_this); /* Get number of records */
nXC = CData_GetNComps(_this); /* Get number of components */
bPur = _this->m_lpTable->m_fsr!=1. && _this->m_lpTable->m_fsr!=0.; /* Displaying physical record units? */
bPuc = _this->m_nCinc!=1. && _this->m_nCinc!=0.; /* Displaying physical comp. units? */
nPps = dlp_maxprintlines()/(nXC+4); /* Compute no. of pages per sceeen */
/* Print vectors */ /* --------------------------------- */
if (nBlock>=0) /* Printing blockwise? */
{ /* >> */
printf("\n Block %ld (offset %ld)",(long)nBlock,(long)nR_); /* Show current block index */
dlp_inc_printlines(1); nL++; /* Adjust number of printed lines */
} /* << */
for (nR0=nR_; nR0<nXR; ) /* Loop over records */
{ /* >> */
CData_PrintVectors_GetColWidth(_this,nR0,0,&nWI,&nW0,&nW); /* Comp. head and data col. widths */
nSR = (dlp_maxprintcols()-nWI-nW0-4)/(nW+1); /* Number of columns to print */
if (nR0+nSR>nXR) nSR = nXR-nR0; /* No more than there are records! */
/* Print record header */ /* - - - - - - - - - - - - - - - - */
if (bPur) /* Display physical record units? */
{ /* >> */
printf("\n %s ->",__pad(strcpy(sBuf,_this->m_lpRunit),nW0+nWI,'r')); /* Print name of physical unit */
for (nR=nR0; nR<nR0+nSR; nR++) /* Loop over remaining records */
{ /* >> */
nBuf = _this->m_lpTable->m_ofs + (nR-nR_)*_this->m_lpTable->m_fsr; /* Compute abscissa value */
__sprintx(sBuf,&nBuf,T_DOUBLE,_this->m_bExact); /* Print to a string */
printf("%s ",__pad(sBuf,nW,'r')); /* Format and print to screen */
} /* << */
dlp_inc_printlines(1); nL++; /* Adjust number of printed lines*/
} /* << */
sBuf[0]='\0'; /* Clear string buffer */
if (bPuc) sprintf(sBuf,"%s| ",_this->m_lpCunit); /* Print phys. comp. unit name... */
printf("\n %s",__pad(sBuf,nW0+nWI+3,'r')); /* ... or empty string */
for (nR=nR0; nR<nR0+nSR; nR++) /* Loop over remaining records */
{ /* >> */
i=nR-nR_; __sprintx(sBuf,&i,T_INT,_this->m_bExact); /* Print record index to a str. */
printf("%s%c",__pad(sBuf,nW,'r'),CData_RecIsMarked(_this,nR)?'*':' '); /* Format and print to screen */
} /* << */
sBuf[0]='\0'; /* Clear string buffer */
if (bPuc) sprintf(sBuf,"%c ",bPuc?'v':' '); /* Print down arrow ... */
printf("\n %s",__pad(sBuf,nW0+nWI+3,'r')); /* ... or empty string */
sBuf[0]='\0'; for (i=0; i<nW; i++) sBuf[i]='.'; sBuf[i]='\0'; /* Make horizonal delimiter */
for (nR=nR0; nR<nR0+nSR; nR++) printf("%s ",sBuf); /* Print one per vector */
dlp_inc_printlines(2); nL+=2; /* Adjust number of printed lines */
/* Print data */ /* - - - - - - - - - - - - - - - - */
for (nC=0; nC<nXC; ) /* Loop over components */
{ /* >> */
__sprintx(sBuf,&nC,T_INT,_this->m_bExact); /* Print comp. index to a string */
printf("\n%c%s ", /* Format and print to screen */
CData_CompIsMarked(_this,nC)?'*':' ',__pad(sBuf,nWI,'r')); /* | (incl. "*" for "marked") */
if (bPuc && dlp_is_numeric_type_code(CData_GetCompType(_this,nC))) /* Display ordinate value? */
{ /* >> */
nBuf = _this->m_nCofs + nC*_this->m_nCinc; /* Compute it */
__sprintx(sBuf,&nBuf,T_DOUBLE,_this->m_bExact); /* Print it to a string */
} /* << */
else strcpy(sBuf,CData_GetCname(_this,nC)); /* else display component name */
printf("%s: ",__pad(dlp_strtrimleft(dlp_strtrimright(sBuf)),nW0,'r')); /* Format and print to screen */
for (nR=nR0; nR<nR0+nSR; nR++) /* Loop over remaining records */
{ /* >> */
__sprintx(sBuf,CData_XAddr(_this,nR,nC), /* Print cell value to a str. */
CData_GetCompType(_this,nC),_this->m_bExact); /* | */
if (dlp_is_symbolic_type_code(CData_GetCompType(_this,nC))) /* Is string value */
if ((INT32)dlp_strlen(sBuf)>nW) /* Will not fit in column */
dlp_strabbrv(sBuf,sBuf,nW); /* Abbreviate it */
if (dlp_is_numeric_type_code(CData_GetCompType(_this,nC))) /* Is numeric value */
if (_this->m_bNz && CMPLX_EQUAL(CData_Cfetch(_this,nR,nC),CMPLX(0.)))
dlp_strcpy(sBuf,"-");
printf("%s%c",__pad(sBuf,nW,'r'), /* Format and print to screen */
CData_CellIsMarked(_this,nR*CData_GetNComps(_this)+nC)?'*':' '); /* | (incl. "*" for "marked") */
} /* << */
dlp_inc_printlines(1); nL++; /* Adjust number of printed lines*/
/* Break component listing */ /* - - - - - - - - - - - - - - - */
if (nPps==0) /* Not all comps. fit on screen */
{ /* >> */
sprintf(sBuf,"component (0..%ld), cancel -3",(long)nXC-1); /* Make user hint */
if ((nC=dlp_printstop_nix(nC,sBuf,NULL))==-1) break; /* Break listing */
if (nC< -2 ) return -1; /* Cancelled by user */
if (nC>=nXC) break; /* No more components -> break */
} /* << */
else nC++; /* No breaking -> count comps. */
} /* << */
nR0+=nSR; /* First record on next page */
nP++; /* Count pages */
if (nR0<nXR) /* There are more records */
{ /* >> */
printf("\n"); dlp_fprint_x_line(stdout,'-',dlp_maxprintcols()); /* Print a separator */
dlp_inc_printlines(1); nL++; /* Adjust number of printed lines*/
} /* << */
/* Break record listing */ /* - - - - - - - - - - - - - - - - */
if (((nPps>0 && nP>=nPps) || nPps==0) && nR0<nXR) /* Complicated break condition :) */
{ /* >> */
dlp_inc_printlines(dlp_maxprintlines()); /* Do stop right here */
sprintf(sBuf,"record (%ld..%ld)%s",(long)nR_,(long)nXR-1, /* Make user hint */
nBlock>=0?", cancel -3":""); /* | */
if ((nR0=dlp_printstop_nix(--nR0,sBuf,NULL))==-1) break; /* Break listing */
if (nR0< -2 ) return -1; /* Cancelled by user */
if (nR0< nR_) nR0=nR_; /* No previous blocks, please! */
if (nR0>=nXR) break; /* No more records -> break */
nP=0; /* Reset page counter */
} /* << */
} /* << */
return nL; /* Return number of printed lines */
}
/**
* Computes the print widths of the head column and one data vector.
*/
INT16 CGEN_PRIVATE CData_PrintVectors_GetColWidth
(
CData* _this, /* Pointer to data instance */
INT32 nR0, /* First record to be printed */
INT32 nC0, /* First component to be printed */
INT32* lpnWI, /* Print width of comp.idx.col.(ret) */
INT32* lpnW0, /* Print width of head column (ret) */
INT32* lpnW /* Print width of data column (ret) */
) /* Returns O_K or (neg.) error code */
{
INT32 nR = 0; /* Current record */
INT32 nXR = 0; /* Number of records */
INT32 nC = 0; /* Current component */
INT32 nXC = 0; /* Number of components */
INT32 nWn = 0; /* Widest number in cols. of screen */
INT32 nWs = 0; /* Widest string in cols. of screen */
FLOAT64 nBuf = 0.; /* Double buffer */
char sBuf[L_SSTR+1]; /* String buffer */
UINT64 nTime = 0;
/* Initialize */ /* --------------------------------- */
*lpnW = 0; /* Data column width */
*lpnWI = 0; /* Component index column width */
*lpnW0 = 0; /* Head column width */
nXR = CData_GetNRecs(_this); /* Get number of records */
nXC = CData_GetNComps(_this); /* Get number of components */
/* Compute head column print width */ /* --------------------------------- */
for (*lpnW0=0,nC=nC0; nC<nXC; nC++) /* Loop over remaining components */
{ /* >> */
if /* Displaying physical units? */
( /* | */
dlp_is_numeric_type_code(CData_GetCompType(_this,nC)) && /* | Numeric component */
dlp_strlen(_this->m_lpCunit) && _this->m_nCinc!=0. /* | Physical units specified */
) /* | */
{ /* >> */
nBuf = _this->m_nCofs + nC*_this->m_nCinc; /* The physical coordinate */
__sprintx(sBuf,&nBuf,T_DOUBLE,_this->m_bExact); /* Print to a string */
} /* << */
else /* String comp. or no phys. units */
__sprintx(sBuf,CData_GetCname(_this,nC),10,_this->m_bExact); /* Print component name to str. */
*lpnW0 = MAX(*lpnW0,(INT32)dlp_strlen(sBuf)); /* Get length of phys. unit / name */
} /* << */
/* Compute component index column print width */ /* --------------------------------- */
nC--; /* Last component to be printed */
__sprintx(sBuf,&nC,T_INT,_this->m_bExact); /* Print greatest comp. index to str.*/
*lpnWI = (INT32)dlp_strlen(sBuf); /* Get length of component index col.*/
/* Compute data vector print width */ /* --------------------------------- */
nTime = dlp_time();
for (*lpnW=0,nR=nR0; nR<nXR; nR++) /* Loop over remaining records */
{ /* >> */
/* Determine width of physical unit */ /* - - - - - - - - - - - - - - - - */
if (dlp_strlen(_this->m_lpRunit) && _this->m_lpTable->m_fsr!=0.) /* Displaying physical units? */
{ /* >> */
nBuf = _this->m_lpTable->m_ofs + nR*_this->m_lpTable->m_fsr; /* The physical coordinate */
__sprintx(sBuf,&nBuf,T_DOUBLE,_this->m_bExact); /* Print to a string */
*lpnW = MAX((INT32)dlp_strlen(sBuf),*lpnW); /* Aggregate actual print width */
} /* << */
/* Determine width of record index */ /* - - - - - - - - - - - - - - - - */
__sprintx(sBuf,&nR,T_INT,_this->m_bExact); /* Print record index to a string */
*lpnW = MAX((INT32)dlp_strlen(sBuf),*lpnW); /* Aggregate actual print width */
/* Determine greatest component width */ /* - - - - - - - - - - - - - - - - */
for (nC=nC0; nC<nXC; nC++) /* Loop over remaining components */
{ /* >> */
__sprintx(sBuf,CData_XAddr(_this,nR,nC), /* Print cell value to a string */
CData_GetCompType(_this,nC),_this->m_bExact); /* | */
if (dlp_is_numeric_type_code(CData_GetCompType(_this,nC))) /* It is a number */
nWn = MAX((INT32)dlp_strlen(sBuf),nWn); /* Aggr. number print width */
else if (dlp_is_symbolic_type_code(CData_GetCompType(_this,nC))) /* It is a string */
nWs = MAX((INT32)dlp_strlen(sBuf),nWs); /* Aggr. string print width */
if (dlp_time()-nTime>__TIMEOUT) break; /* Takes too long -> forget it! */
} /* << */
if (dlp_time()-nTime>__TIMEOUT) break; /* Takes too long -> forget it! */
if ((nR-nR0+2)*((*lpnW)+1)>dlp_maxprintcols()-*lpnWI-*lpnW0-3) break; /* Next vec. would not fit anymore*/
} /* << */
/* If computing data vector print width timed out ... */ /* --------------------------------- */
if (dlp_time()-nTime>__TIMEOUT) /* There was a time out */
for (nC=nC0; nC<nXC; nC++) /* Loop over remaining components */
if (dlp_is_numeric_type_code(CData_GetCompType(_this,nC))) /* It is a number */
nWn = MAX(dlp_printlen(CData_GetCompType(_this,nC)),nWn); /* Use standard print width */
else if (dlp_is_symbolic_type_code(CData_GetCompType(_this,nC))) /* It is a string */
nWs = MAX(dlp_printlen(CData_GetCompType(_this,nC)),nWs); /* Also use std. print width */
/* Aftermath */ /* --------------------------------- */
if (nWs>dlp_maxprintcols()-(*lpnW0)-(*lpnWI)-3) /* Limit string width to line length */
nWs=dlp_maxprintcols()-(*lpnW0)-(*lpnWI)-3; /* ... */
if (nWn<=0) *lpnW = MAX(nWs,*lpnW); /* No numbers -> complete strings */
else *lpnW = MAX(nWn,*lpnW); /* Minimal space req. for numbers */
/*if (nWn>0 && *lpnW+3<nWs) (*lpnW) += 3;*/ /* Print a little more of the strs. */
if (nWn>0 && *lpnW<nWs) *lpnW = MIN(16,nWs); /* Print max. 16 chars. of strings */
return O_K; /* Ok */
}
/**
* Prints the content of one record formatted as columns. If printing requires
* more than <a href="dlp_base.html#cfn_dlp_maxprintcols">dlp_maxprintcols</a>
* characters the listing will be continued on the next line(s).</p>
*
* @param _this
* Pointer to data instance
* @param nRec
* Index of record to print
* @param nIcFirst
* Index of first component to print
* @param nComps
* Number of components to print
* @param nIndent
* Indentation (spaces) at beginning of lines (<b>Note</b>: the first
* line will <em>not</em> be indented!)
* @return The number of lines printed
*/
INT16 CGEN_PUBLIC CData_PrintRec
(
CData* _this,
INT32 nRec,
INT32 nIcFirst,
INT32 nComps,
INT16 nIndent
)
{
INT16 nLines = 1;
INT16 nCol = nIndent;
INT32 nXC = 0;
INT32 nC = 0;
INT16 i = 0;
INT16 I = 0;
char sBuf[L_SSTR+1];
nXC = CData_GetNComps(_this);
if (nIcFirst<0 || nIcFirst>=nXC) return 1; /* NOTE: This is still one line! */
if (nIcFirst+nComps>nXC) nComps=nXC-nIcFirst;
if (nRec>=CData_GetNRecs(_this)) return 0;
for (nC=nIcFirst,nCol=nIndent; nC<nIcFirst+nComps; nC++)
{
if (nRec<0)
{
/* Heading */
I=dlp_printlen(CData_GetCompType(_this,nC));
strcpy(sBuf," ");
for (i=I-(INT16)dlp_strlen(CData_GetCname(_this,nC))-1; i>0; i--) strcat(sBuf," ");
if(CData_CompIsMarked(_this,nC)) sBuf[dlp_strlen(sBuf)-2]='*';
strcat(sBuf,CData_GetCname(_this,nC));
nCol+=dlp_printlen(CData_GetCompType(_this,nC)); /* Count standard width (!) */
printf(sBuf);
}
else
{
/* Print values */
dlp_sprintx(sBuf,(char*)CData_XAddr(_this,nRec,nC),CData_GetCompType(_this,nC),_this->m_bExact);
nCol+=dlp_printlen(CData_GetCompType(_this,nC)); /* Count standard width (!) */
dlp_strconvert(SC_PRC_ESCAPE,sBuf,sBuf);
dlp_strreplace(sBuf,"\n","\\n");
dlp_strreplace(sBuf,"\r","\\r");
dlp_strreplace(sBuf,"\t","\\t");
printf(sBuf);
}
if ((nC<nIcFirst+nComps-1) &&
(nCol+dlp_printlen(CData_GetCompType(_this,nC+1))>dlp_maxprintcols()) )
{
/* Line break */
strcpy(sBuf,"\n");
for (i=nIndent-(nIndent>7?7:0); i>0;i--) strcat(sBuf," ");
printf(sBuf);
if (nIndent>7) printf("%5ld ",(long)(nC+1));
nCol=nIndent;
nLines++;
}
}
return nLines;
}
/*
* Manual page at var.def
*/
INT16 CGEN_PUBLIC CVar_Status(CVar *_this)
{
char lpsBuf[255];
CVar_PopOwnValue(_this);
printf("\n"); dlp_fprint_x_line(stdout,'-',dlp_maxprintcols());
printf("\n Status of instance");
printf("\n var %s\n",BASEINST(_this)->m_lpInstanceName);
dlp_fprint_x_line(stdout,'-',dlp_maxprintcols());
switch (_this->m_nType)
{
case T_BOOL:
printf("\n Type : boolean");
printf("\n Value: %d",(int)_this->m_bBVal);
break;
case T_DOUBLE:
dlp_sprintc(lpsBuf,_this->m_nNVal,FALSE);
printf("\n Type : double");
printf("\n Value: %s", lpsBuf);
break;
case T_COMPLEX:
dlp_sprintc(lpsBuf,_this->m_nNVal,FALSE);
printf("\n Type : complex");
printf("\n Value: %s", lpsBuf);
break;
case T_STRING:
printf("\n Type : string");
printf("\n Value: \"%s\"",_this->m_lpsSVal?_this->m_lpsSVal:"(null)");
break;
case T_INSTANCE:
printf("\n Type : instance");
printf("\n Value: %s",CDlpObject_GetFQName(BASEINST(_this)->m_iAliasInst,lpsBuf,255));
break;
case T_RDOUBLE:
printf("\n Type : double random" );
printf("\n Low boundary : %8lg", (double)_this->m_nLow );
printf("\n High boundary : %8lg", (double)_this->m_nHi );
printf("\n Step size : %8lg", (double)_this->m_nDelta );
printf("\n Most recent value: %8lg", (double)_this->m_nNVal.x );
break;
case T_RDDATA:
printf("\n Type : numeric random data selector");
printf("\n Data table : %s",CDlpObject_GetFQName(_this->m_idRndSet,lpsBuf,255));
printf("\n Component index : %5ld",(long)_this->m_nInd );
printf("\n Component type : %5ld",(long)_this->m_nType);
printf("\n Most recent value: %8lg",(double)_this->m_nNVal.x);
break;
case T_RSDATA:
printf("\n Type : string random data selector");
printf("\n Data table : %s",CDlpObject_GetFQName(_this->m_idRndSet,lpsBuf,255));
printf("\n Component index : %5ld", (long)_this->m_nInd );
printf("\n Component type : %5ld", (long)_this->m_nType);
printf("\n Most recent value: %s",_this->m_lpsSVal?_this->m_lpsSVal:"(null)");
default:
DLPASSERT(FMSG("Unknown variable type"));
}
printf("\n");
dlp_fprint_x_line(stdout,'-',dlp_maxprintcols());
printf("\n");
return O_K;
}