FBCALL int fb_InputString( void *dst, ssize_t strlen, int fillrem )
{
char buffer[FB_INPUT_MAXSTRINGLEN+1];
int isfp;
fb_FileInputNextToken( buffer, FB_INPUT_MAXSTRINGLEN, TRUE, &isfp );
fb_StrAssign( dst, strlen, buffer, 0, fillrem );
return fb_ErrorSetNum( FB_RTERROR_OK );
}
int fb_ConsoleLineInput( FBSTRING *text, void *dst, int dst_len, int fillrem,
int addquestion, int addnewline )
{
FBSTRING *tmp_result;
FB_LOCK();
fb_PrintBufferEx( NULL, 0, FB_PRINT_FORCE_ADJUST );
if( text != NULL )
{
if( text->data != NULL )
{
fb_PrintString( 0, text, 0 );
}
/* del if temp */
else
{
fb_hStrDelTemp( text );
}
if( addquestion != FB_FALSE )
{
fb_PrintFixString( 0, pszDefaultQuestion, 0 );
}
}
FB_UNLOCK();
tmp_result = fb_ConReadLine( FALSE );
if( addnewline ) {
fb_PrintVoid( 0, FB_PRINT_NEWLINE );
}
if( tmp_result!=NULL ) {
fb_StrAssign( dst, dst_len, tmp_result, -1, fillrem );
return fb_ErrorSetNum( FB_RTERROR_OK );
}
return fb_ErrorSetNum( FB_RTERROR_OUTOFMEM );
}
/*:::::*/
FBCALL void fb_StrSwap( void *str1, int size1, int fillrem1,
void *str2, int size2, int fillrem2 )
{
char *p1, *p2;
int len1, len2;
if( (str1 == NULL) || (str2 == NULL) )
return;
/* both var-len? */
if( (size1 == -1) && (size2 == -1) )
{
FBSTRING td;
/* just swap the descriptors */
td.data = ((FBSTRING *)str1)->data;
td.len = ((FBSTRING *)str1)->len;
td.size = ((FBSTRING *)str1)->size;
((FBSTRING *)str1)->data = ((FBSTRING *)str2)->data;
((FBSTRING *)str1)->len = ((FBSTRING *)str2)->len;
((FBSTRING *)str1)->size = ((FBSTRING *)str2)->size;
((FBSTRING *)str2)->data = td.data;
((FBSTRING *)str2)->len = td.len;
((FBSTRING *)str2)->size = td.size;
return;
}
FB_STRSETUP_FIX( str1, size1, p1, len1 );
FB_STRSETUP_FIX( str2, size2, p2, len2 );
/* Same length? Only need to do an fb_MemSwap() */
if( len1 == len2 ) {
if( len1 > 0 ) {
fb_MemSwap( (unsigned char *)p1,
(unsigned char *)p2,
len1 );
/* null terminators don't need to change */
}
return;
}
/* Note: user-allocated zstrings are assumed to be large enough */
/* Is one of them a var-len string? Might need to be (re)allocated */
if( (size1 == -1) || (size2 == -1) )
{
FBSTRING td = { 0 };
fb_StrAssign( &td, -1, str1, size1, FALSE );
fb_StrAssign( str1, size1, str2, size2, fillrem1 );
fb_StrAssign( str2, size2, &td, -1, fillrem2 );
fb_StrDelete( &td );
return;
}
/* Both are fixed-size/user-allocated [z]strings */
/* Make str1/str2 be the smaller/larger string respectively */
if( len1 > len2 ) {
{
char* p = p1;
p1 = p2;
p2 = p;
}
{
int len = len1;
len1 = len2;
len2 = len;
}
{
int size = size1;
size1 = size2;
size2 = size;
}
{
int fillrem = fillrem1;
fillrem1 = fillrem2;
fillrem2 = fillrem;
}
}
/* MemSwap as much as possible (i.e. the smaller length) */
if( len1 > 0 ) {
fb_MemSwap( (unsigned char *)p1,
(unsigned char *)p2,
len1 );
}
/* and copy over the remainder from larger to smaller, unless it's
a fixed-size [z]string that doesn't have enough room left (not even
for the null terminator) */
if( (size1 > 0) && (len2 >= size1) ) {
len2 = len1;
} else if( len2 > len1 ) {
FB_MEMCPYX( (unsigned char *)(p1 + len1),
(unsigned char *)(p2 + len1),
len2 - len1 );
}
/* set null terminators */
p1[len2] = '\0';
p2[len1] = '\0';
/* Clear remainder of the larger (now smaller) string with nulls if
requested (see also fb_StrAssign()). We can assume that the strings
were originally cleared properly, because uninitialized strings
mustn't be used in rvalues, FB_STRSETUP_FIX() doesn't handle that.
The smaller (now larger) string doesn't need to be touched, as it's
remainder didn't increase */
if( fillrem2 ) {
int used2 = len1 + 1;
if( size2 > used2 ) {
memset( p2 + used2, 0, size2 - used2 );
}
}
}
static int fb_hFileLineInputEx
(
FB_FILE *handle,
void *dst,
ssize_t dst_len,
int fillrem
)
{
ssize_t len, readlen;
char buffer[BUFFER_LEN];
eInputMode mode = eIM_Invalid;
if( !FB_HANDLE_USED(handle) )
return fb_ErrorSetNum( FB_RTERROR_ILLEGALFUNCTIONCALL );
FB_LOCK();
if( handle->hooks->pfnReadLine != NULL ) {
mode = eIM_ReadLine;
} else if( handle->hooks->pfnRead != NULL &&
handle->hooks->pfnEof != NULL )
{
mode = eIM_Read;
}
if( mode==eIM_Invalid ) {
FB_UNLOCK();
return fb_ErrorSetNum( FB_RTERROR_ILLEGALFUNCTIONCALL );
}
switch( mode ) {
case eIM_Read:
/* This is the VFS-compatible way to read a line ... but it's slow */
len = readlen = 0;
while (!handle->hooks->pfnEof(handle)) {
int do_add = FALSE, do_break = FALSE;
size_t read_len;
int res = fb_FileGetDataEx( handle, 0, buffer+len, 1, &read_len, FALSE, FALSE );
if( res==FB_RTERROR_OK && read_len==1) {
char ch = buffer[len];
if( ch==13 ) {
res = fb_FileGetDataEx( handle, 0, &ch, 1, &read_len, FALSE, FALSE );
if( res==FB_RTERROR_OK && ch!=10 && read_len==1) {
fb_FilePutBackEx( handle, &ch, 1 );
}
ch = 10;
}
if( ch==10 ) {
do_add = do_break = TRUE;
} else {
do_add = len==(sizeof(buffer)-1);
}
} else {
do_add = len!=0;
}
if( do_add || handle->hooks->pfnEof( handle ) ) {
/* create temporary string to ensure that NUL's are preserved ...
* this function wants the length WITH the NUL character!!! */
buffer[len] = 0;
FBSTRING *src = fb_StrAllocTempDescF( buffer, len + 1);
if( readlen==0 ) {
fb_StrAssign( dst, dst_len, src, -1, fillrem );
} else {
fb_StrConcatAssign ( dst, dst_len, src, -1, fillrem );
}
readlen += len;
len = 0;
} else {
++len;
}
if( res!=FB_RTERROR_OK || do_break )
break;
}
if( readlen == 0 ) {
/* del destine string */
if( dst_len == -1 )
fb_StrDelete( (FBSTRING *)dst );
else
*(char *)dst = '\0';
}
break;
case eIM_ReadLine:
/* The read line mode is the most comfortable ... but IMHO it's
* only useful for special devices (like SCRN:) */
{
/* destine is a var-len string? read directly */
if( dst_len == -1 )
{
handle->hooks->pfnReadLine( handle, dst );
}
/* fixed-len or unknown size (ie: pointers)? use a temp var-len */
else
{
FBSTRING str_result = { 0, 0, 0 };
/* read complete line (may include NULs) */
handle->hooks->pfnReadLine( handle, &str_result );
/* add contents of tempporary string to result buffer */
fb_StrAssign( dst, dst_len, (void *)&str_result, -1, fillrem );
/* delete result */
fb_StrDelete( &str_result );
}
}
break;
case eIM_Invalid:
/* the "invalid" mode was already handled above ... so we don't
* need to do anything here ... */
break;
}
FB_UNLOCK();
return fb_ErrorSetNum( FB_RTERROR_OK );
}
FBCALL FBSTRING *fb_ConReadLine( int soft_cursor )
{
FBSTRING result = { 0 };
int current_x, current_y;
int cols, rows;
size_t pos, len, tmp_buffer_len = 0;
int cursor_visible;
int k;
char ch, tmp_buffer[12];
fb_GetSize(&cols, &rows);
cursor_visible = (fb_Locate( 0, 0, -1, 0, 0 ) & 0x10000) != 0;
fb_Locate( 0, 0, FALSE, 0, 0 );
pos = len = 0;
fb_PrintBufferEx( NULL, 0, 0 );
/* Ensure that the cursor is visible during INPUT */
fb_Locate( 0, 0, (soft_cursor == FALSE), 0, 0 );
do {
size_t delete_char_count = 0, add_char = FALSE;
FBSTRING *sTmp;
fb_GetXY(¤t_x, ¤t_y);
if( soft_cursor )
{
fb_PrintFixString( 0, "\377", 0 );
fb_Locate( current_y, current_x, FALSE, 0, 0 );
}
while( fb_KeyHit( ) == 0 )
{
fb_Delay( 25 ); /* release time slice */
}
sTmp = fb_Inkey( );
if( sTmp->data != NULL )
{
if( FB_STRSIZE(sTmp) == 2 )
{
k = FB_MAKE_EXT_KEY(sTmp->data[1]);
ch = 0;
}
else
{
k = FB_MAKE_KEY(ch = sTmp->data[0]);
}
fb_hStrDelTemp( sTmp );
}
else
{
k = 0;
continue;
}
if( soft_cursor )
{
char mask[2] = { ((result.data != NULL) && (pos < len)? result.data[pos]: ' '), '\0' };
fb_PrintFixString( 0, mask, 0 );
fb_Locate( current_y, current_x, FALSE, 0, 0 );
}
switch (k) {
case 8:
/* DEL */
if (pos!=0) {
DoMove( ¤t_x, ¤t_y, -1, 0, cols, rows );
--pos;
delete_char_count = 1;
}
break;
case 9:
/* TAB */
tmp_buffer_len = ((pos + 8) / 8 * 8) - pos;
memset(tmp_buffer, 32, tmp_buffer_len);
add_char = TRUE;
break;
case 27:
/* ESC */
DoMove( ¤t_x, ¤t_y, -pos, 0, cols, rows );
pos = 0;
delete_char_count = len;
break;
case FB_MAKE_EXT_KEY(0x53):
/* CLeaR */
if( len!=pos ) {
delete_char_count = 1;
} else {
fb_Beep();
}
break;
case FB_MAKE_EXT_KEY(0x4B):
/* Cursor LEFT */
if( pos != 0 ) {
DoMove( ¤t_x, ¤t_y, -1, 0, cols, rows );
--pos;
}
break;
case FB_MAKE_EXT_KEY(0x4D):
/* Cursor RIGHT */
if( pos != len ) {
DoMove( ¤t_x, ¤t_y, 1, 0, cols, rows );
++pos;
}
break;
case FB_MAKE_EXT_KEY(0x47):
/* HOME */
DoMove( ¤t_x, ¤t_y, -pos, 0, cols, rows );
pos = 0;
break;
case FB_MAKE_EXT_KEY(0x4F):
/* END */
DoMove( ¤t_x, ¤t_y, len-pos, 0, cols, rows );
pos = len;
break;
case FB_MAKE_EXT_KEY(0x48):
/* Cursor UP */
if( pos >= cols) {
DoMove( ¤t_x, ¤t_y, -cols, 0, cols, rows );
pos -= cols;
}
break;
case FB_MAKE_EXT_KEY(0x50):
/* Cursor DOWN */
if( ( pos + cols ) <= len ) {
DoMove( ¤t_x, ¤t_y, cols, 0, cols, rows );
pos += cols;
}
break;
default:
if( k>=32 && k<=255 ) {
tmp_buffer[0] = (char) k;
tmp_buffer_len = 1;
add_char = TRUE;
/* DoMove( ¤t_x, ¤t_y, 1, 0, cols ); */
}
break;
}
if( delete_char_count!=0 || add_char ) {
/* Turn off the cursor during output (speed-up) */
fb_Locate( 0, 0, FALSE, 0, 0 );
}
if( delete_char_count ) {
FBSTRING *str_fill;
FBSTRING *str_left = fb_StrMid( &result, 1, pos );
FBSTRING *str_right = fb_StrMid( &result,
pos + 1 + delete_char_count,
len - pos - delete_char_count);
fb_StrAssign( &result, -1, str_left, -1, FALSE );
fb_StrConcatAssign( &result, -1, str_right, -1, FALSE );
len -= delete_char_count;
FB_LOCK();
fb_PrintBufferEx( result.data + pos, len - pos, 0 );
/* Overwrite all deleted characters with SPC's */
str_fill = fb_StrFill1 ( delete_char_count, ' ' );
fb_PrintBufferEx( str_fill->data, delete_char_count, 0 );
fb_hStrDelTemp( str_fill );
fb_Locate( current_y, current_x, -1, 0, 0 );
FB_UNLOCK();
}
if( add_char ) {
tmp_buffer[tmp_buffer_len] = 0;
}
if( add_char ) {
int old_x = current_x, old_y = current_y;
FBSTRING *str_add = fb_StrAllocTempDescF( tmp_buffer, tmp_buffer_len + 1 );
FBSTRING *str_left = fb_StrMid( &result, 1, pos );
FBSTRING *str_right = fb_StrMid( &result, pos + 1, len - pos);
fb_StrAssign( &result, -1, str_left, -1, FALSE );
fb_StrConcatAssign( &result, -1, str_add, -1, FALSE );
fb_StrConcatAssign( &result, -1, str_right, -1, FALSE );
len += tmp_buffer_len;
FB_LOCK();
fb_PrintBufferEx( result.data + pos, len - pos, 0 );
fb_GetXY(¤t_x, ¤t_y);
if( pos==(len-tmp_buffer_len) ) {
current_x = old_x; current_y = old_y;
DoMove( ¤t_x, ¤t_y, tmp_buffer_len, 0, cols, rows );
} else {
int tmp_x_2 = old_x, tmp_y_2 = old_y;
DoAdjust( &tmp_x_2, &tmp_y_2, len - pos, 0, cols, rows );
if( tmp_y_2 > (rows+1) || (tmp_y_2==(rows+1) && tmp_x_2>1) ) {
DoMove( ¤t_x, ¤t_y, -(len - pos - tmp_buffer_len), 0, cols, rows );
} else {
current_x = old_x; current_y = old_y;
DoMove( ¤t_x, ¤t_y, tmp_buffer_len, 0, cols, rows );
}
}
pos += tmp_buffer_len;
FB_UNLOCK();
}
fb_Locate( 0, 0, (soft_cursor == FALSE), 0, 0 );
} while (k!='\r' && k!='\n');
FB_LOCK();
/* set cursor to end of line */
fb_GetXY(¤t_x, ¤t_y);
DoMove( ¤t_x, ¤t_y, len - pos, 0, cols, rows );
/* Restore old cursor visibility */
fb_Locate( 0, 0, cursor_visible, 0, 0 );
FB_UNLOCK();
return fb_StrAllocTempResult( &result );
}
int fb_DevFileReadLineDumb
(
FILE *fp,
FBSTRING *dst,
fb_FnDevReadString pfnReadString
)
{
int res = fb_ErrorSetNum( FB_RTERROR_OK );
size_t buffer_len;
int found, first_run;
char buffer[512];
FBSTRING src = { &buffer[0], 0, 0 };
DBG_ASSERT( dst!=NULL );
buffer_len = sizeof(buffer);
first_run = TRUE;
FB_LOCK();
if( pfnReadString == NULL )
pfnReadString = hWrapper;
found = FALSE;
while (!found)
{
memset( buffer, 0, buffer_len );
if( pfnReadString( buffer, sizeof( buffer ), fp ) == NULL )
{
/* EOF reached ... this is not an error !!! */
res = FB_RTERROR_ENDOFFILE; /* but we have to notify the caller */
if( first_run )
fb_StrDelete( dst );
break;
}
/* the last character always is NUL */
buffer_len = sizeof(buffer) - 1;
/* now let's find the end of the buffer */
while (buffer_len--)
{
char ch = buffer[buffer_len];
if (ch==13 || ch==10)
{
/* accept both CR and LF */
found = TRUE;
break;
}
else if( ch!=0 )
{
/* a character other than CR/LF found ... i.e. buffer full */
break;
}
}
int tmp_buf_len;
if( !found )
{
/* remember the real length */
tmp_buf_len = buffer_len += 1;
/* not found ... so simply add this to the result string */
}
else
{
/* remember the real length */
tmp_buf_len = buffer_len + 1;
/* filter a (possibly valid) CR/LF sequence */
if( buffer[buffer_len]==10 && buffer_len!=0 )
{
if( buffer[buffer_len-1]==13 )
{
--buffer_len;
}
}
/* set the CR or LF to NUL */
buffer[buffer_len] = 0;
}
src.size = src.len = buffer_len;
/* assign or concatenate */
if( first_run )
fb_StrAssign( dst, -1, &src, -1, FALSE );
else
fb_StrConcatAssign( dst, -1, &src, -1, FALSE );
first_run = FALSE;
buffer_len = tmp_buf_len;
}
FB_UNLOCK();
return res;
}
/*:::::*/
int fb_ConsoleLineInput( FBSTRING *text, void *dst, int dst_len, int fillrem,
int addquestion, int addnewline )
{
int res;
size_t len;
int old_x, old_y;
fb_PrintBufferEx( NULL, 0, FB_PRINT_FORCE_ADJUST );
fb_GetXY( &old_x, &old_y );
FB_LOCK();
if( text != NULL )
{
if( text->data != NULL )
{
fb_PrintString( 0, text, 0 );
}
/* del if temp */
else
{
fb_hStrDelTemp( text );
}
if( addquestion != FB_FALSE )
{
fb_PrintFixString( 0, pszDefaultQuestion, 0 );
}
}
{
/* create temporary string */
FBSTRING str_result = { 0 };
res = fb_DevFileReadLineDumb( stdin, &str_result, hWrapper );
len = FB_STRSIZE(&str_result);
/* We have to handle the NEWLINE stuff here because we *REQUIRE*
* the *COMPLETE* temporary input string for the correct position
* adjustment. */
if( !addnewline ) {
/* This is the easy and dumb method to do the position adjustment.
* The problem is that it doesn't take TAB's into account. */
int cols, rows;
int old_y;
fb_GetSize( &cols, &rows );
fb_GetXY( NULL, &old_y );
old_x += len - 1;
old_x %= cols;
old_x += 1;
old_y -= 1;
fb_Locate( old_y, old_x, -1, 0, 0 );
}
/* add contents of tempporary string to result buffer */
fb_StrAssign( dst, dst_len, (void *)&str_result, -1, fillrem );
fb_StrDelete( &str_result );
}
FB_UNLOCK();
return res;
}
