MODULE check_if_answer_is_complete (THREAD *thread)
{
Bool
complete;
tcb = thread-> tcb; /* Point to thread's context */
complete = rdns_check_answer_size (tcb-> query, (dbyte)tcb-> readsize);
if (complete == FALSE)
raise_exception (read_more_event);
}
void helper_boundl(CPUX86State *env, target_ulong a0, int v)
{
int low, high;
low = cpu_ldl_data(env, a0);
high = cpu_ldl_data(env, a0 + 4);
if (v < low || v > high) {
raise_exception(env, EXCP05_BOUND);
}
}
const InputEventDefinition&
ControllerDescription::get_definition(int id) const
{
std::map<int, InputEventDefinition>::const_iterator i = id_to_event.find(id);
if (i == id_to_event.end())
{
raise_exception(std::runtime_error, "Unknown event id");
}
return i->second;
}
/**
* Called by Java's Socket::getLongSockopt(int option).
*/
JNIEXPORT jlong JNICALL Java_org_zeromq_ZMQ_00024Socket_getLongSockopt (JNIEnv *env,
jobject obj,
jint option)
{
switch (option) {
#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(2,1,0)
case ZMQ_TYPE:
case ZMQ_FD:
case ZMQ_EVENTS:
case ZMQ_LINGER:
#endif
case ZMQ_HWM:
case ZMQ_SWAP:
case ZMQ_AFFINITY:
case ZMQ_RATE:
case ZMQ_RECOVERY_IVL:
case ZMQ_MCAST_LOOP:
case ZMQ_SNDBUF:
case ZMQ_RCVBUF:
case ZMQ_RCVMORE:
{
void *s = get_socket (env, obj, 1);
jlong ret = 0;
int rc = 0;
int err = 0;
uint64_t optval = 0;
size_t optvallen = sizeof(optval);
rc = zmq_getsockopt (s, option, &optval, &optvallen);
err = zmq_errno();
ret = (jlong) optval;
if (rc != 0) {
raise_exception (env, err);
return 0L;
}
return ret;
}
default:
raise_exception (env, EINVAL);
return 0L;
}
}
/** @brief Checks whether an OpenCL error has occured.
*
* Do not use this function directly, use the macro CL_ERROR_CHECK instead.
*/
static void checkError(cl_int err, const std::string & file, const std::string & func, int line)
{
if (err != CL_SUCCESS)
{
#ifdef VIENNACL_DEBUG_ALL
std::cerr << "ViennaCL: Error " << err << " in function " << func << " ( "<< file << ":" << line << " ) " << std::endl;
#endif
raise_exception(err);
}
} //checkError()
PyObject * AerospikeScan_Results(AerospikeScan * self, PyObject * args, PyObject * kwds)
{
PyObject * py_policy = NULL;
as_policy_scan scan_policy;
as_policy_scan * scan_policy_p = NULL;
static char * kwlist[] = {"policy", NULL};
if ( PyArg_ParseTupleAndKeywords(args, kwds, "|O:results", kwlist, &py_policy) == false ) {
return NULL;
}
as_error err;
as_error_init(&err);
if (!self || !self->client->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->client->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
// Convert python policy object to as_policy_scan
pyobject_to_policy_scan(&err, py_policy, &scan_policy, &scan_policy_p,
&self->client->as->config.policies.scan);
if ( err.code != AEROSPIKE_OK ) {
as_error_update(&err, err.code, NULL);
goto CLEANUP;
}
PyObject * py_results = NULL;
py_results = PyList_New(0);
PyThreadState * _save = PyEval_SaveThread();
aerospike_scan_foreach(self->client->as, &err, scan_policy_p, &self->scan, each_result, py_results);
PyEval_RestoreThread(_save);
CLEANUP:
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return py_results;
}
std::vector<std::string>
ArchiveManager::get_filenames(const std::string& zip_filename,
const ArchiveLoader** loader_out) const
{
auto loader = find_loader_by_filename(zip_filename);
if (!loader)
{
raise_exception(std::runtime_error, "failed to find loader for archive file: " << zip_filename);
}
else
{
try
{
if (loader_out) { *loader_out = loader; }
return loader->get_filenames(zip_filename);
}
catch(const std::exception& err)
{
auto new_loader = find_loader_by_magic(zip_filename);
if (!new_loader || new_loader == loader)
{
throw;
return std::vector<std::string>();
}
else
{
loader = new_loader;
if (!loader)
{
raise_exception(std::runtime_error, "failed to find loader for archive file: " << zip_filename);
}
else
{
log_warning << err.what() << std::endl;
if (loader_out) { *loader_out = loader; }
return loader->get_filenames(zip_filename);
}
}
}
}
}
void
System::create_dir(std::string directory)
{
#ifndef WIN32
log_info("System::create_dir: %1%", directory);
if (!exist(directory))
{
if (mkdir(directory.c_str(), S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP) != 0)
{
raise_exception(std::runtime_error, "System::create_dir: " << directory << ": " << strerror(errno));
}
else
{
log_info("Successfully created: %1%", directory);
}
}
#else
if (!CreateDirectory(directory.c_str(), 0))
{
DWORD dwError = GetLastError();
if (dwError == ERROR_ALREADY_EXISTS)
{
}
else if (dwError == ERROR_PATH_NOT_FOUND)
{
raise_exception(std::runtime_error,
"CreateDirectory: " << directory <<
": One or more intermediate directories do not exist; this function will only create the final directory in the path.");
}
else
{
raise_exception(std::runtime_error,
"CreateDirectory: " << directory << ": failed with error " << StringUtil::to_string(dwError));
}
}
else
{
log_info("Successfully created: %1%", directory);
}
#endif
}
/** @brief Checks whether an OpenCL error has occured.
*
* Do not use this function directly, use the macro CL_ERROR_CHECK instead.
*/
static void checkError(cl_int err,
const std::string & file,
const std::string & func,
int line)
{
if (err != CL_SUCCESS)
{
std::cerr << "OpenCL: Error " << err << " in function " << func << " ( "<< file << ":" << line << " ) " << std::endl;
raise_exception(err);
}
} //checkError()
UdevSubsystem::UdevSubsystem() :
m_udev(),
m_monitor(),
m_process_match_cb()
{
m_udev = udev_new();
if (!m_udev)
{
raise_exception(std::runtime_error, "udev init failure");
}
}
void helper_rdpmc(CPUX86State *env)
{
if ((env->cr[4] & CR4_PCE_MASK) && ((env->hflags & HF_CPL_MASK) != 0)) {
raise_exception(env, EXCP0D_GPF);
}
cpu_svm_check_intercept_param(env, SVM_EXIT_RDPMC, 0);
/* currently unimplemented */
qemu_log_mask(LOG_UNIMP, "x86: unimplemented rdpmc\n");
raise_exception_err(env, EXCP06_ILLOP, 0);
}
PingusSoundReal::PingusSoundReal() :
music_sample(0),
m_music_volume(1.0f),
m_sound_volume(1.0f),
m_master_volume(1.0f)
{
log_info("Initializing SDL audio");
if (SDL_Init(SDL_INIT_AUDIO) == -1)
{
raise_exception(std::runtime_error, "Unable to initialize SDL: " << SDL_GetError());
}
log_info("Initializing SDL_Mixer");
if (Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 4096) == -1)
{
raise_exception(std::runtime_error, "Unable to initialize SDL_Mixer: " << Mix_GetError());
}
}
static void mce_irq_ipi(void *info)
{
int cpu = smp_processor_id();
struct mce *m = this_cpu_ptr(&injectm);
if (cpumask_test_cpu(cpu, mce_inject_cpumask) &&
m->inject_flags & MCJ_EXCEPTION) {
cpumask_clear_cpu(cpu, mce_inject_cpumask);
raise_exception(m, NULL);
}
}
PyObject *EntryIterator_iternext(PyObject *self)
{
EntryIterator *entryIterator = reinterpret_cast<EntryIterator *>(self);
bool notAtEnd;
Py_BEGIN_ALLOW_THREADS
try {
notAtEnd = entryIterator->iter->hasNext();
} catch (ac::IterationInterrupted &e) {
Py_BLOCK_THREADS
PyErr_SetNone(PyExc_GeneratorExit);
return NULL;
} catch (std::runtime_error &e) {
Py_BLOCK_THREADS
raise_exception(e.what());
return NULL;
}
Py_END_ALLOW_THREADS
if (notAtEnd) {
ac::Entry e;
Py_BEGIN_ALLOW_THREADS
try {
e = entryIterator->iter->next(*entryIterator->reader->reader);
} catch (ac::IterationInterrupted &e) {
Py_BLOCK_THREADS
// XXX - throw a specific exception here
PyErr_SetNone(PyExc_GeneratorExit);
return NULL;
} catch (std::runtime_error &e) {
Py_BLOCK_THREADS
raise_exception(e.what());
return NULL;
}
Py_END_ALLOW_THREADS
PyObject *entry = Entry_new(e);
return entry;
} else {
std::string
Filesystem::get_magic(const std::string& filename)
{
char buf[512];
std::ifstream in(filename, std::ios::binary);
if (!in)
{
raise_exception(std::runtime_error, filename << ": " << strerror(errno));
}
else
{
if (!in.read(buf, sizeof(buf)))
{
raise_exception(std::runtime_error, filename << ": " << strerror(errno));
}
else
{
return std::string(buf, in.gcount());
}
}
}
void
ControllerSlotConfig::set_current_config(int num)
{
if (num >= 0 && num < static_cast<int>(m_config.size()))
{
m_current_config = num;
}
else
{
raise_exception(std::runtime_error, "argument out of range");
}
}
Button2AxisModifier*
Button2AxisModifier::from_string(const std::vector<std::string>& args)
{
if (args.size() != 3)
{
raise_exception(std::runtime_error, "BUTTON:BUTTON:AXIS required as argument");
}
else
{
return new Button2AxisModifier(args[0], args[1], args[2]);
}
}
/** Returns the id of the given name, throws on lookup failure */
int get(const T& name) const
{
typename std::map<T, int>::const_iterator it = m_name2int.find(name);
if (it == m_name2int.end())
{
raise_exception(std::runtime_error, "lookup failure for: '" << name << "'");
}
else
{
return it->second;
}
}
USBSubsystem::USBSubsystem() :
m_usb_gsource()
{
int ret = libusb_init(NULL);
if (ret != LIBUSB_SUCCESS)
{
raise_exception(std::runtime_error, "libusb_init() failed: " << usb_strerror(ret));
}
m_usb_gsource.reset(new USBGSource);
m_usb_gsource->attach(NULL);
}
SplitAxisModifier*
SplitAxisModifier::from_string(const std::vector<std::string>& args)
{
if (args.size() != 3)
{
raise_exception(std::runtime_error, "SplitAxisModifier requires three arguments");
}
else
{
return new SplitAxisModifier(args[0], args[1], args[2]);
}
}
Options
Options::from_file(const Pathname& filename)
{
FileReader reader = FileReader::parse(filename);
if (reader.get_name() != "pingus-config")
{
raise_exception(std::runtime_error, "Error: " << filename << ": not a (pingus-config) file");
}
return from_file_reader(reader);
}
int main(void) {
if (setjmp(j) == 0) {
printf("''setjmp'' is initializing ''j''\n");
raise_exception();
printf("this line should never appear\n");
}
else{
printf("''setjmp'' was just jumped into\n");
/* this code is the exception handler */
}
return 0;
}
void HELPER(ill)(CPULM32State *env)
{
#ifndef CONFIG_USER_ONLY
CPUState *cs = CPU(lm32_env_get_cpu(env));
fprintf(stderr, "VM paused due to illegal instruction. "
"Connect a debugger or switch to the monitor console "
"to find out more.\n");
qemu_system_vmstop_request(RUN_STATE_PAUSED);
cs->halted = 1;
raise_exception(env, EXCP_HALTED);
#endif
}
/**
* Called by Java's Socket::getBytesSockopt(int option).
*/
JNIEXPORT jbyteArray JNICALL Java_org_zeromq_ZMQ_00024Socket_getBytesSockopt (JNIEnv *env,
jobject obj,
jint option)
{
switch (option) {
case ZMQ_IDENTITY:
#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(3,2,0)
case ZMQ_LAST_ENDPOINT:
#endif
#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4,0,0)
case ZMQ_PLAIN_USERNAME:
case ZMQ_PLAIN_PASSWORD:
#endif
{
void *s = get_socket (env, obj);
// Warning: hard-coded limit here.
char optval[1024];
size_t optvallen = 1024;
int rc = zmq_getsockopt (s, option, optval, &optvallen);
int err = zmq_errno();
if (rc != 0) {
raise_exception (env, err);
return env->NewByteArray (0);
}
jbyteArray array = env->NewByteArray (optvallen);
if (array == NULL) {
raise_exception (env, EINVAL);
return env->NewByteArray(0);
}
env->SetByteArrayRegion (array, 0, optvallen, (jbyte*) optval);
return array;
}
default:
raise_exception (env, EINVAL);
return env->NewByteArray(0);
}
}
/**
* Issue a read on the socket.
*/
static zmq_msg_t* do_read(JNIEnv *env, jobject obj, zmq_msg_t *message, int flags)
{
void *s = get_socket (env, obj, 1);
int rc = zmq_msg_init (message);
int err = zmq_errno();
if (rc != 0) {
raise_exception (env, err);
return NULL;
}
#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(3,0,0)
rc = zmq_recvmsg (s, message, flags);
#else
rc = zmq_recv (s, message, flags);
#endif
err = zmq_errno();
if (rc < 0 && err == EAGAIN) {
rc = zmq_msg_close (message);
err = zmq_errno();
if (rc != 0) {
raise_exception (env, err);
return NULL;
}
return NULL;
}
if (rc < 0) {
raise_exception (env, err);
rc = zmq_msg_close (message);
err = zmq_errno();
if (rc != 0) {
raise_exception (env, err);
return NULL;
}
return NULL;
}
return message;
}
unsigned int
GenericLevelObj::get_attributes(std::string obj_type)
{
if (obj_type == "groundpiece")
return HAS_GPTYPE | HAS_SPRITE | CAN_ROTATE;
else if (obj_type == "hotspot")
return HAS_SPEED | HAS_PARALLAX | HAS_SPRITE | CAN_ROTATE;
else if (obj_type == "liquid")
return HAS_SPEED | HAS_REPEAT | HAS_SPRITE;
else if (obj_type == "surface-background")
return HAS_COLOR | HAS_STRETCH | HAS_PARA | HAS_SCROLL | HAS_SPRITE;
else if (obj_type == "solidcolor-background")
return HAS_COLOR | HAS_SPRITE_FAKE;
else if (obj_type == "starfield-background")
return HAS_STARFIELD | HAS_SPRITE_FAKE;
else if (obj_type == "entrance")
return HAS_DIRECTION | HAS_RELEASE_RATE | HAS_OWNER | HAS_SPRITE_FAKE;
else if (obj_type == "exit")
return HAS_OWNER | HAS_SPRITE;
else if (obj_type == "spike")
return HAS_SPRITE_FAKE;
else if (obj_type == "snow-generator" || obj_type == "snow")
return HAS_SPRITE_FAKE;
else if (obj_type == "rain-generator" || obj_type == "rain")
return HAS_SPRITE_FAKE;
else if (obj_type == "smasher")
return HAS_SPRITE_FAKE;
else if (obj_type == "laser_exit")
return HAS_SPRITE_FAKE;
else if (obj_type == "hammer")
return HAS_SPRITE_FAKE;
else if (obj_type == "teleporter")
return HAS_SPRITE_FAKE | HAS_TARGET_ID;
else if (obj_type == "teleporter-target")
return HAS_SPRITE_FAKE | HAS_ID;
else if (obj_type == "fake_exit")
return HAS_SPRITE_FAKE;
else if (obj_type == "guillotine")
return HAS_SPRITE_FAKE;
else if (obj_type == "iceblock")
return HAS_SPRITE_FAKE | HAS_REPEAT;
else if (obj_type == "conveyorbelt")
return HAS_SPRITE_FAKE | HAS_REPEAT | HAS_SPEED;
else if (obj_type == "switchdoor-door")
return HAS_SPRITE_FAKE | HAS_ID | HAS_HEIGHT;
else if (obj_type == "switchdoor-switch")
return HAS_SPRITE_FAKE | HAS_TARGET_ID;
else
{
raise_exception(std::runtime_error, "unknown object type: '" << obj_type << "'");
}
}
MODULE load_ddns_services_list (THREAD *thread)
{
char
*filename;
filename = CONFIG ("ddns:filename");
services = NULL;
switch (xml_load_file (&services, "PATH", filename, FALSE))
{
case XML_FILEERROR:
sendfmt (&operq, "ERROR",
"xiddns: cannot read '%s': %s", filename, xml_error ());
raise_exception (exception_event);
break;
case XML_LOADERROR:
sendfmt (&operq, "ERROR",
"xiddns: error in '%s': %s", filename, xml_error ());
raise_exception (exception_event);
break;
}
}
static int mce_raise_notify(unsigned int cmd, struct pt_regs *regs)
{
int cpu = smp_processor_id();
struct mce *m = &__get_cpu_var(injectm);
if (!cpumask_test_cpu(cpu, mce_inject_cpumask))
return NMI_DONE;
cpumask_clear_cpu(cpu, mce_inject_cpumask);
if (m->inject_flags & MCJ_EXCEPTION)
raise_exception(m, regs);
else if (m->status)
raise_poll(m);
return NMI_HANDLED;
}
void
Environment::add_namespace_alias(const std::string& name, NamespacePtr ns)
{
Namespaces::iterator it = m_namespaces.find(name);
if (it != m_namespaces.end())
{
raise_exception(std::runtime_error, "name conflict for symbol: " << name);
}
else
{
m_namespaces[name] = ns;
}
}
/**
* Called by Java's Socket::setBytesSockopt(int option, byte[] value).
*/
JNIEXPORT void JNICALL Java_org_zeromq_ZMQ_00024Socket_setBytesSockopt (JNIEnv *env,
jobject obj,
jint option,
jbyteArray value)
{
switch (option) {
#if (ZMQ_VERSION_MAJOR <= 3)
case ZMQ_IDENTITY:
#endif
case ZMQ_SUBSCRIBE:
case ZMQ_UNSUBSCRIBE:
{
if (value == NULL) {
raise_exception (env, EINVAL);
return;
}
void *s = get_socket (env, obj, 1);
jbyte *optval = env->GetByteArrayElements (value, NULL);
if (! optval) {
raise_exception (env, EINVAL);
return;
}
size_t optvallen = env->GetArrayLength (value);
int rc = zmq_setsockopt (s, option, optval, optvallen);
int err = zmq_errno();
env->ReleaseByteArrayElements (value, optval, 0);
if (rc != 0) {
raise_exception (env, err);
}
return;
}
default:
raise_exception (env, EINVAL);
return;
}
}
