VALUE CRbFont::clone()
{
VALUE __argv[2] = { m_name, m_size };
VALUE font = rb_class_new_instance(2, __argv, obj_class());
CRbFont * font_ptr = GetObjectPtr<CRbFont>(font);
font_ptr->dm_set_bold(font, m_bold);
font_ptr->dm_set_italic(font, m_italic);
font_ptr->dm_set_shadow(font, m_shadow);
font_ptr = NULL;
return font;
}
/** Calls the first step of the destructor (done) on the object
pointed to by ptr. */
void * obj_done(void * ptr) {
ObjHeader * header;
ObjClass * info;
// look for a destructor in the linked type info tables
for (info = obj_class(ptr); info; info = info->up) {
if(info->done) { // call done destructor if found.
return info->done(ptr);
}
}
// if we get here do nothing.
return ptr;
}
/** Calls the second step of the destructor (free) on the object that must have
been allocated though obj_alloc and pointed to indirectly by ptr. If the object
has no class or no free function, mem_free will be called to free the memory
that ptr(indirectly) references. Give the class a do-nothing free function to
avoid this if needed. Returns NULL, or whatever the free method
of the object's class returns. The idea is to call this as ptr = obj_free(ptr).
*/
void * obj_free(void * ptr) {
ObjHeader * header;
ObjClass * info;
// look for a destructor in the linked type info tables
for (info = obj_class(ptr); info; info = info->up) {
if(info->free) { // free destructor if found.
return info->free(ptr);
}
}
// If we get here, call the default free. First get the header...
header = obj_objheader(ptr);
//... then deallocate through the header, since the pointer to the header
// points to the top of the memory allocated though obj_alloc
// if the header is not found, try to call mem_free directly.
if (header) mem_free(header); else mem_free(ptr);
return NULL;
}
Expr* PrimInliner::tryInline() {
// Returns the failure result or the result of the primitive (if the
// primitive can't fail) if the primitive has been inlined; returns
// NULL otherwise. If the primitive has been inlined but can't fail,
// the bci in the MethodDecoder is set to the first instruction after
// the failure block.
// NB: The comparisons below should be replaced with pointer comparisons
// comparing with the appropriate vmSymbol. Should fix this at some point.
char* name = _pdesc->name();
Expr* res = NULL;
switch (_pdesc->group()) {
case IntArithmeticPrimitive:
if (number_of_parameters() == 2) {
Expr* x = parameter(0);
Expr* y = parameter(1);
if (equal(name, "primitiveAdd:ifFail:")) { res = smi_ArithmeticOp(tAddArithOp, x, y); break; }
if (equal(name, "primitiveSubtract:ifFail:")) { res = smi_ArithmeticOp(tSubArithOp, x, y); break; }
if (equal(name, "primitiveMultiply:ifFail:")) { res = smi_ArithmeticOp(tMulArithOp, x, y); break; }
if (equal(name, "primitiveDiv:ifFail:")) { res = smi_Div(x, y); break; }
if (equal(name, "primitiveMod:ifFail:")) { res = smi_Mod(x, y); break; }
if (equal(name, "primitiveBitAnd:ifFail:")) { res = smi_BitOp(tAndArithOp, x, y); break; }
if (equal(name, "primitiveBitOr:ifFail:")) { res = smi_BitOp(tOrArithOp , x, y); break; }
if (equal(name, "primitiveBitXor:ifFail:")) { res = smi_BitOp(tXOrArithOp, x, y); break; }
if (equal(name, "primitiveRawBitShift:ifFail:")) { res = smi_Shift(x, y); break; }
}
break;
case IntComparisonPrimitive:
if (number_of_parameters() == 2) {
Expr* x = parameter(0);
Expr* y = parameter(1);
if (equal(name, "primitiveSmallIntegerEqual:ifFail:")) { res = smi_Comparison(EQBranchOp, x, y); break; }
if (equal(name, "primitiveSmallIntegerNotEqual:ifFail:")) { res = smi_Comparison(NEBranchOp, x, y); break; }
if (equal(name, "primitiveLessThan:ifFail:")) { res = smi_Comparison(LTBranchOp, x, y); break; }
if (equal(name, "primitiveLessThanOrEqual:ifFail:")) { res = smi_Comparison(LEBranchOp, x, y); break; }
if (equal(name, "primitiveGreaterThan:ifFail:")) { res = smi_Comparison(GTBranchOp, x, y); break; }
if (equal(name, "primitiveGreaterThanOrEqual:ifFail:")) { res = smi_Comparison(GEBranchOp, x, y); break; }
}
break;
case FloatArithmeticPrimitive:
break;
case FloatComparisonPrimitive:
break;
case ObjArrayPrimitive:
if (equal(name, "primitiveIndexedObjectSize")) { res = array_size(); break; }
if (equal(name, "primitiveIndexedObjectAt:ifFail:")) { res = array_at_ifFail(ArrayAtNode::object_at); break; }
if (equal(name, "primitiveIndexedObjectAt:put:ifFail:")) { res = array_at_put_ifFail(ArrayAtPutNode::object_at_put); break; }
break;
case ByteArrayPrimitive:
if (equal(name, "primitiveIndexedByteSize")) { res = array_size(); break; }
if (equal(name, "primitiveIndexedByteAt:ifFail:")) { res = array_at_ifFail(ArrayAtNode::byte_at); break; }
if (equal(name, "primitiveIndexedByteAt:put:ifFail:")) { res = array_at_put_ifFail(ArrayAtPutNode::byte_at_put); break; }
break;
case DoubleByteArrayPrimitive:
if (equal(name, "primitiveIndexedDoubleByteSize")) { res = array_size(); break; }
if (equal(name, "primitiveIndexedDoubleByteAt:ifFail:")) { res = array_at_ifFail(ArrayAtNode::double_byte_at); break; }
if (equal(name, "primitiveIndexedDoubleByteCharacterAt:ifFail:")) { res = array_at_ifFail(ArrayAtNode::character_at); break; }
if (equal(name, "primitiveIndexedDoubleByteAt:put:ifFail:")) { res = array_at_put_ifFail(ArrayAtPutNode::double_byte_at_put);break; }
break;
case BlockPrimitive:
if (strncmp(name, "primitiveValue", 14) == 0) { res = block_primitiveValue(); break; }
break;
case NormalPrimitive:
if (strncmp(name, "primitiveNew", 12) == 0) { res = obj_new(); break; }
if (equal(name, "primitiveShallowCopyIfFail:ifFail:")) { res = obj_shallowCopy(); break; }
if (equal(name, "primitiveEqual:")) { res = obj_equal(); break; }
if (equal(name, "primitiveClass")) { res = obj_class(true); break; }
if (equal(name, "primitiveClassOf:")) { res = obj_class(false); break; }
if (equal(name, "primitiveHash")) { res = obj_hash(true); break; }
if (equal(name, "primitiveHashOf:")) { res = obj_hash(false); break; }
if (equal(name, "primitiveProxyByteAt:ifFail:")) { res = proxy_byte_at(); break; }
if (equal(name, "primitiveProxyByteAt:put:ifFail:")) { res = proxy_byte_at_put(); break; }
break;
default:
fatal1("bad primitive group %d", _pdesc->group());
break;
}
if (CompilerDebug) {
cout(PrintInlining && (res != NULL))->print("%*sinlining %s %s\n", _scope->depth + 2, "", _pdesc->name(),
_usingUncommonTrap ? "(unc. failure)" : (_cannotFail ? "(cannot fail)" : ""));
}
if (!_usingUncommonTrap && !_cannotFail) theCompiler->reporter->report_prim_failure(_pdesc);
return res;
}
