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;
}
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 );
}
CORE_PROC( PTEXT, GatherLineEx )( PTEXT *pOutput, INDEX *pIndex, int bInsert, int bSaveCR, int bData, PTEXT pInput )
// if data - assume data is coming from a preformatted source
// otherwise use escape as command entry and clear buffer...
{
// this routine should be used to process user type character
// input into a legible line buffer....
// results in a complete line....
// the line returned must be used - the output buffer
// is an accumulator and will contain any partial input buffer
// which remaineder if an EOL sequence was found....
// build line in buffer using standard console
// behavior...
INDEX pos
, len = 0
, size
, maxlen = 0;
PTEXT pReturn = NULL;
PTEXT pDelete = NULL;
TEXTCHAR character;
TEXTSTR output;
if( !pOutput ) // must supply a holder for partial collection...
return NULL;
if( !pInput ) // nothing new input - just using previous collection...
{
if( *pOutput )
{
// use prior partial as new input....
pInput = *pOutput;
pDelete = pInput; // this is never deleted if we use prior...
SetStart( pInput );
*pOutput = NULL;
}
else
return NULL;
}
// probably first pass of gathering...
if( !*pOutput )
{
*pOutput = SegCreate( BUILD_LINE_OUTPUT_SIZE );
if( pIndex )
*pIndex = 0;
SetTextSize( *pOutput, 0 );
output = GetText( *pOutput );
len = 0;
}
else if( pIndex )
{
output = GetText( *pOutput );
len = *pIndex;
if( (*pOutput)->data.size != len )
{
if( bInsert )
{
// creates a new segment inbetween here.....
*pOutput = SplitLine( *pOutput, *pIndex );
output = GetText( *pOutput );
len = *pIndex = GetTextSize( *pOutput );
}
else
{
maxlen = (*pOutput)->data.size;
}
}
}
else
{
output = GetText( *pOutput );
len = GetTextSize( *pOutput );
}
while( pInput )
{
size = GetTextSize( pInput );
for( pos = 0; pos < size; pos++ )
{
switch( character = GetText( pInput )[pos] )
{
case '\x1b':
if( !bData )
{
SetEnd( *pOutput );
SetStart( *pOutput )
{
SetTextSize( *pOutput, 0 );
}
SetTextSize( *pOutput, 0 );
output = GetText( *pOutput );
len = 0;
}
else
goto defaultcase;
break;
case '\x7f': // handle unix type delete too ? perhaps...
if( !bInsert )
{
PTEXT pNext;
// this will slide from the middle to the end...
// if bInsert - then prior to entrying this switch
// the data was split and THIS segment is set to zero.
pNext = *pOutput;
if( len != (maxlen = GetTextSize( *pOutput )) )
{
MemCpy( output + len, output+len+1, maxlen - len );
SetTextSize( *pOutput, --maxlen );
}
else
{
PTEXT pDel;
pNext = *pOutput;
do {
pDel = pNext;
pNext = NEXTLINE( pNext );
if( pDel != *pOutput )
{
SegGrab( pDel );
LineRelease( pDel );
}
} while( pNext && !GetTextSize( pNext ) );
if( pNext )
{
size_t len2;
output = GetText( pNext );
len2 = GetTextSize( pNext ) - 1;
*pOutput = pNext;
len = 0;
MemCpy( output, output+1, len2 );
SetTextSize( pNext, len2 );
}
}
}
else // was insert is either at end....
{
// I dunno perform sliding delete operation...
// must refresh the output string....
{
PTEXT pNext, pDel;
pNext = *pOutput;
do {
pDel = pNext;
pNext = NEXTLINE( pNext );
if( pDel != *pOutput )
{
SegGrab( pDel );
LineRelease( pDel );
}
} while( pNext && !GetTextSize( pNext ) );
if( pNext )
{
size_t len2;
TEXTCHAR *data;
data = GetText( pNext );
MemCpy( data, data+1, len2 = (GetTextSize( pNext ) - 1 ));
SetTextSize( pNext, len2 );
}
}
}
break;
case '\b':
/* perhaps consider using split for backspace in a line...*/
if( !bInsert )
{
PTEXT pNext;
size_t maxlen;
// this will slide from the middle to the end...
// if bInsert - then prior to entrying this switch
// the data was split and THIS segment is set to zero.
pNext = *pOutput;
maxlen = GetTextSize( *pOutput );
while( !maxlen && PRIORLINE( *pOutput ) )
{
*pOutput = PRIORLINE( *pOutput );
len = maxlen = GetTextSize( *pOutput );
}
if( maxlen )
{
if( len != maxlen )
{
size_t sz;
sz = maxlen - len;
MemCpy( output + len - 1, output + len, sz );
SetTextSize( *pOutput, maxlen - 1 );
len--;
}
else
{
SetTextSize( *pOutput, --len );
}
}
}
else // was insert is either at end....
{
if( len )
{
SetTextSize( *pOutput, --len );
}
else
{
if( PRIORLINE( *pOutput ) )
{
*pOutput = PRIORLINE( *pOutput );
len = GetTextSize( *pOutput );
}
if( len )
SetTextSize( *pOutput, --len );
}
}
break;
case '\r': // ignore this character...
if( !bSaveCR )
break;
// falls through .. past this and saves the return...
if(0)
case '\n':
if( !pReturn )
{
// transfer *pOutput to pReturn....
pReturn = *pOutput;
SetEnd( pReturn );
output = GetText( pReturn );
len = GetTextSize( pReturn );
output[len] = character;
SetTextSize( pReturn, ++len );
// begin next collection in case more data is in the input...
*pOutput = SegCreate( BUILD_LINE_OUTPUT_SIZE );
SetTextSize( *pOutput, 0 );
output = GetText( *pOutput );
len = 0;
break;
}
// store carriage return...
default:
defaultcase:
output[len++] = character;
if( (maxlen && len == maxlen ) ||
len == BUILD_LINE_OUTPUT_SIZE )
{
PTEXT pTemp;
SetTextSize( *pOutput, len );
if( !NEXTLINE( *pOutput ) )
{
SegAppend( *pOutput, pTemp = SegCreate( BUILD_LINE_OUTPUT_SIZE ) );
SetTextSize( pTemp, 0 );
}
else
{
pTemp = NEXTLINE( *pOutput );
maxlen = GetTextSize( pTemp );
}
*pOutput = pTemp;
output = GetText( *pOutput );
len = 0;
}
else
{
if( bInsert ) // insertion happens at end of segment
// and the segment is broken...
{
if( !pIndex || ( len > *pIndex ) )
SetTextSize( *pOutput, len );
}
else
if( len > GetTextSize( *pOutput ) )
{
SetTextSize( *pOutput, len );
}
}
break;
}
}
