bool SlutTable::read_slut(SlutType type, bool force_reread)
{
bool result = false;
assert(readergp_ != NULL);
if (readergp_ == NULL) return false;
if(entries_ && this->type == type && !force_reread)
{
// we've read the s**t of this type and we're not being forced to do it again, so we're done.
return true;
}
invalidate();
this->type = type;
struct SlutLocation
{
bool (SlutTable::* read_function)(GenericPointer, bool);
GenericPointer gp;
};
static const size_t MAX_SLUT_POSSIBILITIES = 4;
/* Define SlutLocation constants for the various candidate addresses of S***s */
static const SlutLocation raw_prebc7 = { &SlutTable::read_slut_bc, GenericPointer(Mem_RawData, 0x100) };
static const SlutLocation raw_bc7plus = { &SlutTable::read_slut_bc, GenericPointer(Mem_RawData, 0x80) };
static const SlutLocation loader_prebc7 = { &SlutTable::read_slut_bc, GenericPointer(Mem_Flash, 0x100) };
static const SlutLocation loader_bc7plus = { &SlutTable::read_slut_bc_loader, GenericPointer(Mem_Flash, 0x80) };
static const SlutLocation stack_prebc7 = { &SlutTable::read_slut_bc, GenericPointer(Mem_Flash, 0x4100) };
static const SlutLocation stack_bc7plus_monolithic = { &SlutTable::read_slut_bc_stack, GenericPointer(Mem_Flash, 0x80) };
static const SlutLocation stack_bc7plus = { &SlutTable::read_slut_bc, GenericPointer(Mem_Flash, 0x4080) };
size_t num_slut_possibilities = 0;
const SlutLocation *slut_possibilities[MAX_SLUT_POSSIBILITIES];
switch(type)
{
case SlutType_Raw:
num_slut_possibilities = 2;
slut_possibilities[0] = &raw_prebc7;
slut_possibilities[1] = &raw_bc7plus;
if(xap_helper_ && xap_helper_->IsReadyForUse())
{
switch(xap_helper_->GetChipFamily())
{
case CHIP_FAMILY_BLUECORE:
num_slut_possibilities = 1;
slut_possibilities[0] = xap_helper_->IsPreBc7() ? &raw_prebc7 : &raw_bc7plus;
break;
default:
{
break;
}
}
}
else
{
}
break;
case SlutType_FlashLoader:
num_slut_possibilities = 2;
slut_possibilities[0] = &loader_prebc7;
slut_possibilities[1] = &loader_bc7plus;
if(xap_helper_ && xap_helper_->IsReadyForUse())
{
if(xap_helper_->CanHaveLoader())
{
switch(xap_helper_->GetChipFamily())
{
case CHIP_FAMILY_BLUECORE:
num_slut_possibilities = 1;
slut_possibilities[0] = xap_helper_->IsPreBc7() ? &loader_prebc7 : &loader_bc7plus;
break;
default:
// Not a chip type we recognise. Read the full set of s**t possibilities for this s**t type.
break;
}
}
else
{
// this chip cannot contain a loader s**t.
num_slut_possibilities = 0;
}
}
break;
case SlutType_FlashStack:
num_slut_possibilities = 3;
slut_possibilities[0] = &stack_prebc7;
slut_possibilities[1] = &stack_bc7plus_monolithic;
slut_possibilities[2] = &stack_bc7plus;
if(xap_helper_ && xap_helper_->IsReadyForUse())
{
switch(xap_helper_->GetChipFamily())
{
case CHIP_FAMILY_BLUECORE:
if (xap_helper_->IsPreBc7())
{
num_slut_possibilities = 1;
slut_possibilities[0] = &stack_prebc7;
}
else
{
if (xap_helper_->CanHaveLoader())
{
num_slut_possibilities = 2;
slut_possibilities[0] = &stack_bc7plus;
slut_possibilities[1] = &stack_bc7plus_monolithic;
}
else
{
num_slut_possibilities = 1;
slut_possibilities[0] = &stack_bc7plus_monolithic;
}
}
break;
default:
// Not a chip type we recognise. Read the full set of s**t possibilities for this s**t type.
break;
}
}
break;
case SlutType_Rom:
break;
default:
// a s**t type we don't recognise. in release mode don't read anything. in debug assert as this is probably an internal error.
assert(false);
}
// go through the s**t possibilities and try to read them.
for(size_t i = 0; i < num_slut_possibilities && !result; ++i)
{
// if this is the only s**t then retry because we expect it to be there.
// if not then don't retry to go through the possibilities quicker.
# define CALL_MEMBER_FN(fn) (this->*(fn))
if (CALL_MEMBER_FN(slut_possibilities[i]->read_function)(slut_possibilities[i]->gp, num_slut_possibilities == 1))
{
result = true;
}
}
return result;
}
/*********************************************************
NAME : UpdateExpression
DESCRIPTION : Given a bloaded expression buffer,
this routine refreshes the pointers
in the expression array
INPUTS : 1) a bloaded expression buffer
2) the index of the expression to refresh
RETURNS : Nothing useful
SIDE EFFECTS : Expression updated
NOTES : None
*********************************************************/
static void UpdateExpression(
Environment *theEnv,
void *buf,
unsigned long obji)
{
BSAVE_EXPRESSION *bexp;
unsigned long theIndex;
bexp = (BSAVE_EXPRESSION *) buf;
ExpressionData(theEnv)->ExpressionArray[obji].type = bexp->type;
switch(bexp->type)
{
case FCALL:
ExpressionData(theEnv)->ExpressionArray[obji].value = BloadData(theEnv)->FunctionArray[bexp->value];
break;
case GCALL:
#if DEFGENERIC_CONSTRUCT
ExpressionData(theEnv)->ExpressionArray[obji].value = GenericPointer(bexp->value);
#else
ExpressionData(theEnv)->ExpressionArray[obji].value = NULL;
#endif
break;
case PCALL:
#if DEFFUNCTION_CONSTRUCT
ExpressionData(theEnv)->ExpressionArray[obji].value = DeffunctionPointer(bexp->value);
#else
ExpressionData(theEnv)->ExpressionArray[obji].value = NULL;
#endif
break;
case DEFTEMPLATE_PTR:
#if DEFTEMPLATE_CONSTRUCT
ExpressionData(theEnv)->ExpressionArray[obji].value = DeftemplatePointer(bexp->value);
#else
ExpressionData(theEnv)->ExpressionArray[obji].value = NULL;
#endif
break;
case DEFCLASS_PTR:
#if OBJECT_SYSTEM
ExpressionData(theEnv)->ExpressionArray[obji].value = DefclassPointer(bexp->value);
#else
ExpressionData(theEnv)->ExpressionArray[obji].value = NULL;
#endif
break;
case DEFGLOBAL_PTR:
#if DEFGLOBAL_CONSTRUCT
ExpressionData(theEnv)->ExpressionArray[obji].value = DefglobalPointer(bexp->value);
#else
ExpressionData(theEnv)->ExpressionArray[obji].value = NULL;
#endif
break;
case INTEGER_TYPE:
ExpressionData(theEnv)->ExpressionArray[obji].value = SymbolData(theEnv)->IntegerArray[bexp->value];
IncrementIntegerCount(ExpressionData(theEnv)->ExpressionArray[obji].integerValue);
break;
case FLOAT_TYPE:
ExpressionData(theEnv)->ExpressionArray[obji].value = SymbolData(theEnv)->FloatArray[bexp->value];
IncrementFloatCount(ExpressionData(theEnv)->ExpressionArray[obji].floatValue);
break;
case INSTANCE_NAME_TYPE:
#if ! OBJECT_SYSTEM
ExpressionData(theEnv)->ExpressionArray[obji].type = SYMBOL_TYPE;
#endif
case GBL_VARIABLE:
case SYMBOL_TYPE:
case STRING_TYPE:
ExpressionData(theEnv)->ExpressionArray[obji].value = SymbolData(theEnv)->SymbolArray[bexp->value];
IncrementLexemeCount(ExpressionData(theEnv)->ExpressionArray[obji].lexemeValue);
break;
#if DEFTEMPLATE_CONSTRUCT
case FACT_ADDRESS_TYPE:
ExpressionData(theEnv)->ExpressionArray[obji].value = &FactData(theEnv)->DummyFact;
RetainFact((Fact *) ExpressionData(theEnv)->ExpressionArray[obji].value);
break;
#endif
#if OBJECT_SYSTEM
case INSTANCE_ADDRESS_TYPE:
ExpressionData(theEnv)->ExpressionArray[obji].value = &InstanceData(theEnv)->DummyInstance;
RetainInstance((Instance *) ExpressionData(theEnv)->ExpressionArray[obji].value);
break;
#endif
case EXTERNAL_ADDRESS_TYPE:
ExpressionData(theEnv)->ExpressionArray[obji].value = NULL;
break;
case VOID_TYPE:
break;
default:
if (EvaluationData(theEnv)->PrimitivesArray[bexp->type] == NULL) break;
if (EvaluationData(theEnv)->PrimitivesArray[bexp->type]->bitMap)
{
ExpressionData(theEnv)->ExpressionArray[obji].value = SymbolData(theEnv)->BitMapArray[bexp->value];
IncrementBitMapCount((CLIPSBitMap *) ExpressionData(theEnv)->ExpressionArray[obji].value);
}
break;
}
theIndex = bexp->nextArg;
if (theIndex == ULONG_MAX)
{ ExpressionData(theEnv)->ExpressionArray[obji].nextArg = NULL; }
else
{ ExpressionData(theEnv)->ExpressionArray[obji].nextArg = (struct expr *) &ExpressionData(theEnv)->ExpressionArray[theIndex]; }
theIndex = bexp->argList;
if (theIndex == ULONG_MAX)
{ ExpressionData(theEnv)->ExpressionArray[obji].argList = NULL; }
else
{ ExpressionData(theEnv)->ExpressionArray[obji].argList = (struct expr *) &ExpressionData(theEnv)->ExpressionArray[theIndex]; }
}
bool SlutTable::read_slut_bc(GenericPointer slut_location, bool retry)
{
GenericPointer slut_ptr;
uint16 data_buf[IMemoryReaderGP::MAX_BLOCK_SIZE];
uint32 location;
uint16 slut_key;
uint16 slut_val;
bool stack = false;
if(!read_slut_header(slut_location, data_buf, retry))
{
return false;
}
// If we don't find the magic value then give up.
if (data_buf[0] != SLUT_MAGIC)
return false;
// Check if we're looking in the stack.
if (slut_location.Mem() == Mem_Flash && (int)slut_location >= 0x4000)
stack = true;
// If we're looking in the stack part of flash then offset the
// 16-bit location so that it is also in the stack.
location = data_buf[1];
if (stack) location += 0x4000;
// Create a pointer to the actual S**T.
slut_ptr = slut_location = GenericPointer(slut_location.Mem(), location);
unifiSlut = false;
entries_ = new Entries;
assert(entries_);
do
{
if (!readergp_->read_mem(slut_ptr, IMemoryReaderGP::MAX_BLOCK_SIZE, data_buf))
{
invalidate();
return false;
}
int i;
for (i = 0; i < IMemoryReaderGP::MAX_BLOCK_SIZE; i+= 2)
{
slut_key = data_buf[i];
slut_val = data_buf[i + 1];
// If the value is a pointer add an offset.
if (slut_key == bluecore::SLUTID_ID_STRING ||
slut_key == bluecore::SLUTID_ID_INTEGER ||
slut_key == bluecore::SLUTID_ID_STRING_FULL)
{
if (stack) slut_val += 0x4000;
}
if (slut_key == bluecore::SLUTID_NONE)
break;
entries_->add(slut_key, slut_val);
}
slut_ptr += i;
} while ((slut_key != bluecore::SLUTID_NONE) && ((int)slut_ptr - (int)slut_location < 256));
return true;
}