static SEXP
convertNodeSetToR(xmlNodeSetPtr obj, SEXP fun, int encoding, SEXP manageMemory)
{
SEXP ans, expr = NULL, arg = NULL, ref;
int i;
if(!obj)
return(NULL_USER_OBJECT);
PROTECT(ans = NEW_LIST(obj->nodeNr));
if(GET_LENGTH(fun) && (TYPEOF(fun) == CLOSXP || TYPEOF(fun) == BUILTINSXP)) {
PROTECT(expr = allocVector(LANGSXP, 2));
SETCAR(expr, fun);
arg = CDR(expr);
} else if(TYPEOF(fun) == LANGSXP) {
expr = fun;
arg = CDR(expr);
}
for(i = 0; i < obj->nodeNr; i++) {
xmlNodePtr el;
el = obj->nodeTab[i];
if(el->type == XML_ATTRIBUTE_NODE) {
#if 0
PROTECT(ref = mkString((el->children && el->children->content) ? XMLCHAR_TO_CHAR(el->children->content) : ""));
SET_NAMES(ref, mkString(el->name));
#else
PROTECT(ref = ScalarString(mkCharCE((el->children && el->children->content) ? XMLCHAR_TO_CHAR(el->children->content) : "", encoding)));
SET_NAMES(ref, ScalarString(mkCharCE(el->name, encoding)));
#endif
SET_CLASS(ref, mkString("XMLAttributeValue"));
UNPROTECT(1);
} else if(el->type == XML_NAMESPACE_DECL)
ref = R_createXMLNsRef((xmlNsPtr) el);
else
ref = R_createXMLNodeRef(el, manageMemory);
if(expr) {
PROTECT(ref);
SETCAR(arg, ref);
PROTECT(ref = Rf_eval(expr, R_GlobalEnv)); /*XXX do we want to catch errors here? Maybe to release the namespaces. */
SET_VECTOR_ELT(ans, i, ref);
UNPROTECT(2);
} else
SET_VECTOR_ELT(ans, i, ref);
}
if(expr) {
if(TYPEOF(fun) == CLOSXP || TYPEOF(fun) == BUILTINSXP)
UNPROTECT(1);
} else
SET_CLASS(ans, mkString("XMLNodeSet"));
UNPROTECT(1);
return(ans);
}
USER_OBJECT_
toRPointer(void *val, const char *typeName)
{
USER_OBJECT_ ans, klass = NULL;
GType type = 0;
if(val == NULL)
return(NULL_USER_OBJECT);
PROTECT(ans = R_MakeExternalPtr(val, Rf_install(typeName), NULL_USER_OBJECT));
if (typeName)
type = g_type_from_name(typeName);
if(type) {
if (G_TYPE_IS_INSTANTIATABLE(type) || G_TYPE_IS_INTERFACE(type))
type = G_TYPE_FROM_INSTANCE(val);
if (G_TYPE_IS_DERIVED(type)) {
setAttrib(ans, install("interfaces"), R_internal_getInterfaces(type));
PROTECT(klass = R_internal_getGTypeHierarchy(type));
}
}
if (!klass && typeName) {
PROTECT(klass = asRString(typeName));
}
if(klass) {
SET_CLASS(ans, klass);
UNPROTECT(1);
}
UNPROTECT(1);
return(ans);
}
USER_OBJECT_
asREnum(int value, GType etype)
{
USER_OBJECT_ ans, names;
GEnumValue *evalue;
PROTECT(ans = NEW_INTEGER(1));
INTEGER_DATA(ans)[0] = value;
if (!(evalue = g_enum_get_value(g_type_class_ref(etype), value))) {
PROBLEM "Unknown enum value %d", value
ERROR;
}
PROTECT(names = NEW_CHARACTER(1));
SET_STRING_ELT(names, 0, COPY_TO_USER_STRING(evalue->value_name));
SET_NAMES(ans, names);
PROTECT(names = NEW_CHARACTER(2));
SET_STRING_ELT(names, 0, COPY_TO_USER_STRING(g_type_name(etype)));
SET_STRING_ELT(names, 1, COPY_TO_USER_STRING("enum"));
SET_CLASS(ans, names);
UNPROTECT(3);
return(ans);
}
SEXP
R_connect(SEXP className, SEXP raiseError)
{
IUnknown *unknown = NULL;
HRESULT hr;
SEXP ans = R_NilValue;
CLSID classId;
if(R_getCLSIDFromString(className, &classId) == S_OK) {
hr = GetActiveObject(classId, NULL, &unknown);
if(SUCCEEDED(hr)) {
void *ptr;
hr = unknown->QueryInterface(IID_IDispatch, &ptr);
ans = R_createRCOMUnknownObject((void *) ptr, "COMIDispatch");
} else {
if(LOGICAL(raiseError)[0]) {
/* From COMError.cpp - COMError */
TCHAR buf[512];
GetScodeString(hr, buf, sizeof(buf)/sizeof(buf[0]));
PROTECT(ans = mkString(buf));
SET_CLASS(ans, mkString("COMErrorString"));
UNPROTECT(1);
return(ans);
} else
return(R_NilValue);
}
} else {
PROBLEM "Couldn't get clsid from the string"
WARN;
}
return(ans);
}
SEXP
R_connect_hWnd(SEXP className, SEXP excel_hWnd, SEXP raiseError)
{
IUnknown *unknown = NULL;
HRESULT hr;
SEXP ans = R_NilValue;
CLSID classId;
LONG_PTR l_hwnd;
HWND temp_hwdn;
if(R_getCLSIDFromString(className, &classId) == S_OK) {
l_hwnd = (LONG_PTR)INTEGER(excel_hWnd)[0];
temp_hwdn = (HWND)l_hwnd;
hr = AccessibleObjectFromWindow(temp_hwdn, OBJID_NATIVEOM, classId, (void**)&unknown);
if(hr == S_OK) {
void *ptr;
hr = unknown->QueryInterface(IID_IDispatch, &ptr);
ans = R_createRCOMUnknownObject((void *) ptr, "COMIDispatch");
} else {
if(LOGICAL(raiseError)[0]) {
/* From COMError.cpp - COMError */
TCHAR buf[512];
GetScodeString(hr, buf, sizeof(buf)/sizeof(buf[0]));
PROTECT(ans = mkString(buf));
SET_CLASS(ans, mkString("COMErrorString"));
UNPROTECT(1);
return(ans);
} else
return(R_NilValue);
}
} else {
PROBLEM "Couldn't get clsid from the string"
WARN;
}
return(ans);
}
SEXP
R_makeEnumValue(int val, const char *elName, const char *className)
{
SEXP ans, klass;
#if defined(USE_S4_ENUMS)
SEXP tmp;
PROTECT(klass = MAKE_CLASS(className));
PROTECT(ans = NEW(klass));
PROTECT(tmp = ScalarInteger(val));
SET_NAMES(tmp, mkString(elName));
ans = SET_SLOT(ans, Rf_install(".Data"), tmp);
UNPROTECT(3);
#else
PROTECT(ans = ScalarInteger(val));
SET_NAMES(ans, mkString(elName));
PROTECT(klass = NEW_CHARACTER(2));
SET_STRING_ELT(klass, 0, mkChar(className));
SET_STRING_ELT(klass, 1, mkChar("EnumValue"));
SET_CLASS(ans, klass);
UNPROTECT(2);
#endif
return(ans);
}
SEXP
createREnumerationValue(int val, const char * const *names, const int *values, int namesLength, const char *name)
{
SEXP ans;
int i;
PROTECT(ans =allocVector(INTSXP, 1));
INTEGER(ans)[0] = val;
for(i = 0; i < namesLength; i++) {
if(val == values[i]) {
SET_NAMES(ans, mkString(names[i]));
break;
}
}
if(i == namesLength) {
PROBLEM "Unrecognized value (%d) in enumeration %s", val, name
ERROR;
}
/* Do we want an enumeration value element here also. */
SET_CLASS(ans, mkString(name));
Rf_PrintValue(ans);
UNPROTECT(1);
return(ans);
}
USER_OBJECT_
toRPointerWithFinalizer(gconstpointer val, const gchar *typeName, RPointerFinalizer finalizer)
{
USER_OBJECT_ ans;
USER_OBJECT_ r_finalizer = NULL_USER_OBJECT;
USER_OBJECT_ klass = NULL, rgtk_class;
int i = 0;
GType type = 0;
if(!val)
return(NULL_USER_OBJECT);
if (finalizer) {
PROTECT(r_finalizer = R_MakeExternalPtr(finalizer, NULL_USER_OBJECT, NULL_USER_OBJECT));
}
PROTECT(ans = R_MakeExternalPtr((gpointer)val, r_finalizer, NULL_USER_OBJECT));
if (finalizer) {
R_RegisterCFinalizer(ans, RGtk_finalizer);
}
if (typeName)
type = g_type_from_name(typeName);
if(type) {
if (G_TYPE_IS_INSTANTIATABLE(type) || G_TYPE_IS_INTERFACE(type))
type = G_TYPE_FROM_INSTANCE(val);
if (G_TYPE_IS_DERIVED(type)) {
setAttrib(ans, install("interfaces"), R_internal_getInterfaces(type));
PROTECT(klass = R_internal_getGTypeAncestors(type));
}
}
if (!klass && typeName) {
PROTECT(klass = asRString(typeName));
}
if (klass) { /* so much trouble just to add "RGtkObject" onto the end */
PROTECT(rgtk_class = NEW_CHARACTER(GET_LENGTH(klass)+1));
for (i = 0; i < GET_LENGTH(klass); i++)
SET_STRING_ELT(rgtk_class, i, STRING_ELT(klass, i));
} else {
PROTECT(rgtk_class = NEW_CHARACTER(1));
}
SET_STRING_ELT(rgtk_class, i, COPY_TO_USER_STRING("RGtkObject"));
SET_CLASS(ans, rgtk_class);
if (g_type_is_a(type, S_TYPE_G_OBJECT)) {
USER_OBJECT_ public_sym = install(".public");
setAttrib(ans, public_sym, findVar(public_sym, S_GOBJECT_GET_ENV(val)));
}
if (klass)
UNPROTECT(1);
if (finalizer)
UNPROTECT(1);
UNPROTECT(2);
return(ans);
}
SEXP
makeNodeRef(JSONNODE *node)
{
SEXP ans;
PROTECT(ans = R_MakeExternalPtr(node, Rf_install("JSONNODE"), R_NilValue));
SET_CLASS(ans, ScalarString(mkChar("JSONNODE")));
UNPROTECT(1);
return(ans);
}
/*
Set the class of the target object to be the character vector containing
just the specified name.
*/
int
RS_XML(SetClassName)(const char *localClassName, USER_OBJECT_ target)
{
USER_OBJECT_ className;
PROTECT(className = NEW_CHARACTER(1));
SET_STRING_ELT(className, 0, mkChar(localClassName));
SET_CLASS(target, className);
UNPROTECT(1);
return(1);
}
void
R_schemaValidityFunctionCall(R_SchemaValidCallback *ctx, int warning, const char *msg, va_list args)
{
SEXP arg;
char buf[10000];
vsnprintf(buf, sizeof(buf)/sizeof(buf[0]), msg, args);
PROTECT(arg = mkString(buf));
SET_CLASS(arg, mkString(warning ? "XMLSchemaWarning" : "XMLSchemaError"));
SETCAR(CDR(ctx->fun), arg);
Rf_eval(ctx->fun, R_GlobalEnv);
UNPROTECT(1);
}
SEXP
rsbml_create_doc_ptr(SBMLDocument_t *doc)
{
SEXP r_doc, class_vector;
PROTECT(class_vector = NEW_CHARACTER(1));
SET_STRING_ELT(class_vector, 0, mkChar("SBMLDocument"));
r_doc = R_MakeExternalPtr(doc, R_NilValue, R_NilValue);
R_RegisterCFinalizer(r_doc, (R_CFinalizer_t)rsbml_R_free_doc);
SET_CLASS(r_doc, class_vector);
UNPROTECT(1);
return r_doc;
}
void methctx_reference(STATE, OBJECT ctx) {
struct fast_context *fc;
/* Don't do it again. */
if(!stack_context_p(ctx)) return;
/* Has to be done first because this uses informated we're about
to overwrite. */
object_memory_context_referenced(state->om, ctx);
CLEAR_FLAGS(ctx);
ctx->gc_zone = YoungObjectZone;
switch(FASTCTX(ctx)->type) {
case FASTCTX_NORMAL:
SET_CLASS(ctx, BASIC_CLASS(fastctx));
ctx->obj_type = MContextType;
ctx->CTXFast = TRUE;
break;
case FASTCTX_BLOCK:
SET_CLASS(ctx, BASIC_CLASS(blokctx));
ctx->obj_type = BContextType;
break;
case FASTCTX_NMC:
SET_CLASS(ctx, BASIC_CLASS(nmc));
ctx->obj_type = MContextType;
break;
}
SET_NUM_FIELDS(ctx, FASTCTX_FIELDS);
ctx->StoresBytes = TRUE;
ctx->ForeverYoung = TRUE;
fc = FASTCTX(ctx);
/* Fixup the locals tuple. */
if(!NIL_P(fc->locals) && fc->locals->gc_zone == 0) {
fc->locals->gc_zone = YoungObjectZone;
}
}
USER_OBJECT_
makeForeignPerlReference(SV *ref, USER_OBJECT_ classes, ForeignReferenceTable *table)
{
int n;
USER_OBJECT_ rsRef, el;
char *key;
dTHX;
#ifdef USE_NEW_PERL_REFERENCES
SvREFCNT_inc(ref);
/* We make this into a list with the external pointer inside it as the first element
as some of the R code wants to treat it like a list. We will gradually remove this.*/
rsRef = NEW_LIST(1);
PROTECT(rsRef);
SET_VECTOR_ELT(rsRef, 0, el = R_MakeExternalPtr((void *) ref, Rf_install("PerlReference"), R_NilValue));
R_RegisterCFinalizer(el, Rperl_ReleaseReference);
SET_NAMES(rsRef, mkString("ref"));
if(GET_LENGTH(classes)) {
SET_CLASS(rsRef, classes);
}
UNPROTECT(1);
#else
if(table == NULL)
table= &exportReferenceTable;
if(table->entries == NULL) {
table->entries = newHV();
SvREFCNT_inc(table->entries);
n = 0;
} else
n = table->numReferences;
key = (char *) calloc(15, sizeof(char));
if(!key) {
PROBLEM "Cannot allocaate 15 bytes for perl foreign reference key"
ERROR;
}
sprintf(key, "%ld", (long) n);
hv_store(table->entries, key, strlen(key), ref, 0);
SvREFCNT_inc(ref);
table->numReferences++;
rsRef = makeRSReferenceObject(key, classes, table);
#endif
return(rsRef);
}
SEXP wrapPointer(void *ptr, QList<QByteArray> classNames,
R_CFinalizer_t finalizer)
{
SEXP ans;
PROTECT(ans = R_MakeExternalPtr(ptr, R_NilValue, R_NilValue));
if (finalizer)
R_RegisterCFinalizer(ans, finalizer);
SEXP rclassNames = allocVector(STRSXP, classNames.size());
SET_CLASS(ans, rclassNames);
for (int i = 0; i < length(rclassNames); i++)
SET_STRING_ELT(rclassNames, i, mkChar(classNames[i].constData()));
UNPROTECT(1);
return ans;
}
USER_OBJECT_
asRFlag(guint value, GType ftype)
{
USER_OBJECT_ ans, names;
PROTECT(ans = NEW_INTEGER(1));
INTEGER_DATA(ans)[0] = value;
PROTECT(names = NEW_CHARACTER(2));
SET_STRING_ELT(names, 0, COPY_TO_USER_STRING(g_type_name(ftype)));
SET_STRING_ELT(names, 1, COPY_TO_USER_STRING("flag"));
SET_CLASS(ans, names);
UNPROTECT(2);
return(ans);
}
USER_OBJECT_
RGnumeric_createCellReference(Cell *cell, Sheet *sheet)
{
USER_OBJECT_ ans, klass;
const char *elNames[] = {"cell", "sheet"};
PROTECT(ans = NEW_LIST(2));
SET_VECTOR_ELT(ans, 0, RGnumeric_createInternalReference((void*)cell, "GnumericCellPtr"));
SET_VECTOR_ELT(ans, 1, RGnumeric_sheetReference(sheet));
Internal_setNames(elNames, 2, ans);
PROTECT(klass = NEW_CHARACTER(1));
SET_STRING_ELT(klass, 0, COPY_TO_USER_STRING("GnumericCellRef"));
SET_CLASS(ans, klass);
UNPROTECT(2);
return(ans);
}
USER_OBJECT_
RGnumeric_workbookReference(Workbook *sheet)
{
USER_OBJECT_ ans, klass;
double val = (double) (long) sheet;
PROTECT(ans = NEW_NUMERIC(1));
NUMERIC_DATA(ans)[0] = val;
PROTECT(klass = NEW_CHARACTER(1));
SET_STRING_ELT(klass, 0, COPY_TO_USER_STRING("GnumericWorkbookRef"));
SET_CLASS(ans, klass);
UNPROTECT(2);
return(ans);
}
SEXP
R_getEventLoop()
{
SEXP ans, tmp;
/* Will move to S4 classes very soon when we have a NEW() C symbol for these. */
if(!R_eloop) {
return(R_NilValue);
}
#if S4_CLASSES
PROTECT(ans = getREventLoopObject());
/* Have to create _and populate_ the character vector before calling SET_SLOT().
Otherwise, if we create it in the call to SET_SLOT() and populate later, it comes
out empty.*/
PROTECT(tmp = NEW_CHARACTER(1));
if(R_eloop->name)
SET_STRING_ELT(tmp, 0, mkChar(R_eloop->name));
SET_SLOT(ans, Rf_install("name"), tmp);
SET_SLOT(ans, Rf_install("address"), R_MakeExternalPtr(R_eloop, Rf_install("REventLoop"), R_NilValue));
UNPROTECT(2);
#else
PROTECT(ans = NEW_LIST(2));
SET_VECTOR_ELT(ans, ELOOP_NAME_SLOT, tmp = NEW_CHARACTER(1));
if(R_eloop->name)
SET_STRING_ELT(tmp, 0, mkChar(R_eloop->name));
SET_VECTOR_ELT(ans, ELOOP_ADDRESS_SLOT, R_MakeExternalPtr(R_eloop, Rf_install("REventLoop"), R_NilValue));
PROTECT(tmp = NEW_CHARACTER(2));
SET_VECTOR_ELT(tmp, ELOOP_NAME_SLOT, mkChar("name"));
SET_VECTOR_ELT(tmp, ELOOP_ADDRESS_SLOT, mkChar("address"));
SET_NAMES(ans, tmp);
PROTECT(tmp = NEW_CHARACTER(1));
SET_VECTOR_ELT(tmp, 0, mkChar("REventLoop"));
SET_CLASS(ans, tmp);
UNPROTECT(3);
#endif
return(ans);
}
SEXP
makeXMLTextNode(zorba::Item child)
{
SEXP ans, classes, names;
const char * txt;
txt = child.getStringValue().c_str();
PROTECT(ans = NEW_LIST(5));
SET_VECTOR_ELT(ans, 2, mkString(txt));
PROTECT(names = makeRNames(nodeNames, sizeof(nodeNames)/sizeof(nodeNames[0])));
SET_STRING_ELT(names, 2, mkChar("value"));
SET_NAMES(ans, names);
SET_VECTOR_ELT(ans, 0, mkString("text"));
SET_CLASS(ans, makeXMLClassVector("XMLTextNode"));
UNPROTECT(2);
return(ans);
}
SEXP
newRClosureTable(SEXP handlers)
{
R_ObjectTable *tb;
SEXP val, klass, env;
tb = (R_ObjectTable *) malloc(sizeof(R_ObjectTable));
if(!tb)
error("cannot allocate space for an internal R object table");
tb->type = 15;
tb->cachedNames = NULL;
tb->active = TRUE;
R_PreserveObject(handlers);
tb->privateData = handlers;
tb->exists = RClosureTable_exists;
tb->get = RClosureTable_get;
tb->remove = RClosureTable_remove;
tb->assign = RClosureTable_assign;
tb->objects = RClosureTable_objects;
tb->canCache = RClosureTable_canCache;
tb->onAttach = NULL;
tb->onDetach = NULL;
PROTECT(val = R_MakeExternalPtr(tb, Rf_install("UserDefinedDatabase"), R_NilValue));
PROTECT(klass = NEW_CHARACTER(1));
SET_STRING_ELT(klass, 0, COPY_TO_USER_STRING("UserDefinedDatabase"));
SET_CLASS(val, klass);
env = allocSExp(ENVSXP);
SET_HASHTAB(env, val);
SET_ENCLOS(env, R_GlobalEnv);
setAttrib(env, R_ClassSymbol, getAttrib(HASHTAB(env), R_ClassSymbol));
UNPROTECT(2);
return(env);
}
USER_OBJECT_
makeRSReferenceObject(char *id, USER_OBJECT_ classes, ForeignReferenceTable *table)
{
USER_OBJECT_ ans, names, tmp;
char *slotNames[] = {"id", "table", "pid", "class"};
int i;
if(classes && GET_LENGTH(classes)) {
PROTECT(classes);
}
PROTECT(ans = NEW_LIST(NUM_REF_SLOTS));
SET_VECTOR_ELT(ans, ID_SLOT, tmp = NEW_CHARACTER(1));
SET_STRING_ELT(tmp, 0, COPY_TO_USER_STRING(id));
SET_VECTOR_ELT(ans, TABLE_SLOT, tmp = NEW_CHARACTER(1));
/* No name yet. */
SET_VECTOR_ELT(ans, PID_SLOT, tmp = NEW_NUMERIC(1));
NUMERIC_DATA(tmp)[0] = getpid();
PROTECT(names = NEW_CHARACTER(NUM_REF_SLOTS));
for(i = 0; i < NUM_REF_SLOTS; i++)
SET_STRING_ELT(names, i, COPY_TO_USER_STRING(slotNames[i]));
SET_NAMES(ans, names);
if(classes && GET_LENGTH(classes))
SET_CLASS(ans, classes);
UNPROTECT(2);
if(GET_LENGTH(classes)) {
UNPROTECT(1);
}
return(ans);
}
SEXP
R_json_dateStringOp(const char *value, cetype_t encoding)
{
int withNew = 0, noNew = 0;
if( (noNew = (strncmp(value, "/Date(", 6) == 0)) ||
(withNew = strncmp(value, "/new Date(", 10)) == 0) {
double num;
if(noNew)
sscanf(value + 6, "%lf)/", &num);
else
sscanf(value + 10, "%lf)/", &num);
SEXP ans, classNames;
PROTECT(ans = ScalarReal(num));
PROTECT(classNames = NEW_CHARACTER(2));
SET_STRING_ELT(classNames, 0, mkChar("POSIXct"));
SET_STRING_ELT(classNames, 1, mkChar("POSIXt"));
SET_CLASS(ans, classNames);
UNPROTECT(2);
return(ans);
} else
return(ScalarString(mkCharCE(value, encoding)));
}
USER_OBJECT_
toRPangoAttribute(PangoAttribute *attr, gboolean owns)
{
char *type = NULL;
USER_OBJECT_ result;
char *classes[] = { NULL, "PangoAttribute", "RGtkObject", NULL };
if (!attr)
return NULL_USER_OBJECT;
switch(attr->klass->type) {
case PANGO_ATTR_LANGUAGE:
type = "PangoAttrLanguage";
break;
case PANGO_ATTR_FAMILY:
type = "PangoAttrString";
break;
case PANGO_ATTR_STYLE:
case PANGO_ATTR_WEIGHT:
case PANGO_ATTR_VARIANT:
case PANGO_ATTR_STRETCH:
case PANGO_ATTR_UNDERLINE:
case PANGO_ATTR_STRIKETHROUGH:
case PANGO_ATTR_RISE:
case PANGO_ATTR_FALLBACK:
case PANGO_ATTR_LETTER_SPACING:
type = "PangoAttrInt";
break;
case PANGO_ATTR_SIZE:
case PANGO_ATTR_ABSOLUTE_SIZE:
type = "PangoAttrSize";
break;
case PANGO_ATTR_FONT_DESC:
type = "PangoAttrFontDesc";
break;
case PANGO_ATTR_FOREGROUND:
case PANGO_ATTR_BACKGROUND:
case PANGO_ATTR_UNDERLINE_COLOR:
case PANGO_ATTR_STRIKETHROUGH_COLOR:
type = "PangoAttrColor";
break;
case PANGO_ATTR_SHAPE:
type = "PangoAttrShape";
break;
case PANGO_ATTR_SCALE:
type = "PangoAttrFloat";
break;
case PANGO_ATTR_INVALID:
type = "PangoAttrInvalid";
break;
default:
PROBLEM "Error converting PangoAttribute: unknown type %d", attr->klass->type
ERROR;
}
classes[0] = type;
if (!owns)
attr = pango_attribute_copy(attr);
PROTECT(result = toRPointerWithFinalizer(attr, NULL, (RPointerFinalizer)pango_attribute_destroy));
SET_CLASS(result, asRStringArray(classes));
UNPROTECT(1);
return(result);
}
SEXP
makeXMLNode(zorba::Item it, bool ref)
{
SEXP ans;
if(ref) {
return(makeXMLNodeRef(it));
}
PROTECT(ans = NEW_LIST(sizeof(nodeNames)/sizeof(nodeNames[0])));
zorba::Iterator_t kids, vals;
unsigned int n = 0, i, numAttrs = 0;
zorba::Item child, val;
SEXP names, tmp;
it.getNodeName(val);
SET_VECTOR_ELT(ans, 0, mkString(val.getStringValue().c_str()));
kids = it.getAttributes();
kids->open(); while(kids->next(child)) n++; kids->close();
PROTECT(tmp = NEW_CHARACTER(n));
PROTECT(names = NEW_CHARACTER(n));
for(i = 0, kids->open(); i < n ; i++) {
kids->next(child);
child.getNodeName(val);
SET_STRING_ELT(tmp, i, mkChar(child.getStringValue().c_str()));
SET_STRING_ELT(names, i, mkChar(val.getStringValue().c_str()));
}
numAttrs = n;
SET_NAMES(tmp, names);
SET_VECTOR_ELT(ans, 1, tmp);
UNPROTECT(2);
/* child nodes.*/
n = 0;
kids = it.getChildren();
kids->open(); while(kids->next(child)) n++; kids->close();
SEXP r_kids;
PROTECT(r_kids = NEW_LIST(n));
kids->open();
for(i = 0; i < n ; i++) {
kids->next(child);
SEXP tmp = convertItemToR(child);
PROTECT(tmp);
if(TYPEOF(tmp) == STRSXP) {
tmp = makeTextNode(tmp);
}
SET_VECTOR_ELT(r_kids, i, tmp);
UNPROTECT(1);
}
kids->close();
SET_VECTOR_ELT(ans, 2, r_kids);
UNPROTECT(1);
RSetNames(ans, nodeNames);
SET_CLASS(ans, makeRNames(nodeClassNames, sizeof(nodeClassNames)/sizeof(nodeClassNames[0])));
// SET_CLASS(ans, mkString("XMLNode"));
UNPROTECT(1);
return(ans);
}
SEXP
processJSONNode(JSONNODE *n, int parentType, int simplify, SEXP nullValue, int simplifyWithNames, cetype_t charEncoding,
SEXP r_stringCall, StringFunctionType str_fun_type)
{
if (n == NULL){
PROBLEM "invalid JSON input"
ERROR;
}
JSONNODE *i;
int len = 0, ctr = 0;
int nprotect = 0;
int numNulls = 0;
len = json_size(n);
char startType = parentType; // was 127
int isNullHomogeneous = (TYPEOF(nullValue) == LGLSXP || TYPEOF(nullValue) == REALSXP ||
TYPEOF(nullValue) == STRSXP || TYPEOF(nullValue) == INTSXP);
int numStrings = 0;
int numLogicals = 0;
int numNumbers = 0;
SEXP ans, names = NULL;
PROTECT(ans = NEW_LIST(len)); nprotect++;
int homogeneous = 0;
int elType = NILSXP;
while (ctr < len){ // i != json_end(n)
i = json_at(n, ctr);
if (i == NULL){
PROBLEM "Invalid JSON Node"
ERROR;
}
json_char *node_name = json_name(i);
char type = json_type(i);
if(startType == 127)
startType = type;
SEXP el;
switch(type) {
case JSON_NULL:
el = nullValue; /* R_NilValue; */
numNulls++;
if(isNullHomogeneous) {
homogeneous++;
elType = setType(elType, TYPEOF(nullValue));
} else
elType = TYPEOF(nullValue);
break;
case JSON_ARRAY:
case JSON_NODE:
el = processJSONNode(i, type, simplify, nullValue, simplifyWithNames, charEncoding, r_stringCall, str_fun_type);
if(Rf_length(el) > 1)
elType = VECSXP;
else
elType = setType(elType, TYPEOF(el));
break;
case JSON_NUMBER:
el = ScalarReal(json_as_float(i));
homogeneous++;
elType = setType(elType, REALSXP);
numNumbers++;
break;
case JSON_BOOL:
el = ScalarLogical(json_as_bool(i));
elType = setType(elType, LGLSXP);
numLogicals++;
break;
case JSON_STRING:
{
//XXX Garbage collection
#if 0 //def JSON_UNICODE
wchar_t *wtmp = json_as_string(i);
char *tmp;
int len = wcslen(wtmp);
int size = sizeof(char) * (len * MB_LEN_MAX + 1);
tmp = (char *)malloc(size);
if (tmp == NULL) {
PROBLEM "Cannot allocate memory"
ERROR;
}
wcstombs(tmp, wtmp, size);
#else
char *tmp = json_as_string(i);
// tmp = reEnc(tmp, CE_BYTES, CE_UTF8, 1);
#endif
if(r_stringCall != NULL && TYPEOF(r_stringCall) == EXTPTRSXP) {
if(str_fun_type == SEXP_STR_ROUTINE) {
SEXPStringRoutine fun;
fun = (SEXPStringRoutine) R_ExternalPtrAddr(r_stringCall);
el = fun(tmp, charEncoding);
} else {
char *tmp1;
StringRoutine fun;
fun = (StringRoutine) R_ExternalPtrAddr(r_stringCall);
tmp1 = fun(tmp);
if(tmp1 != tmp)
json_free(tmp);
tmp = tmp1;
el = ScalarString(mkCharCE(tmp, charEncoding));
}
} else {
el = ScalarString(mkCharCE(tmp, charEncoding));
/* Call the R function if there is one. */
if(r_stringCall != NULL) {
SETCAR(CDR(r_stringCall), el);
el = Rf_eval(r_stringCall, R_GlobalEnv);
}
/* XXX compute with elType. */
}
json_free(tmp);
elType = setType(elType,
/* If we have a class, not a primitive type */
Rf_length(getAttrib(el, Rf_install("class"))) ? LISTSXP : TYPEOF(el));
if(r_stringCall != NULL && str_fun_type != NATIVE_STR_ROUTINE) {
switch(TYPEOF(el)) {
case REALSXP:
numNumbers++;
break;
case LGLSXP:
numLogicals++;
break;
case STRSXP:
numStrings++;
break;
}
} else if(TYPEOF(el) == STRSXP)
numStrings++;
}
break;
default:
PROBLEM "shouldn't be here"
WARN;
el = R_NilValue;
break;
}
SET_VECTOR_ELT(ans, ctr, el);
if(parentType == JSON_NODE || (node_name && node_name[0])) {
if(names == NULL) {
PROTECT(names = NEW_CHARACTER(len)); nprotect++;
}
if(node_name && node_name[0])
SET_STRING_ELT(names, ctr, mkChar(node_name));
}
json_free(node_name);
ctr++;
}
/* If we have an empty object, we try to make it into a form equivalent to emptyNamedList
if it is a {}, or as an AsIs object in R if an empty array. */
if(len == 0 && (parentType == -1 || parentType == JSON_ARRAY || parentType == JSON_NODE)) {
if(parentType == -1)
parentType = startType;
if(parentType == JSON_NODE)
SET_NAMES(ans, NEW_CHARACTER(0));
else {
SET_CLASS(ans, ScalarString(mkChar("AsIs")));
}
} else if(simplifyWithNames || names == NULL || Rf_length(names) == 0) {
int allSame = (numNumbers == len || numStrings == len || numLogicals == len) ||
((TYPEOF(nullValue) == LGLSXP && LOGICAL(nullValue)[0] == NA_INTEGER) &&
((numNumbers + numNulls) == len || (numStrings + numNulls) == len || (numLogicals + numNulls) == len));
homogeneous = allSame || ( (numNumbers + numStrings + numLogicals + numNulls) == len);
if(simplify == NONE) {
} else if(allSame &&
(numNumbers == len && (simplify & STRICT_NUMERIC)) ||
((numLogicals == len) && (simplify & STRICT_LOGICAL)) ||
( (numStrings == len) && (simplify & STRICT_CHARACTER))) {
ans = makeVector(ans, len, elType, nullValue);
} else if((simplify == ALL && homogeneous) || (simplify == STRICT && allSame)) {
ans = makeVector(ans, len, elType, nullValue);
}
}
if(names)
SET_NAMES(ans, names);
UNPROTECT(nprotect);
return(ans);
}
SEXP sdf_do_biglm(SEXP sdfx, SEXP svecy, SEXP sdfx_dim, SEXP intercept) {
SEXP sdflm, qr, D, rbar, thetab, tmp;
int np, nrbar, nprotect = 0, intrcpt, i, ier;
double *xrow, y, *ptrD, *ptrrbar, *ptrthetab, sserr, weight;
sqlite3_stmt *stmt1, *stmt2;
const char *inamex, *inamey, *tblnamey, *varnamey;
inamex = SDF_INAME(sdfx);
inamey = SDF_INAME(svecy);
tblnamey = SVEC_TBLNAME(svecy);
varnamey = SVEC_VARNAME(svecy);
if (!USE_SDF1(inamex, TRUE, TRUE)) return R_NilValue;
if (!USE_SDF1(inamey, TRUE, TRUE)) return R_NilValue;
/* get number of columns for sdfx */
np = INTEGER(sdfx_dim)[1];
intrcpt = (LOGICAL(intercept)[0]) ? 1 : 0;
np += intrcpt;
nrbar = (np*(np-1))/2;
/* Rprintf("np: %d, nrbar %d\n", np, nrbar); */
PROTECT(D = NEW_NUMERIC(np));
nprotect++;
PROTECT(rbar = NEW_NUMERIC(nrbar));
nprotect++;
PROTECT(thetab = NEW_NUMERIC(np));
nprotect++;
xrow = (double *)R_alloc(np, sizeof(double));
/* initialize bigqr values */
if (intrcpt) xrow[0] = 1.0;
sserr = 0.0;
ptrD = REAL(D);
ptrrbar = REAL(rbar);
ptrthetab = REAL(thetab);
for (i = 0; i < np; i++) ptrD[i] = ptrrbar[i] = ptrthetab[i] = 0.0;
for ( ; i < nrbar; i++) ptrrbar[i] = 0.0;
/* setup sqlite_stmt's */
sprintf(g_sql_buf[0], "select * from [%s].sdf_data", inamex);
_sqlite_error(sqlite3_prepare(g_workspace, g_sql_buf[0], -1, &stmt1, NULL));
sprintf(g_sql_buf[0], "select [%s] from [%s].[%s]", varnamey, inamey, tblnamey);
_sqlite_error(sqlite3_prepare(g_workspace, g_sql_buf[0], -1, &stmt2, NULL));
if (intrcpt) {
while (sqlite3_step(stmt1) == SQLITE_ROW) {
sqlite3_step(stmt2);
for (i = 1; i < np; i++)
xrow[i] = sqlite3_column_double(stmt1, i);
y = sqlite3_column_double(stmt2, 0);
weight = 1.0;
/*__include(np, nrbar, ptrD, ptrrbar, ptrthetab, &sserr, xrow, y, 1.0); */
F77_CALL(includ)(&np, &nrbar, &weight, xrow, &y, ptrD, ptrrbar, ptrthetab, &sserr, &ier);
}
} else {
while (sqlite3_step(stmt1) == SQLITE_ROW) {
sqlite3_step(stmt2);
for (i = 0; i < np; i++)
xrow[i] = sqlite3_column_double(stmt1, i+1);
y = sqlite3_column_double(stmt2, 0);
/*__include(np, nrbar, ptrD, ptrrbar, ptrthetab, &sserr, xrow, y, 1.0); */
weight = 1;
F77_CALL(includ)(&np, &nrbar, &weight, xrow, &y, ptrD, ptrrbar, ptrthetab, &sserr, &ier);
}
}
sqlite3_finalize(stmt1);
sqlite3_finalize(stmt2);
/* setup bigqr SEXP */
PROTECT(qr = NEW_LIST(6));
nprotect++;
/* set names */
PROTECT(tmp = NEW_CHARACTER(6));
nprotect++;
SET_STRING_ELT(tmp, 0, mkChar("D"));
SET_STRING_ELT(tmp, 1, mkChar("rbar"));
SET_STRING_ELT(tmp, 2, mkChar("thetab"));
SET_STRING_ELT(tmp, 3, mkChar("ss"));
SET_STRING_ELT(tmp, 4, mkChar("checked"));
SET_STRING_ELT(tmp, 5, mkChar("tol"));
SET_NAMES(qr, tmp);
/* set values */
SET_VECTOR_ELT(qr, 0, D);
SET_VECTOR_ELT(qr, 1, rbar);
SET_VECTOR_ELT(qr, 2, thetab);
SET_VECTOR_ELT(qr, 3, ScalarReal(sserr));
SET_VECTOR_ELT(qr, 4, ScalarLogical(FALSE));
PROTECT(tmp = NEW_NUMERIC(np));
nprotect++;
for (i = 0; i < np; i++) REAL(tmp)[i] = 0.0;
SET_VECTOR_ELT(qr, 5, tmp);
/* set class */
SET_CLASS(qr, mkString("bigqr"));
/* setup sdflm SEXP */
PROTECT(sdflm = NEW_LIST(3));
nprotect++;
PROTECT(tmp = NEW_CHARACTER(3));
nprotect++;
SET_STRING_ELT(tmp, 0, mkChar("qr"));
SET_STRING_ELT(tmp, 1, mkChar("X"));
SET_STRING_ELT(tmp, 2, mkChar("intercept"));
SET_NAMES(sdflm, tmp);
SET_VECTOR_ELT(sdflm, 0, qr);
SET_VECTOR_ELT(sdflm, 1, duplicate(sdfx));
SET_VECTOR_ELT(sdflm, 2, ScalarLogical(intrcpt));
PROTECT(tmp = NEW_CHARACTER(2));
nprotect++;
SET_STRING_ELT(tmp, 0, mkChar("sdflm"));
SET_STRING_ELT(tmp, 1, mkChar("biglm"));
SET_CLASS(sdflm, tmp);
UNPROTECT(nprotect);
UNUSE_SDF2(inamex);
UNUSE_SDF2(inamey);
return sdflm;
}
