void Sys_Error( const char* error, ... ) {
va_list argptr;
char string[ 1024 ];
// change stdin to non blocking
// NOTE TTimo not sure how well that goes with tty console mode
fcntl( 0, F_SETFL, fcntl( 0, F_GETFL, 0 ) & ~FNDELAY );
// don't bother do a show on this one heh
if ( ttycon_on ) {
tty_Hide();
}
va_start( argptr,error );
Q_vsnprintf( string, sizeof ( string ), error, argptr );
va_end( argptr );
fprintf( stderr, "Sys_Error: %s\n", string );
if ( GGameType & GAME_QuakeHexen ) {
ComQH_HostShutdown();
} else {
CL_Shutdown();
}
Sys_Exit( 1 ); // bk010104 - use single exit point.
}
void Sys_Error( const char *error, ...) {
va_list argptr;
char string[1024];
// change stdin to non blocking
// NOTE TTimo not sure how well that goes with tty console mode
// int on = 0;
// setsockopt(0, SOL_SOCKET, SO_NONBLOCK, &on, sizeof(int));
//jens fcntl (0, F_SETFL, fcntl (0, F_GETFL, 0) & ~FNDELAY);
// don't bother do a show on this one heh
if (ttycon_on)
{
tty_Hide();
}
CL_Shutdown ();
va_start (argptr,error);
vsprintf (string,error,argptr);
va_end (argptr);
fprintf(stderr, "Sys_Error: %s\n", string);
Sys_Exit( 1 ); // bk010104 - use single exit point.
}
void Sys_DebugPrintf( const char *fmt, ... ) {
va_list argptr;
tty_Hide();
va_start( argptr, fmt );
vprintf( fmt, argptr );
va_end( argptr );
tty_Show();
}
void Sys_Printf(const char *msg, ...) {
va_list argptr;
tty_Hide();
va_start( argptr, msg );
vprintf( msg, argptr );
va_end( argptr );
tty_Show();
}
void Sys_Print( const char *msg ) {
if (ttycon_on) {
tty_Hide();
}
fputs(msg, stderr);
if (ttycon_on) {
tty_Show();
}
}
void Sys_VPrintf( const char* fmt, va_list arg )
{
#if defined(__ANDROID__)
__android_log_vprint( ANDROID_LOG_DEBUG, "RBDoom3", fmt, arg );
#else
tty_Hide();
vprintf( fmt, arg );
tty_Show();
#endif
}
void Sys_Warn( char *warning, ... ) {
va_list argptr;
char string[1024];
va_start( argptr,warning );
vsprintf( string,warning,argptr );
va_end( argptr );
if ( ttycon_on ) {
tty_Hide();
}
fprintf( stderr, "Warning: %s", string );
if ( ttycon_on ) {
tty_Show();
}
}
void Sys_Printf( const char* fmt, ... )
{
#if defined(__ANDROID__)
va_list argptr;
char msg[4096];
va_start( argptr, fmt );
idStr::vsnPrintf( msg, sizeof( msg ), fmt, argptr );
va_end( argptr );
msg[sizeof( msg ) - 1] = '\0';
__android_log_print( ANDROID_LOG_DEBUG, "RBDoom3", msg );
#else
va_list argptr;
tty_Hide();
va_start( argptr, fmt );
vprintf( fmt, argptr );
va_end( argptr );
tty_Show();
#endif
}
/*
================
Posix_ConsoleInput
Checks for a complete line of text typed in at the console.
Return NULL if a complete line is not ready.
================
*/
char* Posix_ConsoleInput()
{
if( tty_enabled )
{
int ret;
char key;
bool hidden = false;
while( ( ret = read( STDIN_FILENO, &key, 1 ) ) > 0 )
{
if( !hidden )
{
tty_Hide();
hidden = true;
}
switch( key )
{
case 1:
input_field.SetCursor( 0 );
break;
case 5:
input_field.SetCursor( strlen( input_field.GetBuffer() ) );
break;
case 127:
case 8:
input_field.CharEvent( K_BACKSPACE );
break;
case '\n':
idStr::Copynz( input_ret, input_field.GetBuffer(), sizeof( input_ret ) );
assert( hidden );
tty_Show();
write( STDOUT_FILENO, &key, 1 );
input_field.Clear();
if( history_count < COMMAND_HISTORY )
{
history[ history_count ] = input_ret;
history_count++;
}
else
{
history[ history_start ] = input_ret;
history_start++;
history_start %= COMMAND_HISTORY;
}
history_current = 0;
return input_ret;
case '\t':
input_field.AutoComplete();
break;
case 27:
{
// enter escape sequence mode
ret = read( STDIN_FILENO, &key, 1 );
if( ret <= 0 )
{
Sys_Printf( "dropping sequence: '27' " );
tty_FlushIn();
assert( hidden );
tty_Show();
return NULL;
}
switch( key )
{
case 79:
ret = read( STDIN_FILENO, &key, 1 );
if( ret <= 0 )
{
Sys_Printf( "dropping sequence: '27' '79' " );
tty_FlushIn();
assert( hidden );
tty_Show();
return NULL;
}
switch( key )
{
case 72:
// xterm only
input_field.SetCursor( 0 );
break;
case 70:
// xterm only
input_field.SetCursor( strlen( input_field.GetBuffer() ) );
break;
default:
Sys_Printf( "dropping sequence: '27' '79' '%d' ", key );
tty_FlushIn();
assert( hidden );
tty_Show();
return NULL;
}
break;
case 91:
{
ret = read( STDIN_FILENO, &key, 1 );
if( ret <= 0 )
{
Sys_Printf( "dropping sequence: '27' '91' " );
tty_FlushIn();
assert( hidden );
tty_Show();
return NULL;
}
switch( key )
{
case 49:
{
ret = read( STDIN_FILENO, &key, 1 );
if( ret <= 0 || key != 126 )
{
Sys_Printf( "dropping sequence: '27' '91' '49' '%d' ", key );
tty_FlushIn();
assert( hidden );
tty_Show();
return NULL;
}
// only screen and linux terms
input_field.SetCursor( 0 );
break;
}
case 50:
{
ret = read( STDIN_FILENO, &key, 1 );
if( ret <= 0 || key != 126 )
{
Sys_Printf( "dropping sequence: '27' '91' '50' '%d' ", key );
tty_FlushIn();
assert( hidden );
tty_Show();
return NULL;
}
// all terms
input_field.KeyDownEvent( K_INS );
break;
}
case 52:
{
ret = read( STDIN_FILENO, &key, 1 );
if( ret <= 0 || key != 126 )
{
Sys_Printf( "dropping sequence: '27' '91' '52' '%d' ", key );
tty_FlushIn();
assert( hidden );
tty_Show();
return NULL;
}
// only screen and linux terms
input_field.SetCursor( strlen( input_field.GetBuffer() ) );
break;
}
case 51:
{
ret = read( STDIN_FILENO, &key, 1 );
if( ret <= 0 )
{
Sys_Printf( "dropping sequence: '27' '91' '51' " );
tty_FlushIn();
assert( hidden );
tty_Show();
return NULL;
}
if( key == 126 )
{
input_field.KeyDownEvent( K_DEL );
break;
}
Sys_Printf( "dropping sequence: '27' '91' '51' '%d'", key );
tty_FlushIn();
assert( hidden );
tty_Show();
return NULL;
}
case 65:
case 66:
{
// history
if( history_current == 0 )
{
history_backup = input_field;
}
if( key == 65 )
{
// up
history_current++;
}
else
{
// down
history_current--;
}
// history_current cycle:
// 0: current edit
// 1 .. Min( COMMAND_HISTORY, history_count ): back in history
if( history_current < 0 )
{
history_current = Min( COMMAND_HISTORY, history_count );
}
else
{
history_current %= Min( COMMAND_HISTORY, history_count ) + 1;
}
int index = -1;
if( history_current == 0 )
{
input_field = history_backup;
}
else
{
index = history_start + Min( COMMAND_HISTORY, history_count ) - history_current;
index %= COMMAND_HISTORY;
assert( index >= 0 && index < COMMAND_HISTORY );
input_field.SetBuffer( history[ index ] );
}
assert( hidden );
tty_Show();
return NULL;
}
case 67:
input_field.KeyDownEvent( K_RIGHTARROW );
break;
case 68:
input_field.KeyDownEvent( K_LEFTARROW );
break;
default:
Sys_Printf( "dropping sequence: '27' '91' '%d' ", key );
tty_FlushIn();
assert( hidden );
tty_Show();
return NULL;
}
break;
}
default:
Sys_Printf( "dropping sequence: '27' '%d' ", key );
tty_FlushIn();
assert( hidden );
tty_Show();
return NULL;
}
break;
}
default:
if( key >= ' ' )
{
input_field.CharEvent( key );
break;
}
Sys_Printf( "dropping sequence: '%d' ", key );
tty_FlushIn();
assert( hidden );
tty_Show();
return NULL;
}
}
if( hidden )
{
tty_Show();
}
return NULL;
}
else
{
// disabled on OSX. works fine from a terminal, but launching from Finder is causing trouble
// I'm pretty sure it could be re-enabled if needed, and just handling the Finder failure case right (TTimo)
#ifndef __APPLE__
// no terminal support - read only complete lines
int len;
fd_set fdset;
struct timeval timeout;
FD_ZERO( &fdset );
FD_SET( STDIN_FILENO, &fdset );
timeout.tv_sec = 0;
timeout.tv_usec = 0;
if( select( 1, &fdset, NULL, NULL, &timeout ) == -1 || !FD_ISSET( 0, &fdset ) )
{
return NULL;
}
len = read( 0, input_ret, sizeof( input_ret ) );
if( len == 0 )
{
// EOF
return NULL;
}
if( len < 1 )
{
Sys_Printf( "read failed: %s\n", strerror( errno ) ); // something bad happened, cancel this line and print an error
return NULL;
}
if( len == sizeof( input_ret ) )
{
Sys_Printf( "read overflow\n" ); // things are likely to break, as input will be cut into pieces
}
input_ret[ len - 1 ] = '\0'; // rip off the \n and terminate
return input_ret;
#endif
}
return NULL;
}
void Sys_VPrintf(const char *msg, va_list arg) {
tty_Hide();
vprintf(msg, arg);
tty_Show();
}
void Sys_DebugVPrintf( const char *fmt, va_list arg ) {
tty_Hide();
vprintf( fmt, arg );
tty_Show();
}
char *Sys_ConsoleInput(void)
{
// we use this when sending back commands
static char text[256];
int i;
int avail;
char key;
field_t *history;
if (ttycon && ttycon->value)
{
avail = read(0, &key, 1);
if (avail != -1)
{
// we have something
// backspace?
// NOTE TTimo testing a lot of values .. seems it's the only way to get it to work everywhere
if ((key == tty_erase) || (key == 127) || (key == 8))
{
if (tty_con.cursor > 0)
{
tty_con.cursor--;
tty_con.buffer[tty_con.cursor] = '\0';
tty_Back();
}
return NULL;
}
// check if this is a control char
if ((key) && (key) < ' ')
{
if (key == '\n')
{
// push it in history
Hist_Add(&tty_con);
strcpy(text, tty_con.buffer);
Field_Clear(&tty_con);
key = '\n';
write(1, &key, 1);
return text;
}
if (key == '\t')
{
tty_Hide();
Field_CompleteCommand( &tty_con );
// Field_CompleteCommand does weird things to the string, do a cleanup
// it adds a '\' at the beginning of the string
// cursor doesn't reflect actual length of the string that's sent back
tty_con.cursor = strlen(tty_con.buffer);
if (tty_con.cursor>0)
{
if (tty_con.buffer[0] == '\\')
{
for (i=0; i<=tty_con.cursor; i++)
{
tty_con.buffer[i] = tty_con.buffer[i+1];
}
tty_con.cursor--;
}
}
tty_Show();
return NULL;
}
avail = read(0, &key, 1);
if (avail != -1)
{
// VT 100 keys
if (key == '[' || key == 'O')
{
avail = read(0, &key, 1);
if (avail != -1)
{
switch (key)
{
case 'A':
history = Hist_Prev();
if (history)
{
tty_Hide();
tty_con = *history;
tty_Show();
}
tty_FlushIn();
return NULL;
break;
case 'B':
history = Hist_Next();
tty_Hide();
if (history)
{
tty_con = *history;
} else
{
Field_Clear(&tty_con);
}
tty_Show();
tty_FlushIn();
return NULL;
break;
case 'C':
return NULL;
case 'D':
return NULL;
}
}
}
}
Com_DPrintf("droping ISCTL sequence: %d, tty_erase: %d\n", key, tty_erase);
tty_FlushIn();
return NULL;
}
// push regular character
tty_con.buffer[tty_con.cursor] = key;
tty_con.cursor++;
// print the current line (this is differential)
write(1, &key, 1);
}
return NULL;
} else
{
int len;
fd_set fdset;
struct timeval timeout;
if (!com_dedicated || !com_dedicated->value)
return NULL;
if (!stdin_active)
return NULL;
FD_ZERO(&fdset);
FD_SET(0, &fdset); // stdin
timeout.tv_sec = 0;
timeout.tv_usec = 0;
if (select (1, &fdset, NULL, NULL, &timeout) == -1 || !FD_ISSET(0, &fdset))
{
return NULL;
}
len = read (0, text, sizeof(text));
if (len == 0)
{ // eof!
stdin_active = qfalse;
return NULL;
}
if (len < 1)
return NULL;
text[len-1] = 0; // rip off the /n and terminate
return text;
}
}
