void Compilation::build_hir() {
CHECK_BAILOUT();
// setup ir
CompileLog* log = this->log();
if (log != NULL) {
log->begin_head("parse method='%d' ",
log->identify(_method));
log->stamp();
log->end_head();
}
_hir = new IR(this, method(), osr_bci());
if (log) log->done("parse");
if (!_hir->is_valid()) {
bailout("invalid parsing");
return;
}
#ifndef PRODUCT
if (PrintCFGToFile) {
CFGPrinter::print_cfg(_hir, "After Generation of HIR", true, false);
}
#endif
#ifndef PRODUCT
if (PrintCFG || PrintCFG0) { tty->print_cr("CFG after parsing"); _hir->print(true); }
if (PrintIR || PrintIR0 ) { tty->print_cr("IR after parsing"); _hir->print(false); }
#endif
_hir->verify();
if (UseC1Optimizations) {
NEEDS_CLEANUP
// optimization
PhaseTraceTime timeit(_t_optimize_blocks);
_hir->optimize_blocks();
}
_hir->verify();
_hir->split_critical_edges();
#ifndef PRODUCT
if (PrintCFG || PrintCFG1) { tty->print_cr("CFG after optimizations"); _hir->print(true); }
if (PrintIR || PrintIR1 ) { tty->print_cr("IR after optimizations"); _hir->print(false); }
#endif
_hir->verify();
// compute block ordering for code generation
// the control flow must not be changed from here on
_hir->compute_code();
if (UseGlobalValueNumbering) {
// No resource mark here! LoopInvariantCodeMotion can allocate ValueStack objects.
int instructions = Instruction::number_of_instructions();
GlobalValueNumbering gvn(_hir);
assert(instructions == Instruction::number_of_instructions(),
"shouldn't have created an instructions");
}
_hir->verify();
#ifndef PRODUCT
if (PrintCFGToFile) {
CFGPrinter::print_cfg(_hir, "Before RangeCheckElimination", true, false);
}
#endif
if (RangeCheckElimination) {
if (_hir->osr_entry() == NULL) {
PhaseTraceTime timeit(_t_rangeCheckElimination);
RangeCheckElimination::eliminate(_hir);
}
}
#ifndef PRODUCT
if (PrintCFGToFile) {
CFGPrinter::print_cfg(_hir, "After RangeCheckElimination", true, false);
}
#endif
if (UseC1Optimizations) {
// loop invariant code motion reorders instructions and range
// check elimination adds new instructions so do null check
// elimination after.
NEEDS_CLEANUP
// optimization
PhaseTraceTime timeit(_t_optimize_null_checks);
_hir->eliminate_null_checks();
}
_hir->verify();
// compute use counts after global value numbering
_hir->compute_use_counts();
#ifndef PRODUCT
if (PrintCFG || PrintCFG2) { tty->print_cr("CFG before code generation"); _hir->code()->print(true); }
if (PrintIR || PrintIR2 ) { tty->print_cr("IR before code generation"); _hir->code()->print(false, true); }
#endif
_hir->verify();
}
int
VirtualMethodCall::items()
{
return method().numArgs;
}
void print_method_on(outputStream* st) {
ProfilerNode::print_method_on(st);
MethodCounters* mcs = method()->method_counters();
if (Verbose && mcs != NULL) mcs->invocation_counter()->print_short();
}
MethodReturnValueBase::MethodReturnValueBase(Smoke *smoke, Smoke::Index meth, Smoke::Stack stack) :
_smoke(smoke), _method(meth), _stack(stack)
{
_st.set(_smoke, method().ret);
}
const char*
MethodCallBase::classname()
{
return _smoke->className(method().classId);
}
klassOop OutlinedMethodScope::methodHolder() const {
return selfKlass()->klass_part()->lookup_method_holder_for(method());
}
void javaVFrame::print_lock_info_on(outputStream* st, int frame_count) {
ResourceMark rm;
// If this is the first frame, and java.lang.Object.wait(...) then print out the receiver.
if (frame_count == 0) {
if (method()->name() == vmSymbols::wait_name() &&
method()->method_holder()->name() == vmSymbols::java_lang_Object()) {
StackValueCollection* locs = locals();
if (!locs->is_empty()) {
StackValue* sv = locs->at(0);
if (sv->type() == T_OBJECT) {
Handle o = locs->at(0)->get_obj();
print_locked_object_class_name(st, o, "waiting on");
}
}
} else if (thread()->current_park_blocker() != NULL) {
oop obj = thread()->current_park_blocker();
Klass* k = obj->klass();
st->print_cr("\t- %s <" INTPTR_FORMAT "> (a %s)", "parking to wait for ", (address)obj, k->external_name());
}
}
// Print out all monitors that we have locked or are trying to lock
GrowableArray<MonitorInfo*>* mons = monitors();
if (!mons->is_empty()) {
bool found_first_monitor = false;
for (int index = (mons->length()-1); index >= 0; index--) {
MonitorInfo* monitor = mons->at(index);
if (monitor->eliminated() && is_compiled_frame()) { // Eliminated in compiled code
if (monitor->owner_is_scalar_replaced()) {
Klass* k = java_lang_Class::as_Klass(monitor->owner_klass());
st->print("\t- eliminated <owner is scalar replaced> (a %s)", k->external_name());
} else {
oop obj = monitor->owner();
if (obj != NULL) {
print_locked_object_class_name(st, obj, "eliminated");
}
}
continue;
}
if (monitor->owner() != NULL) {
// the monitor is associated with an object, i.e., it is locked
// First, assume we have the monitor locked. If we haven't found an
// owned monitor before and this is the first frame, then we need to
// see if we have completed the lock or we are blocked trying to
// acquire it - we can only be blocked if the monitor is inflated
const char *lock_state = "locked"; // assume we have the monitor locked
if (!found_first_monitor && frame_count == 0) {
markOop mark = monitor->owner()->mark();
if (mark->has_monitor() &&
( // we have marked ourself as pending on this monitor
mark->monitor() == thread()->current_pending_monitor() ||
// we are not the owner of this monitor
!mark->monitor()->is_entered(thread())
)) {
lock_state = "waiting to lock";
}
}
found_first_monitor = true;
print_locked_object_class_name(st, monitor->owner(), lock_state);
}
}
}
}
MethodData* MethodData::allocate(ClassLoaderData* loader_data, methodHandle method, TRAPS) {
int size = MethodData::compute_allocation_size_in_words(method);
return new (loader_data, size, false, THREAD) MethodData(method(), size, CHECK_NULL);
}
void MethodData::print_value_on(outputStream* st) const {
assert(is_methodData(), "should be method data");
st->print("method data for ");
method()->print_value_on(st);
}
ciField* ciBytecodeStream::get_field() const {
return CURRENT_ENV->get_field_by_index(method()->holder(), get_field_index());
}
std::string TriggerMethod::ToString() const {
std::string ret =
PropertyName::wfd_trigger_method + std::string(SEMICOLON)
+ std::string(SPACE) + name[method()];
return ret;
}
ciConstant ciBytecodeStream::get_constant() const {
return CURRENT_ENV->get_constant_by_index(method()->holder(), get_constant_index());
}
void ObjectMemory::collect_maybe(STATE, GCToken gct, CallFrame* call_frame) {
// Don't go any further unless we're allowed to GC.
if(!can_gc()) return;
while(!state->stop_the_world()) {
state->checkpoint(gct, call_frame);
// Someone else got to the GC before we did! No problem, all done!
if(!collect_young_now && !collect_mature_now) return;
}
// Ok, everyone in stopped! LET'S GC!
SYNC(state);
state->shared().finalizer_handler()->start_collection(state);
if(cDebugThreading) {
std::cerr << std::endl << "[" << state
<< " WORLD beginning GC.]" << std::endl;
}
if(collect_young_now) {
GCData gc_data(state->vm(), gct);
YoungCollectStats stats;
RUBINIUS_GC_BEGIN(0);
#ifdef RBX_PROFILER
if(unlikely(state->vm()->tooling())) {
tooling::GCEntry method(state, tooling::GCYoung);
collect_young(state, &gc_data, &stats);
} else {
collect_young(state, &gc_data, &stats);
}
#else
collect_young(state, &gc_data, &stats);
#endif
RUBINIUS_GC_END(0);
print_young_stats(state, &gc_data, &stats);
}
if(collect_mature_now) {
GCData* gc_data = new GCData(state->vm(), gct);
RUBINIUS_GC_BEGIN(1);
#ifdef RBX_PROFILER
if(unlikely(state->vm()->tooling())) {
tooling::GCEntry method(state, tooling::GCMature);
collect_mature(state, gc_data);
} else {
collect_mature(state, gc_data);
}
#else
collect_mature(state, gc_data);
#endif
if(!mature_mark_concurrent_) {
print_mature_stats(state, gc_data);
}
}
state->restart_world();
UNSYNC;
}
void slotChangedObject(const App::DocumentObject& Obj, const App::Property& Prop)
{
if (object == &Obj && Prop.getTypeId() == Part::PropertyGeometryList::getClassTypeId()) {
const Part::PropertyGeometryList& geom = static_cast<const Part::PropertyGeometryList&>(Prop);
const std::vector<Part::Geometry*>& items = geom.getValues();
if (items.size() != 2)
return;
Part::Geometry* g1 = items[0];
Part::Geometry* g2 = items[1];
if (!g1 || g1->getTypeId() != Part::GeomArcOfCircle::getClassTypeId())
return;
if (!g2 || g2->getTypeId() != Part::GeomLineSegment::getClassTypeId())
return;
Part::GeomArcOfCircle* arc = static_cast<Part::GeomArcOfCircle*>(g1);
Part::GeomLineSegment* seg = static_cast<Part::GeomLineSegment*>(g2);
try {
Base::Vector3d m1 = arc->getCenter();
//Base::Vector3d a3 = arc->getStartPoint();
Base::Vector3d a3 = arc->getEndPoint(true);
//Base::Vector3d l1 = seg->getStartPoint();
Base::Vector3d l2 = seg->getEndPoint();
#if 0
Py::Module pd("FilletArc");
Py::Callable method(pd.getAttr(std::string("makeFilletArc")));
Py::Callable vector(pd.getAttr(std::string("Vector")));
Py::Tuple xyz(3);
Py::Tuple args(6);
xyz.setItem(0, Py::Float(m1.x));
xyz.setItem(1, Py::Float(m1.y));
xyz.setItem(2, Py::Float(m1.z));
args.setItem(0,vector.apply(xyz));
xyz.setItem(0, Py::Float(a3.x));
xyz.setItem(1, Py::Float(a3.y));
xyz.setItem(2, Py::Float(a3.z));
args.setItem(1,vector.apply(xyz));
xyz.setItem(0, Py::Float(l2.x));
xyz.setItem(1, Py::Float(l2.y));
xyz.setItem(2, Py::Float(l2.z));
args.setItem(2,vector.apply(xyz));
xyz.setItem(0, Py::Float((float)0));
xyz.setItem(1, Py::Float((float)0));
xyz.setItem(2, Py::Float((float)1));
args.setItem(3,vector.apply(xyz));
args.setItem(4,Py::Float(radius));
args.setItem(5,Py::Int((int)0));
Py::Tuple ret(method.apply(args));
Py::Object S1(ret.getItem(0));
Py::Object S2(ret.getItem(1));
Py::Object M2(ret.getItem(2));
Base::Vector3d s1, s2, m2;
s1.x = (double)Py::Float(S1.getAttr("x"));
s1.y = (double)Py::Float(S1.getAttr("y"));
s1.z = (double)Py::Float(S1.getAttr("z"));
s2.x = (double)Py::Float(S2.getAttr("x"));
s2.y = (double)Py::Float(S2.getAttr("y"));
s2.z = (double)Py::Float(S2.getAttr("z"));
m2.x = (double)Py::Float(M2.getAttr("x"));
m2.y = (double)Py::Float(M2.getAttr("y"));
m2.z = (double)Py::Float(M2.getAttr("z"));
coords->point.set1Value(0, (float)s1.x,(float)s1.y,(float)s1.z);
coords->point.set1Value(1, (float)m2.x,(float)m2.y,(float)m2.z);
coords->point.set1Value(2, (float)s2.x,(float)s2.y,(float)s2.z);
Base::Console().Message("M1=<%.4f,%.4f>\n", m1.x,m1.y);
Base::Console().Message("M2=<%.4f,%.4f>\n", m2.x,m2.y);
Base::Console().Message("S1=<%.4f,%.4f>\n", s1.x,s1.y);
Base::Console().Message("S2=<%.4f,%.4f>\n", s2.x,s2.y);
Base::Console().Message("P=<%.4f,%.4f>\n", a3.x,a3.y);
Base::Console().Message("Q=<%.4f,%.4f>\n", l2.x,l2.y);
Base::Console().Message("\n");
#else
Py::Module pd("PartDesign");
Py::Callable method(pd.getAttr(std::string("makeFilletArc")));
Py::Tuple args(6);
args.setItem(0,Py::Vector(m1));
args.setItem(1,Py::Vector(a3));
args.setItem(2,Py::Vector(l2));
args.setItem(3,Py::Vector(Base::Vector3d(0,0,1)));
args.setItem(4,Py::Float(radius));
//args.setItem(5,Py::Int((int)0));
args.setItem(5,Py::Int((int)1));
Py::Tuple ret(method.apply(args));
Py::Vector S1(ret.getItem(0));
Py::Vector S2(ret.getItem(1));
Py::Vector M2(ret.getItem(2));
Base::Vector3d s1 = S1.toVector();
Base::Vector3d s2 = S2.toVector();
Base::Vector3d m2 = M2.toVector();
coords->point.set1Value(0, (float)s1.x,(float)s1.y,(float)s1.z);
coords->point.set1Value(1, (float)m2.x,(float)m2.y,(float)m2.z);
coords->point.set1Value(2, (float)s2.x,(float)s2.y,(float)s2.z);
Base::Console().Message("M1=<%.4f,%.4f>\n", m1.x,m1.y);
Base::Console().Message("M2=<%.4f,%.4f>\n", m2.x,m2.y);
Base::Console().Message("S1=<%.4f,%.4f>\n", s1.x,s1.y);
Base::Console().Message("S2=<%.4f,%.4f>\n", s2.x,s2.y);
Base::Console().Message("P=<%.4f,%.4f>\n", a3.x,a3.y);
Base::Console().Message("Q=<%.4f,%.4f>\n", l2.x,l2.y);
Base::Console().Message("\n");
#endif
}
catch (Py::Exception&) {
Base::PyException e; // extract the Python error text
Base::Console().Error("%s\n", e.what());
}
}
}
Sandbox::luabind::stack<Sandbox::Color>::push(L, c);
return 1;
}
SB_META_DECLARE_KLASS(Sandbox::Color, void)
SB_META_BEGIN_KLASS_BIND(Sandbox::Color)
bind( constructor(&sb_color_constructor) );
SB_META_PROPERTY(r)
SB_META_PROPERTY(g)
SB_META_PROPERTY(b)
SB_META_PROPERTY(a)
SB_META_OPERATOR_MUL_(Sandbox::Color(Sandbox::Color::*)(float)const)
bind(method("mul", static_cast<Sandbox::Color(Sandbox::Color::*)(const Sandbox::Color&)const>(&Sandbox::Color::operator*)));
SB_META_METHOD(ToStringRGB)
SB_META_STATIC_METHOD(FromString)
SB_META_METHOD(Premultiply)
SB_META_END_KLASS_BIND()
SB_META_DECLARE_KLASS(Sandbox::Rectf, void)
SB_META_BEGIN_KLASS_BIND(Sandbox::Rectf)
SB_META_CONSTRUCTOR((float,float,float,float))
SB_META_PROPERTY(x)
SB_META_PROPERTY(y)
SB_META_PROPERTY(w)
SB_META_PROPERTY(h)
SB_META_END_KLASS_BIND()
SB_META_DECLARE_KLASS(Sandbox::Recti, void)
void
do_last_stage(resultfile *last_stage, const correction_options &options, genotype_matrix_ptr genotypes, method_data_ptr data, const std::string &output_path)
{
std::ostream &output = std::cout;
std::vector<std::string> header = last_stage->get_header( );
model_matrix *model_matrix = new factor_matrix( data->covariate_matrix, data->phenotype.n_elem );
scaleinv_method method( data, *model_matrix, options.model == "normal" );
std::vector<std::string> method_header = method.init( );
output << "snp1 snp2";
for(int i = 0; i < method_header.size( ); i++)
{
output << "\tP_" << method_header[ i ];
}
output << "\tP_combined\n";
uint64_t num_tests = options.num_tests[ 3 ];
if( num_tests == 0 )
{
num_tests = last_stage->num_pairs( );
}
std::pair<std::string, std::string> pair;
float *values = new float[ header.size( ) ];
float *method_values = new float[ method_header.size( ) ];
while( last_stage->read( &pair, values ) )
{
std::fill( method_values, method_values + method_header.size( ), result_get_missing( ) );
/* Skip N and last p-value */
float pre_p = *std::max_element( values, values + header.size( ) - 2 );
float min_p = 1.0;
float max_p = 0.0;
snp_row const *snp1 = genotypes->get_row( pair.first );
snp_row const *snp2 = genotypes->get_row( pair.second );
method.run( *snp1, *snp2, method_values );
std::vector<float> p_values;
for(int i = 0; i < method_header.size( ); i++)
{
float adjusted_p = result_get_missing( );
if( method_values[ i ] != result_get_missing( ) )
{
adjusted_p = std::min( std::max( method_values[ i ] * num_tests / options.weight[ header.size( ) - 2 ], pre_p ), 1.0f );
min_p = std::min( min_p, adjusted_p );
max_p = std::max( max_p, adjusted_p );
}
p_values.push_back( adjusted_p );
}
if( min_p > options.alpha )
{
continue;
}
output << pair.first << " " << pair.second;
bool any_missing = false;
for(int i = 0; i < p_values.size( ); i++)
{
if( p_values[ i ] != result_get_missing( ) )
{
output << "\t" << p_values[ i ];
}
else
{
any_missing = true;
output << "\tNA";
}
}
if( !any_missing )
{
output << "\t" << max_p << "\n";
}
else
{
output << "\tNA\n";
}
}
delete model_matrix;
delete[] values;
delete[] method_values;
}
void BlockScope::print_short() {
lprintf("(BlockScope*)%#lx (", this); selector()->print_symbol_on();
lprintf(" %#lx)", method());
}
Object* VMMethod::execute_specialized(STATE, CallFrame* previous,
Dispatch& msg, Arguments& args) {
CompiledMethod* cm = as<CompiledMethod>(msg.method);
VMMethod* vmm = cm->backend_method();
#ifdef ENABLE_LLVM
// A negative call_count means we've disabled usage based JIT
// for this method.
if(vmm->call_count >= 0) {
if(vmm->call_count >= state->shared.config.jit_call_til_compile) {
LLVMState* ls = LLVMState::get(state);
ls->compile_callframe(state, cm, previous);
} else {
vmm->call_count++;
}
}
#endif
size_t scope_size = sizeof(StackVariables) +
(vmm->number_of_locals * sizeof(Object*));
StackVariables* scope =
reinterpret_cast<StackVariables*>(alloca(scope_size));
// Originally, I tried using msg.module directly, but what happens is if
// super is used, that field is read. If you combine that with the method
// being called recursively, msg.module can change, causing super() to
// look in the wrong place.
//
// Thus, we have to cache the value in the StackVariables.
scope->initialize(args.recv(), args.block(), msg.module, vmm->number_of_locals);
InterpreterCallFrame* frame = ALLOCA_CALLFRAME(vmm->stack_size);
// If argument handling fails..
if(ArgumentHandler::call(state, vmm, scope, args) == false) {
Exception* exc =
Exception::make_argument_error(state, vmm->required_args, args.total(), msg.name);
exc->locations(state, Location::from_call_stack(state, previous));
state->thread_state()->raise_exception(exc);
return NULL;
}
frame->prepare(vmm->stack_size);
frame->previous = previous;
frame->flags = 0;
frame->arguments = &args;
frame->dispatch_data = &msg;
frame->cm = cm;
frame->scope = scope;
#ifdef RBX_PROFILER
if(unlikely(state->shared.profiling())) {
profiler::MethodEntry method(state, msg, args, cm);
return (*vmm->run)(state, vmm, frame);
} else {
return (*vmm->run)(state, vmm, frame);
}
#else
return (*vmm->run)(state, vmm, frame);
#endif
}
void CompiledIC::set_to_monomorphic(const CompiledICInfo& info) {
assert (CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "");
// Updating a cache to the wrong entry can cause bugs that are very hard
// to track down - if cache entry gets invalid - we just clean it. In
// this way it is always the same code path that is responsible for
// updating and resolving an inline cache
//
// The above is no longer true. SharedRuntime::fixup_callers_callsite will change optimized
// callsites. In addition ic_miss code will update a site to monomorphic if it determines
// that an monomorphic call to the interpreter can now be monomorphic to compiled code.
//
// In both of these cases the only thing being modifed is the jump/call target and these
// transitions are mt_safe
Thread *thread = Thread::current();
if (info._to_interpreter) {
// Call to interpreter
if (info.is_optimized() && is_optimized()) {
assert(is_clean(), "unsafe IC path");
MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
// the call analysis (callee structure) specifies that the call is optimized
// (either because of CHA or the static target is final)
// At code generation time, this call has been emitted as static call
// Call via stub
assert(info.cached_oop().not_null() && info.cached_oop()->is_method(), "sanity check");
CompiledStaticCall* csc = compiledStaticCall_at(instruction_address());
methodHandle method (thread, (methodOop)info.cached_oop()());
csc->set_to_interpreted(method, info.entry());
if (TraceICs) {
ResourceMark rm(thread);
tty->print_cr ("IC@" INTPTR_FORMAT ": monomorphic to interpreter: %s",
instruction_address(),
method->print_value_string());
}
} else {
// Call via method-klass-holder
assert(info.cached_oop().not_null(), "must be set");
InlineCacheBuffer::create_transition_stub(this, info.cached_oop()(), info.entry());
if (TraceICs) {
ResourceMark rm(thread);
tty->print_cr ("IC@" INTPTR_FORMAT ": monomorphic to interpreter via mkh", instruction_address());
}
}
} else {
// Call to compiled code
bool static_bound = info.is_optimized() || (info.cached_oop().is_null());
#ifdef ASSERT
CodeBlob* cb = CodeCache::find_blob_unsafe(info.entry());
assert (cb->is_nmethod(), "must be compiled!");
#endif /* ASSERT */
// This is MT safe if we come from a clean-cache and go through a
// non-verified entry point
bool safe = SafepointSynchronize::is_at_safepoint() ||
(!is_in_transition_state() && (info.is_optimized() || static_bound || is_clean()));
if (!safe) {
InlineCacheBuffer::create_transition_stub(this, info.cached_oop()(), info.entry());
} else {
set_ic_destination(info.entry());
if (!is_optimized()) set_cached_oop(info.cached_oop()());
}
if (TraceICs) {
ResourceMark rm(thread);
assert(info.cached_oop() == NULL || info.cached_oop()()->is_klass(), "must be");
tty->print_cr ("IC@" INTPTR_FORMAT ": monomorphic to compiled (rcvr klass) %s: %s",
instruction_address(),
((klassOop)info.cached_oop()())->print_value_string(),
(safe) ? "" : "via stub");
}
}
// We can't check this anymore. With lazy deopt we could have already
// cleaned this IC entry before we even return. This is possible if
// we ran out of space in the inline cache buffer trying to do the
// set_next and we safepointed to free up space. This is a benign
// race because the IC entry was complete when we safepointed so
// cleaning it immediately is harmless.
// assert(is_call_to_compiled() || is_call_to_interpreted(), "sanity check");
}
(c) 2013, Peersuasive Technologies
*************************************************************/
#include "LOpenGLComponent_inh.h"
const char LOpenGLComponent::className[] = "LOpenGLComponent";
const Luna<LOpenGLComponent>::PropertyType LOpenGLComponent::properties[] = {
{ "swapInterval", &LOpenGLComponent::getSwapInterval, &LOpenGLComponent::setSwapInterval },
{0,0}
};
const Luna<LOpenGLComponent>::FunctionType LOpenGLComponent::methods[] = {
method(LOpenGLComponent, newOpenGLContextCreated),
method(LOpenGLComponent, openGLContextClosing),
method(LOpenGLComponent, renderOpenGL),
method(LOpenGLComponent, triggerRepaint),
method(LOpenGLComponent, setContinuousRepainting),
method(LOpenGLComponent, swapBuffers),
method(LOpenGLComponent, setSwapInterval),
method(LOpenGLComponent, getSwapInterval),
method(LOpenGLComponent, setMultisamplingEnabled),
method(LOpenGLComponent, areShadersAvailable),
method(LOpenGLComponent, getRenderingScale),
method(LOpenGLComponent, copyTexture),
int interpretedVFrame::bci() const {
return method()->bci_from(bcp());
}
#include "Cello/Array.h"
#include "Cello/Bool.h"
#include "Cello/None.h"
#include "Cello/Exception.h"
#include "Cello/Number.h"
#include <math.h>
#include <string.h>
var Array = methods {
methods_begin(Array),
method(Array, New),
method(Array, Assign),
method(Array, Copy),
method(Array, Eq),
method(Array, Collection),
method(Array, Push),
method(Array, At),
method(Array, Iter),
method(Array, Reverse),
method(Array, Append),
method(Array, Sort),
method(Array, Show),
methods_end(Array)
};
var Array_New(var self, va_list* args) {
ArrayData* ad = cast(self, Array);
ad->item_type = cast(va_arg(*args, var), Type);
const char *
MethodReturnValueBase::classname()
{
return _smoke->className(method().classId);
}
/* Initialize the wolfSSL library and create a wolfSSL context.
*
* version The protocol version.
* cert The server's certificate.
* key The server's private key matching the certificate.
* verifyCert The certificate for client authentication.
* cipherList The list of negotiable ciphers.
* wolfsslCtx The new wolfSSL context object.
* returns EXIT_SUCCESS when a wolfSSL context object is created and
* EXIT_FAILURE otherwise.
*/
static int WolfSSLCtx_Init(ThreadData* threadData, int version, int allowDowngrade,
char* cert, char* key, char* verifyCert, char* cipherList)
{
wolfSSL_method_func method = NULL;
method = SSL_GetMethod(version, allowDowngrade);
if (method == NULL)
return(EXIT_FAILURE);
/* Create and initialize WOLFSSL_CTX structure */
if ((threadData->ctx = wolfSSL_CTX_new(method(NULL))) == NULL) {
fprintf(stderr, "wolfSSL_CTX_new error.\n");
return(EXIT_FAILURE);
}
#ifdef WOLFSSL_ASYNC_CRYPT
#ifndef WC_NO_ASYNC_THREADING
if (wolfAsync_DevOpenThread(&threadData->devId, &threadData->thread_id) < 0)
#else
if (wolfAsync_DevOpen(&threadData->devId) < 0)
#endif
{
fprintf(stderr, "Async device open failed\nRunning without async\n");
}
wolfSSL_CTX_UseAsync(threadData->ctx, threadData->devId);
#endif
/* Load server certificate into WOLFSSL_CTX */
if (wolfSSL_CTX_use_certificate_file(threadData->ctx, cert, SSL_FILETYPE_PEM)
!= SSL_SUCCESS) {
fprintf(stderr, "Error loading %s, please check the file.\n", cert);
WolfSSLCtx_Final(threadData);
return(EXIT_FAILURE);
}
/* Load server key into WOLFSSL_CTX */
if (wolfSSL_CTX_use_PrivateKey_file(threadData->ctx, key, SSL_FILETYPE_PEM)
!= SSL_SUCCESS) {
fprintf(stderr, "Error loading %s, please check the file.\n", key);
WolfSSLCtx_Final(threadData);
return(EXIT_FAILURE);
}
/* Setup client authentication. */
wolfSSL_CTX_set_verify(threadData->ctx, SSL_VERIFY_PEER, 0);
if (wolfSSL_CTX_load_verify_locations(threadData->ctx, verifyCert, 0) != SSL_SUCCESS) {
fprintf(stderr, "Error loading %s, please check the file.\n",
verifyCert);
WolfSSLCtx_Final(threadData);
return(EXIT_FAILURE);
}
if (cipherList != NULL) {
if (wolfSSL_CTX_set_cipher_list(threadData->ctx, cipherList) != SSL_SUCCESS) {
fprintf(stderr, "Server can't set cipher list.\n");
WolfSSLCtx_Final(threadData);
return(EXIT_FAILURE);
}
}
#ifndef NO_DH
SetDHCtx(threadData->ctx);
#endif
return EXIT_SUCCESS;
}
VirtualMethodCall::VirtualMethodCall(Smoke *smoke, Smoke::Index meth, Smoke::Stack stack, VALUE obj, VALUE *sp) :
MethodCallBase(smoke,meth,stack), _obj(obj)
{
_sp = sp;
_args = _smoke->argumentList + method().args;
}
// Installed by default in BlockEnvironment::execute, it runs the bytecodes
// for the block in the interpreter.
//
// Future code will detect hot blocks and queue them in the JIT, whereby the
// JIT will install a newly minted machine function into ::execute.
Object* BlockEnvironment::execute_interpreter(STATE, CallFrame* previous,
BlockEnvironment* env, Arguments& args,
BlockInvocation& invocation)
{
// Don't use env->machine_code() because it might lock and the work should
// already be done.
MachineCode* const mcode = env->compiled_code_->machine_code();
if(!mcode) {
Exception::internal_error(state, previous, "invalid bytecode method");
return 0;
}
#ifdef ENABLE_LLVM
if(mcode->call_count >= 0) {
if(mcode->call_count >= state->shared().config.jit_call_til_compile) {
LLVMState* ls = LLVMState::get(state);
GCTokenImpl gct;
OnStack<1> os(state, env);
ls->compile_soon(state, gct, env->compiled_code(), previous, env, true);
} else {
mcode->call_count++;
}
}
#endif
StackVariables* scope = ALLOCA_STACKVARIABLES(mcode->number_of_locals);
Module* mod = invocation.module;
if(!mod) mod = env->module();
scope->initialize(invocation.self, env->top_scope_->block(),
mod, mcode->number_of_locals);
scope->set_parent(env->scope_);
InterpreterCallFrame* frame = ALLOCA_CALLFRAME(mcode->stack_size);
frame->prepare(mcode->stack_size);
frame->previous = previous;
frame->constant_scope_ = invocation.constant_scope;
frame->arguments = &args;
frame->dispatch_data = env;
frame->compiled_code = env->compiled_code_;
frame->scope = scope;
frame->top_scope_ = env->top_scope_;
frame->flags = invocation.flags | CallFrame::cCustomConstantScope
| CallFrame::cMultipleScopes
| CallFrame::cBlock;
// TODO: this is a quick hack to process block arguments in 1.9.
if(!LANGUAGE_18_ENABLED(state)) {
if(!GenericArguments::call(state, frame, mcode, scope, args, invocation.flags)) {
return NULL;
}
}
#ifdef RBX_PROFILER
if(unlikely(state->vm()->tooling())) {
Module* mod = scope->module();
if(SingletonClass* sc = try_as<SingletonClass>(mod)) {
if(Module* ma = try_as<Module>(sc->attached_instance())) {
mod = ma;
}
}
OnStack<2> os(state, env, mod);
// Check the stack and interrupts here rather than in the interpreter
// loop itself.
GCTokenImpl gct;
if(!state->check_interrupts(gct, frame, frame)) return NULL;
state->checkpoint(gct, frame);
tooling::BlockEntry method(state, env, mod);
return (*mcode->run)(state, mcode, frame);
} else {
// Check the stack and interrupts here rather than in the interpreter
// loop itself.
GCTokenImpl gct;
if(!state->check_interrupts(gct, frame, frame)) return NULL;
state->checkpoint(gct, frame);
return (*mcode->run)(state, mcode, frame);
}
#else
// Check the stack and interrupts here rather than in the interpreter
// loop itself.
GCTokenImpl gct;
if(!state->check_interrupts(gct, frame, frame)) return NULL;
state->checkpoint(gct, frame);
return (*mcode->run)(state, mcode, frame);
#endif
}
virtual void bytecode_prolog(JVM_SINGLE_ARG_TRAPS) {
JVM_IGNORE_TRAPS;
_code = method()->bytecode_at(bci());
}
(c) 2014, Peersuasive Technologies
*************************************************************/
// TODO: implement this in lua
#include "LAffineTransform_inh.h"
////// static methods
const char LAffineTransform::className[] = "LAffineTransform";
const Luna<LAffineTransform>::PropertyType LAffineTransform::properties[] = {
{ "identity", &LAffineTransform::getIdentity, &LBase::readOnly },
{0,0}
};
const Luna<LAffineTransform>::FunctionType LAffineTransform::methods[] = {
method( LAffineTransform, rotation ),
method( LAffineTransform, translated ),
method( LAffineTransform, getScaleFactor ),
method( LAffineTransform, withAbsoluteTranslation ),
method( LAffineTransform, isSingularity ),
method( LAffineTransform, translation ),
method( LAffineTransform, getTranslationX ),
method( LAffineTransform, verticalFlip ),
method( LAffineTransform, shear ),
method( LAffineTransform, rotated ),
method( LAffineTransform, scaled ),
method( LAffineTransform, isOnlyTranslation ),
method( LAffineTransform, followedBy ),
method( LAffineTransform, getTranslationY ),
method( LAffineTransform, fromTargetPoints ),
method( LAffineTransform, sheared ),
(c) 2014, Peersuasive Technologies
*************************************************************/
#include "LHyperlinkButton_inh.h"
const char LHyperlinkButton::className[] = "LHyperlinkButton";
const Luna<LHyperlinkButton>::PropertyType LHyperlinkButton::properties[] = {
{"url", &LHyperlinkButton::getURL, &LHyperlinkButton::setURL},
{"font", &LBase::writeOnly, &LHyperlinkButton::setFont},
{0,0}
};
const Luna<LHyperlinkButton>::FunctionType LHyperlinkButton::methods[] = {
method( LHyperlinkButton, getURL ),
method( LHyperlinkButton, setURL ),
method( LHyperlinkButton, setFont ),
method( LHyperlinkButton, changeWidthToFitText ),
{0,0}
};
const Luna<LHyperlinkButton>::StaticType LHyperlinkButton::statics[] = {
{0,0}
};
LHyperlinkButton::LHyperlinkButton(lua_State *L)
: LButton(L, this),
HyperlinkButton()
{
HyperlinkButton::setName(myName());
#ifdef LUACONSOLE
#include <iostream>
#include "LuaScriptInterface.h"
#include "LuaLabel.h"
#include "gui/interface/Label.h"
const char LuaLabel::className[] = "Label";
#define method(class, name) {#name, &class::name}
Luna<LuaLabel>::RegType LuaLabel::methods[] = {
method(LuaLabel, text),
method(LuaLabel, position),
method(LuaLabel, size),
method(LuaLabel, visible),
{0, 0}
};
LuaLabel::LuaLabel(lua_State * l) :
LuaComponent(l)
{
this->l = l;
int posX = luaL_optinteger(l, 1, 0);
int posY = luaL_optinteger(l, 2, 0);
int sizeX = luaL_optinteger(l, 3, 10);
int sizeY = luaL_optinteger(l, 4, 10);
std::string text = luaL_optstring(l, 5, "");
label = new ui::Label(ui::Point(posX, posY), ui::Point(sizeX, sizeY), text);
component = label;
}
