void DaoClass_MakeInterface( DaoClass *self )
{
daoint i, j;
DaoType *tp;
DaoRoutine *meth;
DaoInterface *inter = self->inter;
DMap *deftypes = DHash_New(0,0);
DArray_Clear( self->inter->supers );
DMap_Clear( self->inter->methods );
if( self->parent && self->parent->type == DAO_CLASS )
DArray_Append( inter->supers, self->parent->xClass.inter );
for(i=0; i<self->cstDataName->size; ++i){
DString *name = self->cstDataName->items.pString[i];
DaoValue *value = self->constants->items.pConst[i]->value;
DaoRoutine *rout = (DaoRoutine*) value;
DNode *it;
if( value->type != DAO_ROUTINE ) continue;
if( value->xRoutine.attribs & DAO_ROUT_DECORATOR ) continue;
it = MAP_Find( self->lookupTable, rout->routName );
if( it == NULL || LOOKUP_PM( it->value.pInt ) != DAO_DATA_PUBLIC ) continue;
DMap_Reset( deftypes );
DMap_Insert( deftypes, rout->routHost, inter->abtype );
if( rout->overloads == NULL ){
tp = DaoType_DefineTypes( rout->routType, rout->nameSpace, deftypes );
if( tp == NULL ) continue; /* TODO: handle error; */
meth = DaoRoutine_New( rout->nameSpace, inter->abtype, 0 );
meth->attribs = rout->attribs;
DString_Assign( meth->routName, rout->routName );
GC_ShiftRC( tp, meth->routType );
meth->routType = tp;
DaoMethods_Insert( inter->methods, meth, meth->nameSpace, meth->routHost );
}else{
for(j=0; j<rout->overloads->routines->size; ++j){
DaoRoutine *rout2 = rout->overloads->routines->items.pRoutine[j];
if( rout2->attribs & DAO_ROUT_DECORATOR ) continue;
tp = DaoType_DefineTypes( rout2->routType, rout2->nameSpace, deftypes );
if( tp == NULL ) continue; /* TODO: handle error; */
meth = DaoRoutine_New( rout2->nameSpace, inter->abtype, 0 );
meth->attribs = rout2->attribs;
DString_Assign( meth->routName, rout->routName );
GC_ShiftRC( tp, meth->routType );
meth->routType = tp;
DaoMethods_Insert( inter->methods, meth, meth->nameSpace, meth->routHost );
}
}
}
DMap_Delete( deftypes );
}
void DaoClass_SetName( DaoClass *self, DString *name, DaoNamespace *ns )
{
DaoRoutine *rout;
DString *str;
if( self->classRoutine ) return;
self->inter = DaoInterface_New( ns, name->mbs );
DString_SetMBS( self->inter->abtype->name, "interface<" );
DString_Append( self->inter->abtype->name, name );
DString_AppendChar( self->inter->abtype->name, '>' );
DaoClass_AddReference( self, self->inter );
self->objType = DaoType_New( name->mbs, DAO_OBJECT, (DaoValue*)self, NULL );
self->clsType = DaoType_New( name->mbs, DAO_CLASS, (DaoValue*) self, NULL );
GC_IncRC( self->clsType );
DString_InsertMBS( self->clsType->name, "class<", 0, 0, 0 );
DString_AppendChar( self->clsType->name, '>' );
str = DString_New(1);
DString_SetMBS( str, "self" );
DaoClass_AddObjectVar( self, str, NULL, self->objType, DAO_DATA_PRIVATE );
DString_Assign( self->className, name );
DaoClass_AddType( self, name, self->objType );
rout = DaoRoutine_New( ns, self->objType, 1 );
DString_Assign( rout->routName, name );
DString_AppendMBS( rout->routName, "::" );
DString_Append( rout->routName, name );
self->classRoutine = rout; /* XXX class<name> */
GC_IncRC( rout );
rout->routType = DaoType_New( "routine<=>", DAO_ROUTINE, (DaoValue*)self->objType, NULL );
DString_Append( rout->routType->name, name );
DString_AppendMBS( rout->routType->name, ">" );
GC_IncRC( rout->routType );
rout->attribs |= DAO_ROUT_INITOR;
DaoClass_AddConst( self, name, (DaoValue*) self, DAO_DATA_PUBLIC );
self->classRoutines = DaoRoutines_New( ns, self->objType, NULL );
DString_Assign( self->classRoutines->routName, name );
DaoClass_AddConst( self, rout->routName, (DaoValue*)self->classRoutines, DAO_DATA_PUBLIC );
self->objType->value = (DaoValue*) DaoObject_Allocate( self, 0 );
self->objType->value->xObject.trait |= DAO_VALUE_CONST|DAO_VALUE_NOCOPY;
self->objType->value->xObject.isDefault = 1;
GC_IncRC( self->objType->value );
DString_SetMBS( str, "default" );
DaoClass_AddConst( self, str, self->objType->value, DAO_DATA_PUBLIC );
DString_Delete( str );
}
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;
}
