static PTEXT CPROC ParseCommand( PMYDATAPATH pdp, PTEXT buffer )
{
if( buffer )
{
PTEXT pCommand;
//Log2( WIDE("buffer: %s(%d)"), GetText( buffer ), GetTextSize( buffer ) );
//LogBinary( buffer );
pCommand = burst( buffer );
LineRelease( buffer );
if( pCommand )
{
PTEXT pTemp, pStart;
int bEscaped = FALSE;
pStart = pTemp = pCommand;
while( pTemp )
{
if( TextIs( pTemp, WIDE("\\") ) )
{
if( !bEscaped )
{
PTEXT pNext;
pNext = NEXTLINE( pTemp );
pNext->format.position.offset.spaces = pTemp->format.position.offset.spaces;
LineRelease( SegGrab( pTemp ) );
bEscaped = TRUE;
pTemp = pNext;
continue;
}
}
if( !bEscaped && TextIs( pTemp, WIDE(";") ) )
{
PTEXT pPrior;
//Log( WIDE("Splitting the line and enqueing it...") );
pPrior = pTemp;
SegBreak( pTemp );
if( pStart != pTemp )
{
// end of line included!
pStart = SegAppend( pStart, SegCreate(0) );
EnqueLink( &pdp->output, pStart );
}
pStart = pTemp = NEXTLINE( pTemp );
SegBreak( pTemp );
LineRelease( pPrior ); // remove ';'
bEscaped = FALSE;
continue;
}
bEscaped = FALSE;
pTemp = NEXTLINE( pTemp );
}
if( pStart )
{
PTEXT line;
line = BuildLine( pStart );
//Log1( WIDE("Enqueu: %s"), GetText( line ) );
LineRelease( line );
EnqueLink( &pdp->output, pStart );
}
}
else
{
// well what now? I guess pLine got put into Partial...
// next pass through this all for command recall will blow...
Log( WIDE("No information from the burst!") );
}
}
return (PTEXT)DequeLink( &pdp->output );
}
void HTTPCollapse( PTEXT *ppText )
{
PTEXT output;
PTEXT input = *ppText;
while( input )
{
if( GetText( input )[0] == '+' )
{
PTEXT subst;
// sometimes a + can be attached to a number
// so much for the natural language parser dealing with
// a machine oriented protocol...
if( GetTextSize( input ) > 1 )
{
SegSplit( &input, 1 );
}
subst = GetSubst( '+' );
SegInsert( subst, input );
LineRelease( SegGrab( input ) );
input = subst;
if( !PRIORLINE( input ) )
(*ppText) = input;
}
else if( TextIs( input, WIDE("%") ) )
{
PTEXT next = NEXTLINE( input );
if( next )
{
PTEXT subst;
SegSplit( &next, 2 );
subst = GetSubst( *(unsigned short*)GetText( next ) );
if( subst )
{
PTEXT nextnext = NEXTLINE( next );
PTEXT prior = SegBreak( input );
if( !prior )
{
*ppText = SegAppend( subst, nextnext );
}
if( nextnext )
{
SegBreak( nextnext );
if( !prior )
*ppText = nextnext;
else
SegAppend( prior, nextnext );
SegInsert( subst, nextnext );
input = nextnext;
continue;
}
else
{
SegAppend( prior, (PTEXT)&subst );
input = NULL;
continue;
}
}
// if not subst... just continue stepping, no replacement nessecary?
}
}
input = NEXTLINE( input );
}
output = BuildLine( *ppText );
LineRelease( *ppText );
(*ppText) = output;
}
int CPROC MakeProcess( PSENTIENT ps, PENTITY peInit, PTEXT parameters )
{
// parameters specify command and parameters to launch...
// perhaps a working directory? May or may not want it
// in the current directory...
// /make process test WIDE("command arguments") WIDE("work path") <attributes?>
// /make process test WIDE("notepad trigger.txt")
PSENTIENT ps2;
PPROCESS process = New( PROCESS );
TEXTCHAR MyPath[256];
GetCurrentPath( MyPath, sizeof( MyPath ) );
ps2 = CreateAwareness( peInit );
MemSet( process, 0, sizeof( PROCESS ) );
Log( WIDE("Have a process, and woke it up... setting the link") );
SetLink( &peInit->pPlugin, iProcess, process );
SetLink( &peInit->pDestroy, iProcess, DestroyProcess );
Log( WIDE("Set the link, getting params...") );
{
PTEXT text, cmd = NULL;
text = GetParam( ps, ¶meters );
if( text && TextIs( text, WIDE("\"") ) )
{
Log( WIDE("Found a quote, getting command line") );
while( (text = GetParam( ps, ¶meters )) && !TextIs( text, WIDE("\"") ) )
{
cmd = SegAppend( cmd, SegDuplicate( text ) );
}
cmd->format.position.offset.spaces = 0;
process->command = BuildLine( cmd );
if( text ) // closed, and may have start path....
{
text = GetParam( ps, ¶meters );
if( text && TextIs( text, WIDE("\"") ) )
{
Log( WIDE("Found a quote, getting the path") );
while( (text = GetParam( ps, ¶meters )) && !TextIs( text, WIDE("\"") ) )
{
cmd = SegAppend( cmd, SegDuplicate( text ) );
}
cmd->format.position.offset.spaces = 0;
process->directory = BuildLine( cmd );
}
}
}
else
{
DECLTEXT( msg, WIDE("Must specify process to execute in quotes (\")") );
EnqueLink( &ps->Command->Output, &msg );
WakeAThread( ps2 );
return -1; // abort creation.
}
}
Log2( WIDE("Starting %s in %s"), GetText( process->command ), GetText( process->directory ) );
process->si.cb = sizeof( process->si );
// remaining startup info members are NULL - specifying we do NOT care
// why why when where how the process starts.
if( StartProcess( process ) )
{
DECLTEXTSZ( msg, 256 );
msg.data.size = snprintf( msg.data.data, 256*sizeof(TEXTCHAR), WIDE("Failed to start \"%s\" in \"%s\" error: %ld"),
GetText( process->command ),
GetText( process->directory ),
GetLastError() );
EnqueLink( &ps->Command->Output, SegDuplicate( (PTEXT)&msg ) );
WakeAThread( ps2 );
return -1; // abort creation.
}
// well otherwise would seem we've launched a valid application
// we have valid process and thread handles to it which can be monitored
// and well that's about that.
WakeAThread( ps2 );
return 0;
}
void ParseURI( CTEXTSTR string )
{
int state;
PTEXT words;
PTEXT delete_seg = NULL;
PTEXT line = SegCreateFromText( string );
PTEXT filename = NULL;
PTEXT varname = NULL;
PTEXT varvalue = NULL;
PTEXT content = NULL;
int content_length;
struct {
uint32_t bInvalid : 1;
uint32_t bGet : 1;
uint32_t bPost : 1;
uint32_t bBinary : 1; // reading the content...
uint32_t bValue : 1;
} flags;
// we got a line, therefore we can process it...
// only thing then is the last line in the block ...
state = GET_FILENAME;
words = burst( line );
delete_seg = words;
// though...
LineRelease( line );
flags.bValue = 0;
while( words )
{
DECLTEXT( page, WIDE("page") );
DECLTEXT( CGI, WIDE("CGI") );
//printf( "state:%d word:%s \r\n",state, GetText(words ) );
// what does stuff have now? the whole thign? a line?
if( !GetTextSize( words ) ) switch( state )
{
case GET_HTTP_EOL:
state = GET_HTTP_METAVAR;
break;
case GET_HTTP_METAVAR:
case GET_CGI:
goto AddCGIVariable;
break;
}
else switch( state )
{
case RESET:
state = GET_COMMAND;
continue; // skip ahead and try new state;
break;
case GET_COMMAND:
if( TextLike( words, WIDE("GET") ) )
{
state = GET_FILENAME;
//flags.bGet = TRUE;
}
else if( TextLike( words, WIDE("POST") ) )
{
state = GET_FILENAME;
//flags.bPost = TRUE;
}
else
{
flags.bInvalid = TRUE;
}
break;
case GET_FILENAME:
if( !filename && TextIs( words, WIDE("/") ) )
{
// this is rude, and should never be done,
// however this filter consumes all data anyhow, SO
// mangling this will not hurt much...
words->format.position.offset.spaces = 0;
}
if( TextIs( words, WIDE("?") ) || words->format.position.offset.spaces )
{
if( !words->format.position.offset.spaces )
state = GET_CGI;
else
state = GET_HTTP_VERSION;
filename = NEXTLINE( filename );
LineRelease( SegBreak( filename ) );
HTTPCollapse( &filename );
//AddVariableExxx( ps, ps->Current, (PTEXT)&page, filename, FALSE,TRUE,TRUE DBG_SRC );
//AddVariable( ps, ps->Current, (PTEXT)&CGI, TextDuplicate( NEXTLINE( words ), FALSE ) );
LineRelease( filename );
filename = NULL;
}
else
{
filename = SegAppend( filename, SegDuplicate( words ) );
}
break;
case GET_CGI:
if( words->format.position.offset.spaces )
{
state = GET_HTTP_VERSION;
goto AddCGIVariable;
}
else
{
if( TextIs( words, WIDE("=") ) )
{
HTTPCollapse( &varname );
flags.bValue = 1;
}
else if( TextIs( words, WIDE("&") ) )
{
AddCGIVariable:
HTTPCollapse( &varvalue );
HTTPCollapse( &varname );
if( TextLike( varname, WIDE("content-length") ) )
{
content_length= IntCreateFromText( GetText( varvalue ) );
}
{
struct VAR *v = New( struct VAR );
v->varname = varname;
varname = NULL;
v->varvalue = varvalue;
varvalue = NULL;
AddLink( &l.vars, v );
}
//AddVariableExxx( ps, ps->Current, pmdp->varname, pmdp->varvalue, FALSE,TRUE,TRUE DBG_SRC );
//LineRelease( varname );
//LineRelease( varvalue );
//varname = NULL;
//varvalue = NULL;
flags.bValue = 0;
}
else
{
if( flags.bValue )
{
varvalue = SegAppend( varvalue, SegDuplicate( words ) );
}
else
{
//printf( "add var" );
varname = SegAppend( varname, SegDuplicate( words ) );
}
}
}
break;
case GET_HTTP_VERSION:
if( TextIs( words, WIDE("HTTP") ) )
{
// okay - don't really do anything... next word is the version...
}
else
{
// TextIs( words, "/" ); // this is a token before the number...
// Version better be something like 1.1 1.0?
// well wait for EOL...
state = GET_HTTP_EOL;
}
break;
case GET_HTTP_EOL:
if( !GetTextSize( words ) )
{
state = GET_HTTP_METAVAR;
}
break;
case GET_HTTP_METAVAR:
{
if( !flags.bValue && TextIs( words, WIDE(":") ) )
{
flags.bValue = TRUE;
}
else
{
if( flags.bValue )
{
varvalue = SegAppend( varvalue, SegDuplicate( words ) );
}
else
{
varname = SegAppend( varname, SegDuplicate( words ) );
}
}
}
break;
case GET_HTTP_CONTENT:
if( !content_length )
{
DebugBreak();
state = RESET;
}
else
{
// hmm we've parsed everything up to here, but now we need blocks, binary blocks.
content = SegAppend( content, words );
if( LineLength( content ) == content_length )
{
//ProcessPostCGI( common.Owner, content );
//AddVariableExxx( ps, ps->Current, (PTEXT)&CGI, content, FALSE,TRUE,TRUE DBG_SRC );
//AddVariable( ps, ps->Current, (PTEXT)&CGI, content );
LineRelease( content );
//InvokeBehavior( "http.request", common.Owner->Current, common.Owner, NULL );
//InvokeBehavior( "http_request", common.Owner->Current, common.Owner, NULL );
state = RESET;
}
words = NULL;
}
break;
}
void ProcessEnum( void )
{
PTEXT pLine = GetCurrentWord();
char *text;
// look for enum keyword....
while( pLine )
{
text = GetText( pLine );
if( TextIs( pLine, WIDE("enum") ) )
{
if( g.current_enum )
{
fprintf( stderr, WIDE("%s(%d): Syntax error enumeration within enum?\n")
, GetCurrentFileName(), GetCurrentLine() );
}
g.current_enum = Allocate( sizeof( ENUM_TABLE ) );
g.current_enum->entries = NULL;
g.current_enum->name = NULL;
if( g.current_entry )
{
fprintf( stderr, WIDE("Coding error - uncommited enumeration value. Lost memory.\n") );
g.current_entry = NULL;
}
g.flags.get_identifier = 1;
}
else
{
if( g.flags.get_identifier )
{
if( text[0] != '{' )
{
if( g.current_enum->name )
{
fprintf( stderr, WIDE("%s(%d): Error multiple identifers for enum\n")
, GetCurrentFileName(), GetCurrentLine() );
}
else
g.current_enum->name = SegDuplicate( pLine );
}
else
{
// well whether or not there was an identifier (name)
// we're done getting it....
g.flags.get_identifier = 0;
}
}
else // collecting enumeration values...
{
if( text[0] == '}' )
{
}
else if( text[0] == ',' )
{
}
else if( text[0] == '=' )
{
}
else if( g.current_entry )
{
if( text[0] == ',' )
{
if( !g.flags.current_value_set )
{
if( g.current_enum->last_entry )
g.current_entry->value = g.current_enum->last_entry->value + 1;
else
g.current_entry->value = 0;
}
if( g.current_enum->last_entry )
g.current_enum->last_entry->next = g.current_entry;
else
g.current_enum->entries = g.current_entry;
g.current_enum->last_entry = g.current_entry;
g.current_entry = NULL;
}
else
{
}
}
else
{
if( text[0] == ',' )
{
fprintf( stderr, WIDE("Error - unexpected comma sepeartor enumeration.\n") );
}
if( text[0] == '=' )
{
fprintf( stderr, WIDE("Error - unexpected comma sepeartor enumeration.\n") );
}
g.current_entry = Allocate( sizeof( ENUM_ENTRY ) );
g.flags.current_value_set = 0;
g.current_entry->next = NULL;
g.current_entry->name = SegDuplicate( pLine );
}
}
}
pLine = NEXTLINE( pLine );
}
}
