/*
* Emit the section preamble, absolute location (if any) and
* symbol name(s) for intialized data.
*/
static int
emitIvalLabel(struct dbuf_s *oBuf, symbol *sym)
{
char *segname;
static int in_code = 0;
static int sectionNr = 0;
if (sym) {
// code or data space?
if (IS_CODE(getSpec(sym->type))) {
segname = "code";
in_code = 1;
} else {
segname = "idata";
in_code = 0;
}
dbuf_printf(oBuf, "\nID_%s_%d\t%s", moduleName, sectionNr++, segname);
if (SPEC_ABSA(getSpec(sym->type))) {
// specify address for absolute symbols
dbuf_printf(oBuf, "\t0x%04X", SPEC_ADDR(getSpec(sym->type)));
} // if
dbuf_printf(oBuf, "\n%s\n", sym->rname);
addSet(&emitted, sym->rname);
}
return (in_code);
}
void Filter::update()
{
if (_inTexture.expired())
return;
auto input = _inTexture.lock();
_outTextureSpec = input->getSpec();
_outTexture->resize(_outTextureSpec.width, _outTextureSpec.height);
glViewport(0, 0, _outTextureSpec.width, _outTextureSpec.height);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, _fbo);
GLenum fboBuffers[1] = {GL_COLOR_ATTACHMENT0};
glDrawBuffers(1, fboBuffers);
glDisable(GL_DEPTH_TEST);
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
_screen->activate();
updateUniforms();
_screen->draw();
_screen->deactivate();
glDisable(GL_DEPTH_TEST);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
_outTexture->generateMipmap();
}
RegionImpl* RegionImplFactory::createRegionImpl(const std::string nodeType,
const std::string nodeParams,
Region* region)
{
RegionImpl *impl = nullptr;
Spec *ns = getSpec(nodeType);
ValueMap vm = YAMLUtils::toValueMap(
nodeParams.c_str(),
ns->parameters,
nodeType,
region->getName());
if (cppRegions.find(nodeType) != cppRegions.end())
{
impl = cppRegions[nodeType]->createRegionImpl(vm, region);
}
else if ((nodeType.find(std::string("py.")) == 0))
{
if (!pyLib_)
pyLib_ = boost::shared_ptr<DynamicPythonLibrary>(new DynamicPythonLibrary());
impl = createPyNode(pyLib_.get(), nodeType, &vm, region);
} else
{
NTA_THROW << "Unsupported node type '" << nodeType << "'";
}
return impl;
}
RegionImpl* RegionImplFactory::createRegionImpl(const std::string nodeType,
const std::string nodeParams,
Region* region)
{
RegionImpl *mn = NULL;
Spec *ns = getSpec(nodeType);
ValueMap vm = YAMLUtils::toValueMap(
nodeParams.c_str(),
ns->parameters,
nodeType,
region->getName());
if (nodeType == "TestNode")
{
mn = new TestNode(vm, region);
} else if (nodeType == "VectorFileEffector")
{
mn = new VectorFileEffector(vm, region);
} else if (nodeType == "VectorFileSensor")
{
mn = new VectorFileSensor(vm, region);
} else if ((nodeType.find(std::string("py.")) == 0))
{
if (!pyLib_)
pyLib_ = boost::shared_ptr<DynamicPythonLibrary>(new DynamicPythonLibrary());
mn = createPyNode(pyLib_.get(), nodeType, &vm, region);
} else
{
NTA_THROW << "Unsupported node type '" << nodeType << "'";
}
return mn;
}
static int
getOutputRequest(void)
{
int success = 0;
if (_cmdWant) {
static int initialized = 0;
if (initialized) {
success = 1;
}
else {
(void)strncpy(_wantSpec, _cmdWant, sizeof(_wantSpec));
_wantSpec[sizeof(_wantSpec)-1] = 0;
success = decodeOutput(_wantSpec);
initialized = 1;
}
}
else {
for (;;) {
int nbytes = getSpec("You want: ", _wantSpec, sizeof(_wantSpec));
if (nbytes < 0)
break;
success = decodeOutput(_wantSpec);
if (success)
break;
}
}
return success;
}
NS_IMETHODIMP
txStylesheetSink::OnDataAvailable(nsIRequest *aRequest, nsISupports *aContext,
nsIInputStream *aInputStream,
PRUint32 aOffset, PRUint32 aCount)
{
if (!mCheckedForXML) {
nsCOMPtr<nsIParser> parser = do_QueryInterface(aContext);
nsCOMPtr<nsIDTD> dtd;
parser->GetDTD(getter_AddRefs(dtd));
if (dtd) {
mCheckedForXML = PR_TRUE;
if (!(dtd->GetType() & NS_IPARSER_FLAG_XML)) {
nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
nsAutoString spec;
getSpec(channel, spec);
mCompiler->cancel(NS_ERROR_XSLT_WRONG_MIME_TYPE, nsnull,
spec.get());
return NS_ERROR_XSLT_WRONG_MIME_TYPE;
}
}
}
return mListener->OnDataAvailable(aRequest, aContext, aInputStream,
aOffset, aCount);
}
void Projection::validateQuery( const BSONObj query ) const {
// this function only validates positional operator ($) projections
if ( getArrayOpType() != ARRAY_OP_POSITIONAL )
return;
BSONObjIterator querySpecIter( query );
while ( querySpecIter.more() ) {
// for each query element
BSONElement queryElement = querySpecIter.next();
if ( mongoutils::str::equals( queryElement.fieldName(), "$and" ) )
// don't check $and to avoid deep comparison of the arguments.
// TODO: can be replaced with Matcher::FieldSink when complete (SERVER-4644)
return;
BSONObjIterator projectionSpecIter( getSpec() );
while ( projectionSpecIter.more() ) {
// for each projection element
BSONElement projectionElement = projectionSpecIter.next();
if ( mongoutils::str::contains( projectionElement.fieldName(), ".$" ) &&
mongoutils::str::before( queryElement.fieldName(), '.' ) ==
mongoutils::str::before( projectionElement.fieldName(), "." ) ) {
// found query spec that matches positional array projection spec
LOG(4) << "Query specifies field named for positional operator: "
<< queryElement.fieldName() << endl;
return;
}
}
}
uasserted( 16354, "Positional operator does not match the query specifier." );
}
void Projection::append( BSONObjBuilder& b , const BSONElement& e, const MatchDetails* details,
const ArrayOpType arrayOpType ) const {
FieldMap::const_iterator field = _fields.find( e.fieldName() );
if (field == _fields.end()) {
if (_include)
b.append(e);
}
else {
Projection& subfm = *field->second;
if ( ( subfm._fields.empty() && !subfm._special ) ||
!(e.type()==Object || e.type()==Array) ) {
// field map empty, or element is not an array/object
if (subfm._include)
b.append(e);
}
else if (e.type() == Object) {
BSONObjBuilder subb;
BSONObjIterator it(e.embeddedObject());
while (it.more()) {
subfm.append(subb, it.next(), details, arrayOpType);
}
b.append(e.fieldName(), subb.obj());
}
else { //Array
BSONObjBuilder matchedBuilder;
if ( details && ( arrayOpType == ARRAY_OP_POSITIONAL ||
arrayOpType == ARRAY_OP_POSITIONAL_KEYED )) {
// $ positional operator specified
LOG(4) << "projection: checking if element " << e << " matched spec: "
<< getSpec() << " match details: " << *details << endl;
uassert( 16352, mongoutils::str::stream() << "positional operator ("
<< e.fieldName()
<< ".$) requires corresponding field in query specifier",
details && details->hasElemMatchKey() );
uassert( 16353, "positional operator element mismatch",
! e.embeddedObject()[details->elemMatchKey()].eoo() );
// append as the first element in the projected array
matchedBuilder.appendAs( e.embeddedObject()[details->elemMatchKey()], "0" );
// append the key as the second element in the projected array
if ( arrayOpType == ARRAY_OP_POSITIONAL_KEYED ) {
matchedBuilder.append( "1", details->elemMatchKey() );
}
}
else {
// append exact array; no subarray matcher specified
subfm.appendArray( matchedBuilder, e.embeddedObject() );
}
b.appendArray( e.fieldName(), matchedBuilder.obj() );
}
}
}
static int
getInputValue(void)
{
int success = 0;
if (_cmdHave) {
static int initialized = 0;
if (initialized) {
if (_cmdWant == NULL) {
/*
* Multiple, prompt-driven conversions desired.
*/
success = 1;
}
else {
/*
* Single, previous, command-line-driven conversion desired.
*/
success = 0;
_exitStatus = EXIT_SUCCESS;
}
}
else {
success = decodeInput(_cmdHave);
initialized = 1;
}
}
else {
for (;;) {
char buf[sizeof(_haveUnitSpec)];
int nbytes = getSpec("You have: ", buf, sizeof(buf));
if (nbytes < 0)
break;
if (nbytes > 0) {
success = decodeInput(buf);
if (success)
break;
}
}
}
return success;
}
NS_IMETHODIMP
txStylesheetSink::OnStopRequest(nsIRequest *aRequest, nsISupports *aContext,
nsresult aStatusCode)
{
PRBool success = PR_TRUE;
nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aRequest);
if (httpChannel) {
httpChannel->GetRequestSucceeded(&success);
}
nsresult result = aStatusCode;
if (!success) {
// XXX We sometimes want to use aStatusCode here, but the parser resets
// it to NS_ERROR_NOINTERFACE because we don't implement
// nsIHTMLContentSink.
result = NS_ERROR_XSLT_NETWORK_ERROR;
}
else if (!mCheckedForXML) {
nsCOMPtr<nsIParser> parser = do_QueryInterface(aContext);
nsCOMPtr<nsIDTD> dtd;
parser->GetDTD(getter_AddRefs(dtd));
if (dtd && !(dtd->GetType() & NS_IPARSER_FLAG_XML)) {
result = NS_ERROR_XSLT_WRONG_MIME_TYPE;
}
}
if (NS_FAILED(result)) {
nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
nsAutoString spec;
getSpec(channel, spec);
mCompiler->cancel(result, nsnull, spec.get());
}
nsresult rv = mListener->OnStopRequest(aRequest, aContext, aStatusCode);
mListener = nsnull;
return rv;
}
/*
* Parse the type and its initializer and emit it (recursively).
*/
static void
emitInitVal(struct dbuf_s *oBuf, symbol *topsym, sym_link *my_type, initList *list)
{
symbol *sym;
int size, i;
long lit;
unsigned char *str;
size = getSize(my_type);
if (IS_PTR(my_type)) {
DEBUGprintf ("(pointer, %d byte) %p\n", size, list ? (void *)(long)list2int(list) : NULL);
emitIvals(oBuf, topsym, list, 0, size);
return;
}
if (IS_ARRAY(my_type) && topsym && topsym->isstrlit) {
str = (unsigned char *)SPEC_CVAL(topsym->etype).v_char;
emitIvalLabel(oBuf, topsym);
do {
dbuf_printf (oBuf, "\tretlw 0x%02x ; '%c'\n", str[0], (str[0] >= 0x20 && str[0] < 128) ? str[0] : '.');
} while (*(str++));
return;
}
if (IS_ARRAY(my_type) && list && list->type == INIT_NODE) {
fprintf (stderr, "Unhandled initialized symbol: %s\n", topsym->name);
assert ( !"Initialized char-arrays are not yet supported, assign at runtime instead." );
return;
}
if (IS_ARRAY(my_type)) {
DEBUGprintf ("(array, %d items, %d byte) below\n", DCL_ELEM(my_type), size);
assert (!list || list->type == INIT_DEEP);
if (list) list = list->init.deep;
for (i = 0; i < DCL_ELEM(my_type); i++) {
emitInitVal(oBuf, topsym, my_type->next, list);
topsym = NULL;
if (list) list = list->next;
} // for i
return;
}
if (IS_FLOAT(my_type)) {
// float, 32 bit
DEBUGprintf ("(float, %d byte) %lf\n", size, list ? list2int(list) : 0.0);
emitIvals(oBuf, topsym, list, 0, size);
return;
}
if (IS_CHAR(my_type) || IS_INT(my_type) || IS_LONG(my_type)) {
// integral type, 8, 16, or 32 bit
DEBUGprintf ("(integral, %d byte) 0x%lx/%ld\n", size, list ? (long)list2int(list) : 0, list ? (long)list2int(list) : 0);
emitIvals(oBuf, topsym, list, 0, size);
return;
} else if (IS_STRUCT(my_type) && SPEC_STRUCT(my_type)->type == STRUCT) {
// struct
DEBUGprintf ("(struct, %d byte) handled below\n", size);
assert (!list || (list->type == INIT_DEEP));
// iterate over struct members and initList
if (list) list = list->init.deep;
sym = SPEC_STRUCT(my_type)->fields;
while (sym) {
long bitfield = 0;
int len = 0;
if (IS_BITFIELD(sym->type)) {
while (sym && IS_BITFIELD(sym->type)) {
int bitoff = SPEC_BSTR(getSpec(sym->type)) + 8 * sym->offset;
assert (!list || ((list->type == INIT_NODE)
&& IS_AST_LIT_VALUE(list->init.node)));
lit = (long) (list ? list2int(list) : 0);
DEBUGprintf ( "(bitfield member) %02lx (%d bit, starting at %d, bitfield %02lx)\n",
lit, SPEC_BLEN(getSpec(sym->type)),
bitoff, bitfield);
bitfield |= (lit & ((1ul << SPEC_BLEN(getSpec(sym->type))) - 1)) << bitoff;
len += SPEC_BLEN(getSpec(sym->type));
sym = sym->next;
if (list) list = list->next;
} // while
assert (len < sizeof (long) * 8); // did we overflow our initializer?!?
len = (len + 7) & ~0x07; // round up to full bytes
emitIvals(oBuf, topsym, NULL, bitfield, len / 8);
topsym = NULL;
} // if
if (sym) {
emitInitVal(oBuf, topsym, sym->type, list);
topsym = NULL;
sym = sym->next;
if (list) list = list->next;
} // if
} // while
if (list) {
assert ( !"Excess initializers." );
} // if
return;
} else if (IS_STRUCT(my_type) && SPEC_STRUCT(my_type)->type == UNION) {
// union
DEBUGprintf ("(union, %d byte) handled below\n", size);
assert (list && list->type == INIT_DEEP);
// iterate over union members and initList, try to map number and type of fields and initializers
my_type = matchIvalToUnion(list, my_type, size);
if (my_type) {
emitInitVal(oBuf, topsym, my_type, list->init.deep);
topsym = NULL;
size -= getSize(my_type);
if (size > 0) {
// pad with (leading) zeros
emitIvals(oBuf, NULL, NULL, 0, size);
}
return;
} // if
assert ( !"No UNION member matches the initializer structure.");
} else if (IS_BITFIELD(my_type)) {
assert ( !"bitfields should only occur in structs..." );
} else {
printf ("SPEC_NOUN: %d\n", SPEC_NOUN(my_type));
assert( !"Unhandled initialized type.");
}
}
/*
* For UNIONs, we first have to find the correct alternative to map the
* initializer to. This function maps the structure of the initializer to
* the UNION members recursively.
* Returns the type of the first `fitting' member.
*/
static sym_link *
matchIvalToUnion (initList *list, sym_link *type, int size)
{
symbol *sym;
assert (type);
if (IS_PTR(type) || IS_CHAR(type) || IS_INT(type) || IS_LONG(type)
|| IS_FLOAT(type))
{
if (!list || (list->type == INIT_NODE)) {
DEBUGprintf ("OK, simple type\n");
return (type);
} else {
DEBUGprintf ("ERROR, simple type\n");
return (NULL);
}
} else if (IS_BITFIELD(type)) {
if (!list || (list->type == INIT_NODE)) {
DEBUGprintf ("OK, bitfield\n");
return (type);
} else {
DEBUGprintf ("ERROR, bitfield\n");
return (NULL);
}
} else if (IS_STRUCT(type) && SPEC_STRUCT(getSpec(type))->type == STRUCT) {
if (!list || (list->type == INIT_DEEP)) {
if (list) list = list->init.deep;
sym = SPEC_STRUCT(type)->fields;
while (sym) {
DEBUGprintf ("Checking STRUCT member %s\n", sym->name);
if (!matchIvalToUnion(list, sym->type, 0)) {
DEBUGprintf ("ERROR, STRUCT member %s\n", sym->name);
return (NULL);
}
if (list) list = list->next;
sym = sym->next;
} // while
// excess initializers?
if (list) {
DEBUGprintf ("ERROR, excess initializers\n");
return (NULL);
}
DEBUGprintf ("OK, struct\n");
return (type);
}
return (NULL);
} else if (IS_STRUCT(type) && SPEC_STRUCT(getSpec(type))->type == UNION) {
if (!list || (list->type == INIT_DEEP)) {
if (list) list = list->init.deep;
sym = SPEC_STRUCT(type)->fields;
while (sym) {
DEBUGprintf ("Checking UNION member %s.\n", sym->name);
if (((IS_STRUCT(sym->type) || getSize(sym->type) == size))
&& matchIvalToUnion(list, sym->type, size))
{
DEBUGprintf ("Matched UNION member %s.\n", sym->name);
return (sym->type);
}
sym = sym->next;
} // while
} // if
// no match found
DEBUGprintf ("ERROR, no match found.\n");
return (NULL);
} else {
assert ( !"Unhandled type in UNION." );
}
assert ( !"No match found in UNION for the given initializer structure." );
return (NULL);
}
static char *
parseIvalAst (ast *node, int *inCodeSpace) {
#define LEN 4096
char *buffer = NULL;
char *left, *right;
if (IS_AST_VALUE(node)) {
value *val = AST_VALUE(node);
symbol *sym = IS_AST_SYM_VALUE(node) ? AST_SYMBOL(node) : NULL;
if (inCodeSpace && val->type
&& (IS_FUNC(val->type) || IS_CODE(getSpec(val->type))))
{
*inCodeSpace = 1;
}
if (inCodeSpace && sym
&& (IS_FUNC(sym->type)
|| IS_CODE(getSpec(sym->type))))
{
*inCodeSpace = 1;
}
DEBUGprintf ("%s: AST_VALUE\n", __FUNCTION__);
if (IS_AST_LIT_VALUE(node)) {
buffer = Safe_alloc(LEN);
SNPRINTF(buffer, LEN, "0x%lx", AST_ULONG_VALUE (node));
} else if (IS_AST_SYM_VALUE(node)) {
assert ( AST_SYMBOL(node) );
/*
printf ("sym %s: ", AST_SYMBOL(node)->rname);
printTypeChain(AST_SYMBOL(node)->type, stdout);
printTypeChain(AST_SYMBOL(node)->etype, stdout);
printf ("\n---sym %s: done\n", AST_SYMBOL(node)->rname);
*/
buffer = Safe_strdup(AST_SYMBOL(node)->rname);
} else {
assert ( !"Invalid values type for initializers in AST." );
}
} else if (IS_AST_OP(node)) {
DEBUGprintf ("%s: AST_OP\n", __FUNCTION__);
switch (node->opval.op) {
case CAST:
assert (node->right);
buffer = parseIvalAst(node->right, inCodeSpace);
DEBUGprintf ("%s: %s\n", __FUNCTION__, buffer);
break;
case '&':
assert ( node->left && !node->right );
buffer = parseIvalAst(node->left, inCodeSpace);
DEBUGprintf ("%s: %s\n", __FUNCTION__, buffer);
break;
case '+':
assert (node->left && node->right );
left = parseIvalAst(node->left, inCodeSpace);
right = parseIvalAst(node->right, inCodeSpace);
buffer = Safe_alloc(LEN);
SNPRINTF(buffer, LEN, "(%s + %s)", left, right);
DEBUGprintf ("%s: %s\n", __FUNCTION__, buffer);
Safe_free(left);
Safe_free(right);
break;
case '[':
assert ( node->left && node->right );
assert ( IS_AST_VALUE(node->left) && AST_VALUE(node->left)->sym );
right = parseIvalAst(node->right, inCodeSpace);
buffer = Safe_alloc(LEN);
SNPRINTF(buffer, LEN, "(%s + %u * %s)",
AST_VALUE(node->left)->sym->rname, getSize(AST_VALUE(node->left)->type), right);
Safe_free(right);
DEBUGprintf ("%s: %s\n", __FUNCTION__, &buffer[0]);
break;
default:
assert ( !"Unhandled operation in initializer." );
break;
}
} else {
assert ( !"Invalid construct in initializer." );
}
return (buffer);
}
void IndexDetails::getKeysFromObject( const BSONObj& obj, BSONObjSet& keys) const {
getSpec().getKeys( obj, keys );
}
/*-----------------------------------------------------------------*/
static symbol *
createStackSpil (symbol * sym)
{
symbol *sloc = NULL;
struct dbuf_s dbuf;
D (D_ALLOC, ("createStackSpil: for sym %p %s\n", sym, sym->name));
/* first go try and find a free one that is already
existing on the stack */
if (applyToSet (_G.stackSpil, isFreeSTM8, &sloc, sym))
{
/* found a free one : just update & return */
sym->usl.spillLoc = sloc;
sym->stackSpil = 1;
sloc->isFree = 0;
addSetHead (&sloc->usl.itmpStack, sym);
D (D_ALLOC, ("createStackSpil: found existing\n"));
return sym;
}
/* could not then have to create one , this is the hard part
we need to allocate this on the stack : this is really a
hack!! but cannot think of anything better at this time */
dbuf_init (&dbuf, 128);
dbuf_printf (&dbuf, "sloc%d", _G.slocNum++);
sloc = newiTemp (dbuf_c_str (&dbuf));
dbuf_destroy (&dbuf);
/* set the type to the spilling symbol */
sloc->type = copyLinkChain (sym->type);
sloc->etype = getSpec (sloc->type);
SPEC_SCLS (sloc->etype) = S_AUTO;
SPEC_EXTR (sloc->etype) = 0;
SPEC_STAT (sloc->etype) = 0;
SPEC_VOLATILE (sloc->etype) = 0;
allocLocal (sloc);
sloc->isref = 1; /* to prevent compiler warning */
wassertl (currFunc, "Local variable used outside of function.");
/* if it is on the stack then update the stack */
if (IN_STACK (sloc->etype))
{
if (currFunc)
currFunc->stack += getSize (sloc->type);
_G.stackExtend += getSize (sloc->type);
}
else
{
_G.dataExtend += getSize (sloc->type);
}
/* add it to the stackSpil set */
addSetHead (&_G.stackSpil, sloc);
sym->usl.spillLoc = sloc;
sym->stackSpil = 1;
/* add it to the set of itempStack set
of the spill location */
addSetHead (&sloc->usl.itmpStack, sym);
D (D_ALLOC, ("createStackSpil: created new\n"));
return sym;
}
/*-----------------------------------------------------------------*/
void
allocParms (value * val)
{
value *lval;
int pNum = 1;
for (lval = val; lval; lval = lval->next, pNum++)
{
/* check the declaration */
checkDecl (lval->sym, 0);
/* if this a register parm then allocate
it as a local variable by adding it
to the first block we see in the body */
if (IS_REGPARM (lval->etype))
continue;
/* mark it as my parameter */
lval->sym->ismyparm = 1;
lval->sym->localof = currFunc;
/* if automatic variables r 2b stacked */
if (options.stackAuto || IFFUNC_ISREENT (currFunc->type))
{
if (lval->sym)
lval->sym->onStack = 1;
/* choose which stack 2 use */
/* use xternal stack */
if (options.useXstack)
{
/* PENDING: stack direction support */
SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = xstack;
SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack =
xstackPtr - getSize (lval->type);
xstackPtr -= getSize (lval->type);
}
else
{ /* use internal stack */
SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = istack;
if (port->stack.direction > 0)
{
SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack =
stackPtr - (FUNC_REGBANK (currFunc->type) ? port->stack.bank_overhead : 0) -
getSize (lval->type) -
(FUNC_ISISR (currFunc->type) ? port->stack.isr_overhead : 0);
stackPtr -= getSize (lval->type);
}
else
{
/* This looks like the wrong order but it turns out OK... */
/* PENDING: isr, bank overhead, ... */
SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack =
stackPtr +
((IFFUNC_ISBANKEDCALL (currFunc->type) && !SPEC_STAT(getSpec(currFunc->etype)))? port->stack.banked_overhead : 0) +
(FUNC_ISISR (currFunc->type) ? port->stack.isr_overhead : 0) +
0;
stackPtr += getSize (lval->type);
}
}
allocIntoSeg (lval->sym);
}
else
{ /* allocate them in the automatic space */
/* generate a unique name */
SNPRINTF (lval->sym->rname, sizeof(lval->sym->rname),
"%s%s_PARM_%d", port->fun_prefix, currFunc->name, pNum);
strncpyz (lval->name, lval->sym->rname, sizeof(lval->name));
/* if declared in specific storage */
if (allocDefault (lval->sym))
{
SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype);
continue;
}
/* otherwise depending on the memory model */
SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) =
port->mem.default_local_map;
if (options.model == MODEL_SMALL)
{
/* note here that we put it into the overlay segment
first, we will remove it from the overlay segment
after the overlay determination has been done */
if (!options.noOverlay)
{
SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) =
overlay;
}
}
else if (options.model == MODEL_MEDIUM)
{
SPEC_SCLS (lval->etype) = S_PDATA;
}
else
{
SPEC_SCLS (lval->etype) = S_XDATA;
}
allocIntoSeg (lval->sym);
}
}
return;
}