DaoClass* DaoClass_New()
{
DaoClass *self = (DaoClass*) dao_calloc( 1, sizeof(DaoClass) );
DaoValue_Init( self, DAO_CLASS );
self->trait |= DAO_VALUE_DELAYGC;
self->className = DString_New(1);
self->lookupTable = DHash_New(D_STRING,0);
self->ovldRoutMap = DHash_New(D_STRING,0);
self->abstypes = DMap_New(D_STRING,D_VALUE);
self->constants = DArray_New(D_VALUE);
self->variables = DArray_New(D_VALUE);
self->instvars = DArray_New(D_VALUE);
self->objDataName = DArray_New(D_STRING);
self->cstDataName = DArray_New(D_STRING);
self->glbDataName = DArray_New(D_STRING);
self->parent = NULL;
self->mixinBases = DArray_New(0); /* refcount handled in ::allBases; */
self->allBases = DArray_New(D_VALUE);
self->mixins = DArray_New(0);
self->ranges = DVector_New(sizeof(ushort_t));
self->offsets = DVector_New(sizeof(ushort_t));
self->references = DArray_New(D_VALUE);
self->inter = NULL;
self->cstMixinStart = self->cstMixinEnd = self->cstMixinEnd2 = 0;
self->glbMixinStart = self->glbMixinEnd = self->glbMixinEnd2 = 0;
self->objMixinStart = self->objMixinEnd = self->objMixinEnd2 = 0;
self->cstParentStart = self->cstParentEnd = 0;
self->glbParentStart = self->glbParentEnd = 0;
return self;
}
/* assumed to be called after parsing class body */
void DaoClass_DeriveObjectData( DaoClass *self )
{
DaoType *type;
DaoValue *value;
DArray *parents, *offsets;
DString *mbs;
DNode *search;
daoint i, id, perm, index, offset = 0;
self->objDefCount = self->objDataName->size;
offset = self->objDataName->size;
mbs = DString_New(1);
parents = DArray_New(0);
offsets = DArray_New(0);
DaoClass_Parents( self, parents, offsets );
for( i=0; i<self->superClass->size; i++){
if( self->superClass->items.pValue[i]->type == DAO_CLASS ){
DaoClass *klass = self->superClass->items.pClass[i];
/* for properly arrangement object data: */
for( id=0; id<klass->objDataName->size; id ++ ){
DString *name = klass->objDataName->items.pString[id];
DaoVariable *var = klass->instvars->items.pVar[id];
var = DaoVariable_New( var->value, var->dtype );
DArray_Append( self->objDataName, name );
DArray_Append( self->instvars, var );
DaoValue_MarkConst( (DaoValue*) var->value );
}
offset += klass->objDataName->size;
}
}
for(i=1; i<parents->size; i++){
DaoClass *klass = parents->items.pClass[i];
offset = offsets->items.pInt[i]; /* plus self */
if( klass->type == DAO_CLASS ){
/* For object data: */
for( id=0; id<klass->objDataName->size; id ++ ){
DString *name = klass->objDataName->items.pString[id];
search = MAP_Find( klass->lookupTable, name );
perm = LOOKUP_PM( search->value.pInt );
/* NO deriving private member: */
if( perm <= DAO_DATA_PRIVATE ) continue;
search = MAP_Find( self->lookupTable, name );
if( search == NULL ){ /* To not overide data and routine: */
index = LOOKUP_BIND( DAO_OBJECT_VARIABLE, perm, i, (offset+id) );
MAP_Insert( self->lookupTable, name, index );
}
}
}
}
self->derived = 1;
DString_Delete( mbs );
DArray_Delete( parents );
DArray_Delete( offsets );
DaoObject_Init( & self->objType->value->xObject, NULL, 0 );
self->objType->value->xObject.trait &= ~DAO_VALUE_CONST;
DaoValue_MarkConst( self->objType->value );
DaoValue_MarkConst( self->constants->items.pConst[1]->value ); /* ::default */
}
DaoLexer* DaoLexer_New()
{
DaoLexer *self = (DaoLexer*) dao_malloc( sizeof(DaoLexer) );
self->tokens = DArray_New(D_TOKEN);
self->tokbuf = DArray_New(0);
return self;
}
static DaoMethodFields* DaoMethodFields_New()
{
DaoMethodFields *self = (DaoMethodFields*) dao_malloc( sizeof(DaoMethodFields) );
self->names = DArray_New(D_STRING);
self->perms = DArray_New(0);
self->routines = DArray_New(0);
return self;
}
DaoxTriangulator* DaoxTriangulator_New()
{
DaoxTriangulator *self = (DaoxTriangulator*) dao_calloc( 1, sizeof(DaoxTriangulator) );
self->points = DArray_New( sizeof(DaoxVector2D) );
self->triangles = DArray_New( sizeof(DaoxTriangle) );
self->vertices = DList_New(0);
self->worklist = DList_New(0);
return self;
}
DMacroNode* DMacroNode_New( short leaf, short level )
{
DMacroNode *self = (DMacroNode*) dao_malloc( sizeof( DMacroNode ) );
self->isLeaf = leaf;
self->level = level;
self->nodes = DArray_New(0);
self->leaves = DArray_New(D_TOKEN);
self->parent = NULL;
self->group = NULL;
return self;
}
DaoMacro* DaoMacro_New()
{
DaoMacro *self = (DaoMacro*) dao_malloc( sizeof(DaoMacro) );
DaoValue_Init( self, DAO_MACRO );
self->keyListApply = DArray_New(D_STRING);
self->macroList = DArray_New(0);
self->firstMacro = self;
self->macroMatch = DMacroGroup_New();
self->macroApply = DMacroGroup_New();
DArray_Append( self->macroList, self );
return self;
}
DMacroGroup* DMacroGroup_New()
{
DMacroGroup *self = (DMacroGroup*) dao_malloc( sizeof(DMacroGroup) );
self->type = DMACRO_GRP;
self->repeat = DMACRO_ONE;
self->cpos = 0;
self->units = DArray_New(0);
self->stops = DArray_New(D_TOKEN);
self->variables = DArray_New(D_TOKEN);
self->parent = NULL;
return self;
}
void DCondVar_Init( DCondVar *self )
{
self->thdWaiting = DArray_New(0);
DMutex_Init( & self->thdMutex );
/* manual reset, when signaled, all waiting threads will be waked up: */
self->myCondVar = CreateEvent( NULL, TRUE, FALSE, NULL );
}
DaoxDataFrame* DaoxDataFrame_New()
{
int i;
DaoxDataFrame *self = (DaoxDataFrame*) dao_calloc( 1, sizeof(DaoxDataFrame) );
DaoCstruct_Init( (DaoCstruct*) self, daox_type_dataframe );
for(i=0; i<3; ++i){
self->dims[i] = 0;
self->groups[i] = 0;
self->labels[i] = DArray_New(D_MAP);
}
self->columns = DArray_New(0);
self->caches = DArray_New(0);
self->original = NULL;
self->slices = NULL;
return self;
}
/*
// Note: reference count is not handled for "self"!
// But it is cached in the DaoProcess object, so no need to handle it by user!
*/
int DaoValue_Deserialize( DaoValue **self, DString *serial, DaoNamespace *ns, DaoProcess *proc )
{
DaoParser *parser = DaoParser_New();
DArray *types = DArray_New(0);
DMap *omap = DMap_New(0,0);
int rc;
*self = NULL;
parser->nameSpace = ns;
parser->vmSpace = ns->vmSpace;
DaoParser_LexCode( parser, DString_GetMBS( serial ), 0 );
if( parser->tokens->size == 0 ) goto Failed;
DArray_PushFront( types, NULL );
rc = DaoParser_Deserialize( parser, 0, parser->tokens->size-1, self, types, ns, proc, omap );
if( *self ) DaoProcess_CacheValue( proc, *self );
DaoParser_Delete( parser );
DArray_Delete( types );
DMap_Delete( omap );
return rc;
Failed:
DaoParser_Delete( parser );
DArray_Delete( types );
DMap_Delete( omap );
return 0;
}
/*
// Activate all events waiting on a future value:
*/
void DaoFuture_ActivateEvent( DaoFuture *self )
{
DaoCallServer *server = daoCallServer;
DArray *array = DArray_New(0);
DNode *node;
daoint i;
DMutex_Lock( & server->mutex );
for(i=0; i<server->events2->size; ++i){
DaoTaskEvent *event = (DaoTaskEvent*) server->events2->items.pVoid[i];
if( DaoCallServer_CheckEvent( event, self, NULL ) ){
event->state = DAO_EVENT_RESUME;
DArray_Append( server->events, event );
DArray_Erase( server->events2, i, 1 );
i -= 1;
}
}
for(node=DMap_First(server->waitings); node; node=DMap_Next(server->waitings,node)){
DaoTaskEvent *event = (DaoTaskEvent*) node->value.pValue;
/* remove from timed waiting list: */
if( DaoCallServer_CheckEvent( event, self, NULL ) ){
event->state = DAO_EVENT_RESUME;
DArray_Append( server->events, event );
DArray_Append( array, node->key.pVoid );
}
}
for(i=0; i<array->size; i++) DMap_Erase( server->waitings, array->items.pVoid[i] );
DCondVar_Signal( & server->condv );
DMutex_Unlock( & server->mutex );
DArray_Delete( array );
}
DArray* DArray_Copy( DArray *self )
{
DArray *copy = DArray_New( self->stride );
copy->type = self->type;
DArray_Resize( copy, self->size );
memcpy( copy->data.base, self->data.base, self->size * self->stride );
return copy;
}
DMacroUnit* DMacroUnit_New()
{
DMacroUnit *self = (DMacroUnit*) dao_malloc( sizeof(DMacroUnit) );
self->type = DMACRO_TOK;
self->stops = DArray_New(D_TOKEN);
self->marker = DaoToken_New();
return self;
}
DaoChannel* DaoChannel_New( DaoType *type, int dtype )
{
DaoChannel *self = (DaoChannel*) dao_calloc( 1, sizeof(DaoChannel) );
if( dtype ) type = DaoCdataType_Specialize( dao_type_channel, & type, type != NULL );
DaoCstruct_Init( (DaoCstruct*) self, type );
self->buffer = DArray_New(D_VALUE);
return self;
}
DaoxAnimation* DaoxAnimation_New()
{
DaoxAnimation *self = (DaoxAnimation*) dao_calloc( 1, sizeof(DaoxAnimation) );
DaoCstruct_Init( (DaoCstruct*) self, daox_type_animation );
self->keyFrames = DArray_New( sizeof(DaoxKeyFrame) );
self->transform = DaoxMatrix4D_Identity();
return self;
}
FILE* Dao_OpenFile( const char *file, const char *mode )
{
#if _WIN32
DString file2 = DString_WrapChars( file );
DString mode2 = DString_WrapChars( mode );
DArray *file3 = DArray_New( sizeof(wchar_t) );
DArray *mode3 = DArray_New( sizeof(wchar_t) );
int ret1 = DString_DecodeUTF8( & file2, file3 );
int ret2 = DString_DecodeUTF8( & mode2, mode3 );
if( ret1 && ret2 ){
FILE *pfile = _wfopen( file3->data.wchars, mode3->data.wchars );
DArray_Delete( file3 );
DArray_Delete( mode3 );
return pfile;
}
DArray_Delete( file3 );
DArray_Delete( mode3 );
#endif
return fopen( file, mode );
}
static DaoCallServer* DaoCallServer_New( DaoVmSpace *vms )
{
DaoComplex com = {DAO_COMPLEX,0,0,0,1,{0.0,0.0}};
DaoCallServer *self = (DaoCallServer*)dao_malloc( sizeof(DaoCallServer) );
DMutex_Init( & self->mutex );
DCondVar_Init( & self->condv );
DCondVar_Init( & self->condv2 );
DThread_Init( & self->timer );
self->finishing = 0;
self->timing = 0;
self->total = 0;
self->idle = 0;
self->stopped = 0;
self->threads = DArray_New(0);
self->functions = DArray_New(0);
self->parameters = DArray_New(0);
self->events = DArray_New(0);
self->events2 = DArray_New(0);
self->waitings = DMap_New(D_VALUE,0);
self->pending = DHash_New(0,0);
self->active = DHash_New(0,0);
self->caches = DArray_New(0);
self->vmspace = vms;
self->timestamp = com;
return self;
}
static int DaoxDataFrame_SetFrame( DaoxDataFrame *self, DaoxDataFrame *df )
{
DaoValue value = {0};
DArray *destSlices = self->slices;
DArray *fromSlices = df->slices;
DArray *fromSlices2 = df->slices;
daoint i, j, k, N, M, K;
if( DaoxDataFrame_AlignFrame( self, df ) == 0 ) return DAOX_DF_WRONG_SHAP;
if( self->original == NULL ){
DaoxDataFrame_PrepareSlices( self );
DaoxDataFrame_MakeFullSlice( self, self->slices );
destSlices = self->slices;
}else{
self = self->original;
}
if( df->original == NULL ){
fromSlices = DArray_New(D_VECTOR);
DaoxDataFrame_MakeFullSlice( df, fromSlices );
}else{
df = df->original;
}
N = destSlices->items.pVector[0]->data.daoints[1];
M = destSlices->items.pVector[1]->data.daoints[1];
K = destSlices->items.pVector[2]->data.daoints[1];
for(j=0; j<M; ++j){
daoint jjdes = DaoSlice_GetIndex( destSlices->items.pVector[1], j );
daoint jjsrc = DaoSlice_GetIndex( fromSlices->items.pVector[1], j );
DaoxDataColumn *coldes = (DaoxDataColumn*) self->columns->items.pVoid[jjdes];
DaoxDataColumn *colsrc = (DaoxDataColumn*) df->columns->items.pVoid[jjsrc];
if( DaoType_MatchTo( colsrc->type, coldes->type, NULL ) < DAO_MT_SUB )
return DAOX_DF_WRONG_VALUE;
for(i=0; i<N; ++i){
daoint iides = DaoSlice_GetIndex( destSlices->items.pVector[0], i );
daoint iisrc = DaoSlice_GetIndex( fromSlices->items.pVector[0], i );
for(k=0; k<K; ++k){
daoint kkdes = DaoSlice_GetIndex( destSlices->items.pVector[2], k );
daoint kksrc = DaoSlice_GetIndex( fromSlices->items.pVector[2], k );
daoint idsrc = kksrc * N + iisrc;
daoint iddes = kkdes * N + iides;
DaoValue *val = DaoxDataColumn_GetCell( colsrc, idsrc, & value );
DaoxDataColumn_SetCell( coldes, iddes, val );
}
}
}
if( fromSlices != fromSlices2 ) DArray_Delete( fromSlices );
return 0;
}
int Dao_FileStat( const char *path, struct stat *buf )
{
#if _WIN32
DString path2 = DString_WrapChars( path );
DArray *path3 = DArray_New( sizeof(wchar_t) );
if( DString_DecodeUTF8( & path2, path3 ) ){
int ret = _wstat( path3->data.wchars, buf );
DArray_Delete( path3 );
return ret;
}
DArray_Delete( path3 );
#endif
return stat( path, buf );
}
static int DaoxDataFrame_SetArray( DaoxDataFrame *self, DaoArray *array )
{
DaoValue value = {0};
DArray *destSlices = self->slices;
DArray *fromSlices = array->slices;
DArray *fromSlices2 = array->slices;
daoint i, j, k, N, M, K;
if( DaoxDataFrame_AlignArray( self, array ) == 0 ) return DAOX_DF_WRONG_SHAP;
if( self->original == NULL ){
DaoxDataFrame_PrepareSlices( self );
DaoxDataFrame_MakeFullSlice( self, self->slices );
destSlices = self->slices;
}else{
self = self->original;
}
if( array->original == NULL ){
fromSlices = DArray_New(D_VECTOR);
DaoArray_MakeFullSlice( array, fromSlices );
}else{
array = array->original;
}
N = destSlices->items.pVector[0]->data.daoints[1];
M = destSlices->items.pVector[1]->data.daoints[1];
K = destSlices->items.pVector[2]->data.daoints[1];
for(j=0; j<M; ++j){
daoint jjdes = DaoSlice_GetIndex( destSlices->items.pVector[1], j );
daoint jjsrc = DaoSlice_GetIndex( fromSlices->items.pVector[1], j );
DaoxDataColumn *column = (DaoxDataColumn*) self->columns->items.pVoid[jjdes];
for(i=0; i<N; ++i){
daoint iides = DaoSlice_GetIndex( destSlices->items.pVector[0], i );
daoint iisrc = DaoSlice_GetIndex( fromSlices->items.pVector[0], i );
for(k=0; k<K; ++k){
daoint kkdes = DaoSlice_GetIndex( destSlices->items.pVector[2], k );
daoint kksrc = DaoSlice_GetIndex( fromSlices->items.pVector[2], k );
daoint idsrc = iisrc * M * K + jjsrc * K + kksrc;
daoint iddes = kkdes * N + iides;
DaoArray_GetValue( array, idsrc, & value );
DaoxDataColumn_SetCell( column, iddes, & value );
}
}
}
if( fromSlices != fromSlices2 ) DArray_Delete( fromSlices );
return 0;
}
void DaoxShader_Init( DaoxShader *self )
{
int width = 2*DAOX_MAX_GRADIENT_STOPS;
GLfloat data[2*DAOX_MAX_GRADIENT_STOPS*4];
GLfloat dash[DAOX_MAX_DASH];
GLuint tid = 0;
memset( self, 0, sizeof(DaoxShader) );
memset( data, 0, width*4*sizeof(GLfloat) );
memset( dash, 0, DAOX_MAX_DASH*sizeof(GLfloat) );
self->vertexSources = DArray_New( D_STRING );
self->fragmentSources = DArray_New( D_STRING );
glGenTextures( 1, & tid );
self->textures.gradientSampler = tid;
glBindTexture(GL_TEXTURE_1D, tid);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAX_LEVEL, 0);
glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, width, 0, GL_RGBA, GL_FLOAT, data);
glBindTexture(GL_TEXTURE_1D, 0);
glGenTextures( 1, & tid );
self->textures.dashSampler = tid;
glBindTexture(GL_TEXTURE_1D, tid);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAX_LEVEL, 0);
glTexImage1D(GL_TEXTURE_1D, 0, GL_RED, DAOX_MAX_DASH, 0, GL_RED, GL_FLOAT, dash);
glBindTexture(GL_TEXTURE_1D, 0);
}
DaoClass* DaoClass_New()
{
DaoClass *self = (DaoClass*) dao_calloc( 1, sizeof(DaoClass) );
DaoValue_Init( self, DAO_CLASS );
self->trait |= DAO_VALUE_DELAYGC;
self->className = DString_New(1);
self->lookupTable = DHash_New(D_STRING,0);
self->ovldRoutMap = DHash_New(D_STRING,0);
self->abstypes = DMap_New(D_STRING,D_VALUE);
self->constants = DArray_New(D_VALUE);
self->variables = DArray_New(D_VALUE);
self->instvars = DArray_New(D_VALUE);
self->objDataName = DArray_New(D_STRING);
self->cstDataName = DArray_New(D_STRING);
self->glbDataName = DArray_New(D_STRING);
self->superClass = DArray_New(D_VALUE);
self->references = DArray_New(D_VALUE);
return self;
}
void DString_ToUpper( DString *self )
{
daoint i;
char *bytes;
DArray *wcs;
DString_Detach( self, self->size );
if( DString_IsASCII( self ) ){
for(i=0,bytes=self->chars; i<self->size; i++, bytes++) *bytes = toupper( *bytes );
return;
}
wcs = DArray_New( sizeof(wchar_t) );
DString_DecodeUTF8( self, wcs );
self->size = 0;
for(i=0; i<wcs->size; ++i){
DString_AppendWChar( self, towupper( wcs->data.wchars[i] ) );
}
DArray_Delete( wcs );
}
DArray* DArray_Copy( DArray *self )
{
DArray *copy = DArray_New( self->type );
DArray_Assign( copy, self );
return copy;
}
int DaoParser_ParseMacro( DaoParser *self, int start )
{
int rb1, rb2, i = start, N = self->tokens->size;
DaoToken **toks = self->tokens->items.pToken;
DaoMacro *macro;
DString *lang = NULL;
DArray *stops;
DMap *markers;
if( start + 5 >= N ) return -1;
if( toks[start+1]->type != DTOK_LCB ){
lang = & toks[start+1]->string;
if( toks[start+1]->type != DTOK_IDENTIFIER ){
DaoParser_Error( self, DAO_TOKEN_NEED_NAME, lang );
return -1;
}
if( lang->size == 3 && strcmp( lang->mbs, "dao" ) == 0 ){
DaoParser_Error( self, DAO_TOKEN_NEED_NAME, lang );
return -1;
}
start += 1;
}
if( toks[start+1]->name != DTOK_LCB ) return -1;
self->curLine = toks[start]->line;
rb1 = DaoParser_FindPairToken( self, DTOK_LCB, DTOK_RCB, start, -1 );
if( rb1 <0 || rb1 +3 >= N ) return -1;
if( toks[rb1+1]->name != DKEY_AS || toks[rb1+2]->name != DTOK_LCB ){
DaoParser_Error( self, DAO_CTW_INV_MAC_DEFINE, NULL );
return -1;
}
rb2 = DaoParser_FindPairToken( self, DTOK_LCB, DTOK_RCB, rb1 + 1, -1 );
if( rb2 <0 ) return -1;
/*
for( i=start; i<rb2; i++ ) printf( "%s ", toks[i]->string.mbs ); printf("\n");
*/
macro = DaoMacro_New();
if( DaoParser_MakeMacroGroup( self, macro->macroMatch, macro->macroMatch, start+2, rb1 ) ==0 ){
DaoMacro_Delete( macro );
return -1;
}
if( macro->macroMatch->units->size >0 ){
DMacroUnit *unit = (DMacroUnit*) macro->macroMatch->units->items.pVoid[0];
if( unit->type != DMACRO_TOK )
DaoParser_Error( self, DAO_CTW_INV_MAC_FIRSTOK, & toks[i]->string );
}
if( toks[rb1+3]->line != toks[rb1+2]->line ) macro->macroApply->cpos = toks[rb1+3]->cpos;
if( DaoParser_MakeMacroGroup( self, macro->macroApply, macro->macroApply, rb1+3, rb2 ) ==0 ){
DaoMacro_Delete( macro );
return -1;
}
markers = DMap_New(D_STRING,0);
for(i=start+2; i<rb1; i++){
if( toks[i]->string.mbs[0] == '$' ){
if( MAP_Find( markers, & toks[i]->string ) != NULL ){
self->curLine = toks[i]->line;
DaoParser_Error( self, DAO_CTW_REDEF_MAC_MARKER, & toks[i]->string );
return 0;
}
MAP_Insert( markers, & toks[i]->string, 0 );
}
}
DMap_Clear( markers );
i = rb1+3;
if( DString_EQ( & toks[start+2]->string, & toks[rb1+3]->string ) ) i ++;
while( i < rb2 ){
char ch = toks[i]->string.mbs[0];
if( ch != '$' && ch != '\\' && ch != '\'' ){
if( MAP_Find( markers, & toks[i]->string ) == NULL ){
DArray_Append( macro->keyListApply, & toks[i]->string );
MAP_Insert( markers, & toks[i]->string, 0 );
}
}
i ++;
}
stops = DArray_New(D_TOKEN);
DMacroGroup_SetStop( macro->macroMatch, stops );
DMacroGroup_FindVariables( macro->macroMatch );
DArray_Clear( stops );
DMacroGroup_SetStop( macro->macroApply, stops );
DaoNamespace_AddMacro( self->nameSpace, lang, & toks[start+2]->string, macro );
DArray_Delete( stops );
DMap_Delete( markers );
return rb2;
}
static int DaoParser_MacroApply( DaoParser *self, DArray *tokens,
DMacroGroup *group, DMap *tokMap, DMap *used,
int level, DString *tag, int pos0, int adjust )
{
DMacroUnit **units = (DMacroUnit**) group->units->items.pVoid;
DMacroUnit *unit;
DMacroGroup *grp;
DMacroNode *node, *node2;
DArray *toks = DArray_New(D_TOKEN);
DaoToken *tk = DaoToken_New();
DaoToken *tt = NULL;
DNode *kwnode = NULL;
DMap *check = NULL;
DMap one = { NULL, 0, 0, 0 };
int M, N = group->units->size;
int i, j, gid = -1;
int repeated = 0;
int start_mbs = -1;
int start_wcs = -1;
int squote, dquote;
if( group->repeat != DMACRO_AUTO ) level ++;
for( i=0; i<N; i++ ){
unit = units[i];
if( tokens->size >0 ) pos0 = tokens->items.pToken[ tokens->size -1 ]->line;
self->curLine = pos0;
/*
printf( "apply unit %i: %i\n", i, unit->type );
*/
switch( unit->type ){
case DMACRO_TOK :
squote = unit->marker->type == DTOK_ESC_SQUO;
dquote = unit->marker->type == DTOK_ESC_DQUO;
if( (squote && start_mbs >=0) || (dquote && start_wcs >=0) ){
int qstart = squote ? start_mbs : start_wcs;
tt = tokens->items.pToken[ qstart ];
for(j=qstart+1,M=tokens->size; j<M; j++){
DaoToken *jtok = tokens->items.pToken[j];
int t = j ? tokens->items.pToken[j-1]->type : 0;
if( t == DTOK_IDENTIFIER && jtok->type == t )
DString_AppendChar( & tt->string, ' ' );
DString_Append( & tt->string, & jtok->string );
}
if( squote ){
DString_AppendChar( & tt->string, '\'' );
DArray_Erase( tokens, start_mbs+1, tokens->size );
}else{
DString_AppendChar( & tt->string, '\"' );
DArray_Erase( tokens, start_wcs+1, tokens->size );
}
start_mbs = -1;
break;
}else if( squote ){
start_mbs = tokens->size;
DArray_Append( tokens, unit->marker );
tt = tokens->items.pToken[ start_mbs ];
tt->type = tt->name = DTOK_MBS;
DString_SetMBS( & tt->string, "\'" );
break;
}else if( dquote ){
start_wcs = tokens->size;
DArray_Append( tokens, unit->marker );
tt = tokens->items.pToken[ start_wcs ];
tt->type = tt->name = DTOK_WCS;
DString_SetMBS( & tt->string, "\"" );
break;
}
DArray_Append( tokens, unit->marker );
tokens->items.pToken[ tokens->size-1 ]->cpos += adjust;
break;
case DMACRO_VAR :
DaoToken_Assign( tk, unit->marker );
DString_Append( & tk->string, tag );
DArray_Append( tokens, tk );
break;
case DMACRO_EXP :
case DMACRO_ID :
case DMACRO_OP :
case DMACRO_BL :
case DMACRO_IBL :
kwnode = MAP_Find( tokMap, & unit->marker->string );
if( kwnode ==NULL ){
DaoParser_Error( self, DAO_CTW_UNDEF_MAC_MARKER, & unit->marker->string );
goto Failed;
}
node = (DMacroNode*) kwnode->value.pVoid;
kwnode = MAP_Find( used, unit );
if( kwnode == NULL ){
DMap_Insert( used, unit, & one );
kwnode = MAP_Find( used, unit );
}
check = (DMap*) kwnode->value.pVoid;
repeated = 1;
/*
printf( ">>>\n%s level %i: \n", unit->marker->string.mbs, level );
DMacroNode_Print( node );
printf( "\n" );
*/
/* search a leaf */
node2 = DMacroNode_FindLeaf( node, check, level );
if( node2 ){
/*
printf( "appending tokens\n" );
DMacroNode_Print( node2 );
printf( "\n" );
*/
DArray_InsertArray( tokens, tokens->size, node2->leaves, 0, -1 );
DMap_Insert( check, node2, NULL );
/* DArray_Clear( node2->leaves ); */
}else{
DMacroNode_RemoveEmptyLeftBranch( node, level );
goto Failed;
}
break;
case DMACRO_GRP :
case DMACRO_ALT :
grp = (DMacroGroup*) unit;
DArray_Clear( toks );
j = DaoParser_MacroApply( self, toks, grp, tokMap, used, level, tag, pos0, adjust );
switch( grp->repeat ){
case DMACRO_AUTO :
case DMACRO_ONE :
if( j <0 && group->type != DMACRO_ALT ) goto Failed;
repeated = (j>0);
if( j >=0 ){
gid = i;
DArray_InsertArray( tokens, tokens->size, toks, 0, -1 );
}
break;
case DMACRO_ZERO_OR_ONE :
gid = i;
repeated = (j>0);
if( j >=0 ){
DArray_InsertArray( tokens, tokens->size, toks, 0, -1 );
}
break;
case DMACRO_ZERO_OR_MORE :
gid = i;
repeated = (j>0);
if( j >=0 ){
DArray_InsertArray( tokens, tokens->size, toks, 0, -1 );
}
while( j >0 ){
DArray_Clear( toks );
j = DaoParser_MacroApply( self, toks, grp, tokMap, used, level, tag, pos0, adjust );
if( j >0 ){
DArray_InsertArray( tokens, tokens->size, toks, 0, -1 );
}
}
break;
case DMACRO_ONE_OR_MORE :
if( j <0 && group->type != DMACRO_ALT ) goto Failed;
repeated = (j>0);
if( j >=0 ){
DArray_InsertArray( tokens, tokens->size, toks, 0, -1 );
}
while( j >0 ){
gid = i;
DArray_Clear( toks );
j = DaoParser_MacroApply( self, toks, grp, tokMap, used, level, tag, pos0, adjust );
if( j >0 ){
DArray_InsertArray( tokens, tokens->size, toks, 0, -1 );
}
}
break;
}
break;
default : goto Failed;
}
if( group->type == DMACRO_ALT && gid >=0 ) break;
}
if( group->repeat != DMACRO_AUTO ) level --;
if( group->type == DMACRO_ALT && gid <0 ) goto Failed;
DaoToken_Delete( tk );
DArray_Delete( toks );
return repeated;
Failed :
DaoToken_Delete( tk );
DArray_Delete( toks );
return -1;
}
void STD_Debug( DaoProcess *proc, DaoValue *p[], int N )
{
DaoUserHandler *handler = proc->vmSpace->userHandler;
DaoRoutine *routine = proc->activeRoutine;
DaoStream *stream = proc->vmSpace->stdioStream;
DString *input;
DArray *tokens;
DMap *cycData;
char *chs, *cmd;
int i;
if( ! (proc->vmSpace->options & DAO_OPTION_DEBUG ) ) return;
input = DString_New(1);
if( N > 0 && DaoValue_CastCstruct( p[0], dao_type_stream ) ){
stream = (DaoStream*)p[0];
p ++;
N --;
}
if( N > 0 ){
Dao_AboutVars( proc->activeNamespace, p, N, input );
DaoStream_WriteString( stream, input );
DaoStream_WriteMBS( stream, "\n" );
DString_Delete( input );
return;
}
if( handler && handler->StdlibDebug ){
handler->StdlibDebug( handler, proc );
return;
}
tokens = DArray_New(D_STRING);
cycData = DMap_New(0,0);
while(1){
if( proc->vmSpace->ReadLine ){
chs = proc->vmSpace->ReadLine( "(debug) " );
if( chs ){
DString_SetMBS( input, chs );
DString_Trim( input );
if( input->size && proc->vmSpace->AddHistory )
proc->vmSpace->AddHistory( chs );
dao_free( chs );
}
}else{
DaoStream_WriteMBS( stream, "(debug) " );
DaoStream_ReadLine( stream, input );
}
if( input->size == 0 ) continue;
SplitByWhiteSpaces( input->mbs, tokens );
if( tokens->size == 0 ) continue;
cmd = tokens->items.pString[0]->mbs;
if( strcmp( cmd, "q" ) == 0 || strcmp( cmd, "quit" ) == 0 ){
break;
}else if( strcmp( cmd, "k" ) == 0 || strcmp( cmd, "kill" ) == 0 ){
proc->status = DAO_PROCESS_ABORTED;
break;
}else if( strcmp( cmd, "a" ) == 0 || strcmp( cmd, "about" ) == 0 ){
if( tokens->size > 1 ){
ushort_t reg = (ushort_t)strtod( tokens->items.pString[1]->mbs, 0 );
DaoType *tp = proc->activeTypes[ reg ];
DString_Clear( input );
Dao_AboutVar( proc->activeNamespace, proc->activeValues[reg], input );
DaoStream_WriteMBS( stream, "type: " );
if( tp )
DaoStream_WriteString( stream, tp->name );
else
DaoStream_WriteMBS( stream, "?" );
DaoStream_WriteMBS( stream, ", value: " );
DaoStream_WriteString( stream, input );
DaoStream_WriteMBS( stream, "\n" );
}
}else if( strcmp( cmd, "g" ) == 0 || strcmp( cmd, "goto" ) == 0 ){
if( tokens->size > 1 ){
int n = atoi( tokens->items.pString[1]->mbs );
int entry = proc->activeCode - proc->activeRoutine->body->vmCodes->data.codes;
if( n < 0 ) n = entry - n;
if( n >= routine->body->vmCodes->size ) n = routine->body->vmCodes->size -1;
proc->topFrame->entry = n;
proc->status = DAO_PROCESS_STACKED;
return;
}
}else if( strcmp( cmd, "h" ) == 0 || strcmp( cmd, "help" ) == 0 ){
DaoStream_WriteMBS( stream, help );
}else if( strcmp( cmd, "l" ) == 0 || strcmp( cmd, "list" ) == 0 ){
DString *mbs = DString_New(1);
int entry = proc->activeCode - proc->activeRoutine->body->vmCodes->data.codes;
int start = entry - 10;
int end = entry;
if( tokens->size >1 ){
int dn = atoi( tokens->items.pString[1]->mbs );
if( dn < 0 ){
start = entry + dn;
}else if( dn > 0 ){
start = entry;
end = entry + dn;
}
}
if( start < 0 ) start = 0;
if( end >= routine->body->vmCodes->size ) end = routine->body->vmCodes->size - 1;
DaoStream_WriteString( stream, routine->routName );
DaoStream_WriteMBS( stream, "(): " );
if( routine->routType ) DaoStream_WriteString( stream, routine->routType->name );
DaoStream_WriteMBS( stream, "\n" );
DaoStream_WriteMBS( stream, daoRoutineCodeHeader );
DaoStream_WriteMBS( stream, sep );
for( i=start; i<=end; i++ ){
DaoRoutine_FormatCode( routine, i, *routine->body->annotCodes->items.pVmc[i], mbs );
DaoStream_WriteString( stream, mbs );
}
DString_Delete( mbs );
}else if( strcmp( cmd, "p" ) == 0 || strcmp( cmd, "print" ) == 0 ){
if( tokens->size > 1 ){
ushort_t reg = (ushort_t)atoi( tokens->items.pString[1]->mbs );
DaoValue_Print( proc->activeValues[reg], proc, stream, cycData );
DaoStream_WriteMBS( stream, "\n" );
}
}else if( strcmp( cmd, "t" ) == 0 || strcmp( cmd, "trace" ) == 0 ){
int depth = 1;
if( tokens->size >1 ) depth = atoi( tokens->items.pString[1]->mbs );
DaoProcess_Trace( proc, depth );
}else{
DaoStream_WriteMBS( stream, "Unknown debugging command.\n" );
}
}
DString_Delete( input );
DArray_Delete( tokens );
}
/*
// Note: reference count is handled for "value2"!
//
// Item of list/tuple etc. can be directly passed as parameter "value2",
// to avoid creating unnecessary intermediate objects.
*/
static int DaoParser_Deserialize( DaoParser *self, int start, int end, DaoValue **value2, DArray *types, DaoNamespace *ns, DaoProcess *proc, DMap *omap )
{
DaoToken **tokens = self->tokens->items.pToken;
DaoType *it1 = NULL, *it2 = NULL, *type = NULL;
DaoValue *value = *value2;
DaoValue *tmp = NULL;
DaoValue *tmp2 = NULL;
DaoObject *object;
DaoCdata *cdata;
DaoArray *array;
DaoTuple *tuple;
DaoList *list;
DaoMap *map;
DArray *dims;
DNode *node;
void *key = NULL;
char *str;
int i, j, k, n;
int minus = 0;
int next = start + 1;
int tok2 = start < end ? tokens[start+1]->type : 0;
int maybetype = tok2 == DTOK_COLON2 || tok2 == DTOK_LT || tok2 == DTOK_LCB;
if( tokens[start]->type == DTOK_AT && tok2 == DTOK_LCB ){
int rb = DaoParser_FindPairToken( self, DTOK_LCB, DTOK_RCB, start, end );
if( rb < 0 ) return next;
sscanf( tokens[start+2]->string.mbs, "%p", & key );
node = DMap_Find( omap, key );
if( node ) DaoValue_Copy( node->value.pValue, value2 );
return rb + 1;
}
if( tokens[start]->name == DTOK_ID_SYMBOL ){
DString *mbs = DString_New(1);
while( tokens[start]->name == DTOK_ID_SYMBOL ){
DString_Append( mbs, & tokens[start]->string );
start += 1;
}
type = DaoNamespace_MakeType( ns, mbs->mbs, DAO_ENUM, NULL, NULL, 0 );
DString_Delete( mbs );
if( type == NULL ) return start;
if( tokens[start]->name != DTOK_LCB ) return start;
end = DaoParser_FindPairToken( self, DTOK_LCB, DTOK_RCB, start, end );
if( end < 0 ) return start;
next = end + 1;
start += 1;
end -= 1;
}else if( tokens[start]->type == DTOK_IDENTIFIER && maybetype ){
type = DaoParser_ParseType( self, start, end, & start, NULL );
if( type == NULL ) return next;
if( tokens[start]->name != DTOK_LCB ) return start;
end = DaoParser_FindPairToken( self, DTOK_LCB, DTOK_RCB, start, end );
if( end < 0 ) return start;
next = end + 1;
start += 1;
end -= 1;
}
if( type == NULL ){
type = types->items.pType[0];
if( type && type->tid >= DAO_ARRAY ){
if( tokens[start]->name != DTOK_LCB ) return start;
end = DaoParser_FindPairToken( self, DTOK_LCB, DTOK_RCB, start, end );
if( end < 0 ) return start;
next = end + 1;
start += 1;
end -= 1;
}
}
if( type == NULL ) return next;
DaoValue_Copy( type->value, value2 );
if( start > end ) return next;
if( tokens[start]->name == DTOK_SUB ){
minus = 1;
start += 1;
if( start > end ) return next;
}
if( type->nested && type->nested->size >0 ) it1 = type->nested->items.pType[0];
if( type->nested && type->nested->size >1 ) it2 = type->nested->items.pType[1];
if( tokens[start]->name == DTOK_LB ){
int rb = DaoParser_FindPairToken( self, DTOK_LB, DTOK_RB, start, end );
if( rb < 0 ) return next;
sscanf( tokens[start+1]->string.mbs, "%p", & key );
DMap_Insert( omap, key, *value2 );
start = rb + 1;
}
str = tokens[start]->string.mbs;
#if 0
printf( "type: %s %s\n", type->name->mbs, str );
for(i=start; i<=end; i++) printf( "%s ", tokens[i]->string.mbs ); printf( "\n" );
#endif
value = *value2;
switch( type->tid ){
case DAO_NONE :
break;
case DAO_INTEGER :
value->xInteger.value = DaoDecodeInteger( str );
if( minus ) value->xInteger.value = - value->xInteger.value;
break;
case DAO_FLOAT :
value->xFloat.value = DaoDecodeDouble( str );
if( minus ) value->xFloat.value = - value->xFloat.value;
break;
case DAO_DOUBLE :
value->xDouble.value = DaoDecodeDouble( str );
if( minus ) value->xDouble.value = - value->xDouble.value;
break;
case DAO_COMPLEX :
value->xComplex.value.real = DaoDecodeDouble( str );
if( minus ) value->xComplex.value.real = - value->xComplex.value.real;
if( start + 1 > end ) return start+1;
minus = 0;
if( tokens[start + 1]->name == DTOK_SUB ){
minus = 1;
start += 1;
if( start + 1 > end ) return start+1;
}
value->xComplex.value.imag = DaoDecodeDouble( tokens[start+1]->string.mbs );
if( minus ) value->xComplex.value.imag = - value->xComplex.value.imag;
next = start + 2;
break;
#ifdef DAO_WITH_LONGINT
case DAO_LONG :
value->xLong.value->base = DaoDecodeInteger( str );
start += 1;
if( tokens[start]->name == DTOK_ADD ){
value->xLong.value->sign = 1;
start += 1;
}else if( tokens[start]->name == DTOK_SUB ){
value->xLong.value->sign = -1;
start += 1;
}
for(i=start; i<=end; i++){
if( tokens[i]->name == DTOK_COMMA ) continue;
DLong_PushBack( value->xLong.value, DaoDecodeInteger( tokens[i]->string.mbs ) );
}
break;
#endif
case DAO_STRING :
n = tokens[start]->string.size - 1;
for(i=1; i<n; i++){
char c1 = str[i];
char c2 = str[i+1];
if( c1 < 'A' || c1 > 'P' ) continue;
DString_AppendChar( value->xString.data, (char)((c1-'A')*16 + (c2-'A')) );
i += 1;
}
if( str[0] == '\"' ) DString_ToWCS( value->xString.data );
break;
case DAO_ENUM :
value->xEnum.value = DaoDecodeInteger( str );
break;
case DAO_ARRAY :
#ifdef DAO_WITH_NUMARRAY
if( tokens[start]->name != DTOK_LSB ) return next;
k = DaoParser_FindPairToken( self, DTOK_LSB, DTOK_RSB, start, end );
if( k < 0 ) return next;
n = 1;
for(i=start+1; i<k; i++){
if( tokens[i]->name == DTOK_COMMA ) continue;
n *= strtol( tokens[i]->string.mbs, 0, 0 );
}
if( n < 0 ) return next;
if( it1 == NULL || it1->tid == 0 || it1->tid > DAO_COMPLEX ) return next;
array = & value->xArray;
dims = DArray_New(0);
for(i=start+1; i<k; i++){
if( tokens[i]->name == DTOK_COMMA ) continue;
j = strtol( tokens[i]->string.mbs, 0, 0 );
DArray_Append( dims, (size_t) j );
}
n = dims->size;
DaoArray_ResizeArray( array, dims->items.pInt, n );
DArray_PushFront( types, it1 );
DArray_Delete( dims );
n = 0;
for(i=k+1; i<=end; i++){
j = i + 1;
while( j <= end && tokens[j]->name != DTOK_COMMA ) j += 1;
DaoParser_Deserialize( self, i, j-1, & tmp, types, ns, proc, omap );
switch( it1->tid ){
case DAO_INTEGER : array->data.i[n] = tmp->xInteger.value; break;
case DAO_FLOAT : array->data.f[n] = tmp->xFloat.value; break;
case DAO_DOUBLE : array->data.d[n] = tmp->xDouble.value; break;
}
i = j;
n += 1;
}
DArray_PopFront( types );
#endif
break;
case DAO_LIST :
list = & value->xList;
DArray_PushFront( types, it1 );
n = 0;
for(i=start; i<=end; i++){
if( tokens[i]->name == DTOK_COMMA ) continue;
DArray_Append( & list->items, NULL );
k = DaoParser_Deserialize( self, i, end, list->items.items.pValue + n, types, ns, proc, omap );
i = k - 1;
n += 1;
}
DArray_PopFront( types );
break;
case DAO_MAP :
map = & value->xMap;
n = 0;
for(i=start; i<=end; i++){
if( tokens[i]->name == DTOK_COMMA ) continue;
DaoValue_Clear( & tmp );
DaoValue_Clear( & tmp2 );
DArray_PushFront( types, it1 );
i = DaoParser_Deserialize( self, i, end, &tmp, types, ns, proc, omap );
DArray_PopFront( types );
if( tokens[i]->name == DTOK_COMMA ) continue;
if( map->items->size == 0 ){
if( tokens[i]->name == DTOK_COLON ){
DMap_Delete( map->items );
map->items = DHash_New( D_VALUE, D_VALUE );
}
}
if( tokens[i]->name == DTOK_COLON || tokens[i]->name == DTOK_FIELD ) i += 1;
DArray_PushFront( types, it2 );
i = DaoParser_Deserialize( self, i, end, &tmp2, types, ns, proc, omap );
DArray_PopFront( types );
node = DMap_Insert( map->items, (void*) tmp, (void*) tmp2 );
i -= 1;
n += 1;
}
break;
case DAO_TUPLE :
tuple = & value->xTuple;
n = 0;
for(i=start; i<=end; i++){
if( tokens[i]->name == DTOK_COMMA ) continue;
it1 = NULL;
if( type->nested && type->nested->size > n ){
it1 = type->nested->items.pType[n];
if( it1 && it1->tid == DAO_PAR_NAMED ) it1 = & it1->aux->xType;
}
DArray_PushFront( types, it1 );
i = DaoParser_Deserialize( self, i, end, tuple->items + n, types, ns, proc, omap );
DArray_PopFront( types );
i -= 1;
n += 1;
}
break;
case DAO_OBJECT :
DArray_PushFront( types, NULL );
DaoParser_Deserialize( self, start, end, & tmp, types, ns, proc, omap );
DArray_PopFront( types );
if( tmp == NULL ) break;
object = DaoClass_MakeObject( & type->aux->xClass, tmp, proc );
if( object ) DaoValue_Copy( (DaoValue*) object, value2 );
break;
case DAO_CDATA :
case DAO_CSTRUCT :
DArray_PushFront( types, NULL );
DaoParser_Deserialize( self, start, end, & tmp, types, ns, proc, omap );
DArray_PopFront( types );
if( tmp == NULL ) break;
cdata = DaoCdata_MakeObject( & type->aux->xCdata, tmp, proc );
if( cdata ) DaoValue_Copy( (DaoValue*) cdata, value2 );
break;
}
DaoValue_Clear( & tmp );
DaoValue_Clear( & tmp2 );
return next;
}
void DaoNamespace_Restore( DaoNamespace *self, DaoProcess *proc, FILE *fin )
{
DaoParser *parser = DaoParser_New();
DString *line = DString_New(1);
DArray *types = DArray_New(0);
DArray *tokens = parser->tokens;
DMap *omap = DMap_New(0,0);
DString *name;
DNode *node;
parser->nameSpace = self;
parser->vmSpace = self->vmSpace;
while( DaoFile_ReadLine( fin, line ) ){
DaoValue *value = NULL;
int st = DAO_GLOBAL_VARIABLE;
int pm = DAO_DATA_PRIVATE;
int i, n, start = 0;
char *mbs;
DaoParser_LexCode( parser, line->mbs, 0 );
if( tokens->size == 0 ) continue;
name = & tokens->items.pToken[start]->string;
if( name->size == 6 && strcmp( name->mbs, "inputs" ) == 0 ){
if( tokens->size < 3 ) continue;
DString_Clear( line );
n = tokens->items.pToken[start+2]->string.size;
mbs = tokens->items.pToken[start+2]->string.mbs;
for(i=0; i<n; i++){
char c1 = mbs[i];
char c2 = mbs[i+1];
if( c1 < 'A' || c1 > 'P' ) continue;
DString_AppendChar( line, (char)((c1-'A')*16 + (c2-'A')) );
i += 1;
}
/* printf( "%s\n", line->mbs ); */
DaoProcess_Eval( proc, self, line->mbs );
continue;
}
switch( tokens->items.pToken[start]->name ){
case DKEY_PRIVATE : pm = DAO_DATA_PRIVATE; start += 1; break;
case DKEY_PROTECTED : pm = DAO_DATA_PROTECTED; start += 1; break;
case DKEY_PUBLIC : pm = DAO_DATA_PUBLIC; start += 1; break;
}
if( start >= tokens->size ) continue;
switch( tokens->items.pToken[start]->name ){
case DKEY_CONST : st = DAO_GLOBAL_CONSTANT; start += 1; break;
case DKEY_VAR : st = DAO_GLOBAL_VARIABLE; start += 1; break;
}
if( tokens->items.pToken[start]->name != DTOK_IDENTIFIER ) continue;
name = & tokens->items.pToken[start]->string;
start += 1;
if( start + 3 >= tokens->size ) continue;
if( tokens->items.pToken[start]->name != DTOK_ASSN ) continue;
start += 1;
DArray_Clear( parser->errors );
DArray_Clear( types );
DArray_PushFront( types, NULL );
DaoParser_Deserialize( parser, start, tokens->size-1, &value, types, self, proc, omap );
if( value == NULL ) continue;
node = DMap_Find( self->lookupTable, name );
if( node ) continue;
if( st == DAO_GLOBAL_CONSTANT ){
DaoNamespace_AddConst( self, name, value, pm );
}else{
DaoNamespace_AddVariable( self, name, value, NULL, pm );
}
}
DMap_Delete( omap );
DString_Delete( line );
DArray_Delete( types );
DaoParser_Delete( parser );
}
