DaoStream* DaoProcess_NewStream( DaoProcess *self, FILE *f )
{
DaoStream *res = DaoStream_New();
DaoStream_SetFile( res, f );
DaoProcess_CacheValue( self, (DaoValue*) res );
return res;
}
static void DaoIO_SStream( DaoProcess *proc, DaoValue *p[], int N )
{
DaoStream *stream = DaoStream_New();
if( p[0]->xEnum.value == 1 ) DString_ToWCS( stream->streamString );
stream->attribs |= DAO_IO_STRING;
DaoProcess_PutValue( proc, (DaoValue*)stream );
}
static void SYS_Popen( DaoProcess *proc, DaoValue *p[], int N )
{
DaoStream *stream = NULL;
char *mode;
DString *fname;
stream = DaoStream_New();
stream->attribs |= DAO_IO_PIPE;
fname = stream->fname;
DString_Assign( fname, p[0]->xString.data );
if( DString_Size( fname ) >0 ){
mode = DString_GetMBS( p[1]->xString.data );
stream->file = popen( DString_GetMBS( fname ), mode );
if( stream->file == NULL ){
DaoProcess_RaiseException( proc, DAO_ERROR, "error opening pipe" );
}
stream->mode = 0;
if( strstr( mode, "+" ) )
stream->mode = DAO_IO_WRITE | DAO_IO_READ;
else{
if( strstr( mode, "r" ) )
stream->mode |= DAO_IO_READ;
if( strstr( mode, "w" ) || strstr( mode, "a" ) )
stream->mode |= DAO_IO_WRITE;
}
}else{
DaoProcess_RaiseException( proc, DAO_ERROR, "empty command line" );
}
DaoProcess_PutValue( proc, (DaoValue*)stream );
}
static void DaoIO_Open( DaoProcess *proc, DaoValue *p[], int N )
{
DaoStream *stream = NULL;
char *mode;
if( proc->vmSpace->options & DAO_OPTION_SAFE ){
DaoProcess_RaiseException( proc, DAO_ERROR, "not permitted" );
return;
}
stream = DaoStream_New();
stream->attribs |= DAO_IO_FILE;
if( N==0 ){
stream->file = tmpfile();
if( stream->file <= 0 ){
DaoProcess_RaiseException( proc, DAO_ERROR, "failed to create temporary file" );
return;
}
}else{
/* XXX Error handling? */
mode = DString_GetMBS( p[1]->xString.data );
if( p[0]->type == DAO_INTEGER ){
stream->file = fdopen( p[0]->xInteger.value, mode );
}else{
DString_Assign( stream->fname, p[0]->xString.data );
DString_ToMBS( stream->fname );
stream->file = DaoIO_OpenFile( proc, stream->fname, mode, 0 );
}
stream->mode = 0;
if( strstr( mode, "+" ) )
stream->mode = DAO_IO_WRITE | DAO_IO_READ;
else{
if( strstr( mode, "r" ) )
stream->mode |= DAO_IO_READ;
if( strstr( mode, "w" ) || strstr( mode, "a" ) )
stream->mode |= DAO_IO_WRITE;
}
}
DaoProcess_PutValue( proc, (DaoValue*)stream );
}
bool DaoxDebugger::EditContinue ( DaoProcess *process, int newEntryLine, QList<int> & lineMap, QStringList & newCodes, QStringList & routCodes )
{
DaoRoutine *oldrout = process->activeRoutine;
int i, j, k, dest = 0;
//printf( "=======%s\n", routCodes.join("\n").toLocal8Bit().data() );
//printf( "=======%s\n", newCodes.join("\n").toLocal8Bit().data() );
if( routCodes.size() == newCodes.size() ){
DaoLexer *lexer = DaoLexer_New();
bool eq = true;
for(i=0; i<routCodes.size(); i++){
QString s1 = NormalizeCodes( routCodes[i], lexer );
QString s2 = NormalizeCodes( newCodes[i], lexer );
if( s1 != s2 ){
eq = false;
break;
}
}
DaoLexer_Delete( lexer );
if( eq ) return true;
}
QString codes = newCodes.join( "\n" );
DaoParser *parser = DaoParser_New();
DaoRoutine *routine = DaoRoutine_New( oldrout->nameSpace, oldrout->routHost, 1 );
routine->routType = oldrout->routType;
routine->parCount = oldrout->parCount;
routine->attribs = oldrout->attribs;
routine->defLine = oldrout->defLine;
parser->routine = routine;
parser->nameSpace = routine->nameSpace = oldrout->nameSpace;
parser->vmSpace = oldrout->nameSpace->vmSpace;
DString_Assign( parser->fileName, oldrout->nameSpace->name );
routine->body->codeStart = oldrout->body->codeStart;
routine->body->codeEnd = oldrout->body->codeStart + newCodes.size() + 1;
parser->regCount = routine->parCount;
parser->levelBase = oldrout->defLine != 0;
bool res = DaoParser_LexCode( parser, codes.toLocal8Bit().data(), 1 );
for(i=0; i<(int)parser->tokens->size; i++){
parser->tokens->items.pToken[i]->line += routine->body->codeStart;
}
for(i=0; i<(int)oldrout->body->defLocals->size; i++){
DaoToken *tok = oldrout->body->defLocals->items.pToken[i];
if( tok->index >= oldrout->parCount || tok->type ==0 ) break;
MAP_Insert( DList_Top( parser->lookupTables ), & tok->string, i );
DList_Append( routine->body->defLocals, tok );
}
res = res && DaoParser_ParseRoutine( parser );
DaoParser_Delete( parser );
if( res == false ){
DaoRoutine_Delete( routine );
return false;
}
if( (process->stackSize - process->stackTop) < (routine->body->regCount + DAO_MAX_PARAM) ){
DaoProcess_PushFrame( process, routine->body->regCount );
DaoProcess_PopFrame( process );
}
DaoType **regTypes = routine->body->regType->items.pType;
DaoValue **newValues = process->activeValues;
DaoValue **oldValues = (DaoValue**)calloc( oldrout->body->regCount, sizeof(DaoValue*) );
memcpy( oldValues, newValues, oldrout->body->regCount * sizeof(DaoValue*) );
memset( newValues, 0, oldrout->body->regCount * sizeof(DaoValue*) );
DaoProcess_InitTopFrame( process, routine, process->activeObject );
#if 0
DaoStream *stream = DaoStream_New();
DaoRoutine_PrintCode( oldrout, stream );
DaoRoutine_PrintCode( routine, stream );
#endif
regmap.clear();
for(i=0; i<oldrout->parCount; i++) regmap[i] = i;
DaoVmCode *oldVMC = oldrout->body->vmCodes->data.codes;
DaoVmCode *newVMC = routine->body->vmCodes->data.codes;
DaoVmCodeX **oldAnnot = oldrout->body->annotCodes->items.pVmc;
DaoVmCodeX **newAnnot = routine->body->annotCodes->items.pVmc;
int M = oldrout->body->vmCodes->size;
int N = routine->body->vmCodes->size;
j = k = 0;
for(i=0; i<lineMap.size(); i++){
QList<DaoVmCode> oldLineCodes;
QList<DaoVmCode> newLineCodes;
if( lineMap[i] <0 ) continue;
int old = lineMap[i] + oldrout->body->codeStart + 1;
int niu = i + routine->body->codeStart + 1;
//printf( "%3i %3i: %3i %3i; %3i %3i\n", j, k, i, niu, lineMap[i], old );
while( j<M && oldAnnot[j]->line < old ) ++j;
while( k<N && newAnnot[k]->line < niu ) ++k;
while( j<M && oldAnnot[j]->line == old ){
oldLineCodes.append( oldVMC[j] );
++j;
}
while( k<N && newAnnot[k]->line == niu ){
newLineCodes.append( newVMC[k] );
++k;
}
Matching( oldLineCodes, newLineCodes );
}
QMap<int,int>::iterator it, end = regmap.end();
for(it=regmap.begin(); it != end; ++it){
j = it.key();
i = it.value();
DaoValue_Move( oldValues[j], & newValues[i], regTypes[i] );
}
int offset = 0;
if( newEntryLine <0 ){
DaoVmCodeX **annotCodes = oldrout->body->annotCodes->items.pVmc;
int entry = (process->activeCode - process->topFrame->codes) + 1;
int entryline = oldrout->body->annotCodes->items.pVmc[entry]->line;
/* if the entry line is NOT modified, use it */
entryline -= oldrout->body->codeStart + 1;
for(i=0; i<lineMap.size(); i++) if( lineMap[i] == entryline ) break;
int newEntryLine = i < lineMap.size() ? i : -1;
if( newEntryLine >=0 ){
entryline += oldrout->body->codeStart + 1;
while( (--entry) >=0 && annotCodes[entry]->line == entryline ) offset ++;
}
/* if the entry line IS modified, set the entry line to the first modified line */
if( newEntryLine <0 ){
for(i=0; i<lineMap.size(); i++) if( lineMap[i] <0 ) break;
newEntryLine = i;
}
/* if the entry line is manually set: */
newEntryLine += routine->body->codeStart + 1;
}
//XXX GC_ShiftRC( routine, oldrout );
GC_IncRC( routine );
oldrout->body->revised = routine;
process->activeRoutine = routine;
process->activeTypes = regTypes;
process->topFrame->codes = routine->body->vmCodes->data.codes;
ResetExecution( process, newEntryLine, offset );
i = newCodes.size() - routCodes.size();
DaoNS_UpdateLineInfo( routine->nameSpace, routine->body->codeStart, i );
return true;
}
static void FRAME_PRINT( DaoProcess *proc, DaoValue *p[], int n )
{
DaoxDataFrame *self = (DaoxDataFrame*) p[0];
DaoxDataFrame *original = self->original;
DaoStream *stream = proc->stdioStream;
DaoStream *sstream = DaoStream_New();
DaoValue valueBuffer, *nulls[3] = {NULL,NULL,NULL};
DVector *rlabwidth = DVector_New( sizeof(int) );
DVector *clabwidth = DVector_New( sizeof(int) );
DVector *decimals = DVector_New( sizeof(int) );
DVector *scifmts = DVector_New( sizeof(int) );
DVector *aligns = DVector_New( sizeof(int) );
DString *label = DString_New(1);
daoint d, g, i, j, k, s, N, M, K, J = 1;
int idwidth, maxwidth = 16, maxdec = 3;
char idfmt[16];
char fmt[16];
char buf[512];
sstream->attribs |= DAO_IO_STRING;
memset( &valueBuffer, 0, sizeof(DaoValue) );
if( stream == NULL ) stream = proc->vmSpace->stdioStream;
if( self->original == NULL ){
DaoxDataFrame_PrepareSlices( self );
DaoDataFrame_MakeSlice( self, proc, nulls, 3, self->slices );
original = self;
}
N = self->slices->items.pVector[0]->data.daoints[1];
M = self->slices->items.pVector[1]->data.daoints[1];
K = self->slices->items.pVector[2]->data.daoints[1];
DString_Reset( label, 10 + 4*sizeof(void*) + log10(1+N+M+K) );
sprintf( label->mbs, "\nDataFrame[%p]", self );
DaoStream_WriteMBS( stream, label->mbs );
if( original != self ){
sprintf( label->mbs, " (Slices from DataFrame[%p])", original );
DaoStream_WriteMBS( stream, label->mbs );
}
sprintf( label->mbs, "\nDimensions: Rows=%" DAO_INT_FORMAT ";", N );
DaoStream_WriteMBS( stream, label->mbs );
sprintf( label->mbs, " Cols=%" DAO_INT_FORMAT ";", M );
DaoStream_WriteMBS( stream, label->mbs );
sprintf( label->mbs, " Deps=%" DAO_INT_FORMAT ";\n", K );
DaoStream_WriteMBS( stream, label->mbs );
idwidth = 1 + (int)log10(N+1);
for(i=0; i<N; ++i){
daoint ii = DaoSlice_GetIndex( self->slices->items.pVector[0], i );
int width = 1 + (int)log10(ii+1);
if( width > idwidth ) idwidth = width;
}
sprintf( idfmt, "%%%i%s:", idwidth, DAO_INT_FORMAT );
if( M == 1 ){
maxwidth = 64;
maxdec = 24;
}else if( M == 2 ){
maxwidth = 40;
maxdec = 12;
}else if( M <= 4 ){
maxwidth = 24;
maxdec = 6;
}
for(g=0; g<original->labels[DAOX_DF_ROW]->size; ++g){
int width = 0;
for(i=0; i<N; ++i){
daoint ii = DaoSlice_GetIndex( self->slices->items.pVector[0], i );
DaoxDataFrame_GetLabel( original, DAOX_DF_ROW, g, ii, label );
if( label->size > width ) width = label->size;
if( width > maxwidth ) break;
}
if( width > maxwidth ) width = maxwidth;
DVector_PushInt( rlabwidth, width );
}
for(j=0; j<M; ++j){
int w, datatype, max = 0, min = 0, dec = 0;
daoint width, jj = DaoSlice_GetIndex( self->slices->items.pVector[2], j );
DaoxDataColumn *col = (DaoxDataColumn*) original->columns->items.pVoid[jj];
DVector *cells = col->cells;
datatype = DaoType_GetDataType( col->type );
width = DaoxDataColumn_GetPrintWidth( col, 16 );
for(i=0; i<N && i<1000; ++i){
daoint v, ii = DaoSlice_GetIndex( self->slices->items.pVector[0], i );
complex16 com;
switch( datatype ){
case DAO_INTEGER :
v = cells->data.daoints[ii];
w = log10( fabs(v) + 1E-32 ) + (v < 0);
if( w > max ) max = w;
break;
case DAO_FLOAT :
CheckPrintWidth( cells->data.floats[ii], & max, & min, & dec );
break;
case DAO_DOUBLE :
CheckPrintWidth( cells->data.doubles[ii], & max, & min, & dec );
break;
case DAO_COMPLEX :
com = cells->data.complexes[ii];
CheckPrintWidth( com.real, & max, & min, & dec );
CheckPrintWidth( com.imag, & max, & min, & dec );
break;
case DAO_STRING :
if( cells->data.strings[i].size > max ) max = cells->data.strings[i].size;
break;
default :
break;
}
}
if( dec > maxdec ) dec = maxdec;
if( col->type->tid == DAO_COMPLEX ){
max *= 2;
min *= 2;
}
if( datatype == 0 ){
width = maxwidth;
DVector_PushInt( aligns, 1 );
DVector_PushInt( scifmts, 0 );
DVector_PushInt( decimals, 0 );
}else if( datatype == DAO_STRING ){
width = max;
DVector_PushInt( aligns, 1 );
DVector_PushInt( scifmts, 0 );
DVector_PushInt( decimals, 0 );
}else if( max >= maxwidth || min <= -dec ){
width = 16;
DVector_PushInt( aligns, 0 );
DVector_PushInt( scifmts, 1 );
DVector_PushInt( decimals, dec );
}else{
width = max + dec + 1;
if( col->type->tid == DAO_COMPLEX ) width += dec + 6;
DVector_PushInt( aligns, 0 );
DVector_PushInt( scifmts, 0 );
DVector_PushInt( decimals, dec );
}
for(g=0; g<original->labels[DAOX_DF_COL]->size; ++g){
DaoxDataFrame_GetLabel( original, DAOX_DF_COL, g, jj, label );
if( label->size > width ) width = label->size;
if( width > maxwidth ) break;
}
if( width > maxwidth ) width = maxwidth;
DVector_PushInt( clabwidth, width );
}
for(k=0; k<K; ++k){
daoint kk = DaoSlice_GetIndex( self->slices->items.pVector[2], k );
DaoStream_WriteMBS( stream, "Depth: " );
DaoStream_WriteInt( stream, kk );
DaoStream_WriteMBS( stream, ";" );
if( original->labels[DAOX_DF_DEP]->size ) DaoStream_WriteMBS( stream, "\nLabels:" );
for(g=0; g<original->labels[DAOX_DF_DEP]->size; ++g){
DaoxDataFrame_GetLabel( original, DAOX_DF_DEP, g, kk, label );
DaoStream_WriteMBS( stream, " " );
DaoStream_WriteString( stream, label );
DaoStream_WriteMBS( stream, ";" );
}
DaoStream_WriteMBS( stream, "\n" );
for(j=0; j<M; j=J){
int width2, width = idwidth+1;
for(i=0; i<rlabwidth->size; ++i) width += rlabwidth->data.ints[i] + 1;
width += 1;
J = j;
width2 = width;
for(J=j; J<M; ++J){
daoint jj = DaoSlice_GetIndex( self->slices->items.pVector[1], J );
width2 += clabwidth->data.ints[J] + 2;
if( width2 > 80 ){
width2 -= clabwidth->data.ints[J] + 2;
break;
}
}
if( J == j ) J += 1;
sprintf( buf, "from %" DAO_INT_FORMAT " to %" DAO_INT_FORMAT ":\n", j, J-1 );
DaoStream_WriteMBS( stream, j == 0 ? "| Columns " : "> Columns " );
DaoStream_WriteMBS( stream, buf );
for(g=0; g<original->labels[DAOX_DF_COL]->size; ++g){
sprintf( fmt, "%%-%is", width );
sprintf( buf, fmt, j == 0 ? "|" : ">" );
DaoStream_WriteMBS( stream, buf );
for(s=j; s<J; ++s){
daoint jj = DaoSlice_GetIndex( self->slices->items.pVector[1], s );
int width = clabwidth->data.ints[s];
int align = aligns->data.ints[s];
if( align ){
sprintf( fmt, "%%-%is", width );
}else{
sprintf( fmt, "%%%is", width );
}
DaoxDataFrame_GetLabel( original, DAOX_DF_COL, g, jj, label );
if( label->size > width ) DString_Reset( label, width );
snprintf( buf, width+1, fmt, label->mbs );
DaoStream_WriteMBS( stream, " " );
DaoStream_WriteMBS( stream, buf );
}
DaoStream_WriteMBS( stream, "\n" );
}
printf( j == 0 ? "|" : ">" );
while( --width2 ) printf( "-" );
DaoStream_WriteMBS( stream, J < M ? ">" : "|" );
DaoStream_WriteMBS( stream, "\n" );
for(i=0; i<N; ++i){
daoint ii = DaoSlice_GetIndex( self->slices->items.pVector[0], i );
sprintf( buf, idfmt, ii );
DaoStream_WriteMBS( stream, buf );
for(g=0; g<original->labels[DAOX_DF_ROW]->size; ++g){
int width = rlabwidth->data.ints[g];
DaoxDataFrame_GetLabel( original, DAOX_DF_ROW, g, ii, label );
if( label->size > width ) DString_Reset( label, width );
if( g ) DaoStream_WriteMBS( stream, "," );
sprintf( fmt, "%%-%is", width );
snprintf( buf, width+1, fmt, label->mbs );
DaoStream_WriteMBS( stream, buf );
}
DaoStream_WriteMBS( stream, ": " );
for(s=j; s<J; ++s){
int scifmt = scifmts->data.ints[s];
int dec = decimals->data.ints[s];
int width = clabwidth->data.ints[s];
daoint jj = DaoSlice_GetIndex( self->slices->items.pVector[2], s );
DaoxDataColumn *col = (DaoxDataColumn*) original->columns->items.pVoid[jj];
DaoValue *value = DaoxDataColumn_GetCell( col, i, & valueBuffer );
DaoStream_WriteMBS( stream, " " );
if( value == NULL ){
sprintf( fmt, "%%-%is", width );
snprintf( buf, width+1, fmt, " " );
}else if( value->type == DAO_INTEGER ){
sprintf( fmt, "%%%i%s", width, DAO_INT_FORMAT );
snprintf( buf, width+1, fmt, value->xInteger.value );
}else if( value->type == DAO_FLOAT || value->type == DAO_DOUBLE ){
double f = DaoValue_GetDouble( value );
if( scifmt ){
sprintf( fmt, "%%%iE", width );
}else{
sprintf( fmt, "%%%i.%if", width, dec );
}
snprintf( buf, width+1, fmt, f );
}else if( value->type == DAO_COMPLEX ){
complex16 com = value->xComplex.value;
char s = com.imag>=0 ? '+' : '-';
int w = width/2-2;
int d = dec;
if( scifmt ){
sprintf( fmt, "(%%%i.3E,%%%i.3E)", w, w );
}else{
sprintf( fmt, "(%%%i.%if,%%%i.%if)", w, d, w, d );
}
snprintf( buf, width, fmt, com.real, com.imag );
}else{
DString_Reset( sstream->streamString, 0 );
DaoValue_Print( value, proc, sstream, NULL );
DString_Reset( label, 0 );
DString_Append( label, sstream->streamString );
if( label->size > width ) DString_Reset( label, width );
DString_ChangeMBS( label, "%t", "\\t", 0 );
DString_ChangeMBS( label, "%n", "\\n", 0 );
sprintf( fmt, "%%-%is", width );
snprintf( buf, width+1, fmt, label->mbs );
}
DaoStream_WriteMBS( stream, buf );
}
DaoStream_WriteMBS( stream, "\n" );
}
DaoStream_WriteMBS( stream, "\n" );
}
}
DaoStream_Delete( sstream );
DVector_Delete( aligns );
DVector_Delete( scifmts );
DVector_Delete( decimals );
DVector_Delete( rlabwidth );
DVector_Delete( clabwidth );
DString_Delete( label );
}
