Changeset 20816

Show
Ignore:
Timestamp:
10/05/08 23:04:37 (6 years ago)
Author:
tokuhirom
Message:

rewrite org.coderepos.mysql with macros.h

Location:
lang/cplusplus/llv8call/trunk
Files:
2 added
3 modified

Legend:

Unmodified
Added
Removed
  • lang/cplusplus/llv8call/trunk/ext/mysql/mysql.cc

    r20099 r20816  
    88#include <string> 
    99#include "v8ext.h" 
     10#include "llv8-macros.h" 
    1011#include <cassert> 
    1112 
     
    4243// instance methods 
    4344 
    44 static v8::Handle<v8::Value> _open(const v8::Arguments& args) { 
    45     assert_args(args, 4); 
     45FUNCTION(_open) 
     46    ARG_COUNT(4); 
    4647    MYSQL *conn = mysql_init(NULL); 
    47     String::Utf8Value server(args[0]); 
    48     String::Utf8Value user(args[1]); 
    49     String::Utf8Value password(args[2]); 
    50     String::Utf8Value database(args[3]); 
     48    ARG_str(server,     0); 
     49    ARG_str(user,       1); 
     50    ARG_str(password,   2); 
     51    ARG_str(database,   3); 
    5152    if (mysql_real_connect(conn, *server, *user, *password, *database, 0, NULL, 0) == NULL) { 
    5253        return throw_errmsg(conn); 
     
    5556        return args.This(); 
    5657    } 
    57 } 
    58  
    59 static v8::Handle<v8::Value> _close(const v8::Arguments& args) { 
    60     HandleScope h; 
     58END 
     59 
     60FUNCTION(_close) 
     61    ARG_COUNT(0); 
    6162    MYSQL* conn = handle<MYSQL>(args, 0); 
    6263    mysql_close(conn); 
    6364    return Undefined(); 
    64 } 
    65  
    66 static v8::Handle<v8::Value> _ping(const v8::Arguments& args) { 
    67     HandleScope h; 
     65END 
     66 
     67FUNCTION(_ping) 
     68    ARG_COUNT(0); 
    6869    MYSQL* conn = handle<MYSQL>(args, 0); 
    6970    if (mysql_ping(conn) == 0) { 
     
    7273        return False(); 
    7374    } 
    74 } 
    75  
    76 static v8::Handle<v8::Value> _get_server_version(const v8::Arguments& args) { 
    77     HandleScope h; 
     75END 
     76 
     77FUNCTION(_get_server_version) 
     78    ARG_COUNT(0); 
    7879    MYSQL* conn = handle<MYSQL>(args, 0); 
    7980    return Uint32::New(mysql_get_server_version(conn)); 
    80 } 
    81  
    82 static v8::Handle<v8::Value> _get_server_info(const v8::Arguments& args) { 
    83     HandleScope h; 
     81END 
     82 
     83FUNCTION(_get_server_info) 
     84    ARG_COUNT(0); 
    8485    MYSQL* conn = handle<MYSQL>(args, 0); 
    8586    return String::New(mysql_get_server_info(conn)); 
    86 } 
    87  
    88 static v8::Handle<v8::Value> _get_host_info(const v8::Arguments& args) { 
    89     HandleScope h; 
     87END 
     88 
     89FUNCTION(_get_host_info) 
     90    ARG_COUNT(0); 
    9091    MYSQL* conn = handle<MYSQL>(args, 0); 
    9192    return String::New(mysql_get_host_info(conn)); 
    92 } 
    93  
    94 static v8::Handle<v8::Value> _get_proto_info(const v8::Arguments& args) { 
    95     HandleScope h; 
     93END 
     94 
     95FUNCTION(_get_proto_info) 
     96    ARG_COUNT(0); 
    9697    MYSQL* conn = handle<MYSQL>(args, 0); 
    9798    return Uint32::New(mysql_get_proto_info(conn)); 
    98 } 
    99  
    100 static v8::Handle<v8::Value> _character_set_name(const v8::Arguments& args) { 
    101     HandleScope h; 
     99END 
     100 
     101FUNCTION(_character_set_name) 
     102    ARG_COUNT(0); 
    102103    MYSQL* conn = handle<MYSQL>(args, 0); 
    103104    const char *ret; 
     
    107108        return throw_errmsg(conn); 
    108109    } 
    109 } 
    110  
    111 static v8::Handle<v8::Value> _stat(const v8::Arguments& args) { 
    112     HandleScope h; 
     110END 
     111 
     112FUNCTION(_stat) 
     113    ARG_COUNT(0); 
    113114    MYSQL* conn = handle<MYSQL>(args, 0); 
    114115    return String::New(mysql_stat(conn)); 
    115 } 
    116  
    117 static v8::Handle<v8::Value> _escape_string(const v8::Arguments& args) { 
    118     HandleScope h; 
    119     MYSQL* conn = handle<MYSQL>(args, 0); 
    120     assert_args(args, 1); 
    121     String::Utf8Value src(args[0]); 
     116END 
     117 
     118FUNCTION(_escape_string) 
     119    MYSQL* conn = handle<MYSQL>(args, 0); 
     120    ARG_COUNT(1); 
     121    ARG_str(src, 0); 
    122122    char *buf = new char [src.length() * 2 + 1]; 
    123123    mysql_real_escape_string(conn, buf, *src, src.length()); 
     
    125125    delete [] buf; 
    126126    return ret; 
    127 } 
    128  
    129 static v8::Handle<v8::Value> _thread_id(const v8::Arguments& args) { 
    130     HandleScope h; 
    131     MYSQL* conn = handle<MYSQL>(args, 0); 
    132     assert_args(args, 0); 
     127END 
     128 
     129FUNCTION(_thread_id) 
     130    ARG_COUNT(0); 
     131    MYSQL* conn = handle<MYSQL>(args, 0); 
    133132    return Uint32::New( mysql_thread_id(conn) ); 
    134 } 
    135  
    136 static v8::Handle<v8::Value> _kill(const v8::Arguments& args) { 
    137     HandleScope h; 
    138     MYSQL* conn = handle<MYSQL>(args, 0); 
    139     assert_args(args, 1); 
    140     if (mysql_kill(conn, args[0]->Uint32Value()) == 0) { 
     133END 
     134 
     135FUNCTION(_kill) 
     136    ARG_COUNT(1); 
     137    ARG_uint(thread, 0); 
     138    MYSQL* conn = handle<MYSQL>(args, 0); 
     139    if (mysql_kill(conn, thread) == 0) { 
    141140        return Undefined(); 
    142141    } else { 
    143142        return throw_errmsg(conn); 
    144143    } 
    145 } 
    146  
    147 static v8::Handle<v8::Value> _commit(const v8::Arguments& args) { 
    148     HandleScope h; 
     144END 
     145 
     146FUNCTION(_commit) 
     147    ARG_COUNT(0); 
    149148    MYSQL* conn = handle<MYSQL>(args, 0); 
    150149 
     
    154153        return throw_errmsg(conn); 
    155154    } 
    156 } 
    157  
    158 static v8::Handle<v8::Value> _rollback(const v8::Arguments& args) { 
    159     HandleScope h; 
     155END 
     156 
     157FUNCTION(_rollback) 
     158    ARG_COUNT(0); 
    160159    MYSQL* conn = handle<MYSQL>(args, 0); 
    161160 
     
    165164        return throw_errmsg(conn); 
    166165    } 
    167 } 
    168  
    169 static v8::Handle<v8::Value> _cursor(const v8::Arguments& args) { 
    170     HandleScope h; 
     166END 
     167 
     168FUNCTION(_cursor) 
    171169    MYSQL* conn = handle<MYSQL>(args, 0); 
    172170 
     
    175173    obj->SetInternalField(1, Undefined()); 
    176174    return obj; 
    177 } 
     175END 
    178176 
    179177///////////////////////////////////////////////////////////// 
    180178// statement method 
    181179 
    182 static v8::Handle<v8::Value> _cursor_execute(const v8::Arguments& args) { 
    183     HandleScope h; 
    184     MYSQL* conn = handle<MYSQL>(args, 0); 
    185     assert_args(args, 1); 
    186     String::Utf8Value str(args[0]); 
     180FUNCTION(_cursor_execute) 
     181    MYSQL* conn = handle<MYSQL>(args, 0); 
     182    ARG_COUNT(1); 
     183    ARG_str(str, 0); 
    187184    if (mysql_real_query(conn, *str, str.length()) == 0) { 
    188185        MYSQL_RES * res = mysql_use_result(conn); 
     
    192189        return throw_errmsg(conn); 
    193190    } 
    194 } 
    195  
    196 static v8::Handle<v8::Value> _cursor_fetchall(const v8::Arguments& args) { 
    197     HandleScope h; 
     191END 
     192 
     193FUNCTION(_cursor_fetchall) 
    198194    v8::Local<v8::Value> field = args.This()->GetInternalField(1); 
    199195    if (field->IsExternal()) { 
     
    215211        return ThrowException(String::New("send query first")); 
    216212    } 
    217 } 
    218  
    219 static v8::Handle<v8::Value> _cursor_fetchone(const v8::Arguments& args) { 
    220     HandleScope h; 
     213END 
     214 
     215FUNCTION(_cursor_fetchone) 
    221216    v8::Local<v8::Value> field = args.This()->GetInternalField(1); 
    222217    if (field->IsExternal()) { 
     
    238233        return ThrowException(String::New("send query first")); 
    239234    } 
    240 } 
    241  
    242 static v8::Handle<v8::Value> _cursor_close(const v8::Arguments& args) { 
    243     HandleScope h; 
     235END 
     236 
     237FUNCTION(_cursor_close) 
    244238    v8::Local<v8::Value> field = args.This()->GetInternalField(1); 
    245239    if (field->IsExternal()) { 
     
    249243    } 
    250244    return Undefined(); 
    251 } 
     245END 
    252246 
    253247///////////////////////////////////////////////////////////// 
    254248// class methods 
    255249 
    256 static v8::Handle<v8::Value> _get_client_version(const v8::Arguments& args) { 
     250FUNCTION(_get_client_version) 
     251    ARG_COUNT(0); 
    257252    HandleScope h; 
    258253    return Uint32::New(mysql_get_client_version()); 
    259 } 
    260  
    261 static v8::Handle<v8::Value> _get_client_info(const v8::Arguments& args) { 
     254END 
     255 
     256FUNCTION(_get_client_info) 
    262257    HandleScope h; 
    263258    return String::New(mysql_get_client_info()); 
    264 } 
     259END 
    265260 
    266261///////////////////////////////////////////////////////////// 
    267262// initializer 
    268 V8EXTINIT_FUNC  
    269 Handle<Value> instantiate() { 
    270     HandleScope scope; 
    271     Handle<Object> target = Object::New(); 
    272  
    273     Handle<FunctionTemplate> ft = FunctionTemplate::New(_open); 
    274     ft->Set(String::New("GetClientVersion"), FunctionTemplate::New(_get_client_version)); 
    275     ft->Set(String::New("GetClientInfo"),    FunctionTemplate::New(_get_client_info)); 
    276     ft->SetClassName(String::New("MySQL")); 
    277     Handle<ObjectTemplate>   ot = ft->InstanceTemplate(); 
    278     ot->Set(String::New("Close"),            FunctionTemplate::New(_close)); 
    279     ot->Set(String::New("Commit"),           FunctionTemplate::New(_commit)); 
    280     ot->Set(String::New("Rollback"),         FunctionTemplate::New(_rollback)); 
    281     ot->Set(String::New("Ping"),             FunctionTemplate::New(_ping)); 
    282     ot->Set(String::New("Stat"),             FunctionTemplate::New(_stat)); 
    283     ot->Set(String::New("GetServerVersion"), FunctionTemplate::New(_get_server_version)); 
    284     ot->Set(String::New("GetServerInfo"),    FunctionTemplate::New(_get_server_info)); 
    285     ot->Set(String::New("GetHostInfo"),      FunctionTemplate::New(_get_host_info)); 
    286     ot->Set(String::New("GetProtoInfo"),     FunctionTemplate::New(_get_proto_info)); 
    287     ot->Set(String::New("CharacterSetName"), FunctionTemplate::New(_character_set_name)); 
    288     ot->Set(String::New("EscapeString"),     FunctionTemplate::New(_escape_string)); 
    289     ot->Set(String::New("ThreadID"),         FunctionTemplate::New(_thread_id)); 
    290     ot->Set(String::New("Kill"),             FunctionTemplate::New(_kill)); 
    291     ot->Set(String::New("Cursor"),           FunctionTemplate::New(_cursor)); 
    292     ot->SetInternalFieldCount(1); 
    293     target->Set( 
    294         String::New("MySQL"), 
    295         ft->GetFunction(), 
    296         PropertyAttribute(ReadOnly | DontDelete) 
    297     ); 
    298  
     263 
     264MODULE() 
    299265    { 
    300         Handle<FunctionTemplate> stmt = FunctionTemplate::New(); 
    301         stmt->SetClassName(String::New("MySQL.Cursor")); 
    302         Handle<ObjectTemplate> ot = stmt->InstanceTemplate(); 
    303         ot->SetInternalFieldCount(2); 
    304         ot->Set( String::New("Close"),    FunctionTemplate::New(_cursor_close) ); 
    305         ot->Set( String::New("Execute"),  FunctionTemplate::New(_cursor_execute) ); 
    306         ot->Set( String::New("FetchAll"), FunctionTemplate::New(_cursor_fetchall) ); 
    307         ot->Set( String::New("FetchOne"), FunctionTemplate::New(_cursor_fetchone) ); 
    308         target->Set( 
    309             String::New("Cursor"), 
    310             stmt->GetFunction(), 
    311             PropertyAttribute(ReadOnly | DontDelete) 
    312         ); 
    313     } 
    314  
    315     return target; 
    316 } 
    317  
     266        CLASS_WITH_CONSTRUCTOR(_open); 
     267        BIND_CM("GetClientVersion", _get_client_version); 
     268        BIND_CM("GetClientInfo",    _get_client_info); 
     269        BIND_IM("Close",            _close); 
     270        BIND_IM("Commit",           _commit); 
     271        BIND_IM("Rollback",         _rollback); 
     272        BIND_IM("Ping",             _ping); 
     273        BIND_IM("Stat",             _stat); 
     274        BIND_IM("GetServerVersion", _get_server_version); 
     275        BIND_IM("GetServerInfo",    _get_server_info); 
     276        BIND_IM("GetHostInfo",      _get_host_info); 
     277        BIND_IM("GetProtoInfo",     _get_proto_info); 
     278        BIND_IM("CharacterSetName", _character_set_name); 
     279        BIND_IM("EscapeString",     _escape_string); 
     280        BIND_IM("ThreadID",         _thread_id); 
     281        BIND_IM("Kill",             _kill); 
     282        BIND_IM("Cursor",           _cursor); 
     283        INTERNALCOUNT(1); 
     284        EXPORT_CLASS("MySQL"); 
     285    } 
     286 
     287    { 
     288        CLASS(); 
     289        BIND_IM("Close",    _cursor_close); 
     290        BIND_IM("Execute",  _cursor_execute); 
     291        BIND_IM("FetchAll", _cursor_fetchall); 
     292        BIND_IM("FetchOne", _cursor_fetchone); 
     293        INTERNALCOUNT(2); 
     294        EXPORT_CLASS("Cursor"); 
     295    } 
     296ENDMODULE 
  • lang/cplusplus/llv8call/trunk/manual/articles/about-llv8call.html

    r20809 r20816  
    6767        <div> 
    6868            libv8.so とか libv8.dylib とかを /usr/local/lib/ などに置けば、<pre>./out/bin/llv8call</pre> で起動できる 
    69             です。 
     69            です。out/ 以下を /usr/local/lib/llv8call/ などにrename してつかうとよいです。 
    7070        </div> 
    7171 
  • lang/cplusplus/llv8call/trunk/manual/ext/index.html

    r20805 r20816  
    1919        <ul> 
    2020            <li><a href="clearsilver/clearsilver.html">clearsilver.clearsilver</a></li> 
     21            <li><a href="sqlite3/sqlite3.html">sqlite3.sqlite3</a></li> 
    2122            <li><a href="fs/dir.html">fs.dir</a></li> 
    2223            <li><a href="fs/file.html">fs.file</a></li> 
    2324            <li><a href="libmemcached/libmemcached.html">libmemcached.libmemcached</a></li> 
     25            <li><a href="mysql/mysql.html">mysql.mysql</a></li> 
    2426            <li><a href="shttpd/shttpd.html">shttpd.shttpd</a></li> 
    25             <li><a href="sqlite3/sqlite3.html">sqlite3.sqlite3</a></li> 
    2627        </ul> 
    2728        <a href="../index.html">up</a>