Object* native_file_close(Object *cxt, Object *frame, Object *self) {
FileBuffer *file_buf = get_file_buffer(self);
if ( file_buf == 0 ) {
return new_exception(cxt, frame, "Expected a file as first argument");
}
if ( file_buf->file == 0 ) {
return new_exception(cxt, frame, "File pointer is null");
}
int result = fclose(file_buf->file);
if ( result != 0 ) {
return new_errno_exception(cxt, frame, "Failed while closing file");
}
return frame;
}
// Throw an exception with a message and a cause
void Exceptions::_throw_msg_cause(Thread* thread, const char* file, int line, symbolHandle h_name, const char* message, Handle h_cause, Handle h_loader, Handle h_protection_domain) {
// Check for special boot-strapping/vm-thread handling
if (special_exception(thread, file, line, h_name, message)) return;
// Create and throw exception and init cause
Handle h_exception = new_exception(thread, h_name, message, h_cause, h_loader, h_protection_domain);
_throw(thread, file, line, h_exception, message);
}
// Creates an exception oop, calls the <init> method with the given signature.
// and returns a Handle
// Initializes the cause if cause non-null
Handle Exceptions::new_exception(Thread *thread, Symbol* name,
Symbol* signature, JavaCallArguments *args,
Handle h_cause,
Handle h_loader, Handle h_protection_domain) {
Handle h_exception = new_exception(thread, name, signature, args, h_loader, h_protection_domain);
// Future: object initializer should take a cause argument
if (h_cause.not_null()) {
assert(h_cause->is_a(SystemDictionary::Throwable_klass()),
"exception cause is not a subclass of java/lang/Throwable");
JavaValue result1(T_OBJECT);
JavaCallArguments args1;
args1.set_receiver(h_exception);
args1.push_oop(h_cause);
JavaCalls::call_virtual(&result1, h_exception->klass(),
vmSymbols::initCause_name(),
vmSymbols::throwable_throwable_signature(),
&args1,
thread);
}
// Check if another exception was thrown in the process, if so rethrow that one
if (thread->has_pending_exception()) {
h_exception = Handle(thread, thread->pending_exception());
thread->clear_pending_exception();
}
return h_exception;
}
void Exceptions::_throw_cause(Thread* thread, const char* file, int line, Symbol* name, Handle h_cause,
Handle h_loader, Handle h_protection_domain) {
// Check for special boot-strapping/vm-thread handling
if (special_exception(thread, file, line, h_cause)) return;
// Create and throw exception
Handle h_exception = new_exception(thread, name, h_cause, h_loader, h_protection_domain);
_throw(thread, file, line, h_exception, NULL);
}
void Exceptions::_throw_args(Thread* thread, const char* file, int line, Symbol* name, Symbol* signature, JavaCallArguments *args) {
// Check for special boot-strapping/vm-thread handling
if (special_exception(thread, file, line, name, NULL)) return;
// Create and throw exception
Handle h_loader(thread, NULL);
Handle h_prot(thread, NULL);
Handle exception = new_exception(thread, name, signature, args, h_loader, h_prot);
_throw(thread, file, line, exception);
}
Object* native_file_open_mode(Object *cxt, Object *frame, Object *self) {
Object *stack = get(cxt, frame, "stack");
CharArrayBuffer *file_mode_buf = get_char_array_buffer(pop(cxt, stack));
CharArrayBuffer *file_name_buf = get_char_array_buffer(pop(cxt, stack));
if ( file_name_buf == 0 ) {
return new_exception(cxt, frame, "Expected a char_array as first argument");
}
if ( file_mode_buf == 0 ) {
return new_exception(cxt, frame, "Expected a char_array as second argument");
}
FILE *fp = fopen(file_name_buf->data, file_mode_buf->data);
if ( fp == 0 ) {
return new_exception(cxt, frame, "Unable to open file");
}
else {
Object *file_object = new_file(cxt, fp);
set(cxt, file_object, "parent", self);
push(cxt, stack, file_object);
return frame;
}
}
Object* native_file_read_into_offset_length(Object *cxt, Object *frame, Object *self) {
Object *stack = get_stack(cxt, frame);
FileBuffer *file_buf = get_file_buffer(self);
Object *length_obj = pop(cxt, stack);
Object *offset_obj = pop(cxt, stack);
Object *char_array = pop(cxt, stack);
if ( file_buf == 0 ) {
return new_exception(cxt, frame, "Expected a file as self argument");
}
CharArrayBuffer *char_array_buf = get_char_array_buffer(char_array);
if ( char_array_buf == 0 ) {
return new_exception(cxt, frame, "Expected a char_array as first argument");
}
if ( ! is_boxed_int(cxt, offset_obj) ) {
return new_exception(cxt, frame, "Expected a boxed int as second argument");
}
Fixnum offset = boxed_int_to_fixnum(cxt, offset_obj);
if ( ! is_boxed_int(cxt, length_obj) ) {
return new_exception(cxt, frame, "Expected a fixnum as third argument");
}
Fixnum length = boxed_int_to_fixnum(cxt, length_obj);
if ( offset + length > char_array_buf->reserved ) {
return new_exception(cxt, frame, "Offset + length exceeds char_array length");
}
int num_read = fread(char_array_buf->data + offset, 1, length, file_buf->file);
if ( num_read >= 0 ) {
char_array_truncate_buffer(cxt, char_array, offset + num_read);
return frame;
}
else {
return new_errno_exception(cxt, frame, "Unable to read from file");
}
}
Object* native_file_eof(Object *cxt, Object *frame, Object *self) {
Object *stack = get(cxt, frame, "stack");
FileBuffer *file_buf = get_file_buffer(self);
if ( file_buf == 0 ) {
return new_exception(cxt, frame, "Expected a file as first argument");
}
if ( feof(file_buf->file) ) {
push(cxt, stack, get_true(cxt));
}
else {
push(cxt, stack, get_false(cxt));
}
return frame;
};
// Convenience method. Calls either the <init>() or <init>(Throwable) method when
// creating a new exception
Handle Exceptions::new_exception(Thread* thread, Symbol* name,
Handle h_cause,
Handle h_loader, Handle h_protection_domain,
ExceptionMsgToUtf8Mode to_utf8_safe) {
JavaCallArguments args;
Symbol* signature = NULL;
if (h_cause.is_null()) {
signature = vmSymbols::void_method_signature();
} else {
signature = vmSymbols::throwable_void_signature();
args.push_oop(h_cause);
}
return new_exception(thread, name, signature, &args, h_loader, h_protection_domain);
}
void NLog::append_to_log(LogMessage::Type type, bool fromServer,
const QString & message)
{
QString header = "[ %1 ][ %2 ] ";
QString msg;
header = header.arg(QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm:ss"));
header = header.arg(fromServer ? "Server" : "Client");
msg = message;
msg.replace('\n', QString("\n%1").arg(header));
msg.prepend(header);
emit new_message(msg, type);
if(type == LogMessage::EXCEPTION)
emit new_exception(message);
}
// Convenience method. Calls either the <init>() or <init>(String) method when
// creating a new exception
Handle Exceptions::new_exception(Thread* thread, symbolHandle h_name,
const char* message, Handle h_cause,
Handle h_loader,
Handle h_protection_domain,
ExceptionMsgToUtf8Mode to_utf8_safe) {
JavaCallArguments args;
symbolHandle signature;
if (message == NULL) {
signature = vmSymbolHandles::void_method_signature();
} else {
// We want to allocate storage, but we can't do that if there's
// a pending exception, so we preserve any pending exception
// around the allocation.
// If we get an exception from the allocation, prefer that to
// the exception we are trying to build, or the pending exception.
// This is sort of like what PRESERVE_EXCEPTION_MARK does, except
// for the preferencing and the early returns.
Handle incoming_exception (thread, NULL);
if (thread->has_pending_exception()) {
incoming_exception = Handle(thread, thread->pending_exception());
thread->clear_pending_exception();
}
Handle msg;
if (to_utf8_safe == safe_to_utf8) {
// Make a java UTF8 string.
msg = java_lang_String::create_from_str(message, thread);
} else {
// Make a java string keeping the encoding scheme of the original string.
msg = java_lang_String::create_from_platform_dependent_str(message, thread);
}
if (thread->has_pending_exception()) {
Handle exception(thread, thread->pending_exception());
thread->clear_pending_exception();
return exception;
}
if (incoming_exception.not_null()) {
return incoming_exception;
}
args.push_oop(msg);
signature = vmSymbolHandles::string_void_signature();
}
return new_exception(thread, h_name, signature, &args, h_cause, h_loader, h_protection_domain);
}
job_receiver::job_receiver(std::string the_jobfilenamepattern) {
try {
XERCES_CPP_NAMESPACE_QUALIFIER XMLPlatformUtils::Initialize();
}
catch (const XERCES_CPP_NAMESPACE_QUALIFIER XMLException& toCatch) {
char* ini_error=XERCES_CPP_NAMESPACE_QUALIFIER XMLString::transcode(toCatch.getMessage());
job_exception new_exception(std::string("xerces initialisation error: ")+ini_error);
XERCES_CPP_NAMESPACE_QUALIFIER XMLString::release(&ini_error);
throw new_exception;
}
jobfilename=NULL;
setFilenamePattern(the_jobfilenamepattern);
parser=new XERCES_CPP_NAMESPACE_QUALIFIER XercesDOMParser();
if (parser==NULL) {
delete jobfilename;
throw job_exception("could not allocate parser");
}
parser->setValidationScheme(XERCES_CPP_NAMESPACE_QUALIFIER XercesDOMParser::Val_Always);
parser->setDoNamespaces(true);
errHandler = (XERCES_CPP_NAMESPACE_QUALIFIER ErrorHandler*) new XERCES_CPP_NAMESPACE_QUALIFIER HandlerBase();
parser->setErrorHandler(errHandler);
}
Object *new_exception(Object *cxt, Object *frame, char const* reason) {
return new_exception(cxt, frame, new_char_array(cxt, reason));
}
void register_type(int code, const char *name) {
register_type(code, new_exception(name, m_type.ptr()));
}
void initialize() {
m_type = new_exception("Error");
register_type(-ENOENT, "NotFoundError");
register_type(-ETIMEDOUT, "TimeoutError");
}
Object *new_errno_exception(Object *cxt, Object *frame, char const* message) {
Object *ex = new_exception(cxt, frame, message);
set(cxt, ex, "error", new_char_array(cxt, strerror(errno)));
return ex;
};
