v8 javascript SHELL

参照SHELL例子,写了一个类似编译器一样的东西,其中加了GBK->UTF8转码..可以用EDITPLUS直接写JAVASCRIPT了..

v8shell-3.19.9.7z

#include <windows.h>
#include <iostream>
#include <algorithm>
#include <string>
#include <sstream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <cassert>

#include <v8.h>

using namespace v8;
using namespace std;



// GBK->UTF-8    (WIN32)
Handle<String> ConvertGBKToUTF8( const char* str )
{
    int alen;
    if ( str == NULL || ( alen = strlen( str ) ) == 0 )
    {
        return Handle<String>();
    }

    int wlen = MultiByteToWideChar( CP_ACP, 0, str, alen, NULL, 0 );
    if ( wlen == 0 )
    {
        return Handle<String>();
    }

    wchar_t* lpw = ( wchar_t* )malloc( wlen * sizeof( wchar_t ) );
    if ( lpw == NULL )
    {
        return Handle<String>();
    }

    int ret = MultiByteToWideChar( CP_ACP, 0, str, alen, lpw, wlen );
    if ( ret != wlen )
    {
        free( lpw );
        return Handle<String>();
    }

    alen = WideCharToMultiByte( CP_UTF8, 0, lpw, wlen, NULL, 0, NULL, NULL );
    if ( alen == 0 )
    {
        free( lpw );
        return Handle<String>();
    }

    char* lpa = ( char* )calloc( 1, ( alen + 1 ) * sizeof( char ) );
    if ( lpa == NULL )
    {
        free( lpw );
        return Handle<String>();
    }

    ret = WideCharToMultiByte ( CP_UTF8, 0, lpw, wlen, lpa, alen, NULL, NULL );
    if ( ret != alen )
    {
        free( lpw );
        free( lpa );
        return Handle<String>();
    }

    Handle<String> utf8str = String::New( lpa );

    free( lpw );
    free( lpa );
    return utf8str;
}

