static void SYS_EnvVars( DaoProcess *proc, DaoValue *p[], int N )
{
#define LOCAL_BUF_SIZE 256
DaoMap *map = DaoProcess_PutMap( proc, 0 );
DaoValue *vk = (DaoValue*) DaoProcess_NewMBString( proc, NULL, 0 );
DaoValue *vv = (DaoValue*) DaoProcess_NewMBString( proc, NULL, 0 );
DString *key = DaoString_Get( DaoValue_CastString( vk ) );
DString *value = DaoString_Get( DaoValue_CastString( vv ) );
char **envs = environ;
char buffer[ LOCAL_BUF_SIZE + 1 ];
int nc = 0;
while( *envs != NULL ){
char *c = *envs;
nc = 0;
while( *c != '=' ){
if( nc >= LOCAL_BUF_SIZE ){
buffer[ nc ] = 0;
DString_AppendMBS( key, buffer );
nc = 0;
}
buffer[ nc ] = *c;
nc ++;
c ++;
}
buffer[ nc ] = 0;
DString_AppendMBS( key, buffer );
c ++;
DString_AppendMBS( value, c );
DaoMap_Insert( map, vk, vv );
DString_Clear( key );
DString_Clear( value );
envs ++;
}
}
static void ParseKeyValueStringArray( DaoProcess *proc, DaoMap *map, char **p )
{
int nc = 0;
char buffer[ LOCAL_BUF_SIZE + 1 ];
DaoValue *vk = (DaoValue*) DaoProcess_NewMBString( proc, NULL, 0 );
DaoValue *vv = (DaoValue*) DaoProcess_NewMBString( proc, NULL, 0 );
DString *key = DaoString_Get( DaoValue_CastString( vk ) );
DString *value = DaoString_Get( DaoValue_CastString( vv ) );
while( *p != NULL ){
char *c = *p;
nc = 0;
while( *c != '=' ){
if( nc >= LOCAL_BUF_SIZE ){
buffer[ nc ] = 0;
DString_AppendMBS( key, buffer );
nc = 0;
}
buffer[ nc ] = *c;
nc ++;
c ++;
}
buffer[ nc ] = 0;
DString_AppendMBS( key, buffer );
c ++;
DString_AppendMBS( value, c );
DaoMap_Insert( map, vk, vv );
DString_Clear( key );
DString_Clear( value );
p ++;
}
}
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 );
}
static void CHANNEL_New( DaoProcess *proc, DaoValue *par[], int N )
{
DaoType *retype = DaoProcess_GetReturnType( proc );
DaoChannel *self = DaoChannel_New( retype, 0 );
CHANNEL_SetCap( self, par[0], proc );
if( DaoType_CheckPrimitiveType( retype->nested->items.pType[0] ) == 0 ){
DString *s = DString_New(1);
DString_AppendMBS( s, "data type " );
DString_Append( s, retype->nested->items.pType[0]->name );
DString_AppendMBS( s, " is not supported for channel" );
DaoProcess_RaiseException( proc, DAO_ERROR, s->mbs );
DString_Delete( s );
}
DaoProcess_PutValue( proc, (DaoValue*) self );
DaoCallServer_TryInit( mainVmSpace );
}
static int DaoParser_FindPair( DaoParser *self, const char *lw, const char *rw, int start, int to )
{
DaoToken **tokens = self->tokens->items.pToken;
int i, k = 0;
int found = 0;
if( start < 0 ) goto ErrorUnPaired;
if( to < 0 ) to = self->tokens->size - 1;
for(i=start; i<=to; ++i){
if( strcmp( lw, tokens[i]->string.mbs ) == 0 ){
k++;
}else if( strcmp( rw, tokens[i]->string.mbs ) == 0 ){
k--;
found = 1;
}
if( k == 0 && found ) return i;
}
ErrorUnPaired:
if( self->vmSpace ){
DString_SetMBS( self->mbs, lw );
if( k ==0 ){
DaoParser_Error( self, DAO_TOKEN_NOT_FOUND, self->mbs );
}else{
DString_AppendChar( self->mbs, ' ' );
DString_AppendMBS( self->mbs, rw );
DaoParser_Error( self, DAO_TOKENS_NOT_PAIRED, self->mbs );
}
}
return -100;
}
void DaoStream_WriteFloat( DaoStream *self, double val )
{
const char *format = self->format;
const char *iconvs = "diouxXcC";
char buffer[100];
if( format && strchr( iconvs, format[ strlen(format)-1 ] ) && val ==(long)val ){
DaoStream_WriteInt( self, (daoint)val );
return;
}
if( format == NULL ) format = "%f";
if( self->redirect && self->redirect->StdioWrite ){
DString *mbs = DString_New(1);
sprintf( buffer, format, val );
DString_SetMBS( mbs, buffer );
self->redirect->StdioWrite( self->redirect, mbs );
DString_Delete( mbs );
}else if( self->file ){
fprintf( self->file, format, val );
}else if( self->attribs & DAO_IO_STRING ){
sprintf( buffer, format, val );
DString_AppendMBS( self->streamString, buffer );
}else{
printf( format, val );
}
}
static void Dao_AboutVar( DaoNamespace *ns, DaoValue *var, DString *str )
{
DaoType *abtp = DaoNamespace_GetType( ns, var );
char buf[50];
if( abtp ){
DString_Append( str, abtp->name );
sprintf( buf, "[%p]", var );
DString_AppendMBS( str, buf );
if( var->type == DAO_CDATA ){
sprintf( buf, "(%p)", var->xCdata.data );
DString_AppendMBS( str, buf );
}
}else{
DString_AppendMBS( str, "NULL" );
}
}
static void Dao_AboutVars( DaoNamespace *ns, DaoValue *par[], int N, DString *str )
{
int i;
DString_Clear( str );
for( i=0; i<N; i++ ){
Dao_AboutVar( ns, par[i], str );
if( i+1<N ) DString_AppendMBS( str, " " );
}
}
int DaoFile_ReadLine( FILE *fin, DString *line )
{
char buf[IO_BUF_SIZE];
DString_Reset( line, 0 );
DString_ToMBS( line );
if( feof( fin ) ) return 0;
do{
buf[IO_BUF_SIZE - 1] = 1;
if( !fgets( buf, IO_BUF_SIZE, fin ) ) break;
DString_AppendMBS( line, buf );
} while( buf[IO_BUF_SIZE - 1] != 1 );
return 1;
}
static void NS_Backup( DaoNamespace *self, DaoProcess *proc, FILE *fout, int limit, int store )
{
DNode *node = DMap_First( self->lookupTable );
DString *prefix = DString_New(1);
DString *serial = DString_New(1);
DaoValue *value = NULL;
size_t max = limit * 1000; /* limit per object in KB */
int id, pm, up, st;
for( ; node !=NULL; node = DMap_Next( self->lookupTable, node ) ){
DString *name = node->key.pString;
id = node->value.pInt;
up = LOOKUP_UP( id );
st = LOOKUP_ST( id );
pm = LOOKUP_PM( id );
if( up ) continue;
if( st != store ) continue;
if( st == DAO_GLOBAL_CONSTANT ) value = DaoNamespace_GetConst( self, id );
if( st == DAO_GLOBAL_VARIABLE ) value = DaoNamespace_GetVariable( self, id );
if( value == NULL ) continue;
if( DaoValue_Serialize( value, serial, self, proc ) ==0 ) continue;
prefix->size = 0;
switch( pm ){
case DAO_DATA_PRIVATE : DString_AppendMBS( prefix, "private " ); break;
case DAO_DATA_PROTECTED : DString_AppendMBS( prefix, "protected " ); break;
case DAO_DATA_PUBLIC : DString_AppendMBS( prefix, "public " ); break;
}
switch( st ){
case DAO_GLOBAL_CONSTANT : DString_AppendMBS( prefix, "const " ); break;
case DAO_GLOBAL_VARIABLE : DString_AppendMBS( prefix, "var " ); break;
}
if( max && prefix->size + name->size + serial->size + 4 > max ) continue;
fprintf( fout, "%s%s = %s\n", prefix->mbs, name->mbs, serial->mbs );
}
DString_Delete( prefix );
DString_Delete( serial );
}
void DaoStream_WriteMBS( DaoStream *self, const char *val )
{
const char *format = self->format;
if( format == NULL ) format = "%s";
if( self->redirect && self->redirect->StdioWrite ){
DString *mbs = DString_New(1);
DString_SetMBS( mbs, val );
self->redirect->StdioWrite( self->redirect, mbs );
DString_Delete( mbs );
}else if( self->file ){
fprintf( self->file, format, val );
}else if( self->attribs & DAO_IO_STRING ){
DString_AppendMBS( self->streamString, val );
}else{
printf( format, val );
}
}
void DaoStream_WriteFormatedInt( DaoStream *self, daoint val, const char *format )
{
char buffer[100];
if( self->redirect && self->redirect->StdioWrite ){
DString *mbs = DString_New(1);
sprintf( buffer, format, val );
DString_SetMBS( mbs, buffer );
self->redirect->StdioWrite( self->redirect, mbs );
DString_Delete( mbs );
}else if( self->file ){
fprintf( self->file, format, val );
}else if( self->attribs & DAO_IO_STRING ){
sprintf( buffer, format, val );
DString_AppendMBS( self->streamString, buffer );
}else{
printf( format, val );
}
}
static void DaoClass_GetField( DaoValue *self0, DaoProcess *proc, DString *name )
{
int tid = proc->activeRoutine->routHost ? proc->activeRoutine->routHost->tid : 0;
DaoType *type = proc->activeRoutine->routHost;
DaoClass *host = tid == DAO_OBJECT ? & type->aux->xClass : NULL;
DaoClass *self = & self0->xClass;
DString *mbs = DString_New(1);
DaoValue *value = NULL;
int rc = DaoClass_GetData( self, name, & value, host );
if( rc ){
DString_SetMBS( mbs, DString_GetMBS( self->className ) );
DString_AppendMBS( mbs, "." );
DString_Append( mbs, name );
DaoProcess_RaiseException( proc, rc, mbs->mbs );
}else{
DaoProcess_PutReference( proc, value );
}
DString_Delete( mbs );
}
void DaoStream_WritePointer( DaoStream *self, void *val )
{
const char *format = self->format;
char buffer[100];
if( format == NULL ) format = "%p";
if( self->redirect && self->redirect->StdioWrite ){
DString *mbs = DString_New(1);
sprintf( buffer, format, val );
DString_SetMBS( mbs, buffer );
self->redirect->StdioWrite( self->redirect, mbs );
DString_Delete( mbs );
}else if( self->file ){
fprintf( self->file, format, val );
}else if( self->attribs & DAO_IO_STRING ){
sprintf( buffer, format, val );
DString_AppendMBS( self->streamString, buffer );
}else{
printf( format, val );
}
}
static int DaoMap_Serialize( DaoMap *self, DString *serial, DaoNamespace *ns, DaoProcess *proc, DString *buf, DMap *omap )
{
DaoType *type = self->unitype;
DaoType *keytype = NULL;
DaoType *valtype = NULL;
DNode *node;
char *sep = self->items->hashing ? ":" : "=>";
int i = 0, rc = 1;
if( type->nested && type->nested->size >0 ) keytype = type->nested->items.pType[0];
if( type->nested && type->nested->size >1 ) valtype = type->nested->items.pType[1];
if( keytype && (keytype->tid == 0 || keytype->tid >= DAO_ENUM)) keytype = NULL;
if( valtype && (valtype->tid == 0 || valtype->tid >= DAO_ENUM)) valtype = NULL;
for(node=DMap_First(self->items); node; node=DMap_Next(self->items,node)){
DaoType *kt = NULL, *vt = NULL;
if( keytype == NULL ) kt = DaoNamespace_GetType( ns, node->key.pValue );
if( valtype == NULL ) vt = DaoNamespace_GetType( ns, node->value.pValue );
if( (i++) ) DString_AppendChar( serial, ',' );
rc &= DaoValue_Serialize2( node->key.pValue, serial, ns, proc, kt, buf, omap );
DString_AppendMBS( serial, sep );
rc &= DaoValue_Serialize2( node->value.pValue, serial, ns, proc, vt, buf, omap );
}
return rc;
}
static void ParseKeyValueString( DaoProcess *proc, DaoMap *mulmap, DaoMap *map, const char *s )
{
int i = 0;
int nc = 0;
int len = 0;
char buffer[ LOCAL_BUF_SIZE + 1 ];
DaoValue *vk = (DaoValue*) DaoProcess_NewMBString( proc, NULL, 0 );
DaoValue *vv = (DaoValue*) DaoProcess_NewMBString( proc, NULL, 0 );
DString *key = DaoString_Get( DaoValue_CastString( vk ) );
DString *value = DaoString_Get( DaoValue_CastString( vv ) );
len = strlen( s );
nc = 0;
int isKey = 1;
char tmp[3];
tmp[2] = 0;
for(i=0; i<len; i++){
if( s[i] == '=' ){
buffer[nc] = 0;
DString_AppendMBS( key, buffer );
nc = 0;
isKey = 0;
}else if( s[i] == '&' || s[i] == ';' || i+1==len ){
if( i+1 == len ){
buffer[ nc ] = s[i];
nc ++;
}
if( DString_Size( key ) > 0 ){
buffer[ nc ] = 0;
DString_AppendMBS( value, buffer );
InsertKeyValue( proc, mulmap, map, vk, vv );
DString_Clear( key );
DString_Clear( value );
nc = 0;
isKey = 1;
}else if( nc > 0 ){
buffer[ nc ] = 0;
DString_AppendMBS( key, buffer );
DString_SetMBS( value, "NULL" );
InsertKeyValue( proc, mulmap, map, vk, vv );
DString_Clear( key );
DString_Clear( value );
nc = 0;
isKey = 1;
}
}else if( s[i] != ' ' ){
if( nc >= LOCAL_BUF_SIZE ){
buffer[ nc ] = 0;
if( isKey ){
DString_AppendMBS( key, buffer );
}else{
DString_AppendMBS( value, buffer );
}
nc = 0;
}
if( s[i] == '%' ){
tmp[0] = s[i+1];
tmp[1] = s[i+2];
buffer[ nc ] = strtol( tmp, NULL, 16 );
i += 2;
}else if( s[i] == '+' ){
buffer[ nc ] = ' ';
}else{
buffer[ nc ] = s[i];
}
nc ++;
}
}
if( DString_Size( key ) > 0 ){
buffer[ nc ] = 0;
DString_AppendMBS( value, buffer );
InsertKeyValue( proc, mulmap, map, vk, vv );
}else if( nc > 0 ){
buffer[ nc ] = 0;
DString_AppendMBS( key, buffer );
DString_SetMBS( value, "NULL" );
InsertKeyValue( proc, mulmap, map, vk, vv );
}
}
static void PreparePostData( DaoProcess *proc, DaoMap *httpPOSTS, DaoMap *httpPOST, DaoMap *httpFILE )
{
DaoValue *vk = (DaoValue*) DaoProcess_NewMBString( proc, NULL, 0 );
DaoValue *vv = (DaoValue*) DaoProcess_NewMBString( proc, NULL, 0 );
DString *key = DaoString_Get( DaoValue_CastString( vk ) );
DString *value = DaoString_Get( DaoValue_CastString( vv ) );
DString *dynaBuffer = DString_New(1);
int i = 0;
int len = 0;
char buffer[ LOCAL_BUF_SIZE + 1 ];
char *last = buffer + (LOCAL_BUF_SIZE-1);
char *contentLength = getenv( "CONTENT_LENGTH" );
char *contentType = getenv( "CONTENT_TYPE" );
len = 0;
*last = 0;
if( contentLength != NULL ) len = strtol( contentLength, NULL, 10);
if( contentType != NULL ){
//printf( "CONTENT_TYPE = %s\n", contentType );
if( strstr( contentType, "multipart/form-data" ) == NULL ){
i = 0;
DString_Clear( dynaBuffer );
while( i < len ){
int n = 0;
int ch = getchar();
while( ch != EOF ){
buffer[n] = (char)ch;
n ++;
if( n == LOCAL_BUF_SIZE ) break;
ch = getchar();
}
buffer[ n ] = 0;
//printf( "%s|||||||||||||||||\n", buffer );
char *p = strchr( buffer, '&' );
if( p != NULL ){
*p = 0; // null-terminating
p++;
DString_AppendMBS( dynaBuffer, buffer );
ParseKeyValueString( proc, httpPOSTS, httpPOST, DString_GetMBS( dynaBuffer ) );
DString_Clear( dynaBuffer );
DString_AppendMBS( dynaBuffer, p );
}else{
DString_AppendMBS( dynaBuffer, buffer );
}
i += LOCAL_BUF_SIZE;
}
ParseKeyValueString( proc, httpPOSTS, httpPOST, DString_GetMBS( dynaBuffer ) );
}else{
char *boundary = strstr( contentType, "boundary" );
boundary = strstr( boundary, "=" ) + 1;
i = 0;
char *part = NULL;
while( ! feof( stdin ) ){
if( part == NULL ) part = fgets( buffer, LOCAL_BUF_SIZE, stdin );
if( part == NULL ) break;
if( strstr( part, boundary ) == NULL ) break;
// read content information
DString_Clear( dynaBuffer );
buffer[ LOCAL_BUF_SIZE ] = 0; // null-terminating
char *p = fgets( buffer, LOCAL_BUF_SIZE, stdin );
if( p == NULL ) break; // the last boundary scanned
p = strchr( p, '\n' );
*p = 0; // null-terminating
DString_AppendMBS( dynaBuffer, buffer );
char *info = (char*)DString_GetMBS( dynaBuffer );
info = strchr( info, '=' );
info += 2; // at char after name="
p = info;
while( *p != '\"' ) p ++;
*p = 0; // null-terminating
DString_SetMBS( key, info );
p ++;
if( (p = strstr(p,"filename") ) == NULL ){
p = fgets( buffer, LOCAL_BUF_SIZE, stdin );
p = fgets( buffer, LOCAL_BUF_SIZE, stdin );
// now real data:
DString_Clear( value );
while( p != NULL && strstr( p, boundary ) == NULL ){
char *t = strstr( p, "\r\n" );
if( t != NULL ) *t = 0;
DString_AppendMBS( value, buffer );
if( feof( stdin ) ) break;
p = fgets( buffer, LOCAL_BUF_SIZE, stdin );
t = strchr( p, '\n' );
if( t!= NULL ) *(t+1) = 0;
}
if( p != NULL ) part = p;
DaoMap_Insert( httpPOST, vk, vv );
}else{
DaoValue *vs = (DaoValue*) DaoProcess_NewStream( proc, tmpfile() );
FILE *file = DaoStream_GetFile( DaoValue_CastStream( vs ) );
char *t = NULL;
p = strchr( p, '\"' ) + 1;
info = p;
while( *p != '\"' ) p ++;
*p = 0; // null-terminating
//XXX stream->TYPER->SetName( stream, info );
DString_Clear( value );
// Content-Type ...\r\n
p = fgets( buffer, LOCAL_BUF_SIZE, stdin );
// \r\n
p = fgets( buffer, LOCAL_BUF_SIZE, stdin );
// data
#if 0
int count = fread( buffer, 1, LOCAL_BUF_SIZE, stdin );
while( count && strstr( buffer, boundary ) == NULL ){
fwrite( buffer, 1, count, file );
fprintf( file, "%s\n", "===========================" );
if( feof( stdin ) ) break;
count = fread( buffer, 1, LOCAL_BUF_SIZE, stdin );
}
#else
char tail[3] = { 0, 0, 0 };
int count, ntail = 0;
p = fgets( buffer, LOCAL_BUF_SIZE, stdin );
while( p != NULL && strstr( p, boundary ) == NULL ){
if( feof( stdin ) ){
// XXX
break;
}else{
t = p;
while( t != last && (*t) != '\n' ) t ++;
if( (*t) == '\n' ){
count = t-p+1;
if( count >= 2 ){
count -= 2;
if( ntail ) fwrite( tail, 1, ntail, file );
tail[0] = p[ count ];
tail[1] = p[ count+1 ];
ntail = 2;
fwrite( p, 1, count, file );
}else if( count == 1 ){
if( ntail == 2 ){
fwrite( tail, 1, 1, file );
tail[0] = tail[1];
tail[1] = p[0];
}else if( ntail ==1 ){
tail[1] = p[0];
ntail = 2;
}else{
tail[0] = p[0];
ntail = 1;
}
}
}else{
if( ntail ) fwrite( tail, 1, ntail, file );
count = LOCAL_BUF_SIZE-3;
tail[0] = p[ count ];
tail[1] = p[ count+1 ];
ntail = 2;
fwrite( p, 1, count, file );
}
}
p = fgets( buffer, LOCAL_BUF_SIZE, stdin );
}
#endif
//if( p != NULL ) part = p;
rewind( file );
DaoMap_Insert( httpFILE, vk, vs );
}
}
}
}
DString_Delete( dynaBuffer );
}
void DaoLexer_AnnotateCode( DArray *self, DaoVmCodeX vmc, DString *annot, int max )
{
DaoToken *t1, *t2, **tokens;
daoint i, k, len, pos, m = max/(vmc.middle + vmc.last + 2);
int max2 = max/2;
if( m < 5 ) m = 5;
DString_Clear( annot );
if( self == NULL ) return; /* DaoRoutine::source could be null */
if( vmc.middle > vmc.last ) return;
tokens = self->items.pToken;
for(i=0; i<vmc.middle; i++){
k = i + vmc.first;
if( k >= self->size ) break;
t2 = tokens[k];
if( k != (daoint)vmc.first ){
t1 = tokens[k-1];
pos = t1->cpos + t1->string.size;
if( t1->line != t2->line || pos < t2->cpos ) DString_AppendChar( annot, ' ' );
}
len = t2->string.size;
if( t2->type == DTOK_IDENTIFIER ){
if( len > max2 ) len = max2 - 3;
}else{
if( len > m+3 ) len = m;
}
if( annot->size + len >= max2 ) len = max2 - annot->size;
DString_AppendDataMBS( annot, t2->string.mbs, len );
if( len != t2->string.size ){
DString_AppendMBS( annot, "..." );
if( t2->type == DTOK_MBS ) DString_AppendChar( annot, '\'' );
else if( t2->type == DTOK_WCS ) DString_AppendChar( annot, '\"' );
else break;
}
if( (i+1) < vmc.middle && annot->size >= max2 ){
DString_AppendMBS( annot, "..." );
break;
}
}
for(i=vmc.middle; i<=vmc.last; i++){
k = i + vmc.first;
if( k >= self->size ) break;
t2 = tokens[k];
if( k != (daoint)vmc.first ){
t1 = tokens[k-1];
pos = t1->cpos + t1->string.size;
if( t1->line != t2->line || pos < t2->cpos ) DString_AppendChar( annot, ' ' );
}
len = t2->string.size;
if( t2->type == DTOK_IDENTIFIER ){
if( len > max2 ) len = max2-3;
}else{
if( len > m+3 ) len = m;
}
if( annot->size + len >= max ) len = max - annot->size;
DString_AppendDataMBS( annot, t2->string.mbs, len );
if( len != t2->string.size ){
DString_AppendMBS( annot, "..." );
if( t2->type == DTOK_MBS ) DString_AppendChar( annot, '\'' );
else if( t2->type == DTOK_WCS ) DString_AppendChar( annot, '\"' );
else break;
}
if( i < vmc.last && annot->size >= max ){
DString_AppendMBS( annot, "..." );
break;
}
}
DString_ChangeMBS( annot, "{{\n}}", "\\n", 0 );
}
static void SYS_Ctimef( DaoProcess *proc, DaoValue *p[], int N )
{
int i;
int halfday = 0;
const int size = p[1]->xString.data->size;
const char *format = DString_GetMBS( p[1]->xString.data );
char buf[100];
char *p1 = buf+1;
char *p2;
DaoMap *sym = NULL;
DaoString *ds = DaoString_New(1);
DaoValue *key = (DaoValue*) ds;
DString *S;
struct tm *ctime;
time_t t = (time_t)p[0]->xInteger.value;
if( t == 0 ) t = time(NULL);
ctime = gmtime( & t );
if( N > 1 ){
sym = (DaoMap*)p[2];
if( sym->items->size == 0 ) sym = NULL;
}
S = DaoProcess_PutMBString( proc, "" );
for( i=0; i+1<size; i++ ){
if( format[i] == '%' && ( format[i+1] == 'a' || format[i+1] == 'A' ) ){
halfday = 1;
break;
}
}
buf[0] = '0'; /* for padding */
for( i=0; i+1<size; i++ ){
p2 = p1;
p1[0] = 0;
if( format[i] == '%' ){
const char ch = format[i+1];
switch( ch ){
case 'Y' :
sprintf( p1, "%i", ctime->tm_year+1900 );
break;
case 'y' :
sprintf( p1, "%i", ctime->tm_year+1900 );
p2 += 2;
break;
case 'M' :
case 'm' :
if( ! addStringFromMap( key, S, sym, "month", ctime->tm_mon ) ){
sprintf( p1, "%i", ctime->tm_mon+1 );
if( ch=='M' && p1[1]==0 ) p2 = buf; /* padding 0; */
}else p2 = NULL;
break;
case 'D' :
case 'd' :
if( ! addStringFromMap( key, S, sym, "date", ctime->tm_mday ) ){
sprintf( p1, "%i", ctime->tm_mday );
if( ch=='D' && p1[1]==0 ) p2 = buf; /* padding 0; */
}else p2 = NULL;
break;
case 'W' :
case 'w' :
if( ! addStringFromMap( key, S, sym, "week", ctime->tm_wday ) )
sprintf( p1, "%i", ctime->tm_wday+1 );
else p2 = NULL;
break;
case 'H' :
case 'h' :
if( halfday )
sprintf( p1, "%i", ctime->tm_hour %12 );
else
sprintf( p1, "%i", ctime->tm_hour );
if( ch=='H' && p1[1]==0 ) p2 = buf; /* padding 0; */
break;
case 'I' :
case 'i' :
sprintf( p1, "%i", ctime->tm_min );
if( ch=='I' && p1[1]==0 ) p2 = buf; /* padding 0; */
break;
case 'S' :
case 's' :
sprintf( p1, "%i", ctime->tm_sec );
if( ch=='S' && p1[1]==0 ) p2 = buf; /* padding 0; */
break;
case 'a' :
if( ! addStringFromMap( key, S, sym, "halfday", 0 ) ){
if( ctime->tm_hour >= 12 ) strcpy( p1, "pm" );
else strcpy( p1, "am" );
}else p2 = NULL;
break;
case 'A' :
if( ! addStringFromMap( key, S, sym, "halfday", 1 ) ){
if( ctime->tm_hour >= 12 ) strcpy( p1, "PM" );
else strcpy( p1, "AM" );
}else p2 = NULL;
break;
default : break;
}
if( p2 ) DString_AppendMBS( S, p2 );
i ++;
}else{
DString_AppendChar( S, format[i] );
}
}
if( i+1 == size ) DString_AppendChar( S, format[i] );
DaoString_Delete( ds );
}
static void DaoSerializeInteger( daoint value, DString *serial )
{
char buf[100];
DaoEncodeInteger( buf, value );
DString_AppendMBS( serial, buf );
}
static void DaoSerializeDouble( double value, DString *serial )
{
char buf[100];
DaoEncodeDouble( buf, value );
DString_AppendMBS( serial, buf );
}
int DaoValue_Serialize2( DaoValue *self, DString *serial, DaoNamespace *ns, DaoProcess *proc, DaoType *type, DString *buf, DMap *omap )
{
int rc = 1;
char chs[64];
if( DMap_Find( omap, self ) ){
sprintf( chs, "@{%p}", self );
DString_AppendMBS( serial, chs );
return 1;
}
if( type ){
DString_Append( serial, type->name );
DString_AppendChar( serial, '{' );
}
switch( self->type ){
case DAO_NONE :
break;
case DAO_INTEGER :
DaoSerializeInteger( self->xInteger.value, serial );
break;
case DAO_FLOAT :
DaoSerializeDouble( self->xFloat.value, serial );
break;
case DAO_DOUBLE :
DaoSerializeDouble( self->xDouble.value, serial );
break;
case DAO_COMPLEX :
DaoSerializeComplex( self->xComplex.value, serial );
break;
case DAO_LONG :
DaoSerializeLong( self->xLong.value, serial );
break;
case DAO_STRING :
DString_Serialize( self->xString.data, serial, buf );
break;
case DAO_ENUM :
DaoSerializeInteger( self->xEnum.value, serial );
break;
case DAO_ARRAY :
DaoArray_Serialize( & self->xArray, serial, buf );
break;
case DAO_LIST :
case DAO_MAP :
case DAO_TUPLE :
case DAO_OBJECT :
case DAO_CDATA :
case DAO_CSTRUCT :
DMap_Insert( omap, self, self );
sprintf( chs, "(%p)", self );
DString_AppendMBS( serial, chs );
switch( self->type ){
case DAO_LIST :
rc = DaoList_Serialize( & self->xList, serial, ns, proc, buf, omap );
break;
case DAO_MAP :
rc = DaoMap_Serialize( & self->xMap, serial, ns, proc, buf, omap );
break;
case DAO_TUPLE :
rc = DaoTuple_Serialize( & self->xTuple, serial, ns, proc, buf, omap );
break;
case DAO_OBJECT :
if( proc == NULL ) break;
rc = DaoObject_Serialize( & self->xObject, serial, ns, proc, buf, omap );
break;
case DAO_CDATA :
case DAO_CSTRUCT :
if( proc == NULL ) break;
rc = DaoCdata_Serialize( & self->xCdata, serial, ns, proc, buf, omap );
break;
}
break;
default :
DString_AppendChar( serial, '?' );
rc = 0;
break;
}
if( type ) DString_AppendChar( serial, '}' );
return rc;
}
