static void newJavaGD_Path(double *x, double *y, int npoly, int *nper, Rboolean winding,
R_GE_gcontext *gc, NewDevDesc *dd)
{
newJavaGDDesc *xd = (newJavaGDDesc *) dd->deviceSpecific;
JNIEnv *env = getJNIEnv();
jmethodID mid;
jarray na, xa, ya;
int n;
if (!env || !xd || !xd->talk) return;
checkGC(env, xd, gc);
na = (*env)->NewIntArray(env, npoly);
if (!na) return;
(*env)->SetIntArrayRegion(env, na, 0, npoly, (jint *) nper);
n = 0;
for (int i = 0; i < npoly; ++i)
n += nper[i];
xa = newDoubleArray(env, n, x);
if (!xa) return;
ya = newDoubleArray(env, n, y);
if (!ya) return;
mid = (*env)->GetMethodID(env, xd->talkClass, "gdPath", "(I[I[D[DZ)V");
if (mid) (*env)->CallVoidMethod(env, xd->talk, mid, (jint) npoly, na, xa, ya, winding);
(*env)->DeleteLocalRef(env, na);
(*env)->DeleteLocalRef(env, xa);
(*env)->DeleteLocalRef(env, ya);
chkX(env);
}
static void newJavaGD_MetricInfo(int c, R_GE_gcontext *gc, double* ascent, double* descent, double* width, NewDevDesc *dd)
{
newJavaGDDesc *xd = (newJavaGDDesc *) dd->deviceSpecific;
JNIEnv *env = getJNIEnv();
jmethodID mid;
if(!env || !xd || !xd->talk) return;
checkGC(env,xd, gc);
if(c <0) c = -c;
mid = (*env)->GetMethodID(env, xd->talkClass, "gdMetricInfo", "(I)[D");
if (mid) {
jobject o=(*env)->CallObjectMethod(env, xd->talk, mid, c);
if (o) {
jdouble *ac=(jdouble*)(*env)->GetDoubleArrayElements(env, o, 0);
if (!ac) {
(*env)->DeleteLocalRef(env, o);
return;
}
*ascent=ac[0]; *descent=ac[1]; *width=ac[2];
(*env)->ReleaseDoubleArrayElements(env, o, ac, 0);
(*env)->DeleteLocalRef(env, o);
}
}
chkX(env);
}
static void newJavaGD_Rect(double x0, double y0, double x1, double y1, R_GE_gcontext *gc, NewDevDesc *dd)
{
newJavaGDDesc *xd = (newJavaGDDesc *) dd->deviceSpecific;
JNIEnv *env = getJNIEnv();
if(!env || !xd || !xd->talk) return;
checkGC(env,xd, gc);
(*env)->CallVoidMethod(env, xd->talk, jmGDInterfaceRect, x0, y0, x1, y1);
chkX(env);
}
static void newJavaGD_Circle(double x, double y, double r, R_GE_gcontext *gc, NewDevDesc *dd)
{
newJavaGDDesc *xd = (newJavaGDDesc *) dd->deviceSpecific;
JNIEnv *env = getJNIEnv();
if(!env || !xd || !xd->talk) return;
checkGC(env,xd, gc);
(*env)->CallVoidMethod(env, xd->talk, jmGDInterfaceCircle, x, y, r);
chkX(env);
}
static void newJavaGD_Line(double x1, double y1, double x2, double y2, R_GE_gcontext *gc, NewDevDesc *dd)
{
newJavaGDDesc *xd = (newJavaGDDesc *) dd->deviceSpecific;
JNIEnv *env = getJNIEnv();
jmethodID mid;
if(!env || !xd || !xd->talk) return;
checkGC(env,xd, gc);
mid = (*env)->GetMethodID(env, xd->talkClass, "gdLine", "(DDDD)V");
if (mid) (*env)->CallVoidMethod(env, xd->talk, mid, x1, y1, x2, y2);
chkX(env);
}
static void newJavaGD_TextUTF8(double x, double y, constxt char *str, double rot, double hadj, R_GE_gcontext *gc, NewDevDesc *dd)
{
newJavaGDDesc *xd = (newJavaGDDesc *) dd->deviceSpecific;
JNIEnv *env = getJNIEnv();
jstring s;
if(!env || !xd || !xd->talk) return;
checkGC(env,xd, gc);
s = (*env)->NewStringUTF(env, str);
(*env)->CallVoidMethod(env, xd->talk, jmGDInterfaceText, x, y, s, rot, hadj);
(*env)->DeleteLocalRef(env, s);
chkX(env);
}
static void newJavaGD_Rect(double x0, double y0, double x1, double y1, R_GE_gcontext *gc, NewDevDesc *dd)
{
newJavaGDDesc *xd = (newJavaGDDesc *) dd->deviceSpecific;
JNIEnv *env = getJNIEnv();
jmethodID mid;
if(!env || !xd || !xd->talk) return;
checkGC(env,xd, gc);
mid = (*env)->GetMethodID(env, xd->talkClass, "gdRect", "(DDDD)V");
if (mid) (*env)->CallVoidMethod(env, xd->talk, mid, x0, y0, x1, y1);
else gdWarning("gdRect: can't get mid ");
chkX(env);
}
static double newJavaGD_StrWidthUTF8(constxt char *str, R_GE_gcontext *gc, NewDevDesc *dd)
{
newJavaGDDesc *xd = (newJavaGDDesc *) dd->deviceSpecific;
JNIEnv *env = getJNIEnv();
jstring s;
double width;
if(!env || !xd || !xd->talk) return 0.0;
checkGC(env,xd, gc);
s = (*env)->NewStringUTF(env, str);
width = (*env)->CallDoubleMethod(env, xd->talk, jmGDInterfaceStrWidth, s);
/* s not released! */
chkX(env);
return width;
}
static void newJavaGD_TextUTF8(double x, double y, constxt char *str, double rot, double hadj, R_GE_gcontext *gc, NewDevDesc *dd)
{
newJavaGDDesc *xd = (newJavaGDDesc *) dd->deviceSpecific;
JNIEnv *env = getJNIEnv();
jmethodID mid;
jstring s;
if(!env || !xd || !xd->talk) return;
checkGC(env, xd, gc);
s = (*env)->NewStringUTF(env, str);
mid = (*env)->GetMethodID(env, xd->talkClass, "gdText", "(DDLjava/lang/String;DD)V");
if (mid)
(*env)->CallVoidMethod(env, xd->talk, mid, x, y, s, rot, hadj);
(*env)->DeleteLocalRef(env, s);
chkX(env);
}
static double newJavaGD_StrWidthUTF8(constxt char *str, R_GE_gcontext *gc, NewDevDesc *dd)
{
newJavaGDDesc *xd = (newJavaGDDesc *) dd->deviceSpecific;
JNIEnv *env = getJNIEnv();
jmethodID mid;
jstring s;
double res = 0.0;
if(!env || !xd || !xd->talk) return 0.0;
checkGC(env, xd, gc);
s = (*env)->NewStringUTF(env, str);
mid = (*env)->GetMethodID(env, xd->talkClass, "gdStrWidth", "(Ljava/lang/String;)D");
if (mid) res = (*env)->CallDoubleMethod(env, xd->talk, mid, s);
(*env)->DeleteLocalRef(env, s);
chkX(env);
return res;
}
static void newJavaGD_Polyline(int n, double *x, double *y, R_GE_gcontext *gc, NewDevDesc *dd)
{
newJavaGDDesc *xd = (newJavaGDDesc *) dd->deviceSpecific;
JNIEnv *env = getJNIEnv();
jarray xa, ya;
if(!env || !xd || !xd->talk) return;
checkGC(env,xd, gc);
xa=newDoubleArray(env, n, x);
if (!xa) return;
ya=newDoubleArray(env, n, y);
if (!ya) return;
(*env)->CallVoidMethod(env, xd->talk, jmGDInterfacePolyline, n, xa, ya);
(*env)->DeleteLocalRef(env, xa);
(*env)->DeleteLocalRef(env, ya);
chkX(env);
}
static void newJavaGD_Raster(unsigned int *raster, int w, int h,
double x, double y, double width, double height,
double rot, Rboolean interpolate,
R_GE_gcontext *gc, NewDevDesc *dd)
{
newJavaGDDesc *xd = (newJavaGDDesc *) dd->deviceSpecific;
JNIEnv *env = getJNIEnv();
jmethodID mid;
if(!env || !xd || !xd->talk) return;
checkGC(env, xd, gc);
mid = (*env)->GetMethodID(env, xd->talkClass, "gdRaster", "([BIIDDDDDZ)V");
if (mid) {
jbyteArray img = (*env)->NewByteArray(env, w * h * 4);
(*env)->SetByteArrayRegion(env, img, 0, w * h * 4, (jbyte*) raster);
(*env)->CallVoidMethod(env, xd->talk, mid, img, w, h, x, y, width, height, rot, interpolate);
(*env)->DeleteLocalRef(env, img);
}
chkX(env);
}
static void newJavaGD_Polygon(int n, double *x, double *y, R_GE_gcontext *gc, NewDevDesc *dd)
{
newJavaGDDesc *xd = (newJavaGDDesc *) dd->deviceSpecific;
JNIEnv *env = getJNIEnv();
jmethodID mid;
jarray xa, ya;
if(!env || !xd || !xd->talk) return;
checkGC(env, xd, gc);
xa = newDoubleArray(env, n, x);
if (!xa) return;
ya = newDoubleArray(env, n, y);
if (!ya) return;
mid = (*env)->GetMethodID(env, xd->talkClass, "gdPolygon", "(I[D[D)V");
if (mid) (*env)->CallVoidMethod(env, xd->talk, mid, n, xa, ya);
(*env)->DeleteLocalRef(env, xa);
(*env)->DeleteLocalRef(env, ya);
chkX(env);
}
/*****
* Name: SetValues
* Return Type: Boolean
* Description: xmBalloonWidgetClass SetValues method.
* In:
* current: copy of widget before any set_values methods are called
* request: copy of widget after resources have changed but before any
* set_values methods are called
* set: widget with resources set and as modified by any superclass
* methods that have called XtSetValues()
* args: argument list passed to XtSetValues, done by programmer
* num_args: no of args
* Returns:
* True if a changed resource requires a redisplay, False otherwise.
*****/
static Boolean
SetValues(Widget current, Widget request, Widget set, ArgList args,
Cardinal *num_args)
{
XmBalloonWidget w_curr = (XmBalloonWidget)current;
XmBalloonWidget w_req = (XmBalloonWidget)request;
XmBalloonWidget w_new = (XmBalloonWidget)set;
int i;
/*****
* Values of cancelWaitPeriod and waitPeriod are accepted without checking
*****/
/* widget colors */
if(w_new->balloon.foreground != w_curr->balloon.foreground ||
w_new->core.background_pixel != w_curr->core.background_pixel)
{
checkGC(w_new);
}
/* label string, check if a new one has been provided */
for(i = 0; i < *num_args; i++)
{
if(!strcmp(XmNlabelString, args[i].name))
{
/* a new label has been specified */
setLabel(w_new, w_req->balloon.label);
break;
}
}
/* new label set while widget is up, change it */
if(i != *num_args && w_curr->balloon.popped)
popupBalloon((Widget)w_new, 0);
return(FALSE);
}
Expression *semanticTraits(TraitsExp *e, Scope *sc)
{
#if LOGSEMANTIC
printf("TraitsExp::semantic() %s\n", e->toChars());
#endif
if (e->ident != Id::compiles && e->ident != Id::isSame &&
e->ident != Id::identifier && e->ident != Id::getProtection)
{
if (!TemplateInstance::semanticTiargs(e->loc, sc, e->args, 1))
return new ErrorExp();
}
size_t dim = e->args ? e->args->dim : 0;
if (e->ident == Id::isArithmetic)
{
return isTypeX(e, &isTypeArithmetic);
}
else if (e->ident == Id::isFloating)
{
return isTypeX(e, &isTypeFloating);
}
else if (e->ident == Id::isIntegral)
{
return isTypeX(e, &isTypeIntegral);
}
else if (e->ident == Id::isScalar)
{
return isTypeX(e, &isTypeScalar);
}
else if (e->ident == Id::isUnsigned)
{
return isTypeX(e, &isTypeUnsigned);
}
else if (e->ident == Id::isAssociativeArray)
{
return isTypeX(e, &isTypeAssociativeArray);
}
else if (e->ident == Id::isStaticArray)
{
return isTypeX(e, &isTypeStaticArray);
}
else if (e->ident == Id::isAbstractClass)
{
return isTypeX(e, &isTypeAbstractClass);
}
else if (e->ident == Id::isFinalClass)
{
return isTypeX(e, &isTypeFinalClass);
}
else if (e->ident == Id::isPOD)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Type *t = isType(o);
StructDeclaration *sd;
if (!t)
{
e->error("type expected as second argument of __traits %s instead of %s", e->ident->toChars(), o->toChars());
goto Lfalse;
}
Type *tb = t->baseElemOf();
if (tb->ty == Tstruct
&& ((sd = (StructDeclaration *)(((TypeStruct *)tb)->sym)) != NULL))
{
if (sd->isPOD())
goto Ltrue;
else
goto Lfalse;
}
goto Ltrue;
}
else if (e->ident == Id::isNested)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
AggregateDeclaration *a;
FuncDeclaration *f;
if (!s) { }
else if ((a = s->isAggregateDeclaration()) != NULL)
{
if (a->isNested())
goto Ltrue;
else
goto Lfalse;
}
else if ((f = s->isFuncDeclaration()) != NULL)
{
if (f->isNested())
goto Ltrue;
else
goto Lfalse;
}
e->error("aggregate or function expected instead of '%s'", o->toChars());
goto Lfalse;
}
else if (e->ident == Id::isAbstractFunction)
{
return isFuncX(e, &isFuncAbstractFunction);
}
else if (e->ident == Id::isVirtualFunction)
{
return isFuncX(e, &isFuncVirtualFunction);
}
else if (e->ident == Id::isVirtualMethod)
{
return isFuncX(e, &isFuncVirtualMethod);
}
else if (e->ident == Id::isFinalFunction)
{
return isFuncX(e, &isFuncFinalFunction);
}
else if (e->ident == Id::isOverrideFunction)
{
return isFuncX(e, &isFuncOverrideFunction);
}
else if (e->ident == Id::isStaticFunction)
{
return isFuncX(e, &isFuncStaticFunction);
}
else if (e->ident == Id::isRef)
{
return isDeclX(e, &isDeclRef);
}
else if (e->ident == Id::isOut)
{
return isDeclX(e, &isDeclOut);
}
else if (e->ident == Id::isLazy)
{
return isDeclX(e, &isDeclLazy);
}
else if (e->ident == Id::identifier)
{
// Get identifier for symbol as a string literal
/* Specify 0 for bit 0 of the flags argument to semanticTiargs() so that
* a symbol should not be folded to a constant.
* Bit 1 means don't convert Parameter to Type if Parameter has an identifier
*/
if (!TemplateInstance::semanticTiargs(e->loc, sc, e->args, 2))
return new ErrorExp();
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Parameter *po = isParameter(o);
Identifier *id;
if (po)
{
id = po->ident;
assert(id);
}
else
{
Dsymbol *s = getDsymbol(o);
if (!s || !s->ident)
{
e->error("argument %s has no identifier", o->toChars());
goto Lfalse;
}
id = s->ident;
}
StringExp *se = new StringExp(e->loc, id->toChars());
return se->semantic(sc);
}
else if (e->ident == Id::getProtection)
{
if (dim != 1)
goto Ldimerror;
Scope *sc2 = sc->push();
sc2->flags = sc->flags | SCOPEnoaccesscheck;
bool ok = TemplateInstance::semanticTiargs(e->loc, sc2, e->args, 1);
sc2->pop();
if (!ok)
return new ErrorExp();
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
if (!s)
{
if (!isError(o))
e->error("argument %s has no protection", o->toChars());
goto Lfalse;
}
if (s->scope)
s->semantic(s->scope);
PROT protection = s->prot();
const char *protName = Pprotectionnames[protection];
assert(protName);
StringExp *se = new StringExp(e->loc, (char *) protName);
return se->semantic(sc);
}
else if (e->ident == Id::parent)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
if (s)
{
if (FuncDeclaration *fd = s->isFuncDeclaration()) // Bugzilla 8943
s = fd->toAliasFunc();
if (!s->isImport()) // Bugzilla 8922
s = s->toParent();
}
if (!s || s->isImport())
{
e->error("argument %s has no parent", o->toChars());
goto Lfalse;
}
if (FuncDeclaration *f = s->isFuncDeclaration())
{
if (TemplateDeclaration *td = getFuncTemplateDecl(f))
{
if (td->overroot) // if not start of overloaded list of TemplateDeclaration's
td = td->overroot; // then get the start
Expression *ex = new TemplateExp(e->loc, td, f);
ex = ex->semantic(sc);
return ex;
}
if (FuncLiteralDeclaration *fld = f->isFuncLiteralDeclaration())
{
// Directly translate to VarExp instead of FuncExp
Expression *ex = new VarExp(e->loc, fld, 1);
return ex->semantic(sc);
}
}
return (new DsymbolExp(e->loc, s))->semantic(sc);
}
else if (e->ident == Id::hasMember ||
e->ident == Id::getMember ||
e->ident == Id::getOverloads ||
e->ident == Id::getVirtualMethods ||
e->ident == Id::getVirtualFunctions)
{
if (dim != 2)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Expression *ex = isExpression((*e->args)[1]);
if (!ex)
{
e->error("expression expected as second argument of __traits %s", e->ident->toChars());
goto Lfalse;
}
ex = ex->ctfeInterpret();
StringExp *se = ex->toStringExp();
if (!se || se->length() == 0)
{
e->error("string expected as second argument of __traits %s instead of %s", e->ident->toChars(), ex->toChars());
goto Lfalse;
}
se = se->toUTF8(sc);
if (se->sz != 1)
{
e->error("string must be chars");
goto Lfalse;
}
Identifier *id = Lexer::idPool((char *)se->string);
/* Prefer dsymbol, because it might need some runtime contexts.
*/
Dsymbol *sym = getDsymbol(o);
if (sym)
{
ex = new DsymbolExp(e->loc, sym);
ex = new DotIdExp(e->loc, ex, id);
}
else if (Type *t = isType(o))
ex = typeDotIdExp(e->loc, t, id);
else if (Expression *ex2 = isExpression(o))
ex = new DotIdExp(e->loc, ex2, id);
else
{
e->error("invalid first argument");
goto Lfalse;
}
if (e->ident == Id::hasMember)
{
if (sym)
{
Dsymbol *sm = sym->search(e->loc, id);
if (sm)
goto Ltrue;
}
/* Take any errors as meaning it wasn't found
*/
Scope *sc2 = sc->push();
ex = ex->trySemantic(sc2);
sc2->pop();
if (!ex)
goto Lfalse;
else
goto Ltrue;
}
else if (e->ident == Id::getMember)
{
ex = ex->semantic(sc);
return ex;
}
else if (e->ident == Id::getVirtualFunctions ||
e->ident == Id::getVirtualMethods ||
e->ident == Id::getOverloads)
{
unsigned errors = global.errors;
Expression *eorig = ex;
ex = ex->semantic(sc);
if (errors < global.errors)
e->error("%s cannot be resolved", eorig->toChars());
/* Create tuple of functions of ex
*/
//ex->print();
Expressions *exps = new Expressions();
FuncDeclaration *f;
if (ex->op == TOKvar)
{
VarExp *ve = (VarExp *)ex;
f = ve->var->isFuncDeclaration();
ex = NULL;
}
else if (ex->op == TOKdotvar)
{
DotVarExp *dve = (DotVarExp *)ex;
f = dve->var->isFuncDeclaration();
if (dve->e1->op == TOKdottype || dve->e1->op == TOKthis)
ex = NULL;
else
ex = dve->e1;
}
else
f = NULL;
Ptrait p;
p.exps = exps;
p.e1 = ex;
p.ident = e->ident;
overloadApply(f, &p, &fptraits);
TupleExp *tup = new TupleExp(e->loc, exps);
return tup->semantic(sc);
}
else
assert(0);
}
else if (e->ident == Id::classInstanceSize)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
ClassDeclaration *cd;
if (!s || (cd = s->isClassDeclaration()) == NULL)
{
e->error("first argument is not a class");
goto Lfalse;
}
if (cd->sizeok == SIZEOKnone)
{
if (cd->scope)
cd->semantic(cd->scope);
}
if (cd->sizeok != SIZEOKdone)
{
e->error("%s %s is forward referenced", cd->kind(), cd->toChars());
goto Lfalse;
}
return new IntegerExp(e->loc, cd->structsize, Type::tsize_t);
}
else if (e->ident == Id::getAliasThis)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
AggregateDeclaration *ad;
if (!s || (ad = s->isAggregateDeclaration()) == NULL)
{
e->error("argument is not an aggregate type");
goto Lfalse;
}
Expressions *exps = new Expressions();
if (ad->aliasthis)
exps->push(new StringExp(e->loc, ad->aliasthis->ident->toChars()));
Expression *ex = new TupleExp(e->loc, exps);
ex = ex->semantic(sc);
return ex;
}
else if (e->ident == Id::getAttributes)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
if (!s)
{
#if 0
Expression *x = isExpression(o);
Type *t = isType(o);
if (x) printf("e = %s %s\n", Token::toChars(x->op), x->toChars());
if (t) printf("t = %d %s\n", t->ty, t->toChars());
#endif
e->error("first argument is not a symbol");
goto Lfalse;
}
//printf("getAttributes %s, attrs = %p, scope = %p\n", s->toChars(), s->userAttributes, s->userAttributesScope);
UserAttributeDeclaration *udad = s->userAttribDecl;
TupleExp *tup = new TupleExp(e->loc, udad ? udad->getAttributes() : new Expressions());
return tup->semantic(sc);
}
else if (e->ident == Id::getFunctionAttributes)
{
/// extract all function attributes as a tuple (const/shared/inout/pure/nothrow/etc) except UDAs.
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
Type *t = isType(o);
TypeFunction *tf = NULL;
if (s)
{
if (FuncDeclaration *f = s->isFuncDeclaration())
t = f->type;
else if (VarDeclaration *v = s->isVarDeclaration())
t = v->type;
}
if (t)
{
if (t->ty == Tfunction)
tf = (TypeFunction *)t;
else if (t->ty == Tdelegate)
tf = (TypeFunction *)t->nextOf();
else if (t->ty == Tpointer && t->nextOf()->ty == Tfunction)
tf = (TypeFunction *)t->nextOf();
}
if (!tf)
{
e->error("first argument is not a function");
goto Lfalse;
}
Expressions *mods = new Expressions();
PushAttributes pa;
pa.mods = mods;
tf->modifiersApply(&pa, &PushAttributes::fp);
tf->attributesApply(&pa, &PushAttributes::fp, TRUSTformatSystem);
TupleExp *tup = new TupleExp(e->loc, mods);
return tup->semantic(sc);
}
else if (e->ident == Id::allMembers || e->ident == Id::derivedMembers)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
ScopeDsymbol *sds;
if (!s)
{
e->error("argument has no members");
goto Lfalse;
}
Import *import;
if ((import = s->isImport()) != NULL)
{
// Bugzilla 9692
sds = import->mod;
}
else if ((sds = s->isScopeDsymbol()) == NULL)
{
e->error("%s %s has no members", s->kind(), s->toChars());
goto Lfalse;
}
// use a struct as local function
struct PushIdentsDg
{
static int dg(void *ctx, size_t n, Dsymbol *sm)
{
if (!sm)
return 1;
//printf("\t[%i] %s %s\n", i, sm->kind(), sm->toChars());
if (sm->ident)
{
if (sm->ident != Id::ctor &&
sm->ident != Id::dtor &&
sm->ident != Id::_postblit &&
memcmp(sm->ident->string, "__", 2) == 0)
{
return 0;
}
//printf("\t%s\n", sm->ident->toChars());
Identifiers *idents = (Identifiers *)ctx;
/* Skip if already present in idents[]
*/
for (size_t j = 0; j < idents->dim; j++)
{ Identifier *id = (*idents)[j];
if (id == sm->ident)
return 0;
#ifdef DEBUG
// Avoid using strcmp in the first place due to the performance impact in an O(N^2) loop.
assert(strcmp(id->toChars(), sm->ident->toChars()) != 0);
#endif
}
idents->push(sm->ident);
}
else
{
EnumDeclaration *ed = sm->isEnumDeclaration();
if (ed)
{
ScopeDsymbol::foreach(NULL, ed->members, &PushIdentsDg::dg, (Identifiers *)ctx);
}
}
return 0;
}
};
Identifiers *idents = new Identifiers;
ScopeDsymbol::foreach(sc, sds->members, &PushIdentsDg::dg, idents);
ClassDeclaration *cd = sds->isClassDeclaration();
if (cd && e->ident == Id::allMembers)
{
struct PushBaseMembers
{
static void dg(ClassDeclaration *cd, Identifiers *idents)
{
for (size_t i = 0; i < cd->baseclasses->dim; i++)
{
ClassDeclaration *cb = (*cd->baseclasses)[i]->base;
ScopeDsymbol::foreach(NULL, cb->members, &PushIdentsDg::dg, idents);
if (cb->baseclasses->dim)
dg(cb, idents);
}
}
};
PushBaseMembers::dg(cd, idents);
}
// Turn Identifiers into StringExps reusing the allocated array
assert(sizeof(Expressions) == sizeof(Identifiers));
Expressions *exps = (Expressions *)idents;
for (size_t i = 0; i < idents->dim; i++)
{
Identifier *id = (*idents)[i];
StringExp *se = new StringExp(e->loc, id->toChars());
(*exps)[i] = se;
}
/* Making this a tuple is more flexible, as it can be statically unrolled.
* To make an array literal, enclose __traits in [ ]:
* [ __traits(allMembers, ...) ]
*/
Expression *ex = new TupleExp(e->loc, exps);
ex = ex->semantic(sc);
return ex;
}
else if (e->ident == Id::compiles)
{
/* Determine if all the objects - types, expressions, or symbols -
* compile without error
*/
if (!dim)
goto Lfalse;
for (size_t i = 0; i < dim; i++)
{
unsigned errors = global.startGagging();
unsigned oldspec = global.speculativeGag;
global.speculativeGag = global.gag;
Scope *sc2 = sc->push();
sc2->speculative = true;
sc2->flags = sc->flags & ~SCOPEctfe | SCOPEcompile;
bool err = false;
RootObject *o = (*e->args)[i];
Type *t = isType(o);
Expression *ex = t ? t->toExpression() : isExpression(o);
if (!ex && t)
{
Dsymbol *s;
t->resolve(e->loc, sc2, &ex, &t, &s);
if (t)
{
t->semantic(e->loc, sc2);
if (t->ty == Terror)
err = true;
}
else if (s && s->errors)
err = true;
}
if (ex)
{
ex = ex->semantic(sc2);
ex = resolvePropertiesOnly(sc2, ex);
ex = ex->optimize(WANTvalue);
ex = checkGC(sc2, ex);
if (ex->op == TOKerror)
err = true;
}
sc2->pop();
global.speculativeGag = oldspec;
if (global.endGagging(errors) || err)
{
goto Lfalse;
}
}
goto Ltrue;
}
else if (e->ident == Id::isSame)
{
/* Determine if two symbols are the same
*/
if (dim != 2)
goto Ldimerror;
if (!TemplateInstance::semanticTiargs(e->loc, sc, e->args, 0))
return new ErrorExp();
RootObject *o1 = (*e->args)[0];
RootObject *o2 = (*e->args)[1];
Dsymbol *s1 = getDsymbol(o1);
Dsymbol *s2 = getDsymbol(o2);
//printf("isSame: %s, %s\n", o1->toChars(), o2->toChars());
#if 0
printf("o1: %p\n", o1);
printf("o2: %p\n", o2);
if (!s1)
{
Expression *ea = isExpression(o1);
if (ea)
printf("%s\n", ea->toChars());
Type *ta = isType(o1);
if (ta)
printf("%s\n", ta->toChars());
goto Lfalse;
}
else
printf("%s %s\n", s1->kind(), s1->toChars());
#endif
if (!s1 && !s2)
{
Expression *ea1 = isExpression(o1);
Expression *ea2 = isExpression(o2);
if (ea1 && ea2)
{
if (ea1->equals(ea2))
goto Ltrue;
}
}
if (!s1 || !s2)
goto Lfalse;
s1 = s1->toAlias();
s2 = s2->toAlias();
if (s1->isFuncAliasDeclaration())
s1 = ((FuncAliasDeclaration *)s1)->toAliasFunc();
if (s2->isFuncAliasDeclaration())
s2 = ((FuncAliasDeclaration *)s2)->toAliasFunc();
if (s1 == s2)
goto Ltrue;
else
goto Lfalse;
}
else if (e->ident == Id::getUnitTests)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
if (!s)
{
e->error("argument %s to __traits(getUnitTests) must be a module or aggregate", o->toChars());
goto Lfalse;
}
Import *imp = s->isImport();
if (imp) // Bugzilla 10990
s = imp->mod;
ScopeDsymbol* scope = s->isScopeDsymbol();
if (!scope)
{
e->error("argument %s to __traits(getUnitTests) must be a module or aggregate, not a %s", s->toChars(), s->kind());
goto Lfalse;
}
Expressions* unitTests = new Expressions();
Dsymbols* symbols = scope->members;
if (global.params.useUnitTests && symbols)
{
// Should actually be a set
AA* uniqueUnitTests = NULL;
collectUnitTests(symbols, uniqueUnitTests, unitTests);
}
TupleExp *tup = new TupleExp(e->loc, unitTests);
return tup->semantic(sc);
}
else if(e->ident == Id::getVirtualIndex)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
FuncDeclaration *fd;
if (!s || (fd = s->isFuncDeclaration()) == NULL)
{
e->error("first argument to __traits(getVirtualIndex) must be a function");
goto Lfalse;
}
fd = fd->toAliasFunc(); // Neccessary to support multiple overloads.
return new IntegerExp(e->loc, fd->vtblIndex, Type::tptrdiff_t);
}
else
{
if (const char *sub = (const char *)speller(e->ident->toChars(), &trait_search_fp, NULL, idchars))
e->error("unrecognized trait '%s', did you mean '%s'?", e->ident->toChars(), sub);
else
e->error("unrecognized trait '%s'", e->ident->toChars());
goto Lfalse;
}
return NULL;
Ldimerror:
e->error("wrong number of arguments %d", (int)dim);
goto Lfalse;
Lfalse:
return new IntegerExp(e->loc, 0, Type::tbool);
Ltrue:
return new IntegerExp(e->loc, 1, Type::tbool);
}
/*****
* Name: Initialize
* Return Type: void
* Description: XmBalloonWidgetClass initialize method
* In:
* request: widget with resource values set as requested by the argument
* list, resource database and widget defaults
* init: same widget with values as modified by superclass initialize()
* methods
* args: argument list passed to XtCreateWidget
* num_args: number of entries in the argument list
* Returns:
* nothing, but init is updated with checked/updated resource values.
*****/
static void
Initialize(Widget request, Widget init, ArgList args, Cardinal *num_args)
{
XmBalloonWidget balloon = (XmBalloonWidget)init;
XmBalloonWidget req = (XmBalloonWidget)request;
int shape_event_base, shape_error_base;
/* initialize fields */
ATTR(gc) = NULL;
ATTR(popped) = False;
ATTR(pop_x) = (Position)0;
ATTR(pop_y) = (Position)0;
ATTR(popup_id) = (XtIntervalId)0;
ATTR(popdown_id) = (XtIntervalId)0;
ATTR(context) = XtWidgetToApplicationContext(XtParent(request));
balloon->core.x = 0;
balloon->core.y = 0;
balloon->core.width = 1;
balloon->core.height= 1;
/* select default backingStore model */
ATTR(backing_store) = Always + WhenMapped + NotUseful;
/* check for correct XmNcornerStyle value */
if(!XmRepTypeValidValue(corner_style_repid, ATTR(corner_style), init))
{
_XmHTMLWarning(__WFUNC__(balloon, "initialize"),
"Bad XmNcornerStyle value, reset to XmCORNER_STRAIGHT");
ATTR(corner_style) = XmCORNER_STRAIGHT;
}
/* check for correct XmNballoonStyle value */
if(!XmRepTypeValidValue(balloon_style_repid, ATTR(balloon_style), init))
{
_XmHTMLWarning(__WFUNC__(balloon, "Initialize"),
"Bad XmNballoonStyle value, reset to XmBALLOON_SQUARE");
ATTR(balloon_style) = XmBALLOON_SQUARE;
}
/* When a shaped balloon is requested, check if the server supports it. */
if(ATTR(balloon_style) == XmBALLOON_SHAPED &&
!XShapeQueryExtension(XtDisplay(balloon), &shape_event_base,
&shape_error_base))
{
_XmHTMLWarning(__WFUNC__(balloon, "Initialize"),
"Shape extension not supported by XServer, resetting "
"XmNballoonStyle to XmBALLOON_SQUARE.");
ATTR(balloon_style) = XmBALLOON_SQUARE;
}
ATTR(shape_window) = (ATTR(balloon_style) == XmBALLOON_SHAPED);
ATTR(shape_mask) = None;
ATTR(shape_gc) = 0;
ATTR(shape_width) = 0;
ATTR(shape_height) = 0;
/* get font info */
computeFontInfo(balloon);
/* and create the GC's for us to use */
checkGC(balloon);
/* label string */
if(req->balloon.label != NULL)
{
ATTR(source) = strdup(req->balloon.label);
ATTR(source_len) = strlen(req->balloon.label);
}
else
{
ATTR(source) = NULL;
ATTR(source_len) = 0;
}
}
