root/trunk/thune/console.c

/*============================================================================
    Thune Interpreter
    Copyright (C) 2005-2007  Karl Robillard

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
===========================================================================*/


#include <assert.h>
#include <stdio.h>
#include "urlan.h"


#if defined(LANG_RUNE)
#define APPNAME     "Rune"
#define CUSTOM_DT           0
#define CUSTOM_DT_COUNT     0

#elif defined(THUNE_GL)

#include "gx.h"
#define APPNAME     "Thune-GL"
#define CUSTOM_DT           ug_datatypes
#define CUSTOM_DT_COUNT     UG_DT_COUNT

#else

#define APPNAME     "Thune"
#define CUSTOM_DT           0
#define CUSTOM_DT_COUNT     0
#endif


#define ESC         27
#define PRINT_MAX   156
#define HALT_RESET  ut->callOp = 0


void usage( char* arg0 )
{
    printf( APPNAME " %s (%s)\n\n", UR_VERSION_STR, __DATE__ );
    printf( "Usage: %s [options] [script [script args]]\n\n", arg0 );
    printf( "Options:\n"
            "  -s     Disable security\n"
            "  -h     Show this help and exit\n"
          );
}


int quitResult( UThread* ut )
{
    UCell* val = ur_result( ut, 0 );
    return ur_sel(val);
}


#if 0
static const char* exceptionName( int type )
{
    switch( type )
    {
        case UR_EX_DATATYPE: return "Datatype";
        case UR_EX_SCRIPT:   return "Script";
        case UR_EX_SYNTAX:   return "Syntax";
        case UR_EX_ACCESS:   return "Access";
        case UR_EX_INTERNAL: return "Internal";
        default:             return "?";
    }
}
#endif


static void reportError( UThread* ut )
{
    UString* str;
#if 0
    UCell* val;
    val = ur_result( ut, 0 );
    str = ur_binPtr( val->err.strN );

    printf( "%s Error - %s\n",
            exceptionName( val->err.exType ),
            str->ptr.c );
#else
    str = ur_threadTmp( ut );
    str->used = 0;
    ur_toStr( ur_result(ut, 0), str, 0 );
    ur_termCStr( str );
    printf( str->ptr.c );
#endif

    //ur_threadReset( ut );
}


/*
  Returns pointer in 'to' buffer at end of copy.
*/
char* strCopy( char* to, const char* from )
{
    while( *from )
        *to++ = *from++;
    return to;
}


int main( int argc, char** argv )
{
    UrlanEnv* env;
    UThread* ut;
    char cmd[ 2048 ];
    int fileN = 0;
    int ret = 0;


    env = ur_makeEnv( CUSTOM_DT, CUSTOM_DT_COUNT );
    if( ! env )
    {
        printf( "ur_makeEnv failed\n" );
        return -1;
    }

#ifdef THUNE_GL
    if( gx_startup( env, 0, 0, 0 ) != UR_EVAL_OK )
    {
        printf( "gx_startup failed\n" );
        return -1;
    }
#endif

    ur_freezeEnv( env, 128, 256 );
    ut = ur_thread( env );

    if( argc > 1 )
    {
        int i;
        char* arg;

        for( i = 1; i < argc; ++i )
        {
            arg = argv[i];
            if( arg[0] == '-' )
            {
                switch( arg[1] )
                {
                    case 's':
                        ur_disable( env, UR_ENV_SECURE );
                        break;

                    case 'h':
                        usage( argv[0] );
                        return 0;
                }
            }
            else
            {
                fileN = i;
                break;
            }
        }
    }

    if( fileN )
    {
        char* pos;

        pos = cmd;
        cmd[ sizeof(cmd) - 1 ] = -1;

#ifdef LANG_THUNE
        if( (argc - fileN) > 1 )
        {
            int i;
            *pos++ = '[';
            for( i = fileN + 1; i < argc; ++i )
            {
                if( i > 2 )
                    *pos++ = ' ';
                *pos++ = '"';
                pos = strCopy( pos, argv[i] );
                *pos++ = '"';
            }
            pos = strCopy( pos, "] :args " );
        }
        else
        {
            pos = strCopy( pos, "none :args " );
        }
#endif

#ifdef LANG_RUNE
        pos = strCopy( pos, "do load " );
#endif
        *pos++ = '"';
        pos = strCopy( pos, argv[fileN] );
        *pos++ = '"';
#ifdef LANG_THUNE
        pos = strCopy( pos, " load do" );
#endif

        assert( cmd[ sizeof(cmd) - 1 ] == -1 && "cmd buffer overflow" );

        switch( ur_evalCStr( ut, cmd, pos - cmd ) )
        {
            case UR_EVAL_HALT:
                HALT_RESET;
                goto prompt;

            case UR_EVAL_QUIT:
                ret = quitResult( ut );
                goto quit;

            case UR_EVAL_ERROR:
                reportError( ut );
                goto prompt;
        }
    }
    else
    {
        printf( APPNAME " %s (%s)\n", UR_VERSION_STR, __DATE__ );

prompt:

        while( 1 )
        {
            printf( ")> " );
            fflush( stdout );   /* Required on Windows. */
            fgets( cmd, 128, stdin ); 

#if 0
            {
                char* cp = cmd;
                while( *cp != '\n' )
                    printf( " %d", (int) *cp++ );
                printf( "\n" );
            }
#endif

            if( cmd[0] == ESC )
            {
                // Up   27 91 65
                // Down 27 91 66
                printf( "\n" );
            }
            else if( cmd[0] != '\n' )
            {
                switch( ur_evalCStr( ut, cmd, -1 ) )
                {
                    case UR_EVAL_OK:
                    {
                        UCell* val;
                        UString str;

                        val = ur_result( ut, 0 );
                        if( ur_is(val, UT_UNSET) ||
                            ur_is(val, UT_CONTEXT) ||
                            ur_is(val, UT_FUNCTION) )
                            break;

                        ur_arrayInit( &str, 1, 0 );
                        ur_toStrT( ut, val, &str, 0 );
                        if( str.ptr.c )
                        {
                            UString* sp = &str;
                            ur_termCStr( sp );

                            if( str.used > PRINT_MAX )
                            {
                                char* cp = strCopy( str.ptr.c + PRINT_MAX - 4,
                                                    "..." );
                                *cp = '\0';
                            }

                            printf( "== %s\n", str.ptr.c );
                        }
                        ur_arrayFree( &str );
                    }
                        break;

                    case UR_EVAL_HALT:
                        HALT_RESET;
                        printf( "**halt\n" );
                        break;

                    case UR_EVAL_QUIT:
                        ret = quitResult( ut );
                        goto quit;

                    case UR_EVAL_ERROR:
                        reportError( ut );
                        ur_threadReset( ut );
                        break;
                }
            }
        }
    }

quit:

#ifdef THUNE_GL
    gx_shutdown( env );
#endif

    ur_freeEnv( env );

    return ret;
}


/*EOF*/