void DaoxGraphData_Init( DaoxGraphData *self, DaoType *type )
{
DaoCstruct_Init( (DaoCstruct*) self, type );
self->graph = NULL;
self->edgeData = DString_New();
self->nodeData = DString_New();
DString_SetSharing( self->nodeData, 0 );
DString_SetSharing( self->edgeData, 0 );
}
/* Real copying, no implicit sharing here. For thread safty. */
DString* DString_DeepCopy( DString *self )
{
int share = self->sharing;
DString *copy = DString_New();
DString_SetSharing( copy, share );
DString_Resize( copy, self->size );
memcpy( copy->chars, self->chars, self->size *sizeof(char) );
return copy;
}
void DString_Clear( DString *self )
{
int share = self->sharing;
if( ((int*)self->chars - self->sharing) == dao_string ) return;
DString_Detach( self, 0 );
DString_DeleteData( self );
DString_Init( self );
DString_SetSharing( self, share );
}
static void PreparePostData( DaoProcess *proc, DaoMap *httpPOSTS, DaoMap *httpPOST, DaoMap *httpFILE )
{
DString *fname;
DString *buffer = DString_New();
DaoValue *vk = (DaoValue*) DaoProcess_NewString( proc, NULL, 0 );
DaoValue *vv = (DaoValue*) DaoProcess_NewString( proc, NULL, 0 );
DString *key = DaoString_Get( DaoValue_CastString( vk ) );
DString *value = DaoString_Get( DaoValue_CastString( vv ) );
char *content_length = getenv( "CONTENT_LENGTH" );
char *content_type = getenv( "CONTENT_TYPE" );
const char *boundary;
char postbuf[1024];
daoint postlen, boundarylen, len = 0;
daoint pos, pos2, pos_rnrn, offset;
if( content_length != NULL ) len = strtol( content_length, NULL, 10);
if( len == 0 ) return;
DString_SetSharing( buffer, 0 );
if( content_type == NULL || strstr( content_type, "multipart/form-data" ) == NULL ) {
postlen = fread( postbuf, 1, sizeof(postbuf), stdin );
while( postlen ) {
DString_AppendBytes( buffer, postbuf, postlen );
postlen = fread( postbuf, 1, sizeof(postbuf), stdin );
}
ParseKeyValueString( proc, httpPOSTS, httpPOST, buffer->chars );
DString_Delete( buffer );
return;
}
boundary = strstr( content_type, "boundary=" ) + strlen( "boundary=" );
boundarylen = strlen( boundary );
fname = DString_New();
buffer->size = 0;
for(;;) {
postlen = fread( postbuf, 1, sizeof(postbuf), stdin );
if( postlen == 0 && buffer->size < boundarylen ) break;
DString_AppendBytes( buffer, postbuf, postlen );
while( strstr( buffer->chars, "\r\n\r\n" ) == 0 && postlen != 0 ) {
postlen = fread( postbuf, 1, sizeof(postbuf), stdin );
DString_AppendBytes( buffer, postbuf, postlen );
}
//printf( "###############\n%s\n", buffer->chars );
key->size = 0;
fname->size = 0;
pos = DString_FindChars( buffer, "name=", 20 ); /* Skip: Content-Disposition: ; */
pos2 = DString_FindChar( buffer, '\"', pos+6 );
DString_SubString( buffer, key, pos + 6, pos2 - pos - 6 );
pos_rnrn = DString_FindChars( buffer, "\r\n\r\n", pos2 );
pos = DString_FindChars( buffer, "filename=", pos2 );
if( pos != DAO_NULLPOS && pos < pos_rnrn ) {
daoint pos3 = DString_FindChar( buffer, '\"', pos+10 );
DString_SubString( buffer, fname, pos + 10, pos3 - pos - 10 );
}
buffer->size -= pos_rnrn + 4;
memmove( buffer->chars, buffer->chars + pos_rnrn + 4, buffer->size );
if( fname->size == 0 ) {
offset = 0;
while( (pos2 = DString_FindChars( buffer, boundary, offset )) == DAO_NULLPOS ) {
offset = buffer->size - boundarylen;
if( offset < 0 ) offset = 0;
postlen = fread( postbuf, 1, sizeof(postbuf), stdin );
DString_AppendBytes( buffer, postbuf, postlen );
}
DString_SubString( buffer, value, 0, pos2 - 4 ); /* \r\n-- */
DaoMap_Insert( httpPOST, (DaoValue*) vk, (DaoValue*) vv );
buffer->size -= pos2 + boundarylen;
memmove( buffer->chars, buffer->chars + pos2 + boundarylen, buffer->size );
} else {
DaoInteger isize = {DAO_INTEGER,0,0,0,0,0};
DaoFileStream *stream = _DaoFileStream_New();
DaoTuple *tuple = DaoTuple_New(3);
FILE *file = tmpfile();
DaoString_Set( (DaoString*) vv, fname );
stream->file = file;
stream->base.mode |= DAO_STREAM_READABLE|DAO_STREAM_WRITABLE;
_DaoFileStream_InitCallbacks( stream );
DaoTuple_SetType( tuple, daox_type_namestream );
DaoTuple_SetItem( tuple, (DaoValue*) vv, 0 );
DaoTuple_SetItem( tuple, (DaoValue*) stream, 2 );
DaoMap_Insert( httpFILE, (DaoValue*) vk, (DaoValue*) tuple );
offset = 0;
while( (pos2 = DString_FindChars( buffer, boundary, 0 )) == DAO_NULLPOS ) {
offset = buffer->size - boundarylen;
if( offset > 0 ) {
isize.value += offset;
fwrite( buffer->chars, 1, offset, file );
buffer->size -= offset;
memmove( buffer->chars, buffer->chars + offset, buffer->size );
}
postlen = fread( postbuf, 1, sizeof(postbuf), stdin );
DString_AppendBytes( buffer, postbuf, postlen );
}
isize.value += pos2 - 4;
fwrite( buffer->chars, 1, pos2 - 4, file ); /* \r\n-- */
buffer->size -= pos2 + boundarylen;
memmove( buffer->chars, buffer->chars + pos2 + boundarylen, buffer->size );
rewind( file );
DaoTuple_SetItem( tuple, (DaoValue*) & isize, 1 );
}
}
DString_Delete( buffer );
}
int DaoLexer_Tokenize( DaoLexer *self, const char *src, int flags )
{
DString *source = DString_New(1);
DVector *lexenvs = DVector_New( sizeof(int) );
DaoToken *token = DaoToken_New();
DString *literal = & token->string;
char ch, *ss, hex[11] = "0x00000000";
int replace = flags & DAO_LEX_ESCAPE;
int comment = flags & DAO_LEX_COMMENT;
int space = flags & DAO_LEX_SPACE;
int srcSize = (int)strlen( src );
int old=0, state = TOK_START;
int lexenv = LEX_ENV_NORMAL;
int unicoded = 0;
int line = 1;
int cpos = 0;
int ret = 1;
int it = 0;
int i, m = 4;
DString_SetSharing( literal, 0 );
for(it=0; it<srcSize; it++){
if( (signed char) src[it] < 0 ){
unicoded = 1;
break;
}
}
if( unicoded && daoConfig.mbs == 0 ){
DString *wcs = DString_New(0);
/* http://www.cl.cam.ac.uk/~mgk25/ucs/quotes.html */
wchar_t quotes[] = {
0x27 , 0x27 , 0x27, /* single q.m. */
0x22 , 0x22 , 0x22, /* double q.m. */
0x27 + 0xfee0 , 0x27 + 0xfee0 , 0x27 , /* single q.m. unicode */
0x22 + 0xfee0 , 0x22 + 0xfee0 , 0x22 , /* double q.m. unicode */
0x60 , 0x27 , 0x27, /* grave accent */
0x2018 , 0x2019 , 0x27 , /* left/right single q.m. */
0x201C , 0x201D , 0x22 /* left/right double q.m. */
};
wchar_t sl = L'\\' + 0xfee0;
wchar_t stop;
int i, N = 21;
it = 0;
DString_SetMBS( wcs, src );
while( it < wcs->size ){ // TODO: handle verbatim string!
for( i=0; i<N; i+=3 ){
if( wcs->wcs[it] == quotes[i] ){
stop = quotes[i+1];
wcs->wcs[it] = quotes[i+2];
it ++;
while( it < wcs->size && wcs->wcs[it] != stop ){
if( wcs->wcs[it] == sl || wcs->wcs[it] == L'\\' ){
it ++;
continue;
}
it ++;
}
if( it < wcs->size ) wcs->wcs[it] = quotes[i+2];
break;
}
}
if( it >= wcs->size ) break;
if( wcs->wcs[it] == 0x3000 ){
wcs->wcs[it] = 32; /* blank space */
}else if( wcs->wcs[it] > 0xff00 && wcs->wcs[it] < 0xff5f ){
wcs->wcs[it] -= 0xfee0; /* DBC to SBC */
}
it ++;
}
if( wcs->size ){
DString_SetWCS( source, wcs->wcs );
src = source->mbs;
srcSize = source->size;
}
DString_Delete( wcs );
}
DaoLexer_Reset( self );
DVector_PushInt( lexenvs, LEX_ENV_NORMAL );
it = 0;
token->cpos = 0;
while( it < srcSize ){
#if 0
printf( "tok: %i %i %i %c %s\n", srcSize, it, ch, ch, literal->mbs );
#endif
token->type = state;
token->name = 0;
token->line = line;
ch = src[it];
cpos += ch == '\t' ? daoConfig.tabspace : 1;
if( ch == '\n' ) cpos = 0, line ++;
if( literal->size == 0 ) token->cpos = cpos;
if( state == TOK_STRING_MBS || state == TOK_STRING_WCS ){
if( ch == '\\' ){
it ++;
if( replace == 0 ){
DString_AppendChar( literal, ch );
if( it < srcSize ){
if( src[it] == '\n' ) cpos = 0, line ++;
DString_AppendChar( literal, src[it] );
}
it ++;
continue;
}
if( it >= srcSize ){
ret = 0;
printf( "error: incomplete string at line %i.\n", line );
break;
}
if( src[it] == '\n' ) cpos = 0, line ++;
switch( src[it] ){
case '0' : case '1' : case '2' : case '3' :
case '4' : case '5' : case '6' : case '7' : /* \ooo */
i = 2;
while( i < 5 && it < srcSize && src[it] >= '0' && src[it] < '8' ){
hex[i] = src[it++];
hex[++i] = 0;
}
DString_AppendChar( literal, (char) strtol( hex+2, NULL, 8 ) );
it --;
break;
case '8' : case '9' :
DString_AppendChar( literal, (char) (src[it] - '0') );
break;
case 'x' :
case 'u' :
case 'U' :
i = 2;
switch( src[it] ){
case 'x' : m = 4; break; /* \xhh: max 2 hex digit; */
case 'u' : m = 6; break; /* \uhhhh: max 4 hex digit; */
case 'U' : m = 10; break; /* \Uhhhhhhhh: max 8 hex digit; */
}
while( i < m && (it+1) < srcSize && isxdigit( src[it+1] ) ){
hex[i] = src[++it];
hex[++i] = 0;
}
DString_AppendWChar( literal, (wchar_t) strtol( hex, NULL, 0 ) );
break;
case 't' : DString_AppendChar( literal, '\t' ); break;
case 'n' : DString_AppendChar( literal, '\n' ); break;
case 'r' : DString_AppendChar( literal, '\r' ); break;
case '\'' : DString_AppendChar( literal, '\'' ); break;
case '\"' : DString_AppendChar( literal, '\"' ); break;
default : DString_AppendChar( literal, src[it] ); break;
}
}else if( ch == '\'' && state == TOK_STRING_MBS ){
DString_AppendChar( literal, ch );
state = TOK_RESTART;
token->type = token->name = DTOK_MBS;
DaoLexer_AppendToken( self, token );
DString_Clear( literal );
}else if( ch == '\"' && state == TOK_STRING_WCS ){
DString_AppendChar( literal, ch );
state = TOK_RESTART;
token->type = token->name = DTOK_WCS;
DaoLexer_AppendToken( self, token );
DString_Clear( literal );
}else{
DString_AppendChar( literal, ch );
}
}else if( ch == ']' && state == TOK_VERBATIM ){
int len = srcSize - it - 1;
DString_AppendChar( literal, ']' );
token->type = token->name = DTOK_VBT_OPEN;
if( (ss = strstr( src + it + 1, literal->mbs )) != NULL ){
len = (ss - src) - it - 1 + literal->size;
token->type = token->name = DTOK_VERBATIM;
}
for(i=0; i<len; i++) if( src[it+1+i] == '\n' ) line += 1;
DString_AppendDataMBS( literal, src + it + 1, len );
state = TOK_RESTART;
DaoLexer_AppendToken( self, token );
DString_Clear( literal );
it += len;
}else if( lexenv == LEX_ENV_NORMAL ){
old = state;
if( ch >=0 ){
state = daoLexTable[ state ][ (int)ch ];
}else if( state <= TOK_START ){
state = TOK_RESTART;
}else if( state != TOK_IDENTIFIER && state != TOK_STRING_MBS
&& state != TOK_STRING_WCS
&& state != TOK_COMT_LINE && state != TOK_COMT_OPEN ){
state = TOK_RESTART;
}
if( state >= TOK_END ){
DString_AppendChar( literal, ch );
token->type = token->name = daoTokenMap[ state ];
if( token->type == DTOK_ID_THTYPE || token->type == DTOK_ID_SYMBOL )
token->type = DTOK_IDENTIFIER;
if( space || comment || token->type != DTOK_COMMENT ){
if( isspace( token->string.mbs[0] ) )
token->type = token->name = daoSpaceType[ (int)token->string.mbs[0] ];
DaoLexer_AppendToken( self, token );
}
/* may be a token before the line break; */
DString_Clear( literal );
state = TOK_START;
}else if( state == TOK_RESTART ){
if( literal->size ){
if( old == TOK_IDENTIFIER ){
token->name = dao_key_hash( literal->mbs, literal->size );
token->type = DTOK_IDENTIFIER;
if( token->name == 0 ) token->name = DTOK_IDENTIFIER;
DaoLexer_AppendToken( self, token );
}else if( old > TOK_RESTART && old != TOK_END ){
token->type = token->name = daoTokenMap[ old ];
if( token->type == DTOK_ID_THTYPE || token->type == DTOK_ID_SYMBOL )
token->type = DTOK_IDENTIFIER;
DaoLexer_AppendToken( self, token );
}else if( space ){
if( isspace( token->string.mbs[0] ) )
token->type = token->name = daoSpaceType[ (int)token->string.mbs[0] ];
DaoLexer_AppendToken( self, token );
}
DString_Clear( literal );
token->cpos = cpos;
}
DString_AppendChar( literal, ch );
if( ch >=0 )
state = daoLexTable[ TOK_START ][ (int)ch ];
else
state = TOK_IDENTIFIER;
}else if( state == TOK_COMT_OPEN ){
DString_AppendChar( literal, ch );
lexenv = LEX_ENV_COMMENT;
DVector_PushInt( lexenvs, LEX_ENV_COMMENT );
}else{
DString_AppendChar( literal, ch );
}
}else if( lexenv == LEX_ENV_COMMENT ){
DString_AppendChar( literal, ch );
if( ch == '#' ){
state = TOK_OP_SHARP;
}else if( ch == '{' && state == TOK_OP_SHARP ){
state = TOK_COMT_OPEN;
DVector_PushInt( lexenvs, LEX_ENV_COMMENT );
}else if( ch == '}' && state == TOK_OP_SHARP ){
state = TOK_COMT_CLOSE;
DVector_Pop( lexenvs );
lexenv = lexenvs->data.ints[lexenvs->size-1];
if( lexenv != LEX_ENV_COMMENT ){
token->type = token->name = DTOK_COMMENT;
if( comment ) DaoLexer_AppendToken( self, token );
DString_Clear( literal );
state = TOK_RESTART;
}
}else{
state = TOK_START;
}
}
it ++;
}
if( literal->size ){
token->type = token->name = daoTokenMap[ state ];
if( lexenv == LEX_ENV_COMMENT ) token->type = token->name = DTOK_CMT_OPEN;
switch( state ){
case TOK_STRING_MBS : token->type = token->name = DTOK_MBS_OPEN; break;
case TOK_STRING_WCS : token->type = token->name = DTOK_WCS_OPEN; break;
}
if( token->type == DTOK_IDENTIFIER ){
token->name = dao_key_hash( literal->mbs, literal->size );
if( token->name == 0 ) token->name = DTOK_IDENTIFIER;
}else if( token->type == DTOK_ID_THTYPE || token->type == DTOK_ID_SYMBOL ){
token->type = DTOK_IDENTIFIER;
}
if( token->type || space ){
if( isspace( token->string.mbs[0] ) )
token->type = token->name = daoSpaceType[ (int)token->string.mbs[0] ];
DaoLexer_AppendToken( self, token );
}
}
DaoToken_Delete( token );
DVector_Delete( lexenvs );
DString_Delete( source );
#if 0
for(i=0; i<self->tokens->size; i++){
DaoToken *tk = self->tokens->items.pToken[i];
printf( "%4i: %4i %4i , %4i, %s\n", i, tk->type, tk->name, tk->cpos, tk->string.mbs );
}
#endif
return ret ? line : 0;
}
