PTEXT SplitLine( PTEXT pLine, INDEX nPos ) { PTEXT newseg, end; if( !nPos ) { if( PRIORLINE( pLine ) ) return PRIORLINE( pLine ); // otherwise we'll have to insert a new segment // in front of this.... newseg = SegCreate( BUILD_LINE_OUTPUT_SIZE ); newseg->data.size = 0; pLine->format.position.offset.spaces = 0; SegAppend( newseg, pLine ); return newseg; } else if( pLine->data.size == nPos ) { // if the point to split is not in the middle of // this segment.... return pLine; } newseg = SegCreate( BUILD_LINE_OUTPUT_SIZE ); end = NEXTLINE( pLine ); SegBreak( end ); // fill in new segment with trailing data newseg->data.size = pLine->data.size - nPos; MemCpy( newseg->data.data, pLine->data.data + nPos, newseg->data.size ); pLine->data.size = nPos; pLine->data.data[nPos] = 0; // terminate with null also... SegAppend( pLine , SegAppend( newseg, end ) ); return pLine; }
PTEXT win_get_line(HANDLE hFile) { // extern HANDLE hStdin; #define WORKSPACE 1024 // character for workspace PTEXT workline=(PTEXT)NULL; uint32_t length = 0; do { // create a workspace to read input from the file. workline=SegAppend(workline,SegCreate(WORKSPACE)); SetEnd( workline ); // read a line of input from the file. if( !ReadConsole( hFile , GetText(workline) , WORKSPACE , &length , NULL) ) // if no input read. { if (PRIORLINE(workline)) // if we've read some. { PTEXT t; workline=PRIORLINE(workline); // go back one. SegBreak(t = NEXTLINE(workline)); LineRelease(t); // destroy the current segment. } else { LineRelease(workline); // destory only segment. workline = NULL; } break; // get out of the loop- there is no more to read. } } while (GetText(workline)[length-1]!='\n'); //while not at the end of the line. if (workline&&length) // if I got a line, and there was some length to it. SetStart(workline); // set workline to the beginning. return(workline); // return the line read from the file. }
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; }
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; } }