static void DaoIO_ReadFile( DaoProcess *proc, DaoValue *p[], int N )
{
DString *res = DaoProcess_PutMBString( proc, "" );
daoint silent = p[1]->xInteger.value;
if( proc->vmSpace->options & DAO_OPTION_SAFE ){
DaoProcess_RaiseException( proc, DAO_ERROR, "not permitted" );
return;
}
if( DString_Size( p[0]->xString.data ) ==0 ){
char buf[1024];
while(1){
size_t count = fread( buf, 1, sizeof( buf ), stdin );
if( count ==0 ) break;
DString_AppendDataMBS( res, buf, count );
}
}else{
FILE *fin = DaoIO_OpenFile( proc, p[0]->xString.data, "r", silent );
struct stat info;
if( fin == NULL ) return;
fstat( fileno( fin ), &info );
DString_Resize( res, info.st_size );
DString_Resize( res, fread( res->mbs, 1, res->size, fin ) );
fclose( fin );
}
}
int DaoStream_ReadLine( DaoStream *self, DString *line )
{
int ch, delim = '\n';
char buf[IO_BUF_SIZE];
char *start = buf, *end = buf + IO_BUF_SIZE;
DString_Clear( line );
DString_ToMBS( line );
if( self->redirect && self->redirect->StdioRead ){
self->redirect->StdioRead( self->redirect, line, 0 );
return line->size >0;
}else if( self->file ){
return DaoFile_ReadLine( self->file, line );
}else if( self->attribs & DAO_IO_STRING ){
daoint pos = DString_FindWChar( self->streamString, delim, 0 );
if( pos == MAXSIZE ){
DString_Assign( line, self->streamString );
DString_Clear( self->streamString );
}else{
DString_SubString( self->streamString, line, 0, pos+1 );
DString_Erase( self->streamString, 0, pos+1 );
}
return self->streamString->size >0;
}else{
*start = ch = getchar();
start += 1;
while( ch != delim && ch != EOF ){
*start = ch = getchar();
start += 1;
if( start == end ){
if( ch == EOF ) start -= 1;
DString_AppendDataMBS( line, buf, start-buf );
start = buf;
}
}
if( ch == EOF && start != buf ) start -= 1;
DString_AppendDataMBS( line, buf, start-buf );
clearerr( stdin );
return ch != EOF;
}
return 0;
}
void DaoStream_WriteString( DaoStream *self, DString *val )
{
int i;
if( val->mbs ){
const char *data = val->mbs;
if( self->redirect && self->redirect->StdioWrite ){
DString *mbs = DString_New(1);
DString_SetDataMBS( mbs, data, val->size );
self->redirect->StdioWrite( self->redirect, mbs );
DString_Delete( mbs );
}else if( self->file ){
if( self->format ){
fprintf( self->file, self->format, data );
}else{
DaoFile_WriteString( self->file, val );
}
}else if( self->attribs & DAO_IO_STRING ){
DString_AppendDataMBS( self->streamString, data, val->size );
}else{
if( self->format ){
printf( self->format, data );
}else{
DaoFile_WriteString( stdout, val );
}
}
}else{
const wchar_t *data = val->wcs;
if( self->redirect && self->redirect->StdioWrite ){
DString *mbs = DString_New(1);
DString_SetWords( mbs, data, val->size );
self->redirect->StdioWrite( self->redirect, mbs );
DString_Delete( mbs );
}else if( self->file ){
if( self->format ){
fprintf( self->file, self->format, data );
}else{
DaoFile_WriteString( self->file, val );
}
}else if( self->attribs & DAO_IO_STRING ){
DString *wcs = self->streamString;
int size = 0;
DString_ToWCS( self->streamString );
size = wcs->size;
DString_Resize( self->streamString, wcs->size + val->size );
memcpy( wcs->wcs + size, val->wcs, val->size * sizeof(wchar_t) );
}else{
if( self->format ){
printf( self->format, data );
}else{
DaoFile_WriteString( stdout, val );
}
}
}
}
int DaoFile_ReadAll( FILE *fin, DString *all, int close )
{
char buf[IO_BUF_SIZE];
DString_Reset( all, 0 );
DString_ToMBS( all );
if( fin == NULL ) return 0;
while(1){
size_t count = fread( buf, 1, IO_BUF_SIZE, fin );
if( count ==0 ) break;
DString_AppendDataMBS( all, buf, count );
}
if( close ) fclose( fin );
return 1;
}
void DaoCGI_SendFile( DaoProcess *proc, DaoValue *p[], int N )
{
DString *mbs;
DString *file = DaoValue_TryGetString( p[0] );
DString *mime = DaoValue_TryGetString( p[1] );
DString *notfound = DaoValue_TryGetString( p[2] );
char buf[IO_BUF_SIZE];
FILE *fin = fopen( DString_GetMBS( file ), "r" );
if( fin == NULL ){
printf( "%s", DString_GetMBS( notfound ) );
return;
}
mbs = DString_New(1);
printf( "Content-Type: %s\n\n", DString_GetMBS( mime ) );
while(1){
size_t count = fread( buf, 1, IO_BUF_SIZE, fin );
if( count ==0 ) break;
DString_Reset( mbs, 0 );
DString_AppendDataMBS( mbs, buf, count );
DaoFile_WriteString( stdout, mbs );
}
fclose( fin );
DString_Delete( mbs );
}
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 );
}
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;
}
