SEXP attribute_hidden do_subset2_dflt(SEXP call, SEXP op, SEXP args, SEXP rho)
{
SEXP ans, dims, dimnames, indx, subs, x;
int i, ndims, nsubs;
int drop = 1, pok, exact = -1;
int named_x;
R_xlen_t offset = 0;
PROTECT(args);
ExtractDropArg(args, &drop);
/* Is partial matching ok? When the exact arg is NA, a warning is
issued if partial matching occurs.
*/
exact = ExtractExactArg(args);
if (exact == -1)
pok = exact;
else
pok = !exact;
x = CAR(args);
/* This code was intended for compatibility with S, */
/* but in fact S does not do this. Will anyone notice? */
if (x == R_NilValue) {
UNPROTECT(1);
return x;
}
/* Get the subscripting and dimensioning information */
/* and check that any array subscripting is compatible. */
subs = CDR(args);
if(0 == (nsubs = length(subs)))
errorcall(call, _("no index specified"));
dims = getAttrib(x, R_DimSymbol);
ndims = length(dims);
if(nsubs > 1 && nsubs != ndims)
errorcall(call, _("incorrect number of subscripts"));
/* code to allow classes to extend environment */
if(TYPEOF(x) == S4SXP) {
x = R_getS4DataSlot(x, ANYSXP);
if(x == R_NilValue)
errorcall(call, _("this S4 class is not subsettable"));
}
/* split out ENVSXP for now */
if( TYPEOF(x) == ENVSXP ) {
if( nsubs != 1 || !isString(CAR(subs)) || length(CAR(subs)) != 1 )
errorcall(call, _("wrong arguments for subsetting an environment"));
ans = findVarInFrame(x, install(translateChar(STRING_ELT(CAR(subs), 0))));
if( TYPEOF(ans) == PROMSXP ) {
PROTECT(ans);
ans = eval(ans, R_GlobalEnv);
UNPROTECT(1);
} else SET_NAMED(ans, 2);
UNPROTECT(1);
if(ans == R_UnboundValue)
return(R_NilValue);
if (NAMED(ans))
SET_NAMED(ans, 2);
return ans;
}
/* back to the regular program */
if (!(isVector(x) || isList(x) || isLanguage(x)))
errorcall(call, R_MSG_ob_nonsub, type2char(TYPEOF(x)));
named_x = NAMED(x); /* x may change below; save this now. See PR#13411 */
if(nsubs == 1) { /* vector indexing */
SEXP thesub = CAR(subs);
int len = length(thesub);
if (len > 1)
x = vectorIndex(x, thesub, 0, len-1, pok, call);
offset = get1index(thesub, getAttrib(x, R_NamesSymbol),
xlength(x), pok, len > 1 ? len-1 : -1, call);
if (offset < 0 || offset >= xlength(x)) {
/* a bold attempt to get the same behaviour for $ and [[ */
if (offset < 0 && (isNewList(x) ||
isExpression(x) ||
isList(x) ||
isLanguage(x))) {
UNPROTECT(1);
return R_NilValue;
}
else errorcall(call, R_MSG_subs_o_b);
}
} else { /* matrix indexing */
/* Here we use the fact that: */
/* CAR(R_NilValue) = R_NilValue */
/* CDR(R_NilValue) = R_NilValue */
int ndn; /* Number of dimnames. Unlikely to be anything but
0 or nsubs, but just in case... */
PROTECT(indx = allocVector(INTSXP, nsubs));
dimnames = getAttrib(x, R_DimNamesSymbol);
ndn = length(dimnames);
for (i = 0; i < nsubs; i++) {
INTEGER(indx)[i] = (int)
get1index(CAR(subs),
(i < ndn) ? VECTOR_ELT(dimnames, i) : R_NilValue,
INTEGER(indx)[i], pok, -1, call);
subs = CDR(subs);
if (INTEGER(indx)[i] < 0 ||
INTEGER(indx)[i] >= INTEGER(dims)[i])
errorcall(call, R_MSG_subs_o_b);
}
offset = 0;
for (i = (nsubs - 1); i > 0; i--)
offset = (offset + INTEGER(indx)[i]) * INTEGER(dims)[i - 1];
offset += INTEGER(indx)[0];
UNPROTECT(1);
}
if(isPairList(x)) {
#ifdef LONG_VECTOR_SUPPORT
if (offset > R_SHORT_LEN_MAX)
error("invalid subscript for pairlist");
#endif
ans = CAR(nthcdr(x, (int) offset));
if (named_x > NAMED(ans))
SET_NAMED(ans, named_x);
} else if(isVectorList(x)) {
/* did unconditional duplication before 2.4.0 */
ans = VECTOR_ELT(x, offset);
if (named_x > NAMED(ans))
SET_NAMED(ans, named_x);
} else {
ans = allocVector(TYPEOF(x), 1);
switch (TYPEOF(x)) {
case LGLSXP:
case INTSXP:
INTEGER(ans)[0] = INTEGER(x)[offset];
break;
case REALSXP:
REAL(ans)[0] = REAL(x)[offset];
break;
case CPLXSXP:
COMPLEX(ans)[0] = COMPLEX(x)[offset];
break;
case STRSXP:
SET_STRING_ELT(ans, 0, STRING_ELT(x, offset));
break;
case RAWSXP:
RAW(ans)[0] = RAW(x)[offset];
break;
default:
UNIMPLEMENTED_TYPE("do_subset2", x);
}
}
UNPROTECT(1);
return ans;
}
int
interface_validation(char *interfac)
{
return isString(interfac);
}
string CppVariant::toString() const
{
BLINK_ASSERT(isString());
return string(value.stringValue.UTF8Characters,
value.stringValue.UTF8Length);
}
SEXP attribute_hidden do_substrgets(SEXP call, SEXP op, SEXP args, SEXP env)
{
SEXP s, x, sa, so, value, el, v_el;
R_xlen_t i, len;
int start, stop, k, l, v;
size_t slen;
cetype_t ienc, venc;
const char *ss, *v_ss;
char *buf;
const void *vmax;
checkArity(op, args);
x = CAR(args);
sa = CADR(args);
so = CADDR(args);
value = CADDDR(args);
k = LENGTH(sa);
l = LENGTH(so);
if (!isString(x))
error(_("replacing substrings in a non-character object"));
len = LENGTH(x);
PROTECT(s = allocVector(STRSXP, len));
if (len > 0) {
if (!isInteger(sa) || !isInteger(so) || k == 0 || l == 0)
error(_("invalid substring arguments"));
v = LENGTH(value);
if (!isString(value) || v == 0) error(_("invalid value"));
vmax = vmaxget();
for (i = 0; i < len; i++) {
el = STRING_ELT(x, i);
v_el = STRING_ELT(value, i % v);
start = INTEGER(sa)[i % k];
stop = INTEGER(so)[i % l];
if (el == NA_STRING || v_el == NA_STRING ||
start == NA_INTEGER || stop == NA_INTEGER) {
SET_STRING_ELT(s, i, NA_STRING);
continue;
}
ienc = getCharCE(el);
ss = CHAR(el);
slen = strlen(ss);
if (start < 1) start = 1;
if (stop > slen) stop = (int) slen; /* SBCS optimization */
if (start > stop) {
/* just copy element across */
SET_STRING_ELT(s, i, STRING_ELT(x, i));
} else {
int ienc2 = ienc;
v_ss = CHAR(v_el);
/* is the value in the same encoding?
FIXME: could prefer UTF-8 here
*/
venc = getCharCE(v_el);
if (venc != ienc && !strIsASCII(v_ss)) {
ss = translateChar(el);
slen = strlen(ss);
v_ss = translateChar(v_el);
ienc2 = CE_NATIVE;
}
/* might expand under MBCS */
buf = R_AllocStringBuffer(slen+strlen(v_ss), &cbuff);
strcpy(buf, ss);
substrset(buf, v_ss, ienc2, start, stop);
SET_STRING_ELT(s, i, mkCharCE(buf, ienc2));
}
vmaxset(vmax);
}
R_FreeStringBufferL(&cbuff);
}
UNPROTECT(1);
return s;
}
SEXP attribute_hidden do_switch(SEXP call, SEXP op, SEXP args, SEXP rho)
{
int argval, nargs = length(args);
SEXP x, y, z, w, ans, dflt = NULL;
if (nargs < 1) errorcall(call, _("'EXPR' is missing"));
check1arg(args, call, "EXPR");
PROTECT(x = eval(CAR(args), rho));
if (!isVector(x) || length(x) != 1)
errorcall(call, _("EXPR must be a length 1 vector"));
if (isFactor(x))
warningcall(call,
_("EXPR is a \"factor\", treated as integer.\n"
" Consider using '%s' instead."),
"switch(as.character( * ), ...)");
if (nargs > 1) {
/* There is a complication: if called from lapply
there may be a ... argument */
PROTECT(w = expandDots(CDR(args), rho));
if (isString(x)) {
for (y = w; y != R_NilValue; y = CDR(y)) {
if (TAG(y) != R_NilValue) {
if (pmatch(STRING_ELT(x, 0), TAG(y), 1 /* exact */)) {
/* Find the next non-missing argument.
(If there is none, return NULL.) */
while (CAR(y) == R_MissingArg) {
y = CDR(y);
if (y == R_NilValue) break;
if (TAG(y) == R_NilValue) dflt = setDflt(y, dflt);
}
if (y == R_NilValue) {
R_Visible = FALSE;
UNPROTECT(2);
return R_NilValue;
}
/* Check for multiple defaults following y. This loop
is not necessary to determine the value of the
switch(), but it should be fast and will detect
typos. */
for (z = CDR(y); z != R_NilValue; z = CDR(z))
if (TAG(z) == R_NilValue) dflt = setDflt(z, dflt);
ans = eval(CAR(y), rho);
UNPROTECT(2);
return ans;
}
} else
dflt = setDflt(y, dflt);
}
if (dflt) {
ans = eval(dflt, rho);
UNPROTECT(2);
return ans;
}
/* fall through to error */
} else { /* Treat as numeric */
argval = asInteger(x);
if (argval != NA_INTEGER && argval >= 1 && argval <= length(w)) {
SEXP alt = CAR(nthcdr(w, argval - 1));
if (alt == R_MissingArg)
error("empty alternative in numeric switch");
ans = eval(alt, rho);
UNPROTECT(2);
return ans;
}
/* fall through to error */
}
UNPROTECT(1); /* w */
}
/* an error */
UNPROTECT(1); /* x */
R_Visible = FALSE;
return R_NilValue;
}
/* Note that NA_STRING is not handled separately here. This is
deliberate -- see ?paste -- and implicitly coerces it to "NA"
*/
SEXP attribute_hidden do_paste(SEXP call, SEXP op, SEXP args, SEXP env)
{
SEXP ans, collapse, sep, x;
int sepw, u_sepw, ienc;
R_xlen_t i, j, k, maxlen, nx, pwidth;
const char *s, *cbuf, *csep=NULL, *u_csep=NULL;
char *buf;
Rboolean allKnown, anyKnown, use_UTF8, use_Bytes,
sepASCII = TRUE, sepUTF8 = FALSE, sepBytes = FALSE, sepKnown = FALSE,
use_sep = (PRIMVAL(op) == 0);
const void *vmax;
checkArity(op, args);
/* We use formatting and so we must initialize printing. */
PrintDefaults();
/* Check the arguments */
x = CAR(args);
if (!isVectorList(x))
error(_("invalid first argument"));
nx = xlength(x);
if(use_sep) { /* paste(..., sep, .) */
sep = CADR(args);
if (!isString(sep) || LENGTH(sep) <= 0 || STRING_ELT(sep, 0) == NA_STRING)
error(_("invalid separator"));
sep = STRING_ELT(sep, 0);
csep = translateChar(sep);
u_sepw = sepw = (int) strlen(csep); // will be short
sepASCII = strIsASCII(csep);
sepKnown = ENC_KNOWN(sep) > 0;
sepUTF8 = IS_UTF8(sep);
sepBytes = IS_BYTES(sep);
collapse = CADDR(args);
} else { /* paste0(..., .) */
u_sepw = sepw = 0; sep = R_NilValue;/* -Wall */
collapse = CADR(args);
}
if (!isNull(collapse))
if(!isString(collapse) || LENGTH(collapse) <= 0 ||
STRING_ELT(collapse, 0) == NA_STRING)
error(_("invalid '%s' argument"), "collapse");
if(nx == 0)
return (!isNull(collapse)) ? mkString("") : allocVector(STRSXP, 0);
/* Maximum argument length, coerce if needed */
maxlen = 0;
for (j = 0; j < nx; j++) {
if (!isString(VECTOR_ELT(x, j))) {
/* formerly in R code: moved to C for speed */
SEXP call, xj = VECTOR_ELT(x, j);
if(OBJECT(xj)) { /* method dispatch */
PROTECT(call = lang2(install("as.character"), xj));
SET_VECTOR_ELT(x, j, eval(call, env));
UNPROTECT(1);
} else if (isSymbol(xj))
SET_VECTOR_ELT(x, j, ScalarString(PRINTNAME(xj)));
else
SET_VECTOR_ELT(x, j, coerceVector(xj, STRSXP));
if (!isString(VECTOR_ELT(x, j)))
error(_("non-string argument to internal 'paste'"));
}
if(xlength(VECTOR_ELT(x, j)) > maxlen)
maxlen = xlength(VECTOR_ELT(x, j));
}
if(maxlen == 0)
return (!isNull(collapse)) ? mkString("") : allocVector(STRSXP, 0);
PROTECT(ans = allocVector(STRSXP, maxlen));
for (i = 0; i < maxlen; i++) {
/* Strategy for marking the encoding: if all inputs (including
* the separator) are ASCII, so is the output and we don't
* need to mark. Otherwise if all non-ASCII inputs are of
* declared encoding, we should mark.
* Need to be careful only to include separator if it is used.
*/
anyKnown = FALSE; allKnown = TRUE; use_UTF8 = FALSE; use_Bytes = FALSE;
if(nx > 1) {
allKnown = sepKnown || sepASCII;
anyKnown = sepKnown;
use_UTF8 = sepUTF8;
use_Bytes = sepBytes;
}
pwidth = 0;
for (j = 0; j < nx; j++) {
k = xlength(VECTOR_ELT(x, j));
if (k > 0) {
SEXP cs = STRING_ELT(VECTOR_ELT(x, j), i % k);
if(IS_UTF8(cs)) use_UTF8 = TRUE;
if(IS_BYTES(cs)) use_Bytes = TRUE;
}
}
if (use_Bytes) use_UTF8 = FALSE;
vmax = vmaxget();
for (j = 0; j < nx; j++) {
k = xlength(VECTOR_ELT(x, j));
if (k > 0) {
if(use_Bytes)
pwidth += strlen(CHAR(STRING_ELT(VECTOR_ELT(x, j), i % k)));
else if(use_UTF8)
pwidth += strlen(translateCharUTF8(STRING_ELT(VECTOR_ELT(x, j), i % k)));
else
pwidth += strlen(translateChar(STRING_ELT(VECTOR_ELT(x, j), i % k)));
vmaxset(vmax);
}
}
if(use_sep) {
if (use_UTF8 && !u_csep) {
u_csep = translateCharUTF8(sep);
u_sepw = (int) strlen(u_csep); // will be short
}
pwidth += (nx - 1) * (use_UTF8 ? u_sepw : sepw);
}
if (pwidth > INT_MAX)
error(_("result would exceed 2^31-1 bytes"));
cbuf = buf = R_AllocStringBuffer(pwidth, &cbuff);
vmax = vmaxget();
for (j = 0; j < nx; j++) {
k = xlength(VECTOR_ELT(x, j));
if (k > 0) {
SEXP cs = STRING_ELT(VECTOR_ELT(x, j), i % k);
if (use_UTF8) {
s = translateCharUTF8(cs);
strcpy(buf, s);
buf += strlen(s);
} else {
s = use_Bytes ? CHAR(cs) : translateChar(cs);
strcpy(buf, s);
buf += strlen(s);
allKnown = allKnown && (strIsASCII(s) || (ENC_KNOWN(cs)> 0));
anyKnown = anyKnown || (ENC_KNOWN(cs)> 0);
}
}
if (sepw != 0 && j != nx - 1) {
if (use_UTF8) {
strcpy(buf, u_csep);
buf += u_sepw;
} else {
strcpy(buf, csep);
buf += sepw;
}
}
vmax = vmaxget();
}
ienc = 0;
if(use_UTF8) ienc = CE_UTF8;
else if(use_Bytes) ienc = CE_BYTES;
else if(anyKnown && allKnown) {
if(known_to_be_latin1) ienc = CE_LATIN1;
if(known_to_be_utf8) ienc = CE_UTF8;
}
SET_STRING_ELT(ans, i, mkCharCE(cbuf, ienc));
}
/* Now collapse, if required. */
if(collapse != R_NilValue && (nx = XLENGTH(ans)) > 0) {
sep = STRING_ELT(collapse, 0);
use_UTF8 = IS_UTF8(sep);
use_Bytes = IS_BYTES(sep);
for (i = 0; i < nx; i++) {
if(IS_UTF8(STRING_ELT(ans, i))) use_UTF8 = TRUE;
if(IS_BYTES(STRING_ELT(ans, i))) use_Bytes = TRUE;
}
if(use_Bytes) {
csep = CHAR(sep);
use_UTF8 = FALSE;
} else if(use_UTF8)
csep = translateCharUTF8(sep);
else
csep = translateChar(sep);
sepw = (int) strlen(csep);
anyKnown = ENC_KNOWN(sep) > 0;
allKnown = anyKnown || strIsASCII(csep);
pwidth = 0;
vmax = vmaxget();
for (i = 0; i < nx; i++)
if(use_UTF8) {
pwidth += strlen(translateCharUTF8(STRING_ELT(ans, i)));
vmaxset(vmax);
} else /* already translated */
pwidth += strlen(CHAR(STRING_ELT(ans, i)));
pwidth += (nx - 1) * sepw;
if (pwidth > INT_MAX)
error(_("result would exceed 2^31-1 bytes"));
cbuf = buf = R_AllocStringBuffer(pwidth, &cbuff);
vmax = vmaxget();
for (i = 0; i < nx; i++) {
if(i > 0) {
strcpy(buf, csep);
buf += sepw;
}
if(use_UTF8)
s = translateCharUTF8(STRING_ELT(ans, i));
else /* already translated */
s = CHAR(STRING_ELT(ans, i));
strcpy(buf, s);
while (*buf)
buf++;
allKnown = allKnown &&
(strIsASCII(s) || (ENC_KNOWN(STRING_ELT(ans, i)) > 0));
anyKnown = anyKnown || (ENC_KNOWN(STRING_ELT(ans, i)) > 0);
if(use_UTF8) vmaxset(vmax);
}
UNPROTECT(1);
ienc = CE_NATIVE;
if(use_UTF8) ienc = CE_UTF8;
else if(use_Bytes) ienc = CE_BYTES;
else if(anyKnown && allKnown) {
if(known_to_be_latin1) ienc = CE_LATIN1;
if(known_to_be_utf8) ienc = CE_UTF8;
}
PROTECT(ans = allocVector(STRSXP, 1));
SET_STRING_ELT(ans, 0, mkCharCE(cbuf, ienc));
}
R_FreeStringBufferL(&cbuff);
UNPROTECT(1);
return ans;
}
bool StyleContext::evalStyle(FunctionID _id, StyleParamKey _key, StyleParam::Value& _val) {
_val = none_type{};
JSScope jsScope(*m_jsContext);
auto jsValue = jsScope.getFunctionResult(_id);
if (!jsValue) {
return false;
}
if (jsValue.isString()) {
std::string value = jsValue.toString();
switch (_key) {
case StyleParamKey::outline_style:
case StyleParamKey::repeat_group:
case StyleParamKey::sprite:
case StyleParamKey::sprite_default:
case StyleParamKey::style:
case StyleParamKey::text_align:
case StyleParamKey::text_repeat_group:
case StyleParamKey::text_source:
case StyleParamKey::text_source_left:
case StyleParamKey::text_source_right:
case StyleParamKey::text_transform:
case StyleParamKey::texture:
_val = value;
break;
case StyleParamKey::color:
case StyleParamKey::outline_color:
case StyleParamKey::text_font_fill:
case StyleParamKey::text_font_stroke_color: {
Color result;
if (StyleParam::parseColor(value, result)) {
_val = result.abgr;
} else {
LOGW("Invalid color value: %s", value.c_str());
}
break;
}
default:
_val = StyleParam::parseString(_key, value);
break;
}
} else if (jsValue.isBoolean()) {
bool value = jsValue.toBool();
switch (_key) {
case StyleParamKey::interactive:
case StyleParamKey::text_interactive:
case StyleParamKey::visible:
_val = value;
break;
case StyleParamKey::extrude:
_val = value ? glm::vec2(NAN, NAN) : glm::vec2(0.0f, 0.0f);
break;
default:
break;
}
} else if (jsValue.isArray()) {
auto len = jsValue.getLength();
switch (_key) {
case StyleParamKey::extrude: {
if (len != 2) {
LOGW("Wrong array size for extrusion: '%d'.", len);
break;
}
double v1 = jsValue.getValueAtIndex(0).toDouble();
double v2 = jsValue.getValueAtIndex(1).toDouble();
_val = glm::vec2(v1, v2);
break;
}
case StyleParamKey::color:
case StyleParamKey::outline_color:
case StyleParamKey::text_font_fill:
case StyleParamKey::text_font_stroke_color: {
if (len < 3 || len > 4) {
LOGW("Wrong array size for color: '%d'.", len);
break;
}
double r = jsValue.getValueAtIndex(0).toDouble();
double g = jsValue.getValueAtIndex(1).toDouble();
double b = jsValue.getValueAtIndex(2).toDouble();
double a = 1.0;
if (len == 4) {
a = jsValue.getValueAtIndex(3).toDouble();
}
_val = ColorF(r, g, b, a).toColor().abgr;
break;
}
default:
break;
}
} else if (jsValue.isNumber()) {
double number = jsValue.toDouble();
if (std::isnan(number)) {
LOGD("duk evaluates JS method to NAN.\n");
}
switch (_key) {
case StyleParamKey::text_source:
case StyleParamKey::text_source_left:
case StyleParamKey::text_source_right:
_val = doubleToString(number);
break;
case StyleParamKey::extrude:
_val = glm::vec2(0.f, number);
break;
case StyleParamKey::placement_spacing: {
_val = StyleParam::Width{static_cast<float>(number), Unit::pixel};
break;
}
case StyleParamKey::width:
case StyleParamKey::outline_width: {
// TODO more efficient way to return pixels.
// atm this only works by return value as string
_val = StyleParam::Width{static_cast<float>(number)};
break;
}
case StyleParamKey::angle:
case StyleParamKey::priority:
case StyleParamKey::text_priority:
case StyleParamKey::text_font_stroke_width:
case StyleParamKey::placement_min_length_ratio: {
_val = static_cast<float>(number);
break;
}
case StyleParamKey::size: {
StyleParam::SizeValue vec;
vec.x.value = static_cast<float>(number);
_val = vec;
break;
}
case StyleParamKey::order:
case StyleParamKey::outline_order:
case StyleParamKey::color:
case StyleParamKey::outline_color:
case StyleParamKey::text_font_fill:
case StyleParamKey::text_font_stroke_color: {
_val = static_cast<uint32_t>(number);
break;
}
default:
break;
}
} else if (jsValue.isUndefined()) {
// Explicitly set value as 'undefined'. This is important for some styling rules.
_val = Undefined();
} else {
LOGW("Unhandled return type from Javascript style function for %d.", _key);
}
return !_val.is<none_type>();
}
SEXP R_handle_setheaders(SEXP ptr, SEXP vec){
if(!isString(vec))
error("header vector must be a string.");
set_headers(get_ref(ptr), vec_to_slist(vec));
return ScalarLogical(1);
}
/* These are defaulst that we always want to set */
void set_handle_defaults(reference *ref){
/* the actual curl handle */
CURL *handle = ref->handle;
assert(curl_easy_setopt(handle, CURLOPT_PRIVATE, ref));
/* set the response header collector */
reset_resheaders(ref);
curl_easy_setopt(handle, CURLOPT_HEADERFUNCTION, append_buffer);
curl_easy_setopt(handle, CURLOPT_HEADERDATA, &(ref->resheaders));
#ifdef _WIN32
if(CA_BUNDLE != NULL && strlen(CA_BUNDLE)){
/* on windows a cert bundle is included with R version 3.2.0 */
curl_easy_setopt(handle, CURLOPT_CAINFO, CA_BUNDLE);
} else {
/* disable cert validation for older versions of R */
curl_easy_setopt(handle, CURLOPT_SSL_VERIFYHOST, 0L);
curl_easy_setopt(handle, CURLOPT_SSL_VERIFYPEER, 0L);
}
#endif
/* needed to support compressed responses */
assert(curl_easy_setopt(handle, CURLOPT_ENCODING, "gzip, deflate"));
/* follow redirect */
assert(curl_easy_setopt(handle, CURLOPT_FOLLOWLOCATION, 1L));
assert(curl_easy_setopt(handle, CURLOPT_MAXREDIRS, 10L));
/* a sensible timeout (10s) */
assert(curl_easy_setopt(handle, CURLOPT_CONNECTTIMEOUT, 10L));
/* needed to start the cookie engine */
assert(curl_easy_setopt(handle, CURLOPT_COOKIEFILE, ""));
assert(curl_easy_setopt(handle, CURLOPT_FILETIME, 1L));
/* set the default user agent */
SEXP agent = GetOption1(install("HTTPUserAgent"));
if(isString(agent) && Rf_length(agent)){
assert(curl_easy_setopt(handle, CURLOPT_USERAGENT, CHAR(STRING_ELT(agent, 0))));
} else {
assert(curl_easy_setopt(handle, CURLOPT_USERAGENT, "r/curl/jeroen"));
}
/* allow all authentication methods */
assert(curl_easy_setopt(handle, CURLOPT_HTTPAUTH, CURLAUTH_ANY));
assert(curl_easy_setopt(handle, CURLOPT_UNRESTRICTED_AUTH, 1L));
assert(curl_easy_setopt(handle, CURLOPT_PROXYAUTH, CURLAUTH_ANY));
/* enables HTTP2 on HTTPS (match behavior of curl cmd util) */
#if defined(CURL_VERSION_HTTP2) && defined(HAS_HTTP_VERSION_2TLS)
if(curl_version_info(CURLVERSION_NOW)->features & CURL_VERSION_HTTP2)
assert(curl_easy_setopt(handle, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2TLS));
#endif
/* set an error buffer */
assert(curl_easy_setopt(handle, CURLOPT_ERRORBUFFER, ref->errbuf));
/* dummy readfunction because default can freeze R */
assert(curl_easy_setopt(handle, CURLOPT_READFUNCTION, dummy_read));
/* seems to be needed for native WinSSL */
#ifdef _WIN32
curl_easy_setopt(handle, CURLOPT_SSL_OPTIONS, CURLSSLOPT_NO_REVOKE);
#endif
/* set default headers (disables the Expect: http 100)*/
#ifdef HAS_CURLOPT_EXPECT_100_TIMEOUT_MS
assert(curl_easy_setopt(handle, CURLOPT_EXPECT_100_TIMEOUT_MS, 0L));
#endif
assert(curl_easy_setopt(handle, CURLOPT_HTTPHEADER, default_headers));
/* set default progress printer (disabled by default) */
#ifdef HAS_XFERINFOFUNCTION
assert(curl_easy_setopt(handle, CURLOPT_XFERINFOFUNCTION, xferinfo_callback));
#else
assert(curl_easy_setopt(handle, CURLOPT_PROGRESSFUNCTION, xferinfo_callback));
#endif
}
bool JSON::isType<std::string>() const
{
return isString();
}
SEXP impliedLinearity(SEXP m, SEXP h)
{
GetRNGstate();
if (! isMatrix(m))
error("'m' must be matrix");
if (! isLogical(h))
error("'h' must be logical");
if (LENGTH(h) != 1)
error("'h' must be scalar");
if (! isString(m))
error("'m' must be character");
SEXP m_dim;
PROTECT(m_dim = getAttrib(m, R_DimSymbol));
int nrow = INTEGER(m_dim)[0];
int ncol = INTEGER(m_dim)[1];
UNPROTECT(1);
if (nrow <= 1)
error("no use if only one row");
if (ncol <= 3)
error("no use if only one col");
for (int i = 0; i < nrow; i++) {
const char *foo = CHAR(STRING_ELT(m, i));
if (strlen(foo) != 1)
error("column one of 'm' not zero-or-one valued");
if (! (foo[0] == '0' || foo[0] == '1'))
error("column one of 'm' not zero-or-one valued");
}
if (! LOGICAL(h)[0])
for (int i = nrow; i < 2 * nrow; i++) {
const char *foo = CHAR(STRING_ELT(m, i));
if (strlen(foo) != 1)
error("column two of 'm' not zero-or-one valued");
if (! (foo[0] == '0' || foo[0] == '1'))
error("column two of 'm' not zero-or-one valued");
}
dd_set_global_constants();
/* note actual type of "value" is mpq_t (defined in cddmp.h) */
mytype value;
dd_init(value);
dd_MatrixPtr mf = dd_CreateMatrix(nrow, ncol - 1);
/* note our matrix has one more column than Fukuda's */
/* representation */
if(LOGICAL(h)[0])
mf->representation = dd_Inequality;
else
mf->representation = dd_Generator;
mf->numbtype = dd_Rational;
/* linearity */
for (int i = 0; i < nrow; i++) {
const char *foo = CHAR(STRING_ELT(m, i));
if (foo[0] == '1')
set_addelem(mf->linset, i + 1);
/* note conversion from zero-origin to one-origin indexing */
}
/* matrix */
for (int j = 1, k = nrow; j < ncol; j++)
for (int i = 0; i < nrow; i++, k++) {
const char *rat_str = CHAR(STRING_ELT(m, k));
if (mpq_set_str(value, rat_str, 10) == -1) {
dd_FreeMatrix(mf);
dd_clear(value);
dd_free_global_constants();
error("error converting string to GMP rational");
}
mpq_canonicalize(value);
dd_set(mf->matrix[i][j - 1], value);
/* note our matrix has one more column than Fukuda's */
}
dd_ErrorType err = dd_NoError;
dd_rowset out = dd_ImplicitLinearityRows(mf, &err);
if (err != dd_NoError) {
rr_WriteErrorMessages(err);
set_free(out);
dd_FreeMatrix(mf);
dd_clear(value);
dd_free_global_constants();
error("failed");
}
SEXP foo;
PROTECT(foo = rr_set_fwrite(out));
set_free(out);
dd_FreeMatrix(mf);
dd_clear(value);
dd_free_global_constants();
PutRNGstate();
UNPROTECT(1);
return foo;
}
// ----------------------------------------------------------------------------
// process_prefs
// ----------------------------------------------------------------------------
int ipsec_process_prefs(struct vpn_params *params)
{
char *errstr, c;
CFStringRef string;
if (ipsec_conf) {
CFRelease(ipsec_conf);
ipsec_conf = NULL;
}
ipsec_conf = (CFMutableDictionaryRef)CFDictionaryGetValue(params->serverRef, kRASEntIPSec);
if (ipsec_conf == NULL) {
vpnlog(LOG_ERR, "IPSec plugin: IPSec dictionary not present\n");
goto fail;
}
ipsec_conf = CFDictionaryCreateMutableCopy(NULL, 0, ipsec_conf);
remoteaddress[0] = 0;
string = CFDictionaryGetValue(ipsec_conf, kRASPropIPSecRemoteAddress);
if (isString(string))
CFStringGetCString(string, remoteaddress, sizeof(remoteaddress), kCFStringEncodingUTF8);
if (inet_aton(remoteaddress, &peer_address) == 0) {
if (pipe(resolverfds) < 0) {
vpnlog(LOG_ERR, "IPSec plugin: failed to create pipe for gethostbyname\n");
goto fail;
}
if (pthread_create(&resolverthread, NULL, ipsec_resolver_thread, NULL)) {
vpnlog(LOG_ERR, "IPSec plugin: failed to create thread for gethostbyname...\n");
close(resolverfds[0]);
close(resolverfds[1]);
goto fail;
}
while (read(resolverfds[0], &c, 1) != 1) {
if (got_terminate()) {
pthread_cancel(resolverthread);
break;
}
}
close(resolverfds[0]);
close(resolverfds[1]);
if (got_terminate())
goto fail;
if (c) {
vpnlog(LOG_ERR, "IPSec plugin: Host '%s' not found...\n", remoteaddress);
goto fail;
}
string = CFStringCreateWithCString(0, addr2ascii(AF_INET, &peer_address, sizeof(peer_address), 0), kCFStringEncodingASCII);
CFDictionarySetValue(ipsec_conf, kRASPropIPSecRemoteAddress, string);
CFRelease(string);
}
// verify the dictionary
if (IPSecValidateConfiguration(ipsec_conf, &errstr)) {
vpnlog(LOG_ERR, "IPSec plugin: Incorrect preferences (%s)\n", errstr);
goto fail;
}
return 0;
fail:
if (ipsec_conf) {
CFRelease(ipsec_conf);
ipsec_conf = NULL;
}
return -1;
}
result_t util_base::format(const char *fmt, const v8::FunctionCallbackInfo<v8::Value> &args,
std::string &retVal)
{
const char *s1;
char ch;
int argc = args.Length();
int idx = 1;
if (fmt == NULL)
{
idx = 0;
fmt = "";
}
else if (argc == 1)
{
retVal = fmt;
return 0;
}
const char *s = fmt;
while (1)
{
s1 = s;
while ((ch = *s++) && (ch != '%'));
retVal.append(s1, s - s1 - 1);
if (ch == '%')
{
switch (ch = *s++)
{
case 's':
if (idx < argc)
{
v8::String::Utf8Value s(args[idx++]);
if (*s)
retVal.append(*s);
}
else
retVal.append("%s", 2);
break;
case 'd':
if (idx < argc)
{
v8::String::Utf8Value s(args[idx++]->ToNumber());
if (*s)
retVal.append(*s);
}
else
retVal.append("%d", 2);
break;
case 'j':
if (idx < argc)
{
std::string s;
s = json_format(args[idx++]);
retVal.append(s);
}
else
retVal.append("%j", 2);
break;
default:
retVal.append("%", 1);
case '%':
retVal.append(&ch, 1);
break;
}
}
else
break;
}
while (idx < argc)
{
if (!retVal.empty())
retVal.append(" ", 1);
bool v;
isString(args[idx], v);
if (v)
{
v8::String::Utf8Value s(args[idx++]);
retVal.append(*s);
}
else
{
std::string s;
s = json_format(args[idx++]);
retVal.append(s);
}
}
return 0;
}
/* .Call, so manages R_alloc stack */
SEXP
delim_match(SEXP x, SEXP delims)
{
/*
Match delimited substrings in a character vector x.
Returns an integer vector with the same length of x giving the
starting position of the match (including the start delimiter), or
-1 if there is none, with attribute "match.length" giving the
length of the matched text (including the end delimiter), or -1
for no match.
This is still very experimental.
Currently, the start and end delimiters must be single characters;
it would be nice to allow for arbitrary regexps.
Currently, the only syntax supported is Rd ('\' is the escape
character, '%' starts a comment extending to the next newline, no
quote characters. It would be nice to generalize this, too.
Nevertheless, this is already useful for parsing Rd.
*/
char c;
const char *s, *delim_start, *delim_end;
Sint n, i, pos, start, end, delim_depth;
int lstart, lend;
Rboolean is_escaped, equal_start_and_end_delims;
SEXP ans, matchlen;
mbstate_t mb_st; int used;
if(!isString(x) || !isString(delims) || (length(delims) != 2))
error(_("invalid argument type"));
delim_start = translateChar(STRING_ELT(delims, 0));
delim_end = translateChar(STRING_ELT(delims, 1));
lstart = (int) strlen(delim_start); lend = (int) strlen(delim_end);
equal_start_and_end_delims = strcmp(delim_start, delim_end) == 0;
n = length(x);
PROTECT(ans = allocVector(INTSXP, n));
PROTECT(matchlen = allocVector(INTSXP, n));
for(i = 0; i < n; i++) {
memset(&mb_st, 0, sizeof(mbstate_t));
start = end = -1;
s = translateChar(STRING_ELT(x, i));
pos = is_escaped = delim_depth = 0;
while((c = *s) != '\0') {
if(c == '\n') {
is_escaped = FALSE;
}
else if(c == '\\') {
is_escaped = is_escaped ? FALSE : TRUE;
}
else if(is_escaped) {
is_escaped = FALSE;
}
else if(c == '%') {
while((c != '\0') && (c != '\n')) {
if(mbcslocale) {
used = (int) Rf_mbrtowc(NULL, s, MB_CUR_MAX, &mb_st);
if(used == 0) break;
s += used; c = *s;
} else
c = *++s;
pos++;
}
}
else if(strncmp(s, delim_end, lend) == 0) {
if(delim_depth > 1) delim_depth--;
else if(delim_depth == 1) {
end = pos;
break;
}
else if(equal_start_and_end_delims) {
start = pos;
delim_depth++;
}
}
else if(strncmp(s, delim_start, lstart) == 0) {
if(delim_depth == 0) start = pos;
delim_depth++;
}
if(mbcslocale) {
used = (int) Rf_mbrtowc(NULL, s, MB_CUR_MAX, &mb_st);
if(used == 0) break;
s += used;
} else
s++; pos++;
}
if(end > -1) {
INTEGER(ans)[i] = start + 1; /* index from one */
INTEGER(matchlen)[i] = end - start + 1;
}
else {
INTEGER(ans)[i] = INTEGER(matchlen)[i] = -1;
}
}
setAttrib(ans, install("match.length"), matchlen);
UNPROTECT(2);
return(ans);
}
SEXP Win_selectlist(SEXP args)
{
SEXP choices, preselect, ans = R_NilValue;
const char **clist;
int i, j = -1, n, mw = 0, multiple, nsel = 0;
int xmax, ymax, ylist, fht, h0;
Rboolean haveTitle;
choices = CAR(args);
if(!isString(choices)) error(_("invalid '%s' argument"), "choices");
preselect = CADR(args);
if(!isNull(preselect) && !isString(preselect))
error(_("invalid '%s' argument"), "preselect");
multiple = asLogical(CADDR(args));
if(multiple == NA_LOGICAL) multiple = 0;
haveTitle = isString(CADDDR(args));
if(!multiple && isString(preselect) && LENGTH(preselect) != 1)
error(_("invalid '%s' argument"), "preselect");
n = LENGTH(choices);
clist = (const char **) R_alloc(n + 1, sizeof(char *));
for(i = 0; i < n; i++) {
clist[i] = translateChar(STRING_ELT(choices, i));
mw = max(mw, gstrwidth(NULL, SystemFont, clist[i]));
}
clist[n] = NULL;
fht = getSysFontSize().height;
xmax = max(170, mw+60); /* allow for scrollbar */
if(ismdi()) {
RECT *pR = RgetMDIsize();
h0 = pR->bottom;
} else {
h0 = deviceheight(NULL);
}
ymax = min(80+fht*n, h0-100); /* allow for window widgets, toolbar */
ylist = ymax - 60;
wselect = newwindow(haveTitle ? translateChar(STRING_ELT(CADDDR(args), 0)):
(multiple ? _("Select one or more") : _("Select one")),
rect(0, 0, xmax, ymax),
Titlebar | Centered | Modal | Floating);
setbackground(wselect, dialog_bg());
if(multiple)
f_list = newmultilist(clist, rect(10, 10, xmax-25, ylist), NULL, finish);
else
f_list = newlistbox(clist, rect(10, 10, xmax-25, ylist), NULL, finish);
if(!isNull(preselect) && LENGTH(preselect)) {
for(i = 0; i < n; i++)
for(j = 0; j < LENGTH(preselect); j++)
if(strcmp(clist[i], translateChar(STRING_ELT(preselect, j))) == 0) {
setlistitem(f_list, i);
break;
}
}
bFinish = newbutton(G_("OK"), rect(xmax-160, ymax-40, 70, 25), finish);
bCancel = newbutton(G_("Cancel"), rect(xmax-80, ymax-40, 70, 25), cancel);
setkeydown(wselect, key1);
show(wselect);
done = 0;
while(!done) {
R_WaitEvent();
R_ProcessEvents();
}
if(multiple) {
if (done == 1) { /* Finish */
for(i = 0; i < n; i++) if(isselected(f_list, i)) nsel++;
PROTECT(ans = allocVector(STRSXP, nsel));
for(i = 0, j = 0; i < n; i++)
if(isselected(f_list, i))
SET_STRING_ELT(ans, j++, mkChar(clist[i]));
} else { /* cancel */
PROTECT(ans = allocVector(STRSXP, 0));
}
} else
PROTECT(ans = mkString(selected));
cleanup();
show(RConsole);
R_ProcessEvents();
UNPROTECT(1);
return ans;
}
//------------------------------------------------------------------------------
bool MaterialLoader::loadFromVariant(const sn::Variant & doc, sn::Material & mat) const
{
const AssetMetadata & meta = mat.getAssetMetadata();
// Shader
ShaderProgram * shader = getAssetBySerializedLocation<ShaderProgram>(doc["shader"].getString(), meta.project, true);
if (shader)
mat.setShader(shader);
// Depth
bool depthTest = false;
sn::unserialize(doc["depthTest"], depthTest);
mat.setDepthTest(depthTest);
// Blending
BlendMode blendMode;
sn::unserialize(doc["blend"], blendMode);
mat.setBlendMode(blendMode);
// Params
const Variant::Dictionary params = doc["params"].getDictionary();
if (!params.empty())
{
for (auto it = params.begin(); it != params.end(); ++it)
{
auto & v = it->second;
// {"@type":"texture|rendertexture", "value":"foobar"}
if (v.isDictionary())
{
auto a = it->second.getDictionary();
auto typeTag = a["@type"];
auto valueTag = a["value"];
if (typeTag.isString() && valueTag.isString())
{
std::string stype = typeTag.getString();
std::string loc = valueTag.getString();
if (stype == "texture")
{
Texture * tex = getAssetBySerializedLocation<Texture>(loc, meta.project, true);
if (tex)
mat.setTexture(it->first, tex);
else
SN_ERROR("Texture not found: " << loc);
}
else if (stype == "rendertexture")
{
RenderTexture * rt = getAssetBySerializedLocation<RenderTexture>(loc, meta.project, true);
if (rt)
mat.setRenderTexture(it->first, rt);
else
SN_ERROR("RenderTexture not found: " << loc);
}
else
SN_ERROR("Unknown specified type: " << stype);
}
}
else if (v.isArray())
{
auto & a = it->second.getArray();
if (a.size() == 2)
{
Vector2f p;
sn::unserialize(v, p);
mat.setParam(it->first, p.x(), p.y());
}
else if (a.size() == 3)
{
Vector3f p;
sn::unserialize(v, p);
mat.setParam(it->first, p.x(), p.y(), p.z());
}
else if (a.size() == 4)
{
Vector4f p;
sn::unserialize(v, p);
mat.setParam(it->first, p.x(), p.y(), p.z(), p.w());
}
// ...
}
else if (v.isFloat())
{
mat.setParam(it->first, static_cast<f32>(v.getFloat()));
}
// TODO Handle other param types
}
}
return mat.getShader() != nullptr;
}
SEXP attribute_hidden do_filepath(SEXP call, SEXP op, SEXP args, SEXP env)
{
SEXP ans, sep, x;
int i, j, k, ln, maxlen, nx, nzero, pwidth, sepw;
const char *s, *csep, *cbuf;
char *buf;
checkArity(op, args);
/* Check the arguments */
x = CAR(args);
if (!isVectorList(x))
error(_("invalid first argument"));
nx = length(x);
if(nx == 0) return allocVector(STRSXP, 0);
sep = CADR(args);
if (!isString(sep) || LENGTH(sep) <= 0 || STRING_ELT(sep, 0) == NA_STRING)
error(_("invalid separator"));
sep = STRING_ELT(sep, 0);
csep = CHAR(sep);
sepw = (int) strlen(csep); /* hopefully 1 */
/* Any zero-length argument gives zero-length result */
maxlen = 0; nzero = 0;
for (j = 0; j < nx; j++) {
if (!isString(VECTOR_ELT(x, j))) {
/* formerly in R code: moved to C for speed */
SEXP call, xj = VECTOR_ELT(x, j);
if(OBJECT(xj)) { /* method dispatch */
PROTECT(call = lang2(install("as.character"), xj));
SET_VECTOR_ELT(x, j, eval(call, env));
UNPROTECT(1);
} else if (isSymbol(xj))
SET_VECTOR_ELT(x, j, ScalarString(PRINTNAME(xj)));
else
SET_VECTOR_ELT(x, j, coerceVector(xj, STRSXP));
if (!isString(VECTOR_ELT(x, j)))
error(_("non-string argument to Internal paste"));
}
ln = length(VECTOR_ELT(x, j));
if(ln > maxlen) maxlen = ln;
if(ln == 0) {nzero++; break;}
}
if(nzero || maxlen == 0) return allocVector(STRSXP, 0);
PROTECT(ans = allocVector(STRSXP, maxlen));
for (i = 0; i < maxlen; i++) {
pwidth = 0;
for (j = 0; j < nx; j++) {
k = length(VECTOR_ELT(x, j));
pwidth += (int) strlen(translateChar(STRING_ELT(VECTOR_ELT(x, j), i % k)));
}
pwidth += (nx - 1) * sepw;
cbuf = buf = R_AllocStringBuffer(pwidth, &cbuff);
for (j = 0; j < nx; j++) {
k = length(VECTOR_ELT(x, j));
if (k > 0) {
s = translateChar(STRING_ELT(VECTOR_ELT(x, j), i % k));
strcpy(buf, s);
buf += strlen(s);
}
if (j != nx - 1 && sepw != 0) {
strcpy(buf, csep);
buf += sepw;
}
}
#ifdef Win32
// Trailing seps are invalid for file paths except for / and d:/
if(streql(csep, "/") || streql(csep, "\\")) {
if(buf > cbuf) {
buf--;
if(*buf == csep[0] && buf > cbuf &&
(buf != cbuf+2 || cbuf[1] != ':')) *buf = '\0';
}
}
#endif
SET_STRING_ELT(ans, i, mkChar(cbuf));
}
R_FreeStringBufferL(&cbuff);
UNPROTECT(1);
return ans;
}
/**
* From idl/base.php:get_serialized_default()
*/
fbstring PhpParam::getDefaultSerialized() const {
auto valIt = m_param.find("value");
if (valIt == m_param.items().end()) {
return ""; // No default
}
auto dval = valIt->second;
if (!dval.isString()) {
throw std::logic_error(
folly::format("Parameter '{0}' default value is non-string",
m_name).str()
);
}
auto val = dval.asString();
if (!val.size()) {
throw std::logic_error(
folly::format("Parameter '{0}' default value malformed (empty string), "
"specify \"\" as default value for actual empty string",
m_name).str()
);
}
// Function calls "foo()" or "foo::bar()" to C/C++ functions/static methods,
// a constant, or a bitmask of constants
//
// Used by ext_reflection to resolve the value at runtime or
// represent the function/method call.
if ((val.size() > 2) &&
(!strncmp(val.c_str(), "k_", 2) ||
!strncmp(val.c_str(), "q_", 2) ||
!strcmp(val.c_str() + val.size() - 2, "()"))) {
return "\x01";
}
// Fixed substitutions
auto it = g_serializedDefaults.find(val);
if (it != g_serializedDefaults.end()) {
return it->second;
}
if (val == "RAND_MAX") {
return folly::to<fbstring>("i:", RAND_MAX, ";");
}
// Quoted string: "foo"
if ((val.size() >= 2) && (val[0] == '"') && (val[val.size()-1] == '"')) {
auto s = unescapeString(val.substr(1, val.size() - 2));
return phpSerialize(s);
}
// Integers and Floats
if (strchr(val.c_str(), '.')) {
// Decimal float?
char *e = nullptr;
double dval = strtod(val.c_str(), &e);
if (e && !*e) {
return folly::to<fbstring>("d:", dval, ";");
}
}
if (val[0] == '0') {
if ((val.size() > 1) && (val[1] == 'x')) {
// Hex?
char *e = nullptr;
long lval = strtol(val.c_str() + 2, &e, 16);
if (e && !*e) {
return folly::to<fbstring>("i:", lval, ";");
}
} else {
// Octal?
char *e = nullptr;
long lval = strtol(val.c_str() + 1, &e, 8);
if (e && !*e) {
return folly::to<fbstring>("i:", lval, ";");
}
}
}
// Decimal?
char *e = nullptr;
long lval = strtol(val.c_str(), &e, 10);
if (e && !*e) {
return folly::to<fbstring>("i:", lval, ";");
}
throw std::logic_error(
folly::format("'{0}' is not a valid default arg value", val).str()
);
}
SEXP writeClipboard(SEXP text, SEXP sformat)
{
int i, n, format;
HGLOBAL hglb;
char *s;
const char *p;
Rboolean success = FALSE, raw = FALSE;
const void *vmax = vmaxget();
format = asInteger(sformat);
if (TYPEOF(text) == RAWSXP) raw = TRUE;
else if(!isString(text))
error(_("argument must be a character vector or a raw vector"));
n = length(text);
if(n > 0) {
int len = 1;
if(raw) len = n;
else if (format == CF_UNICODETEXT)
for(i = 0; i < n; i++)
len += 2 * (wcslen(wtransChar(STRING_ELT(text, i))) + 2);
else
for(i = 0; i < n; i++)
len += strlen(translateChar(STRING_ELT(text, i))) + 2;
if ( (hglb = GlobalAlloc(GHND, len)) &&
(s = (char *)GlobalLock(hglb)) ) {
if(raw)
for(i = 0; i < n; i++) *s++ = RAW(text)[i];
else if (format == CF_UNICODETEXT) {
const wchar_t *wp;
wchar_t *ws = (wchar_t *) s;
for(i = 0; i < n; i++) {
wp = wtransChar(STRING_ELT(text, i));
while(*wp) *ws++ = *wp++;
*ws++ = L'\r'; *ws++ = L'\n';
}
*ws = L'\0';
} else {
for(i = 0; i < n; i++) {
p = translateChar(STRING_ELT(text, i));
while(*p) *s++ = *p++;
*s++ = '\r'; *s++ = '\n';
}
*s = '\0';
}
GlobalUnlock(hglb);
if (!OpenClipboard(NULL) || !EmptyClipboard()) {
warning(_("unable to open the clipboard"));
GlobalFree(hglb);
} else {
success = SetClipboardData(CF_TEXT, hglb) != 0;
if(!success) {
warning(_("unable to write to the clipboard"));
GlobalFree(hglb);
}
CloseClipboard();
}
}
}
vmaxset(vmax);
return ScalarLogical(success);
}
PhpFunc::PhpFunc(const folly::dynamic& d,
const fbstring& className) :
m_name(d["name"].asString()),
m_className(className),
m_func(d),
m_desc(getFollyDynamicDefaultString(d, "desc", "")),
m_returnRef(d.getDefault("ref", "false") == "true"),
m_returnKindOf(KindOfNull),
m_returnCppType("void"),
m_returnPhpType("void"),
m_minNumParams(0),
m_numTypeChecks(0) {
auto returnIt = d.find("return");
if (returnIt != d.items().end()) {
auto retNode = returnIt->second;
auto typeIt = retNode.find("type");
if (typeIt != retNode.items().end()) {
auto type = typeIt->second;
if ((type.isString()) && (type != "void") && (type != "null")) {
m_returnKindOf = m_returnRef ? KindOfRef : kindOfFromDynamic(type);
m_returnCppType = typeString(type, true);
m_returnPhpType = phpTypeFromDataType(m_returnKindOf);
}
}
m_returnDesc = getFollyDynamicDefaultString(retNode, "desc", "");
}
auto args = d.find("args");
if (args == d.items().end() || !args->second.isArray()) {
throw std::logic_error(
folly::format("'{0}' must have an array field 'args'", name()).str()
);
}
auto ret = d.find("return");
if (ret == d.items().end() || !ret->second.isObject() ||
ret->second.find("type") == ret->second.items().end()) {
throw std::logic_error(
folly::format("'{0}' must have an array field 'return', which must have "
"a string field 'type'", name()).str()
);
}
bool magic = isMagicMethod();
m_flags = parseFlags(m_func["flags"]);
ParamMode paramMode = ParamMode::CoerceAndCall;
if (m_flags & ZendParamModeNull) {
paramMode = ParamMode::ZendNull;
} else if (m_flags & ZendParamModeFalse) {
paramMode = ParamMode::ZendFalse;
}
for (auto &p : args->second) {
PhpParam param(p, magic, paramMode);
m_params.push_back(param);
if (!param.hasDefault()) {
++m_minNumParams;
}
if (param.isCheckedType()) {
++m_numTypeChecks;
}
}
}
SEXP attribute_hidden do_nchar(SEXP call, SEXP op, SEXP args, SEXP env)
{
SEXP d, s, x, stype;
R_xlen_t i, len;
int allowNA;
size_t ntype;
int nc;
const char *type;
const char *xi;
wchar_t *wc;
const void *vmax;
checkArity(op, args);
if (isFactor(CAR(args)))
error(_("'%s' requires a character vector"), "nchar()");
PROTECT(x = coerceVector(CAR(args), STRSXP));
if (!isString(x))
error(_("'%s' requires a character vector"), "nchar()");
len = XLENGTH(x);
stype = CADR(args);
if (!isString(stype) || LENGTH(stype) != 1)
error(_("invalid '%s' argument"), "type");
type = CHAR(STRING_ELT(stype, 0)); /* always ASCII */
ntype = strlen(type);
if (ntype == 0) error(_("invalid '%s' argument"), "type");
allowNA = asLogical(CADDR(args));
if (allowNA == NA_LOGICAL) allowNA = 0;
PROTECT(s = allocVector(INTSXP, len));
vmax = vmaxget();
for (i = 0; i < len; i++) {
SEXP sxi = STRING_ELT(x, i);
if (sxi == NA_STRING) {
INTEGER(s)[i] = 2;
continue;
}
if (strncmp(type, "bytes", ntype) == 0) {
INTEGER(s)[i] = LENGTH(sxi);
} else if (strncmp(type, "chars", ntype) == 0) {
if (IS_UTF8(sxi)) { /* assume this is valid */
const char *p = CHAR(sxi);
nc = 0;
for( ; *p; p += utf8clen(*p)) nc++;
INTEGER(s)[i] = nc;
} else if (IS_BYTES(sxi)) {
if (!allowNA) /* could do chars 0 */
error(_("number of characters is not computable for element %d in \"bytes\" encoding"), i+1);
INTEGER(s)[i] = NA_INTEGER;
} else if (mbcslocale) {
nc = (int) mbstowcs(NULL, translateChar(sxi), 0);
if (!allowNA && nc < 0)
error(_("invalid multibyte string %d"), i+1);
INTEGER(s)[i] = nc >= 0 ? nc : NA_INTEGER;
} else
INTEGER(s)[i] = (int) strlen(translateChar(sxi));
} else if (strncmp(type, "width", ntype) == 0) {
if (IS_UTF8(sxi)) { /* assume this is valid */
const char *p = CHAR(sxi);
wchar_t wc1;
nc = 0;
for( ; *p; p += utf8clen(*p)) {
utf8toucs(&wc1, p);
nc += Ri18n_wcwidth(wc1);
}
INTEGER(s)[i] = nc;
} else if (IS_BYTES(sxi)) {
if (!allowNA) /* could do width 0 */
error(_("width is not computable for element %d in \"bytes\" encoding"), i+1);
INTEGER(s)[i] = NA_INTEGER;
} else if (mbcslocale) {
xi = translateChar(sxi);
nc = (int) mbstowcs(NULL, xi, 0);
if (nc >= 0) {
wc = (wchar_t *) R_AllocStringBuffer((nc+1)*sizeof(wchar_t), &cbuff);
mbstowcs(wc, xi, nc + 1);
INTEGER(s)[i] = Ri18n_wcswidth(wc, 2147483647);
if (INTEGER(s)[i] < 1) INTEGER(s)[i] = nc;
} else if (allowNA)
error(_("invalid multibyte string %d"), i+1);
else
INTEGER(s)[i] = NA_INTEGER;
} else
INTEGER(s)[i] = (int) strlen(translateChar(sxi));
} else
error(_("invalid '%s' argument"), "type");
vmaxset(vmax);
}
R_FreeStringBufferL(&cbuff);
if ((d = getAttrib(x, R_NamesSymbol)) != R_NilValue)
setAttrib(s, R_NamesSymbol, d);
if ((d = getAttrib(x, R_DimSymbol)) != R_NilValue)
setAttrib(s, R_DimSymbol, d);
if ((d = getAttrib(x, R_DimNamesSymbol)) != R_NilValue)
setAttrib(s, R_DimNamesSymbol, d);
UNPROTECT(2);
return s;
}
void startLex()
{
char *result;
char red;
char *number;
int iString;
while((red = fgetc(myFile)) != EOF)
{
//red = NULL;
//red = EOF;
if(red == '\n')
iLn++;
if(red == ' ' || red == '\n' || red == '\t')
continue;
if(isComment(red) == 1)
{
remove();
continue;
}
else
returnItAll();
iString = isString(red);
if(iString)
{
if(iString == 2)
{
iUnrec++;
printf("\nUnrecognized lexeme: %s",word);
recognized(word,"UNIDENTIFIED");
continue;
}
iRec++;
recognized(word, "STRING_LITERAL");
continue;
}
else
returnItAll();
if(!(strcmp((number = isNumber(red)),"ERR") == 0))
{
iRec++;
recognized(word, number);
continue;
}
else
returnItAll();
if(red == '\'');
else if(isTerminated(red) == 1)
{
int found = 1;
red = fgetc(myFile);
addletter(red);
char sec = fgetc(myFile);
if(sec == '=')
{
addletter(sec);
if(red == '<')
{
iRec++;
recognized(word,"LESSEQL");
continue;
}
else if(red == '>')
{
iRec++;
recognized(word,"GRTREQL");
continue;
}
else if(red == '!')
{
iRec++;
recognized(word,"NOTEQL");
continue;
}
else if(red == '=')
found = 0;
}
else if(red == '<')
recognized(word,"GRTRTH");
else if(red == '>')
recognized(word,"LESSTH");
else if(red == '!')
recognized(word,"NOT");
else if(red == '+')
recognized(word,"ADD");
else if(red == '-')
recognized(word,"SUB");
else if(red == '*')
recognized(word,"MUL");
else if(red == '^')
recognized(word,"RAISE");
else if(red == '/')
recognized(word,"DIV");
else if(red == '%')
recognized(word,"MOD");
else if(red == '~')
recognized(word,"TRUNC_DIV");
else if(red == '|')
recognized(word,"OR");
else if(red == '&')
recognized(word,"AND");
else if(red == '=')
recognized(word,"EQLTO");
else if(red == '?')
recognized(word,"COND_END");
else if(red == ':')
recognized(word,"ASSIGN");
else if(red == '{')
recognized(word,"B_START");
else if(red == '}')
recognized(word,"B_END");
else if(red == ';')
recognized(word,"STMNT_END");
else if(red == '(')
recognized(word,"P_START");
else if(red == ')')
recognized(word,"P_END");
else if(red == ',')
recognized(word,"COM");
if(found)
{
iRec++;
ungetc(sec,myFile);
continue;
}
else
returnItAll();
}
if(!(strcmp((result = isKeyword(red)),"ERR") == 0))
{
iRec++;
recognized(word, result);
continue;
}
else
returnItAll();
if(isIdentifier(red))
{
iRec++;
recognized(word,"ID");
continue;
}
else
returnItAll();
{
iUnrec++;
while((red = fgetc(myFile)) != EOF)
{
if(red == EOF)
break;
if(isTerminated(red))
{
if(red == '\n')
iLn--;
if(red == '\'' || red == '=');
else
{
ungetc(red,myFile);
break;
}
}
addletter(red);
}
printf("\nLine %d: Unrecognized lexeme %s",iLn,word);
recognized(word, "UNIDENTIFIED");
}
}//while((red = fgetc(myFile)) != EOF);
}
SEXP attribute_hidden do_makenames(SEXP call, SEXP op, SEXP args, SEXP env)
{
SEXP arg, ans;
R_xlen_t i, n;
int l, allow_;
char *p, *tmp = NULL, *cbuf;
const char *This;
Rboolean need_prefix;
const void *vmax;
checkArity(op ,args);
arg = CAR(args);
if (!isString(arg))
error(_("non-character names"));
n = XLENGTH(arg);
allow_ = asLogical(CADR(args));
if (allow_ == NA_LOGICAL)
error(_("invalid '%s' value"), "allow_");
PROTECT(ans = allocVector(STRSXP, n));
vmax = vmaxget();
for (i = 0 ; i < n ; i++) {
This = translateChar(STRING_ELT(arg, i));
l = (int) strlen(This);
/* need to prefix names not beginning with alpha or ., as
well as . followed by a number */
need_prefix = FALSE;
if (mbcslocale && This[0]) {
int nc = l, used;
wchar_t wc;
mbstate_t mb_st;
const char *pp = This;
mbs_init(&mb_st);
used = (int) Mbrtowc(&wc, pp, MB_CUR_MAX, &mb_st);
pp += used; nc -= used;
if (wc == L'.') {
if (nc > 0) {
Mbrtowc(&wc, pp, MB_CUR_MAX, &mb_st);
if (iswdigit(wc)) need_prefix = TRUE;
}
} else if (!iswalpha(wc)) need_prefix = TRUE;
} else {
if (This[0] == '.') {
if (l >= 1 && isdigit(0xff & (int) This[1])) need_prefix = TRUE;
} else if (!isalpha(0xff & (int) This[0])) need_prefix = TRUE;
}
if (need_prefix) {
tmp = Calloc(l+2, char);
strcpy(tmp, "X");
strcat(tmp, translateChar(STRING_ELT(arg, i)));
} else {
tmp = Calloc(l+1, char);
strcpy(tmp, translateChar(STRING_ELT(arg, i)));
}
if (mbcslocale) {
/* This cannot lengthen the string, so safe to overwrite it.
Would also be possible a char at a time.
*/
int nc = (int) mbstowcs(NULL, tmp, 0);
wchar_t *wstr = Calloc(nc+1, wchar_t), *wc;
if (nc >= 0) {
mbstowcs(wstr, tmp, nc+1);
for (wc = wstr; *wc; wc++) {
if (*wc == L'.' || (allow_ && *wc == L'_'))
/* leave alone */;
else if (!iswalnum((int)*wc)) *wc = L'.';
/* If it changes into dot here,
* length will become short on mbcs.
* The name which became short will contain garbage.
* cf.
* > make.names(c("\u30fb"))
* [1] "X.\0"
*/
}
wcstombs(tmp, wstr, strlen(tmp)+1);
Free(wstr);
} else error(_("invalid multibyte string %d"), i+1);
} else {
for (p = tmp; *p; p++) {
SEXP
do_getGraphicsEvent(SEXP call, SEXP op, SEXP args, SEXP env)
{
SEXP result = R_NilValue, prompt;
pDevDesc dd;
pGEDevDesc gd;
int i, count=0, devNum;
checkArity(op, args);
prompt = CAR(args);
if (!isString(prompt) || !length(prompt)) error(_("invalid prompt"));
/* NB: cleanup of event handlers must be done by driver in onExit handler */
if (!NoDevices()) {
/* Initialize all devices */
i = 1;
devNum = curDevice();
while (i++ < NumDevices()) {
if ((gd = GEgetDevice(devNum)) && (dd = gd->dev)) {
if (dd->gettingEvent)
error(_("recursive use of 'getGraphicsEvent' not supported"));
if (dd->eventEnv != R_NilValue) {
if (dd->eventHelper) dd->eventHelper(dd, 1);
dd->gettingEvent = TRUE;
defineVar(install("result"), R_NilValue, dd->eventEnv);
count++;
}
}
devNum = nextDevice(devNum);
}
if (!count)
error(_("no graphics event handlers set"));
Rprintf("%s\n", CHAR(asChar(prompt)));
R_FlushConsole();
/* Poll them */
while (result == R_NilValue) {
/* make sure we still have at least one device listening for events, and throw an error if not*/
if(!haveListeningDev())
return R_NilValue;
#ifdef Win32
R_WaitEvent();
#endif
R_ProcessEvents();
R_CheckUserInterrupt();
i = 1;
devNum = curDevice();
while (i++ < NumDevices()) {
if ((gd = GEgetDevice(devNum)) && (dd = gd->dev)) {
if (dd->eventEnv != R_NilValue) {
if (dd->eventHelper) dd->eventHelper(dd, 2);
result = findVar(install("result"), dd->eventEnv);
if (result != R_NilValue && result != R_UnboundValue) {
break;
}
}
}
devNum = nextDevice(devNum);
}
}
/* clean up */
i = 1;
devNum = curDevice();
while (i++ < NumDevices()) {
if ((gd = GEgetDevice(devNum)) && (dd = gd->dev)) {
if (dd->eventEnv != R_NilValue) {
if (dd->eventHelper) dd->eventHelper(dd, 0);
dd->gettingEvent = FALSE;
}
}
devNum = nextDevice(devNum);
}
}
return(result);
}
SEXP attribute_hidden do_cat(SEXP call, SEXP op, SEXP args, SEXP rho)
{
cat_info ci;
RCNTXT cntxt;
SEXP objs, file, fill, sepr, labs, s;
int ifile;
Rconnection con;
int append;
int i, iobj, n, nobjs, pwidth, width, sepw, lablen, ntot, nlsep, nlines;
char buf[512];
const char *p = "";
checkArity(op, args);
/* Use standard printing defaults */
PrintDefaults();
objs = CAR(args);
args = CDR(args);
file = CAR(args);
ifile = asInteger(file);
con = getConnection(ifile);
if(!con->canwrite) /* if it is not open, we may not know yet */
error(_("cannot write to this connection"));
args = CDR(args);
sepr = CAR(args);
if (!isString(sepr))
error(_("invalid '%s' specification"), "sep");
nlsep = 0;
for (i = 0; i < LENGTH(sepr); i++)
if (strstr(CHAR(STRING_ELT(sepr, i)), "\n")) nlsep = 1; /* ASCII */
args = CDR(args);
fill = CAR(args);
if ((!isNumeric(fill) && !isLogical(fill)) || (length(fill) != 1))
error(_("invalid '%s' argument"), "fill");
if (isLogical(fill)) {
if (asLogical(fill) == 1)
pwidth = R_print.width;
else
pwidth = INT_MAX;
}
else pwidth = asInteger(fill);
if(pwidth <= 0) {
warning(_("non-positive 'fill' argument will be ignored"));
pwidth = INT_MAX;
}
args = CDR(args);
labs = CAR(args);
if (!isString(labs) && labs != R_NilValue)
error(_("invalid '%s' argument"), "labels");
lablen = length(labs);
args = CDR(args);
append = asLogical(CAR(args));
if (append == NA_LOGICAL)
error(_("invalid '%s' specification"), "append");
ci.wasopen = con->isopen;
ci.changedcon = switch_stdout(ifile, 0);
/* will open new connection if required, and check for writeable */
#ifdef Win32
/* do this after re-sinking output */
WinCheckUTF8();
#endif
ci.con = con;
/* set up a context which will close the connection if there is an error */
begincontext(&cntxt, CTXT_CCODE, R_NilValue, R_BaseEnv, R_BaseEnv,
R_NilValue, R_NilValue);
cntxt.cend = &cat_cleanup;
cntxt.cenddata = &ci;
nobjs = length(objs);
width = 0;
ntot = 0;
nlines = 0;
for (iobj = 0; iobj < nobjs; iobj++) {
s = VECTOR_ELT(objs, iobj);
if (iobj != 0 && !isNull(s))
cat_printsep(sepr, ntot++);
n = length(s);
/* 0-length objects are ignored */
if (n > 0) {
if (labs != R_NilValue && (iobj == 0)
&& (asInteger(fill) > 0)) {
Rprintf("%s ", trChar(STRING_ELT(labs, nlines % lablen)));
/* FIXME -- Rstrlen allows for double-width chars */
width += Rstrlen(STRING_ELT(labs, nlines % lablen), 0) + 1;
nlines++;
}
if (isString(s))
p = trChar(STRING_ELT(s, 0));
else if (isSymbol(s)) /* length 1 */
p = CHAR(PRINTNAME(s));
else if (isVectorAtomic(s)) {
/* Not a string, as that is covered above.
Thus the maximum size is about 60.
The copy is needed as cat_newline might reuse the buffer.
Use strncpy is in case these assumptions change.
*/
p = EncodeElement0(s, 0, 0, OutDec);
strncpy(buf, p, 512); buf[511] = '\0';
p = buf;
}
#ifdef fixed_cat
else if (isVectorList(s)) {
/* FIXME: call EncodeElement() for every element of s.
Real Problem: `s' can be large;
should do line breaking etc.. (buf is of limited size)
*/
}
#endif
else
errorcall(call,
_("argument %d (type '%s') cannot be handled by 'cat'"),
1+iobj, type2char(TYPEOF(s)));
/* FIXME : cat(...) should handle ANYTHING */
size_t w = strlen(p);
cat_sepwidth(sepr, &sepw, ntot);
if ((iobj > 0) && (width + w + sepw > pwidth)) {
cat_newline(labs, &width, lablen, nlines);
nlines++;
}
for (i = 0; i < n; i++, ntot++) {
Rprintf("%s", p);
width += (int)(w + sepw);
if (i < (n - 1)) {
cat_printsep(sepr, ntot);
if (isString(s))
p = trChar(STRING_ELT(s, i+1));
else {
p = EncodeElement0(s, i+1, 0, OutDec);
strncpy(buf, p, 512); buf[511] = '\0';
p = buf;
}
w = (int) strlen(p);
cat_sepwidth(sepr, &sepw, ntot);
/* This is inconsistent with the version above.
As from R 2.3.0, fill <= 0 is ignored. */
if ((width + w + sepw > pwidth) && pwidth) {
cat_newline(labs, &width, lablen, nlines);
nlines++;
}
} else ntot--; /* we don't print sep after last, so don't advance */
}
}
}
if ((pwidth != INT_MAX) || nlsep)
Rprintf("\n");
/* end the context after anything that could raise an error but before
doing the cleanup so the cleanup doesn't get done twice */
endcontext(&cntxt);
cat_cleanup(&ci);
return R_NilValue;
}
const std::string &VariantValue::getString() const {
assert(isString());
return *Value.String;
}
/* par fn gr method options */
SEXP optim(SEXP call, SEXP op, SEXP args, SEXP rho)
{
SEXP par, fn, gr, method, options, tmp, slower, supper;
SEXP res, value, counts, conv;
int i, npar=0, *mask, trace, maxit, fncount = 0, grcount = 0, nREPORT, tmax;
int ifail = 0;
double *dpar, *opar, val = 0.0, abstol, reltol, temp;
const char *tn;
OptStruct OS;
PROTECT_INDEX par_index;
args = CDR(args);
OS = (OptStruct) R_alloc(1, sizeof(opt_struct));
OS->usebounds = 0;
OS->R_env = rho;
par = CAR(args);
OS->names = getAttrib(par, R_NamesSymbol);
args = CDR(args); fn = CAR(args);
if (!isFunction(fn)) error(_("'fn' is not a function"));
args = CDR(args); gr = CAR(args);
args = CDR(args); method = CAR(args);
if (!isString(method)|| LENGTH(method) != 1)
error(_("invalid '%s' argument"), "method");
tn = CHAR(STRING_ELT(method, 0));
args = CDR(args); options = CAR(args);
PROTECT(OS->R_fcall = lang2(fn, R_NilValue));
PROTECT_WITH_INDEX(par = coerceVector(par, REALSXP), &par_index);
if (MAYBE_REFERENCED(par))
REPROTECT(par = duplicate(par), par_index);
npar = LENGTH(par);
dpar = vect(npar);
opar = vect(npar);
trace = asInteger(getListElement(options, "trace"));
OS->fnscale = asReal(getListElement(options, "fnscale"));
tmp = getListElement(options, "parscale");
if (LENGTH(tmp) != npar)
error(_("'parscale' is of the wrong length"));
PROTECT(tmp = coerceVector(tmp, REALSXP));
OS->parscale = vect(npar);
for (i = 0; i < npar; i++) OS->parscale[i] = REAL(tmp)[i];
UNPROTECT(1);
for (i = 0; i < npar; i++)
dpar[i] = REAL(par)[i] / (OS->parscale[i]);
PROTECT(res = allocVector(VECSXP, 5));
SEXP names;
PROTECT(names = allocVector(STRSXP, 5));
SET_STRING_ELT(names, 0, mkChar("par"));
SET_STRING_ELT(names, 1, mkChar("value"));
SET_STRING_ELT(names, 2, mkChar("counts"));
SET_STRING_ELT(names, 3, mkChar("convergence"));
SET_STRING_ELT(names, 4, mkChar("message"));
setAttrib(res, R_NamesSymbol, names);
UNPROTECT(1);
PROTECT(value = allocVector(REALSXP, 1));
PROTECT(counts = allocVector(INTSXP, 2));
SEXP countnames;
PROTECT(countnames = allocVector(STRSXP, 2));
SET_STRING_ELT(countnames, 0, mkChar("function"));
SET_STRING_ELT(countnames, 1, mkChar("gradient"));
setAttrib(counts, R_NamesSymbol, countnames);
UNPROTECT(1);
PROTECT(conv = allocVector(INTSXP, 1));
abstol = asReal(getListElement(options, "abstol"));
reltol = asReal(getListElement(options, "reltol"));
maxit = asInteger(getListElement(options, "maxit"));
if (maxit == NA_INTEGER) error(_("'maxit' is not an integer"));
if (strcmp(tn, "Nelder-Mead") == 0) {
double alpha, beta, gamm;
alpha = asReal(getListElement(options, "alpha"));
beta = asReal(getListElement(options, "beta"));
gamm = asReal(getListElement(options, "gamma"));
nmmin(npar, dpar, opar, &val, fminfn, &ifail, abstol, reltol,
(void *)OS, alpha, beta, gamm, trace, &fncount, maxit);
for (i = 0; i < npar; i++)
REAL(par)[i] = opar[i] * (OS->parscale[i]);
grcount = NA_INTEGER;
}
else if (strcmp(tn, "SANN") == 0) {
tmax = asInteger(getListElement(options, "tmax"));
temp = asReal(getListElement(options, "temp"));
if (trace) trace = asInteger(getListElement(options, "REPORT"));
if (tmax == NA_INTEGER || tmax < 1) // PR#15194
error(_("'tmax' is not a positive integer"));
if (!isNull(gr)) {
if (!isFunction(gr)) error(_("'gr' is not a function"));
PROTECT(OS->R_gcall = lang2(gr, R_NilValue));
} else {
PROTECT(OS->R_gcall = R_NilValue); /* for balance */
}
samin (npar, dpar, &val, fminfn, maxit, tmax, temp, trace, (void *)OS);
for (i = 0; i < npar; i++)
REAL(par)[i] = dpar[i] * (OS->parscale[i]);
fncount = npar > 0 ? maxit : 1;
grcount = NA_INTEGER;
UNPROTECT(1); /* OS->R_gcall */
} else if (strcmp(tn, "BFGS") == 0) {
SEXP ndeps;
nREPORT = asInteger(getListElement(options, "REPORT"));
if (!isNull(gr)) {
if (!isFunction(gr)) error(_("'gr' is not a function"));
PROTECT(OS->R_gcall = lang2(gr, R_NilValue));
} else {
PROTECT(OS->R_gcall = R_NilValue); /* for balance */
ndeps = getListElement(options, "ndeps");
if (LENGTH(ndeps) != npar)
error(_("'ndeps' is of the wrong length"));
OS->ndeps = vect(npar);
PROTECT(ndeps = coerceVector(ndeps, REALSXP));
for (i = 0; i < npar; i++) OS->ndeps[i] = REAL(ndeps)[i];
UNPROTECT(1);
}
mask = (int *) R_alloc(npar, sizeof(int));
for (i = 0; i < npar; i++) mask[i] = 1;
vmmin(npar, dpar, &val, fminfn, fmingr, maxit, trace, mask, abstol,
reltol, nREPORT, (void *)OS, &fncount, &grcount, &ifail);
for (i = 0; i < npar; i++)
REAL(par)[i] = dpar[i] * (OS->parscale[i]);
UNPROTECT(1); /* OS->R_gcall */
} else if (strcmp(tn, "CG") == 0) {
int type;
SEXP ndeps;
type = asInteger(getListElement(options, "type"));
if (!isNull(gr)) {
if (!isFunction(gr)) error(_("'gr' is not a function"));
PROTECT(OS->R_gcall = lang2(gr, R_NilValue));
} else {
PROTECT(OS->R_gcall = R_NilValue); /* for balance */
ndeps = getListElement(options, "ndeps");
if (LENGTH(ndeps) != npar)
error(_("'ndeps' is of the wrong length"));
OS->ndeps = vect(npar);
PROTECT(ndeps = coerceVector(ndeps, REALSXP));
for (i = 0; i < npar; i++) OS->ndeps[i] = REAL(ndeps)[i];
UNPROTECT(1);
}
cgmin(npar, dpar, opar, &val, fminfn, fmingr, &ifail, abstol,
reltol, (void *)OS, type, trace, &fncount, &grcount, maxit);
for (i = 0; i < npar; i++)
REAL(par)[i] = opar[i] * (OS->parscale[i]);
UNPROTECT(1); /* OS->R_gcall */
} else if (strcmp(tn, "L-BFGS-B") == 0) {
SEXP ndeps, smsg;
double *lower = vect(npar), *upper = vect(npar);
int lmm, *nbd = (int *) R_alloc(npar, sizeof(int));
double factr, pgtol;
char msg[60];
nREPORT = asInteger(getListElement(options, "REPORT"));
factr = asReal(getListElement(options, "factr"));
pgtol = asReal(getListElement(options, "pgtol"));
lmm = asInteger(getListElement(options, "lmm"));
if (!isNull(gr)) {
if (!isFunction(gr)) error(_("'gr' is not a function"));
PROTECT(OS->R_gcall = lang2(gr, R_NilValue));
} else {
PROTECT(OS->R_gcall = R_NilValue); /* for balance */
ndeps = getListElement(options, "ndeps");
if (LENGTH(ndeps) != npar)
error(_("'ndeps' is of the wrong length"));
OS->ndeps = vect(npar);
PROTECT(ndeps = coerceVector(ndeps, REALSXP));
for (i = 0; i < npar; i++) OS->ndeps[i] = REAL(ndeps)[i];
UNPROTECT(1);
}
args = CDR(args); slower = CAR(args); /* coerce in calling code */
args = CDR(args); supper = CAR(args);
for (i = 0; i < npar; i++) {
lower[i] = REAL(slower)[i] / (OS->parscale[i]);
upper[i] = REAL(supper)[i] / (OS->parscale[i]);
if (!R_FINITE(lower[i])) {
if (!R_FINITE(upper[i])) nbd[i] = 0; else nbd[i] = 3;
} else {
if (!R_FINITE(upper[i])) nbd[i] = 1; else nbd[i] = 2;
}
}
OS->usebounds = 1;
OS->lower = lower;
OS->upper = upper;
lbfgsb(npar, lmm, dpar, lower, upper, nbd, &val, fminfn, fmingr,
&ifail, (void *)OS, factr, pgtol, &fncount, &grcount,
maxit, msg, trace, nREPORT);
for (i = 0; i < npar; i++)
REAL(par)[i] = dpar[i] * (OS->parscale[i]);
UNPROTECT(1); /* OS->R_gcall */
PROTECT(smsg = mkString(msg));
SET_VECTOR_ELT(res, 4, smsg);
UNPROTECT(1);
} else
error(_("unknown 'method'"));
if(!isNull(OS->names)) setAttrib(par, R_NamesSymbol, OS->names);
REAL(value)[0] = val * (OS->fnscale);
SET_VECTOR_ELT(res, 0, par); SET_VECTOR_ELT(res, 1, value);
INTEGER(counts)[0] = fncount; INTEGER(counts)[1] = grcount;
SET_VECTOR_ELT(res, 2, counts);
INTEGER(conv)[0] = ifail;
SET_VECTOR_ELT(res, 3, conv);
UNPROTECT(6);
return res;
}
String JSCell::getString(ExecState* exec) const
{
return isString() ? static_cast<const JSString*>(this)->value(exec) : String();
}
JSValue JSCell::toPrimitive(ExecState* exec, PreferredPrimitiveType preferredType) const
{
if (isString())
return static_cast<const JSString*>(this)->toPrimitive(exec, preferredType);
return static_cast<const JSObject*>(this)->toPrimitive(exec, preferredType);
}
/* This is for all cases with a single index, including 1D arrays and
matrix indexing of arrays */
static SEXP VectorSubset(SEXP x, SEXP s, SEXP call)
{
R_xlen_t n;
int mode;
R_xlen_t stretch = 1;
SEXP indx, result, attrib, nattrib;
if (s == R_MissingArg) return duplicate(x);
PROTECT(s);
attrib = getAttrib(x, R_DimSymbol);
/* Check to see if we have special matrix subscripting. */
/* If we do, make a real subscript vector and protect it. */
if (isMatrix(s) && isArray(x) && ncols(s) == length(attrib)) {
if (isString(s)) {
s = strmat2intmat(s, GetArrayDimnames(x), call);
UNPROTECT(1);
PROTECT(s);
}
if (isInteger(s) || isReal(s)) {
s = mat2indsub(attrib, s, call);
UNPROTECT(1);
PROTECT(s);
}
}
/* Convert to a vector of integer subscripts */
/* in the range 1:length(x). */
PROTECT(indx = makeSubscript(x, s, &stretch, call));
n = XLENGTH(indx);
/* Allocate the result. */
mode = TYPEOF(x);
/* No protection needed as ExtractSubset does not allocate */
result = allocVector(mode, n);
if (mode == VECSXP || mode == EXPRSXP)
/* we do not duplicate the values when extracting the subset,
so to be conservative mark the result as NAMED = 2 */
SET_NAMED(result, 2);
PROTECT(result = ExtractSubset(x, result, indx, call));
if (result != R_NilValue) {
if (
((attrib = getAttrib(x, R_NamesSymbol)) != R_NilValue) ||
( /* here we might have an array. Use row names if 1D */
isArray(x) && LENGTH(getAttrib(x, R_DimNamesSymbol)) == 1 &&
(attrib = getAttrib(x, R_DimNamesSymbol)) != R_NilValue &&
(attrib = GetRowNames(attrib)) != R_NilValue
)
) {
nattrib = allocVector(TYPEOF(attrib), n);
PROTECT(nattrib); /* seems unneeded */
nattrib = ExtractSubset(attrib, nattrib, indx, call);
setAttrib(result, R_NamesSymbol, nattrib);
UNPROTECT(1);
}
if ((attrib = getAttrib(x, R_SrcrefSymbol)) != R_NilValue &&
TYPEOF(attrib) == VECSXP) {
nattrib = allocVector(VECSXP, n);
PROTECT(nattrib); /* seems unneeded */
nattrib = ExtractSubset(attrib, nattrib, indx, call);
setAttrib(result, R_SrcrefSymbol, nattrib);
UNPROTECT(1);
}
/* FIXME: this is wrong, because the slots are gone, so result is an invalid object of the S4 class! JMC 3/3/09 */
#ifdef _S4_subsettable
if(IS_S4_OBJECT(x)) { /* e.g. contains = "list" */
setAttrib(result, R_ClassSymbol, getAttrib(x, R_ClassSymbol));
SET_S4_OBJECT(result);
}
#endif
}
UNPROTECT(3);
return result;
}