root/lang/cplusplus/fcgi-v8/trunk/src/core.cc @ 18872

#include <v8.h>
#include <cstdio>
#include <cstdlib>
#include <memory.h>
#include <curl/curl.h>
#include <iconv.h>
#include <errno.h>
#include "v8-util.h"

extern int __argc;
extern char ** __argv;

extern v8::Handle<v8::Value> UrlFetch(const v8::Arguments& args);

int utf_char2bytes(int c, unsigned char* buf) {
    if (c < 0x80) {
        buf[0] = c;
        return 1;
    }
    if (c < 0x800) {
        buf[0] = 0xc0 + ((unsigned)c >> 6);
        buf[1] = 0x80 + (c & 0x3f);
        return 2;
    }
    if (c < 0x10000) {
        buf[0] = 0xe0 + ((unsigned)c >> 12);
        buf[1] = 0x80 + (((unsigned)c >> 6) & 0x3f);
        buf[2] = 0x80 + (c & 0x3f);
        return 3;
    }
    if (c < 0x200000) {
        buf[0] = 0xf0 + ((unsigned)c >> 18);
        buf[1] = 0x80 + (((unsigned)c >> 12) & 0x3f);
        buf[2] = 0x80 + (((unsigned)c >> 6) & 0x3f);
        buf[3] = 0x80 + (c & 0x3f);
        return 4;
    }
    if (c < 0x4000000) {
        buf[0] = 0xf8 + ((unsigned)c >> 24);
        buf[1] = 0x80 + (((unsigned)c >> 18) & 0x3f);
        buf[2] = 0x80 + (((unsigned)c >> 12) & 0x3f);
        buf[3] = 0x80 + (((unsigned)c >> 6) & 0x3f);
        buf[4] = 0x80 + (c & 0x3f);
        return 5;
    }
    /* 31 bits */
    buf[0] = 0xfc + ((unsigned)c >> 30);
    buf[1] = 0x80 + (((unsigned)c >> 24) & 0x3f);
    buf[2] = 0x80 + (((unsigned)c >> 18) & 0x3f);
    buf[3] = 0x80 + (((unsigned)c >> 12) & 0x3f);
    buf[4] = 0x80 + (((unsigned)c >> 6) & 0x3f);
    buf[5] = 0x80 + (c & 0x3f);
    return 6;
}

char* ucs2utf_alloc(uint16_t *instr) {
    uint16_t *p = instr;
    int inlen = 0;

    while(*p++) inlen++;
    char* outstr = new char[inlen * MB_LEN_MAX];
    char* outp = outstr;
    memset(outstr, 0, inlen * MB_LEN_MAX);

    p = instr;
    while (*p) outstr += utf_char2bytes(*p++, (unsigned char*) outstr);
    return outp;
}

v8::Handle<v8::Value> P(const v8::Arguments& args) {
    for (int i = 0; i < args.Length(); i++) {
        v8::HandleScope handle_scope;
        v8::String::Value val(args[i]);
        char* buf = ucs2utf_alloc(*val);
        printf("%s", buf);
        delete[] buf;
    }
    printf("\n");
    return v8::Undefined();
}

v8::Handle<v8::Value> Print(const v8::Arguments& args) {
    for (int i = 0; i < args.Length(); i++) {
        v8::HandleScope handle_scope;
        v8::String::Value val(args[i]);
        char* buf = ucs2utf_alloc(*val);
        printf("%s", buf);
        delete[] buf;
    }
    printf("\n");
    return v8::Undefined();
}

v8::Handle<v8::Value> Say(const v8::Arguments& args) {
    for (int i = 0; i < args.Length(); i++) {
        v8::HandleScope handle_scope;
        v8::String::Value val(args[i]);
        char* buf = ucs2utf_alloc(*val);
        printf("%s", buf);
        delete[] buf;
    }
    return v8::Undefined();
}

v8::Handle<v8::Value> Require(const v8::Arguments& args) {
    for (int i = 0; i < args.Length(); i++) {
        v8::HandleScope handle_scope;
        v8::String::AsciiValue file(args[i]);
        v8::Handle<v8::String> source = ReadFile(*file);
        if (source.IsEmpty()) {
            return v8::ThrowException(v8::String::New("Error loading file"));
        }
        ExecuteString(source, v8::String::New(*file), false);
    }
    return v8::Undefined();
}

v8::Handle<v8::Value> Exit(const v8::Arguments& args) {
    int exit_code = args[0]->Int32Value();
    exit(exit_code);
    return v8::Undefined();
}

v8::Handle<v8::Value> Version(const v8::Arguments& args) {
    return v8::String::New(v8::V8::GetVersion());
}

v8::Handle<v8::Value> GetEnv(const v8::Arguments& args) {
    v8::HandleScope handle_scope;
    v8::String::AsciiValue str(args[0]);
    const char * env = getenv(*str);
    return env ? v8::String::New(env) : v8::Undefined();
}

// TODO: cache? or store to global variables?
v8::Handle<v8::Value> ARGV(const v8::Arguments& args) {
    v8::HandleScope handle_scope;
    v8::Local<v8::Array> array = v8::Array::New();
    for (int i=0; i<__argc; i++) {
        array->Set(v8::Integer::New(i), v8::String::New(__argv[i]));
    }
    return array;
}

void setup_core(v8::Handle<v8::ObjectTemplate> target) {
    target->Set(v8::String::New("p"), v8::FunctionTemplate::New(P));
    target->Set(v8::String::New("print"), v8::FunctionTemplate::New(Print));
    target->Set(v8::String::New("say"), v8::FunctionTemplate::New(Say));
    target->Set(v8::String::New("getenv"), v8::FunctionTemplate::New(GetEnv));
    target->Set(v8::String::New("require"), v8::FunctionTemplate::New(Require));
    target->Set(v8::String::New("exit"), v8::FunctionTemplate::New(Exit));
    target->Set(v8::String::New("version"), v8::FunctionTemplate::New(Version));
    target->Set(v8::String::New("getargv"), v8::FunctionTemplate::New(ARGV));
    target->Set(v8::String::New("urlfetch"), v8::FunctionTemplate::New(UrlFetch));
}