// 读取文件,并由GBK改为UTF-8    (WIN32)
Handle<String> ReadScript( const char* lpszFile )
{
    HANDLE hFile = ::CreateFile( lpszFile, GENERIC_READ, FILE_SHARE_READ, \
                                 NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
    if ( hFile == INVALID_HANDLE_VALUE )
    {
        return Handle<String>();
    }

    DWORD dwFileSize = ::GetFileSize( hFile, NULL );
    if ( dwFileSize == INVALID_FILE_SIZE )
    {
        ::CloseHandle( hFile );
        return Handle<String>();
    }

    char* lpData = ( char* )calloc( 1, ( dwFileSize + 1 ) * sizeof( char ) );
    if ( lpData == NULL )
    {
        ::CloseHandle( hFile );
        return Handle<String>();
    }

    DWORD dwBytes;
    BOOL bRet = ::ReadFile( hFile, ( LPVOID )lpData, dwFileSize, &dwBytes, NULL );
    if ( !bRet || dwBytes != dwFileSize )
    {
        free( lpData );
        ::CloseHandle( hFile );
        return Handle<String>();
    }

    ::CloseHandle( hFile );

    Handle<String> scriptText = ConvertGBKToUTF8( lpData );

    free( lpData );

    return scriptText;
}


// UTF-8->GBK    (WIN32)
string ConvertUTF8ToGBK( const char* str )
{
    string gbk;

    int alen;
    if ( str == NULL || ( alen = strlen( str ) ) == 0 )
    {
        return gbk;
    }

    int wlen = MultiByteToWideChar( CP_UTF8, 0, str, alen, NULL, 0 );
    if ( wlen == 0 )
    {
        return gbk;
    }

    wchar_t* lpw = ( wchar_t* )malloc( wlen * sizeof( wchar_t ) );
    if ( lpw == NULL )
    {
        return gbk;
    }

    int ret = MultiByteToWideChar( CP_UTF8, 0, str, alen, lpw, wlen );
    if ( ret != wlen )
    {
        free( lpw );
        return gbk;
    }

    alen = WideCharToMultiByte( CP_ACP, 0, lpw, wlen, NULL, 0, NULL, NULL );
    if ( alen == 0 )
    {
        free( lpw );
        return gbk;
    }

    char* lpa = ( char* )malloc( alen * sizeof( char ) );
    if ( lpa == NULL )
    {
        free( lpw );
        return gbk;
    }

    ret = WideCharToMultiByte ( CP_ACP, 0, lpw, wlen, lpa, alen, NULL, NULL );
    if ( ret != alen )
    {
        free( lpw );
        free( lpa );
        return gbk;
    }

    gbk.assign( lpa, alen );

    free( lpw );
    free( lpa );
    return gbk;
}



Handle<Value> Print( const Arguments& args )
{
    bool first = true;
    Isolate* isolate = args.GetIsolate();
    stringstream ss;
    int cnt = 0;

    int len = args.Length();
    for ( int i = 0; i < len; i ++ )
    {
        HandleScope handle_scope( isolate );
        if ( first )
        {
            first = false;
        }
        else
        {
            ss << " ";
        }

        cnt ++;

        if ( args[i]->IsString() )
        {
            ss << ConvertUTF8ToGBK( *String::Utf8Value( args[i] ) );
        }
        else if ( args[i]->IsInt32() )
        {
            ss << args[i]->Int32Value();
        }
        else if ( args[i]->IsNumber() )
        {
            ss << args[i]->NumberValue();
        }
        else if ( args[i]->IsBoolean() )
        {
            if ( args[i]->BooleanValue() )
            {
                ss << "true";
            }
            else
            {
                ss << "false";
            }
        }
        else
        {
            ss << "<undefined>";
            cnt --;
        }
    }

    cout << ss.str() << endl;

    return Integer::New( cnt );
}


void ReportException( Isolate* isolate, TryCatch* try_catch )
{
    HandleScope handle_scope( isolate );
    String::Utf8Value exception( try_catch->Exception() );
    Handle<Message> message = try_catch->Message();
    stringstream ss;

    if ( message.IsEmpty() )
    {
        cerr << ConvertUTF8ToGBK( *exception ) << endl;
        return;
    }


    String::Utf8Value filename( message->GetScriptResourceName() );
    ss << ConvertUTF8ToGBK( *filename ) << ':';
    ss << message->GetLineNumber() << ':';
    ss << ConvertUTF8ToGBK( *exception ) << '\n';

    Handle<Value> stack = try_catch->StackTrace();
    if ( !stack.IsEmpty() )
    {
        String::Utf8Value sstack( stack );
        ss << ConvertUTF8ToGBK( *sstack ) << '\n';
    }

    cout << ss.str();
}

// 版本信息
Handle<Value> Version( const Arguments& args )
{
    return String::New( V8::GetVersion() );
}

// 压入自定义函数, 并创建上下文
Handle<Context> CreateContext( Isolate* isolate )
{
    Handle<ObjectTemplate> global = ObjectTemplate::New();
    global->Set( String::New( "print" ), FunctionTemplate::New( Print ) );
    global->Set( String::New( "version" ), FunctionTemplate::New( Version ) );

    return Context::New( isolate, NULL, global );
}


int main( int argc, char* argv[] )
{
    if ( argc == 1 )
    {
        return -1;
    }

    V8::SetFlagsFromCommandLine( &argc, argv, true );
    Isolate* isolate = Isolate::GetCurrent();

    {
        HandleScope handle_scope( isolate );
        Handle<Context> context = CreateContext( isolate );
        if ( context.IsEmpty() )
        {
            fprintf( stderr, "Error creating context\n" );
            return 1;
        }

        Context::Scope context_scope( context );

        Handle<String> file_name = ConvertGBKToUTF8( argv[1] );

        Handle<String> source = ReadScript( argv[1] );
        if ( !source.IsEmpty() )
        {
            TryCatch try_catch;
            Handle<Script> script = Script::Compile( source, file_name );
            if ( !script.IsEmpty() )
            {
                Handle<Value> result = script->Run();
                if ( result.IsEmpty() )
                {
                    ReportException( isolate, &try_catch );
                }
            }
            else
            {
                ReportException( isolate, &try_catch );
            }
        }
    }

    V8::Dispose();
    return 0;
}