mkxp-freebird/binding-mri/binding-util.cpp

322 lines
5.4 KiB
C++
Raw Normal View History

2013-09-01 14:27:21 +00:00
/*
** binding-util.cpp
**
** This file is part of mkxp.
**
** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
**
** mkxp is free software: you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation, either version 2 of the License, or
** (at your option) any later version.
**
** mkxp 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 General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
*/
#include "binding-util.h"
#include "sharedstate.h"
2013-09-01 14:27:21 +00:00
#include "exception.h"
#include "util.h"
#include <stdarg.h>
#include <string.h>
#include <assert.h>
2013-09-01 14:27:21 +00:00
RbData *getRbData()
{
return static_cast<RbData*>(shState->bindingData());
2013-09-01 14:27:21 +00:00
}
struct
{
RbException id;
const char *name;
} static customExc[] =
{
2013-09-03 13:22:00 +00:00
{ MKXP, "MKXPError" },
2013-09-01 14:27:21 +00:00
{ PHYSFS, "PHYSFSError" },
{ SDL, "SDLError" }
};
RbData::RbData()
{
for (size_t i = 0; i < ARRAY_SIZE(customExc); ++i)
exc[customExc[i].id] = rb_define_class(customExc[i].name, rb_eException);
exc[RGSS] = rb_define_class("RGSSError", rb_eStandardError);
exc[Reset] = rb_define_class(rgssVer >= 3 ? "RGSSReset" : "Reset", rb_eException);
2013-09-01 14:27:21 +00:00
exc[ErrnoENOENT] = rb_const_get(rb_const_get(rb_cObject, rb_intern("Errno")), rb_intern("ENOENT"));
exc[IOError] = rb_eIOError;
exc[TypeError] = rb_eTypeError;
exc[ArgumentError] = rb_eArgError;
}
RbData::~RbData()
{
}
/* Indexed with Exception::Type */
static const RbException excToRbExc[] =
{
RGSS, /* RGSSError */
ErrnoENOENT, /* NoFileError */
IOError,
TypeError,
ArgumentError,
PHYSFS, /* PHYSFSError */
2013-09-03 13:22:00 +00:00
SDL, /* SDLError */
MKXP /* MKXPError */
2013-09-01 14:27:21 +00:00
};
void raiseRbExc(const Exception &exc)
{
RbData *data = getRbData();
VALUE excClass = data->exc[excToRbExc[exc.type]];
rb_raise(excClass, "%s", exc.msg.c_str());
2013-09-01 14:27:21 +00:00
}
void
raiseDisposedAccess(VALUE self)
{
const char *klassName = RTYPEDDATA_TYPE(self)->wrap_struct_name;
char buf[32];
strncpy(buf, klassName, sizeof(buf));
buf[0] = tolower(buf[0]);
rb_raise(getRbData()->exc[RGSS], "disposed %s", buf);
}
2013-09-01 14:27:21 +00:00
int
rb_get_args(int argc, VALUE *argv, const char *format, ...)
{
char c;
VALUE *arg = argv;
va_list ap;
bool opt = false;
int argI = 0;
va_start(ap, format);
while ((c = *format++))
{
switch (c)
{
case '|' :
break;
default:
// FIXME print num of needed args vs provided
if (argc <= argI && !opt)
rb_raise(rb_eArgError, "wrong number of arguments");
2014-01-01 11:56:45 +00:00
2013-09-01 14:27:21 +00:00
break;
}
if (argI >= argc)
break;
switch (c)
{
case 'o' :
{
if (argI >= argc)
break;
VALUE *obj = va_arg(ap, VALUE*);
*obj = *arg++;
++argI;
2014-01-01 11:56:45 +00:00
2013-09-01 14:27:21 +00:00
break;
}
case 'S' :
{
if (argI >= argc)
break;
VALUE *str = va_arg(ap, VALUE*);
VALUE tmp = *arg;
if (!RB_TYPE_P(tmp, RUBY_T_STRING))
2013-09-01 14:27:21 +00:00
rb_raise(rb_eTypeError, "Argument %d: Expected string", argI);
*str = tmp;
++argI;
2014-01-01 11:56:45 +00:00
2013-09-01 14:27:21 +00:00
break;
}
case 's' :
{
if (argI >= argc)
break;
const char **s = va_arg(ap, const char**);
int *len = va_arg(ap, int*);
VALUE tmp = *arg;
if (!RB_TYPE_P(tmp, RUBY_T_STRING))
2013-09-01 14:27:21 +00:00
rb_raise(rb_eTypeError, "Argument %d: Expected string", argI);
*s = RSTRING_PTR(tmp);
*len = RSTRING_LEN(tmp);
++argI;
2014-01-01 11:56:45 +00:00
2013-09-01 14:27:21 +00:00
break;
}
case 'z' :
{
if (argI >= argc)
break;
const char **s = va_arg(ap, const char**);
VALUE tmp = *arg++;
if (!RB_TYPE_P(tmp, RUBY_T_STRING))
2013-09-01 14:27:21 +00:00
rb_raise(rb_eTypeError, "Argument %d: Expected string", argI);
*s = StringValueCStr(tmp);
2013-09-01 14:27:21 +00:00
++argI;
2014-01-01 11:56:45 +00:00
2013-09-01 14:27:21 +00:00
break;
}
case 'f' :
{
if (argI >= argc)
break;
double *f = va_arg(ap, double*);
VALUE fVal = *arg++;
2013-12-20 09:22:01 +00:00
rb_float_arg(fVal, f, argI);
2013-09-01 14:27:21 +00:00
++argI;
break;
}
case 'i' :
{
if (argI >= argc)
break;
int *i = va_arg(ap, int*);
VALUE iVal = *arg++;
2013-12-20 09:22:01 +00:00
rb_int_arg(iVal, i, argI);
2013-09-01 14:27:21 +00:00
++argI;
break;
}
case 'b' :
{
if (argI >= argc)
break;
bool *b = va_arg(ap, bool*);
VALUE bVal = *arg++;
2013-12-20 09:22:01 +00:00
rb_bool_arg(bVal, b, argI);
2013-09-01 14:27:21 +00:00
++argI;
break;
}
case 'n' :
{
if (argI >= argc)
break;
ID *sym = va_arg(ap, ID*);
VALUE symVal = *arg++;
if (!SYMBOL_P(symVal))
rb_raise(rb_eTypeError, "Argument %d: Expected symbol", argI);
*sym = SYM2ID(symVal);
++argI;
break;
}
2013-09-01 14:27:21 +00:00
case '|' :
opt = true;
break;
default:
rb_raise(rb_eFatal, "invalid argument specifier %c", c);
}
}
#ifndef NDEBUG
/* Pop remaining arg pointers off
* the stack to check for RB_ARG_END */
format--;
while ((c = *format++))
{
switch (c)
{
case 'o' :
case 'S' :
va_arg(ap, VALUE*);
break;
case 's' :
va_arg(ap, const char**);
va_arg(ap, int*);
break;
case 'z' :
va_arg(ap, const char**);
break;
case 'f' :
va_arg(ap, double*);
break;
case 'i' :
va_arg(ap, int*);
break;
case 'b' :
va_arg(ap, bool*);
break;
}
}
2013-09-01 14:27:21 +00:00
// FIXME print num of needed args vs provided
if (!c && argc > argI)
rb_raise(rb_eArgError, "wrong number of arguments");
/* Verify correct termination */
void *argEnd = va_arg(ap, void*);
(void) argEnd;
assert(argEnd == RB_ARG_END_VAL);
#endif
2013-09-01 14:27:21 +00:00
va_end(ap);
return argI;
}