void
Rsqlite_ReleaseAggregate(void *ptr)
{
SEXP *arr = (SEXP *) ptr;
R_ReleaseObject(arr[0]);
R_ReleaseObject(arr[1]);
free(ptr);
}
SEXP onUnload() {
R_ReleaseObject(TRUESEXP);
R_ReleaseObject(FALSESEXP);
return R_NilValue;
}/*C_ONUNLOAD*/
/* Generic callback stuff */
void R_freeCBData(R_CallbackData *cbdata) {
R_ReleaseObject(cbdata->function);
if(cbdata->useData && cbdata->data != NULL) {
R_ReleaseObject(cbdata->data);
}
g_free(cbdata);
}
void SexpObject_clear(SexpObject *sexpobj)
{
(*sexpobj).count--;
#ifdef RPY_VERBOSE
printf("R:%p -- sexp count is %i...",
sexpobj->sexp, sexpobj->count);
#endif
if (((*sexpobj).count == 0) && (*sexpobj).sexp) {
#ifdef RPY_VERBOSE
printf("freeing SEXP resources...");
#endif
if (sexpobj->sexp != R_NilValue) {
#ifdef RPY_DEBUG_PRESERVE
printf(" PRESERVE -- Sexp_clear: R_ReleaseObject -- %p ",
sexpobj->sexp);
preserved_robjects -= 1;
printf("-- %i\n", preserved_robjects);
#endif
R_ReleaseObject(sexpobj->sexp);
}
PyMem_Free(sexpobj);
/* self->ob_type->tp_free((PyObject*)self); */
#ifdef RPY_VERBOSE
printf("done.\n");
#endif
}
}
SEXP deque_pop(deque_t *dl)
{
list_t *tmp;
if (dl->len == 0)
return R_NilValue;
list_t *l = dl->start;
if (l->next)
{
tmp = l;
l = l->next;
l->prev = NULL;
l = tmp;
}
dl->start = l->next;
if (dl->len == 1)
dl->end = NULL;
dl->len--;
SEXP ret = l->data;
R_ReleaseObject(ret);
free(l);
return ret;
}
void RFunction::Deallocate()
{
if(this->object)
{
R_ReleaseObject(this->object);
this->object=NULL;
}
}
static void userCleanup(void **userData)
{
for (int i=0; i<3; i++) {
if (userData[i]) {
R_ReleaseObject((SEXP)userData[i]);
userData[i] = 0;
}
}
}
gboolean onWinDestroy (GtkWidget * wnd, GdkEvent * event, gpointer user_data) {
udata *dat=(udata *)user_data;
UNUSED(wnd);
UNUSED(event);
R_ReleaseObject(dat->xx);
g_free (dat);
return FALSE;
}
DataFrameModel::~DataFrameModel() {
R_ReleaseObject(_dataframe);
R_ReleaseObject(_roles);
R_ReleaseObject(_rowHeader);
R_ReleaseObject(_colHeader);
R_ReleaseObject(_useRoles);
R_ReleaseObject(_editable);
}
SEXP Rserve_set_context(SEXP sObj) {
if (!sObj)
sObj = R_NilValue;
if (RS_current_context == sObj) return sObj;
if (RS_current_context != R_NilValue && RS_current_context_is_protected)
R_ReleaseObject(RS_current_context);
RS_current_context = sObj;
RS_current_context_is_protected = 0;
if (RS_current_context != R_NilValue) {
R_PreserveObject(RS_current_context);
RS_current_context_is_protected = 1;
}
return RS_current_context;
}
SEXP
R_setInitialModuleFunction(SEXP v)
{
SEXP prev;
if(R_initializeModuleFunction && GET_LENGTH(R_initializeModuleFunction))
R_ReleaseObject(R_initializeModuleFunction);
prev = R_initializeModuleFunction ? R_initializeModuleFunction : R_NilValue;
if(GET_LENGTH(v))
R_PreserveObject(v);
R_initializeModuleFunction = v;
return(prev);
}
USER_OBJECT_
RS_GGOBI(setSmoothFunction)(USER_OBJECT_ func)
{
USER_OBJECT_ old;
old = RS_smoothFunction;
if(old != NULL)
R_ReleaseObject(RS_smoothFunction);
else
old = NULL_USER_OBJECT;
RS_smoothFunction = func;
R_PreserveObject(RS_smoothFunction);
return(old);
}
void RVector::append(SEXP e) {
if (size_ == capacity_) {
Protect p(e);
capacity_ *= grow;
SEXP new_vector = Rf_allocVector(VECSXP, capacity_);
for (size_t i = 0; i < size_; ++i) {
SET_VECTOR_ELT(new_vector, i, at(i));
}
R_ReleaseObject(vector);
R_PreserveObject(new_vector);
vector = new_vector;
}
size_++;
SETLENGTH(vector, size_);
SET_VECTOR_ELT(vector, size_ - 1, e);
}
void deque_free(deque_t *dl)
{
list_t *tmp;
list_t *l = dl->start;
while (l)
{
if (l->data != R_NilValue)
R_ReleaseObject(l->data);
tmp = l->next;
free(l);
l = tmp;
}
free(dl);
}
/* this is pretty much hard-coded for now - it's picking "xp" attribute */
REPC SEXP RReleaseREXP(SEXP ptr) {
jobject o;
if (TYPEOF(ptr)==EXTPTRSXP) error("invalid object");
o = (jobject)EXTPTR_PTR(ptr);
{
JNIEnv *env = getJNIEnv();
jclass cls = (*env)->GetObjectClass(env, o);
if (cls) {
jfieldID fid=(*env)->GetFieldID(env,cls,"xp","J");
if (fid) {
jlong r = (*env)->GetLongField(env, o, fid);
SEXP x = (SEXP) r;
if (x) R_ReleaseObject(x);
}
}
}
return R_NilValue;
}
SmokeObject::~SmokeObject() {
#ifdef MEM_DEBUG
qDebug("%p: destructing", this);
#endif
if (_sexp) {
#ifdef MEM_DEBUG
qDebug("%p: orphaned sexp %p", this, _sexp);
#endif
orphanTable(HASHTAB(_sexp));
}
if (_internalTable) {
#ifdef MEM_DEBUG
qDebug("%p: orphaned internal table %p", this, _internalTable);
#endif
orphanTable(_internalTable);
}
if (_fieldEnv)
R_ReleaseObject(_fieldEnv);
instances.remove(_ptr);
}
bool DataFrameModel::setData(const QModelIndex &index, const QVariant &value,
int role)
{
int col = index.column();
int row = index.row();
QModelIndex dummy;
if (!index.isValid()) {
qCritical("Model index is invalid");
return false;
}
if (col >= columnCount(dummy)) {
qCritical("Column index %d out of bounds", col);
return false;
}
if (row >= rowCount(dummy)) {
qCritical("Row index %d out of bounds", row);
return false;
}
if (role >= length(_roles)) {
qCritical("Role index %d out of bounds", role);
return false;
}
SEXP roleVector = VECTOR_ELT(_roles, role);
int dfIndex;
if (roleVector == R_NilValue || (dfIndex = INTEGER(roleVector)[col]) == -1)
return(false);
SEXP tmpDataframe = duplicate(_dataframe);
R_ReleaseObject(_dataframe);
_dataframe = tmpDataframe;
R_PreserveObject(_dataframe);
SEXP v = VECTOR_ELT(_dataframe, dfIndex);
bool success = qvariant_into_vector(value, v, row);
if (success)
dataChanged(index, index);
return success;
}
RClass::~RClass() {
R_ReleaseObject(_klass);
}
void
Rsqlite_Release(void *val)
{
R_ReleaseObject((SEXP) val);
}
RDynamicQObject::~RDynamicQObject() {
R_ReleaseObject(_function);
if (_userData)
R_ReleaseObject(_userData);
}
/* TODO: This needs implementing as a Ruby destructor for each RObj */
void
Robj_dealloc(SEXP robj)
{
R_ReleaseObject(robj);
}
static void matrix_finalizer(SEXP handle)
{
R_ReleaseObject(protected_objects[*INTEGER(R_ExternalPtrTag(handle))]);
std::cout << "R/PLEX: Distance matrix unprotected." << std::endl;
}