status_t
AttributeMessage::SetAttribute(const char* name, const entry_ref& value)
{
if (ReplaceRef(name, &value) == B_OK)
return B_OK;
return AddRef(name, &value);
}
DratMesh *YGetDMesh(Symbol *s, int nilOK)
{
DratMesh *dm;
if (s->ops==&referenceSym) ReplaceRef(s);
if (s->ops!=&dataBlockSym || s->value.db->ops!=&meshOps)
YError("expecting Drat-Mesh argument");
dm= (DratMesh *)s->value.db;
if (!nilOK && dm->mesh.mesh.kmax<2)
YError("mesh has not yet been updated -- call update_mesh");
return (DratMesh *)s->value.db;
}
void RenderTarget<Tex2DResource>::SetRT(Tex2DResource* value)
{
if (ReplaceRef(_texture, value))
{
if (_createTexture)
{
delete _texture;
_createTexture = false;
}
_texture = value;
}
}
void Y_eq_nocopy(int nArgs)
{
Symbol *stack= sp-nArgs+1;
Symbol *glob;
if (nArgs!=2) YError("eq_nocopy takes exactly two arguments");
if (stack->ops!=&referenceSym)
YError("eq_nocopy first argument not simple variable reference");
glob= &globTab[stack->index];
/* destroy current value of variable */
if (glob->ops==&dataBlockSym) {
glob->ops= &intScalar;
Unref(glob->value.db);
}
/* copy top of stack to variable */
if (sp->ops==&referenceSym) ReplaceRef(sp);
if (sp->ops==&dataBlockSym) {
Array *array= (Array *)sp->value.db;
/* fetch an LValue, but otherwise just increase the reference
* count of the object
* unlike Define() action, which copies arrays that have other
* references */
if (array->ops==&lvalueOps) {
LValue *lvalue= (LValue *)array;
Array *owner= lvalue->owner;
/* actually only want to fetch a non-trivial LValue */
if (!owner || lvalue->strider ||
lvalue->type.dims!=owner->type.dims ||
lvalue->type.base!=owner->type.base) {
array= FetchLValue(array, sp);
} else {
array= owner;
}
}
glob->value.db= (DataBlock *)Ref(array);
} else {
glob->value= sp->value;
}
glob->ops= sp->ops;
}
void EvalFN(Operand *op)
{
Symbol *stack= op->owner;
int n= op->references; /* (sic) # of actual parameters supplied */
Function *func= op->value;
Instruction *code= &func->code[1]; /* (code[0] is index to function) */
int nReq= func->nReq; /* (see CheckStack call below) */
int nPos= func->nPos; /* number of dummy positional parameters */
int nKey= func->nKey; /* number of dummy keyword parameters */
int nLoc= func->nLocal; /* number of local variables */
long hasPosList= func->hasPosList;
long posList;
int actual, dummy, index, nExtra;
Symbol *spnow, *extraPos, *key;
P_SOFTFPE_TEST;
/* Be sure the stack is long enough for a worst-case invocation of this
function. nReq= nPos + (hasPosList&1) + nKey + nLoc + (deepest stack
required for expression evaluation) + 10
+ 1 for return address for this function
The nPos and nKey terms must be present because they may not be
actual arguments, and because even if they are supplied they may
be referenceSyms which must be copied for use during return.
The extra 10 is so that builtin procedures are always guaranteed
8(+2 for luck) free stack slots without calling CheckStack. */
if (CheckStack(nReq)) stack= sp-n;
/* Handle all actual parameters.
This must be done in two passes to avoid accidental collisions
between dummy parameters and indirect references on the stack
to external variables of the same name. All of this could be
avoided if function parameters were always passed by value,
never by reference. But I can't bring myself to disallow the
FORTRAN-like function which uses its parameters to return values. */
/* First pass copies any indirect references.
The parser has guaranteed that index (dummy) will not be repeated,
since there may not be 2 dummy parameters with the same name.
However, nothing prevents the one or more of the actual parameters
(stack) from being referenceSyms to the same name as a dummy
parameter. This possibility requires copying all referenceSym
actual parameters onto the stack (possibly multiple times).
Also, note that a globTab entry may NEVER be a referenceSym, so
if return is to affect external values of parameters, any
referenceSym parameters must remain on the stack. */
posList= hasPosList>>1;
hasPosList&= 1;
nExtra= -nPos;
spnow= stack;
for (actual=0 ; actual<n ; actual++) {
spnow++;
if (spnow->ops) {
if (spnow->ops==&referenceSym) {
if (posList) {
if (nExtra<0 && (posList&1)) {
/* this is an output parameter */
extraPos= sp+1; /* push copy of referenceSym */
extraPos->ops= &referenceSym;
extraPos->index= spnow->index;
extraPos->value.offset= extraPos-spnow; /* install ref offset */
sp= extraPos;
}
posList>>= 1;
}
ReplaceRef(spnow); /* replace original reference by object */
} else if (posList) {
posList>>= 1;
}
nExtra++;
} else {
void TraceGfx::SetPointLink(PointLink* value)
{
if (ReplaceRef(_pointLink, value))
_pointLink = value;
}
void TraceGfx::SetSelNode(WayNode* value)
{
if (ReplaceRef(_selNode, value))
_selNode = value;
}
void Y_grow(int nArgs)
{
Symbol *s0, *s= sp-nArgs+1;
long index= s->index;
Array *array;
Dimension *dims;
StructDef *base;
Operand op;
long extra, number;
int nDims;
DataBlock *db;
int amSubroutine= CalledAsSubroutine();
if (nArgs < 2) YError("grow function needs at least two arguments");
if (amSubroutine && s->ops!=&referenceSym)
YError("1st argument to grow must be a variable reference");
if (!s->ops) YError("unxepected keyword argument in grow");
dims= growDims;
growDims= 0;
FreeDimension(dims);
/* scan argument list to find first non-nil argument */
base= 0;
s0= 0;
for (;;) {
if (!s0 && amSubroutine) array= (Array *)ForceToDB(&globTab[index]);
else array= (Array *)ForceToDB(s); /* does ReplaceRef if required */
s0= s;
if (array->ops==&lvalueOps) array= FetchLValue(array, s);
if (array->ops->isArray) {
base= array->type.base;
if (array->references) {
/* the grow operation is destructive, must copy 1st arg */
Array *copy= PushDataBlock(NewArray(base, array->type.dims));
base->Copy(base, copy->value.c, array->value.c, array->type.number);
PopTo(s);
array= copy;
}
if (array->type.dims) {
growDims= NewDimension(1L, 1L, Ref(array->type.dims->next));
} else {
growDims= NewDimension(1L, 1L, (Dimension *)0);
array->type.dims= NewDimension(1L, 1L, (Dimension *)0);
}
break;
} else if (array->ops!=&voidOps) {
YError("bad data type in function grow");
}
if (++s > sp) { /* all arguments void, will return nil */
Drop(nArgs-1);
PopTo(sp-1);
return;
}
}
nDims= CountDims(growDims);
/* scan through remaining arguments to force right-conformability with
growDims and count the number of extra dimensions */
extra= 0;
while (s<sp) {
s++;
if (!s->ops) YError("unxepected keyword argument in grow");
s->ops->FormOperand(s, &op);
if (op.ops->isArray) {
if (nDims==CountDims(op.type.dims))
growDims->number= op.type.dims->number;
else
growDims->number= 1;
if (RightConform(growDims, &op))
YError("later arguments not conformable with 1st in grow");
extra+= growDims->number;
} else if (op.ops!=&voidOps) {
YError("illegal data type in function grow");
}
}
if (extra) {
LValue lvalue;
long size;
BinaryOp *Assign= base->dataOps->Assign;
/* phony LValue necessary for Assign virtual function */
lvalue.references= nArgs; /* NEVER want to free this */
lvalue.ops= &lvalueOps;
lvalue.owner= 0; /* not true, but safer */
lvalue.type.base= base; /* NOT Ref(base) -- won't be freed */
lvalue.address.m= 0;
lvalue.strider= 0;
size= base->size;
/* copy 1st non-nil argument */
number= array->type.number;
array= PushDataBlock(GrowArray(array, extra));
lvalue.address.m= array->value.c + size*number;
/* second pass through argument list copies 2nd-Nth arguments
into result array using the Assign virtual function */
s= s0;
while (++s<sp) { /* note that sp is bigger than for previous loop */
s->ops->FormOperand(s, &op);
if (op.ops->isArray) {
lvalue.type.dims= op.type.dims; /* NOT Ref(dims) -- won't be freed */
lvalue.type.number= op.type.number;
/* Assign virtual functions assume their first parameter is an
LValue* rather than an Operation* (like all other BinaryOps). */
(*Assign)((Operand *)&lvalue, &op);
lvalue.address.m+= size*lvalue.type.number;
}
}
}
/* store result back to first reference -- will also be left on stack
by EvalBI */
if (amSubroutine) {
s= &globTab[index]; /* guaranteed this is a dataBlockSym by ForceToDB */
db= s->value.db;
s->value.db= (DataBlock *)Ref(array);
Unref(db);
if (extra) Drop(nArgs);
else Drop(nArgs-1);
ReplaceRef(sp); /* result is 1st argument */
PopTo(sp-1);
} else {
if (extra) { /* result is on top of stack */
PopTo(sp-nArgs-1);
Drop(nArgs);
} else { /* result is unchanged s0 argument */
int nAbove= sp-s0;
Drop(nAbove);
nArgs-= nAbove;
PopTo(sp-nArgs);
Drop(nArgs-1);
}
}
}
void Y_merge(int nArgs)
{
Operand t, f;
Operations *ops;
Dimension *dims;
int *cond;
long i, n;
void *rslt= 0;
StructDef *base;
if (nArgs!=3) YError("merge function takes exactly three arguments");
if (sp->ops==&referenceSym) ReplaceRef(sp);
True(); /* convert condition to type int, values 0 or 1 */
sp->ops->FormOperand(sp, &t);
dims= t.type.dims;
n= t.type.number;
cond= t.value;
if (!(sp-2)->ops)
YError("merge function recognizes no keyword arguments");
(sp-2)->ops->FormOperand(sp-2, &t);
(sp-1)->ops->FormOperand(sp-1, &f);
if (t.ops==&voidOps) {
t.type.number= 0;
if (f.ops==&voidOps) f.type.number= 0;
ops= f.ops;
base= f.type.base;
} else if (f.ops==&voidOps) {
f.type.number= 0;
ops= t.ops;
base= t.type.base;
} else {
ops= t.ops->Promote[f.ops->promoteID](&t, &f);
base= t.type.base;
if (ops==&structOps && !StructEqual(base, f.type.base))
YError("two different struct instance types cannot be merged");
}
if (!ops || !ops->isArray)
YError("merge requires array or nil arguments");
if (t.type.number+f.type.number != n)
YError("number of trues + number of falses not number of conditions");
if (!dims) {
if (base==&doubleStruct) {
PushDoubleValue(0.0);
rslt= &sp->value.d;
} else if (base==&longStruct) {
PushLongValue(0L);
rslt= &sp->value.l;
} else if (base==&intStruct) {
PushIntValue(0);
rslt= &sp->value.i;
}
}
if (!rslt) {
Array *result= PushDataBlock(NewArray(base, dims));
rslt= result->value.c;
}
for (i=0 ; i<n ; i++) if (cond[i]) t.type.number--;
if (t.type.number)
YError("number of falses does not match number of 0 conditions");
MrgCpy[ops->typeID](base, rslt, t.value, f.value, cond, n);
}
