PmReturn_t
pm_run(uint8_t const *modstr)
{
PmReturn_t retval;
pPmObj_t pmod;
pPmObj_t pstring;
uint8_t const *pmodstr = modstr;
/* Import module from global struct */
retval = string_new(&pmodstr, &pstring);
PM_RETURN_IF_ERROR(retval);
retval = mod_import(pstring, &pmod);
PM_RETURN_IF_ERROR(retval);
/* Load builtins into thread */
retval = global_setBuiltins((pPmFunc_t)pmod);
PM_RETURN_IF_ERROR(retval);
/* Interpret the module's bcode */
retval = interp_addThread((pPmFunc_t)pmod);
PM_RETURN_IF_ERROR(retval);
retval = interpret(INTERP_RETURN_ON_NO_THREADS);
/*
* De-initialize the hardware platform.
* Ignore plat_deinit's retval so interpret's retval returns to caller.
*/
plat_deinit();
return retval;
}
PmReturn_t
dict_delItem(pPmObj_t pdict, pPmObj_t pkey)
{
PmReturn_t retval = PM_RET_OK;
int16_t indx = 0;
C_ASSERT(pdict != C_NULL);
/* Check for matching key */
retval = seglist_findEqual(((pPmDict_t)pdict)->d_keys, pkey, &indx);
/* Raise KeyError if key is not found */
if (retval == PM_RET_NO)
{
PM_RAISE(retval, PM_RET_EX_KEY);
}
/* Return any other error */
PM_RETURN_IF_ERROR(retval);
/* Remove the key and value */
retval = seglist_removeItem(((pPmDict_t)pdict)->d_keys, indx);
PM_RETURN_IF_ERROR(retval);
retval = seglist_removeItem(((pPmDict_t)pdict)->d_vals, indx);
/* Reduce the item count */
((pPmDict_t)pdict)->length--;
return retval;
}
PmReturn_t
pm_init(uint8_t *heap_base, uint32_t heap_size,
PmMemSpace_t memspace, uint8_t const * const pusrimg)
{
PmReturn_t retval;
/* Initialize the hardware platform */
retval = plat_init();
PM_RETURN_IF_ERROR(retval);
/* Initialize the heap and the globals */
retval = heap_init(heap_base, heap_size);
PM_RETURN_IF_ERROR(retval);
retval = global_init();
PM_RETURN_IF_ERROR(retval);
/* Load usr image info if given */
if (pusrimg != C_NULL)
{
retval = img_appendToPath(memspace, pusrimg);
}
return retval;
}
PmReturn_t
dict_clear(pPmObj_t pdict)
{
PmReturn_t retval = PM_RET_OK;
C_ASSERT(pdict != C_NULL);
/* Raise TypeError if arg is not a dict */
if (OBJ_GET_TYPE(pdict) != OBJ_TYPE_DIC)
{
PM_RAISE(retval, PM_RET_EX_TYPE);
return retval;
}
/* clear length */
((pPmDict_t)pdict)->length = 0;
/* Free the keys and values seglists if needed */
if (((pPmDict_t)pdict)->d_keys != C_NULL)
{
PM_RETURN_IF_ERROR(seglist_clear(((pPmDict_t)pdict)->d_keys));
PM_RETURN_IF_ERROR(heap_freeChunk((pPmObj_t)
((pPmDict_t)pdict)->d_keys));
((pPmDict_t)pdict)->d_keys = C_NULL;
}
if (((pPmDict_t)pdict)->d_vals != C_NULL)
{
PM_RETURN_IF_ERROR(seglist_clear(((pPmDict_t)pdict)->d_vals));
retval = heap_freeChunk((pPmObj_t)((pPmDict_t)pdict)->d_vals);
((pPmDict_t)pdict)->d_vals = C_NULL;
}
return retval;
}
PmReturn_t
thread_new(pPmObj_t pframe, pPmObj_t *r_pobj)
{
PmReturn_t retval = PM_RET_OK;
pPmThread_t pthread = C_NULL;
C_ASSERT(pframe != C_NULL);
/* If it's not a frame, raise TypeError */
if (OBJ_GET_TYPE(pframe) != OBJ_TYPE_FRM)
{
PM_RAISE(retval, PM_RET_EX_TYPE);
return retval;
}
/* Allocate a thread */
retval = heap_getChunk(sizeof(PmThread_t), (uint8_t **)r_pobj);
PM_RETURN_IF_ERROR(retval);
/* Set type, frame and initialize status */
pthread = (pPmThread_t)*r_pobj;
OBJ_SET_TYPE(pthread, OBJ_TYPE_THR);
pthread->pframe = (pPmFrame_t)pframe;
pthread->interpctrl = INTERP_CTRL_CONT;
return retval;
}
PmReturn_t
seqiter_new(pPmObj_t pobj, pPmObj_t *r_pobj)
{
PmReturn_t retval;
uint8_t *pchunk;
pPmSeqIter_t psi;
C_ASSERT(pobj != C_NULL);
C_ASSERT(*r_pobj != C_NULL);
/* Raise a TypeError if pobj is not a sequence */
if ((OBJ_GET_TYPE(pobj) != OBJ_TYPE_STR)
&& (OBJ_GET_TYPE(pobj) != OBJ_TYPE_TUP)
&& (OBJ_GET_TYPE(pobj) != OBJ_TYPE_LST))
{
PM_RAISE(retval, PM_RET_EX_TYPE);
return retval;
}
/* Alloc a chunk for the sequence iterator obj */
retval = heap_getChunk(sizeof(PmSeqIter_t), &pchunk);
PM_RETURN_IF_ERROR(retval);
/* Set the sequence iterator's fields */
psi = (pPmSeqIter_t)pchunk;
OBJ_SET_TYPE(psi, OBJ_TYPE_SQI);
psi->si_sequence = pobj;
psi->si_index = 0;
*r_pobj = (pPmObj_t)psi;
return retval;
}
PmReturn_t
seqiter_getNext(pPmObj_t pobj, pPmObj_t *r_pitem)
{
PmReturn_t retval;
int16_t length;
C_ASSERT(pobj != C_NULL);
C_ASSERT(*r_pitem != C_NULL);
C_ASSERT(OBJ_GET_TYPE(pobj) == OBJ_TYPE_SQI);
/*
* Raise TypeError if sequence iterator's object is not a sequence
* otherwise, the get sequence's length
*/
retval = seq_getLength(((pPmSeqIter_t)pobj)->si_sequence, &length);
PM_RETURN_IF_ERROR(retval);
/* Raise StopIteration if at the end of the sequence */
if (((pPmSeqIter_t)pobj)->si_index == length)
{
/* Make null the pointer to the sequence */
((pPmSeqIter_t)pobj)->si_sequence = C_NULL;
PM_RAISE(retval, PM_RET_EX_STOP);
return retval;
}
/* Get the item at the current index */
retval = seq_getSubscript(((pPmSeqIter_t)pobj)->si_sequence,
((pPmSeqIter_t)pobj)->si_index, r_pitem);
/* Increment the index */
((pPmSeqIter_t)pobj)->si_index++;
return retval;
}
PmReturn_t
class_method(pPmObj_t pinstance, pPmObj_t pfunc, pPmObj_t *r_pmeth)
{
PmReturn_t retval = PM_RET_OK;
uint8_t *pchunk;
pPmMethod_t pmeth;
pPmObj_t pattrs;
uint8_t objid;
/* Allocate a method */
retval = heap_getChunk(sizeof(PmMethod_t), &pchunk);
PM_RETURN_IF_ERROR(retval);
OBJ_SET_TYPE(pchunk, OBJ_TYPE_MTH);
/* Set method fields */
pmeth = (pPmMethod_t)pchunk;
pmeth->m_instance = (pPmInstance_t)pinstance;
pmeth->m_func = (pPmFunc_t)pfunc;
pmeth->m_attrs = C_NULL;
/* Create the attributes dict */
heap_gcPushTempRoot((pPmObj_t)pmeth, &objid);
retval = dict_new(&pattrs);
heap_gcPopTempRoot(objid);
pmeth->m_attrs = (pPmDict_t)pattrs;
*r_pmeth = (pPmObj_t)pmeth;
return retval;
}
/* Runs the mark-sweep garbage collector */
PmReturn_t
heap_gcRun(void)
{
PmReturn_t retval;
C_DEBUG_PRINT(VERBOSITY_LOW, "heap_gcRun()\n");
/*
* Prevent the GC from running twice during one session of native code.
* Corruption can occur from collecting objects that were allocated
* during the native code session and are not yet reachable from the
* roots list. Running the GC once is acceptable, a special case was
* created in the allocator to handle that situation.
* See #104 for greater detail.
*/
if (gVmGlobal.nativeframe.nf_active)
{
if (++gVmGlobal.nativeframe.nf_gcCount >= 2)
{
/*PM_RAISE(retval, PM_RET_EX_MEM); TODO: change back to error here rather than later?*/
retval = PM_RET_OK;
return retval;
}
}
retval = heap_gcMarkRoots();
PM_RETURN_IF_ERROR(retval);
retval = heap_gcSweep();
return retval;
}
PmReturn_t
class_new(pPmObj_t pattrs, pPmObj_t pbases, pPmObj_t pname, pPmObj_t *r_pclass)
{
PmReturn_t retval = PM_RET_OK;
uint8_t *pchunk;
pPmObj_t pobj;
/* Ensure types */
if ((OBJ_GET_TYPE(pattrs) != OBJ_TYPE_DIC)
|| (OBJ_GET_TYPE(pbases) != OBJ_TYPE_TUP)
|| (OBJ_GET_TYPE(pname) != OBJ_TYPE_STR))
{
PM_RAISE(retval, PM_RET_EX_TYPE);
return retval;
}
/* Allocate a class obj */
retval = heap_getChunk(sizeof(PmClass_t), &pchunk);
PM_RETURN_IF_ERROR(retval);
pobj = (pPmObj_t)pchunk;
OBJ_SET_TYPE(pobj, OBJ_TYPE_CLO);
/* Class has no access to its CO */
((pPmClass_t)pobj)->cl_attrs = (pPmDict_t)pattrs;
((pPmClass_t)pobj)->cl_bases = (pPmTuple_t)pbases;
*r_pclass = pobj;
return retval;
}
PmReturn_t
mod_new(pPmObj_t pco, pPmObj_t *pmod)
{
PmReturn_t retval;
uint8_t *pchunk;
pPmObj_t pobj;
/* If it's not a code obj, raise TypeError */
if (OBJ_GET_TYPE(pco) != OBJ_TYPE_COB)
{
PM_RAISE(retval, PM_RET_EX_TYPE);
return retval;
}
/* Alloc and init func obj */
retval = heap_getChunk(sizeof(PmFunc_t), &pchunk);
PM_RETURN_IF_ERROR(retval);
*pmod = (pPmObj_t)pchunk;
OBJ_SET_TYPE(*pmod, OBJ_TYPE_MOD);
((pPmFunc_t)*pmod)->f_co = (pPmCo_t)pco;
/* Alloc and init attrs dict */
retval = dict_new(&pobj);
((pPmFunc_t)*pmod)->f_attrs = (pPmDict_t)pobj;
/* A module's globals is the same as its attrs */
((pPmFunc_t)*pmod)->f_globals = (pPmDict_t)pobj;
return retval;
}
/* Returns an instance of the class by reference */
PmReturn_t
class_instantiate(pPmObj_t pclass, pPmObj_t *r_pobj)
{
PmReturn_t retval = PM_RET_OK;
uint8_t *pchunk;
pPmObj_t pobj;
pPmObj_t pattrs;
uint8_t objid;
/* Allocate a class instance */
retval = heap_getChunk(sizeof(PmInstance_t), &pchunk);
PM_RETURN_IF_ERROR(retval);
pobj = (pPmObj_t)pchunk;
OBJ_SET_TYPE(pobj, OBJ_TYPE_CLI);
/* Set the instance's fields */
((pPmInstance_t)pobj)->cli_class = (pPmClass_t)pclass;
((pPmInstance_t)pobj)->cli_attrs = C_NULL;
/* Create the attributes dict */
heap_gcPushTempRoot(pobj, &objid);
retval = dict_new(&pattrs);
heap_gcPopTempRoot(objid);
((pPmInstance_t)pobj)->cli_attrs = (pPmDict_t)pattrs;
/* TODO: Store pclass in __class__ attr */
*r_pobj = pobj;
return retval;
}
PmReturn_t
obj_repr(pPmObj_t pobj, pPmObj_t *r_pstr)
{
uint8_t tBuffer[32];
PmReturn_t retval = PM_RET_OK;
uint8_t const *pcstr = (uint8_t *)tBuffer;;
C_ASSERT(pobj != C_NULL);
switch (OBJ_GET_TYPE(pobj))
{
case OBJ_TYPE_INT:
retval = sli_ltoa10(((pPmInt_t)pobj)->val, tBuffer, sizeof(tBuffer));
PM_RETURN_IF_ERROR(retval);
retval = string_new(&pcstr, r_pstr);
break;
#ifdef HAVE_FLOAT
case OBJ_TYPE_FLT:
/* #212: Use homebrew float formatter */
retval = sli_ftoa(((pPmFloat_t)pobj)->val, tBuffer, sizeof(tBuffer));
sli_strlen((char *)tBuffer);
retval = string_new(&pcstr, r_pstr);
break;
#endif /* HAVE_FLOAT */
default:
/* Otherwise raise a TypeError */
PM_RAISE(retval, PM_RET_EX_TYPE);
break;
}
return retval;
}
PmReturn_t
float_print(pPmObj_t pf)
{
uint8_t tBuffer[32];
uint8_t bytesWritten;
uint8_t i;
PmReturn_t retval = PM_RET_OK;
C_ASSERT(pf != C_NULL);
/* Raise TypeError if obj is not an float */
if (OBJ_GET_TYPE(pf) != OBJ_TYPE_FLT)
{
PM_RAISE(retval, PM_RET_EX_TYPE);
return retval;
}
/* #196: Changed to use snprintf */
bytesWritten = snprintf((char *)&tBuffer, 32, "%f", ((pPmFloat_t) pf)->val);
/* Sanity check */
C_ASSERT(bytesWritten != 0);
C_ASSERT(bytesWritten < sizeof(tBuffer));
for (i = (uint8_t)0; i < bytesWritten; i++)
{
retval = plat_putByte(tBuffer[i]);
PM_RETURN_IF_ERROR(retval);
}
return PM_RET_OK;
}
PmReturn_t
global_loadBuiltins(void)
{
PmReturn_t retval = PM_RET_OK;
pPmObj_t pkey = C_NULL;
uint8_t const *nonestr = (uint8_t const *)"None";
uint8_t const *falsestr = (uint8_t const *)"False";
uint8_t const *truestr = (uint8_t const *)"True";
pPmObj_t pstr = C_NULL;
pPmObj_t pbimod;
uint8_t const *pbistr = bistr;
/* Import the builtins */
retval = string_new(&pbistr, &pstr);
PM_RETURN_IF_ERROR(retval);
retval = mod_import(pstr, &pbimod);
PM_RETURN_IF_ERROR(retval);
/* Must interpret builtins' root code to set the attrs */
C_ASSERT(gVmGlobal.threadList->length == 0);
interp_addThread((pPmFunc_t)pbimod);
retval = interpret(INTERP_RETURN_ON_NO_THREADS);
PM_RETURN_IF_ERROR(retval);
/* Builtins points to the builtins module's attrs dict */
gVmGlobal.builtins = ((pPmFunc_t)pbimod)->f_attrs;
/* Set None manually */
retval = string_new(&nonestr, &pkey);
PM_RETURN_IF_ERROR(retval);
retval = dict_setItem(PM_PBUILTINS, pkey, PM_NONE);
PM_RETURN_IF_ERROR(retval);
/* Set False manually */
retval = string_new(&falsestr, &pkey);
PM_RETURN_IF_ERROR(retval);
retval = dict_setItem(PM_PBUILTINS, pkey, PM_FALSE);
PM_RETURN_IF_ERROR(retval);
/* Set True manually */
retval = string_new(&truestr, &pkey);
PM_RETURN_IF_ERROR(retval);
retval = dict_setItem(PM_PBUILTINS, pkey, PM_TRUE);
PM_RETURN_IF_ERROR(retval);
/* Deallocate builtins module */
retval = heap_freeChunk((pPmObj_t)pbimod);
return retval;
}
PmReturn_t
dict_update(pPmObj_t pdestdict, pPmObj_t psourcedict, uint8_t omit_underscored)
{
PmReturn_t retval = PM_RET_OK;
int16_t i;
pPmObj_t pkey;
pPmObj_t pval;
C_ASSERT(pdestdict != C_NULL);
C_ASSERT(psourcedict != C_NULL);
/* If it's not a dict, raise TypeError */
if (OBJ_GET_TYPE(pdestdict) != OBJ_TYPE_DIC)
{
PM_RAISE(retval, PM_RET_EX_TYPE);
return retval;
}
/* If it's not a dict, raise TypeError */
if (OBJ_GET_TYPE(psourcedict) != OBJ_TYPE_DIC)
{
PM_RAISE(retval, PM_RET_EX_TYPE);
return retval;
}
/* Iterate over the add-on dict */
for (i = 0; i < ((pPmDict_t)psourcedict)->length; i++)
{
/* Get the key,val from the add-on dict */
retval = seglist_getItem(((pPmDict_t)psourcedict)->d_keys, i, &pkey);
PM_RETURN_IF_ERROR(retval);
retval = seglist_getItem(((pPmDict_t)psourcedict)->d_vals, i, &pval);
PM_RETURN_IF_ERROR(retval);
if (!(omit_underscored && (OBJ_GET_TYPE(pkey) == OBJ_TYPE_STR)
&& ((pPmString_t)pkey)->val[0] == '_'))
{
/* Set the key,val to the destination dict */
retval = dict_setItem(pdestdict, pkey, pval);
PM_RETURN_IF_ERROR(retval);
}
}
return retval;
}
PmReturn_t
dict_print(pPmObj_t pdict)
{
PmReturn_t retval = PM_RET_OK;
int16_t index;
pSeglist_t keys,
vals;
pPmObj_t pobj1;
C_ASSERT(pdict != C_NULL);
/* if it's not a dict, raise TypeError */
if (OBJ_GET_TYPE(pdict) != OBJ_TYPE_DIC)
{
PM_RAISE(retval, PM_RET_EX_TYPE);
return retval;
}
plat_putByte('{');
keys = ((pPmDict_t)pdict)->d_keys;
vals = ((pPmDict_t)pdict)->d_vals;
/* if dict is empty, raise KeyError */
for (index = 0; index < ((pPmDict_t)pdict)->length; index++)
{
if (index != 0)
{
plat_putByte(',');
plat_putByte(' ');
}
retval = seglist_getItem(keys, index, &pobj1);
PM_RETURN_IF_ERROR(retval);
retval = obj_print(pobj1, C_FALSE, C_TRUE);
PM_RETURN_IF_ERROR(retval);
plat_putByte(':');
retval = seglist_getItem(vals, index, &pobj1);
PM_RETURN_IF_ERROR(retval);
retval = obj_print(pobj1, C_FALSE, C_TRUE);
PM_RETURN_IF_ERROR(retval);
}
return plat_putByte('}');
}
PmReturn_t
co_loadFromImg(PmMemSpace_t memspace, uint8_t const **paddr, pPmObj_t *r_pco)
{
PmReturn_t retval = PM_RET_OK;
pPmObj_t pobj;
pPmCo_t pco = C_NULL;
uint8_t *pchunk;
/* Store ptr to top of code img (less type byte) */
uint8_t const *pci = *paddr - 1;
/* Get size of code img */
uint16_t size = mem_getWord(memspace, paddr);
/* Allocate a code obj */
retval = heap_getChunk(sizeof(PmCo_t), &pchunk);
PM_RETURN_IF_ERROR(retval);
pco = (pPmCo_t)pchunk;
/* Fill in the CO struct */
OBJ_SET_TYPE(pco, OBJ_TYPE_COB);
pco->co_memspace = memspace;
pco->co_codeimgaddr = pci;
/* Load names (tuple obj) */
*paddr = pci + CI_NAMES_FIELD;
retval = obj_loadFromImg(memspace, paddr, &pobj);
PM_RETURN_IF_ERROR(retval);
pco->co_names = (pPmTuple_t)pobj;
/* Load consts (tuple obj) assume it follows names */
retval = obj_loadFromImg(memspace, paddr, &pobj);
PM_RETURN_IF_ERROR(retval);
pco->co_consts = (pPmTuple_t)pobj;
/* Start of bcode always follows consts */
pco->co_codeaddr = *paddr;
/* Set addr to point one past end of img */
*paddr = pci + size;
*r_pco = (pPmObj_t)pco;
return PM_RET_OK;
}
int main(void)
{
PmReturn_t retval;
retval = pm_init(MEMSPACE_PROG, usrlib_img);
PM_RETURN_IF_ERROR(retval);
retval = pm_run((uint8_t *)"main");
return (int)retval;
}
int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
#endif
{
PmReturn_t retval;
retval = pm_init(MEMSPACE_PROG, usrlib_img);
PM_RETURN_IF_ERROR(retval);
retval = pm_run((uint8_t *)"main");
return (int)retval;
}
PmReturn_t
float_new(float f, pPmObj_t *r_pf)
{
PmReturn_t retval = PM_RET_OK;
retval = heap_getChunk(sizeof(PmFloat_t), (uint8_t **)r_pf);
PM_RETURN_IF_ERROR(retval);
OBJ_SET_TYPE(*r_pf, OBJ_TYPE_FLT);
((pPmFloat_t) * r_pf)->val = f;
return retval;
}
int main(void)
{
uint8_t heap[HEAP_SIZE] __attribute__((aligned((4))));
PmReturn_t retval;
retval = pm_init(heap, HEAP_SIZE, MEMSPACE_PROG, usrlib_img);
PM_RETURN_IF_ERROR(retval);
retval = pm_run((uint8_t *)"main");
return (int)retval;
}
int main(void)
{
uint8_t heap[HEAP_SIZE];
PmReturn_t retval;
retval = pm_init(heap, HEAP_SIZE, MEMSPACE_PROG, usrlib_img);
PM_RETURN_IF_ERROR(retval);
retval = pm_run((uint8_t *)"t080");
return (int)retval;
}
/*----------------------------------------------------------------------------*/
PmReturn_t
tres_pm_get_state(pPmFrame_t *ppframe)
{
PmReturn_t retv = PM_RET_OK;
pPmObj_t pobj;
pPmObj_t pobj_new;
pPmInstance_t pcli;
pPmDict_t pdict;
int16_t index;
float fval;
int32_t ival;
if(NATIVE_GET_NUM_ARGS() != 1) {
PM_RAISE(retv, PM_RET_EX_TYPE);
return retv;
}
pobj = NATIVE_GET_LOCAL(0);
if(OBJ_GET_TYPE(pobj) != OBJ_TYPE_CLI) {
PM_RAISE(retv, PM_RET_EX_TYPE);
return retv;
}
pcli = (pPmInstance_t)pobj;
pdict = pcli->cli_attrs;
if(*tres_pm_io.state_len > 0) {
// restore each attribute of the object
for(index = pdict->length - 1; index >= 0; index--) {
seglist_getItem(pdict->d_keys, index, &pobj);
retv = seglist_getItem(pdict->d_vals, index, &pobj);
PM_RETURN_IF_ERROR(retv);
switch (OBJ_GET_TYPE(pobj)) {
case OBJ_TYPE_INT:
//pop int
pop_int(&ival);
retv = int_new(ival, &pobj_new);
break;
case OBJ_TYPE_FLT:
//pop float
pop_float(&fval);
retv = float_new(fval, &pobj_new);
break;
default:
/* Raise TypeError */
PM_RAISE(retv, PM_RET_EX_TYPE);
}
if (retv == PM_RET_OK) {
seglist_setItem(pdict->d_vals, pobj_new, index);
}
}
}
NATIVE_SET_TOS((pPmObj_t)pcli);
return retv;
}
int main(void)
{
PmReturn_t retval;
retval = pm_init(MEMSPACE_PROG, usrlib_img);
PM_RETURN_IF_ERROR(retval);
retval = pm_run((uint8_t *)"t119");
C_ASSERT((int)retval == PM_RET_EX_ZDIV);
if (retval == PM_RET_EX_ZDIV) return (int)PM_RET_OK;
return (int)retval;
}
int8_t
dict_compare(pPmObj_t d1, pPmObj_t d2)
{
pPmDict_t pd1 = (pPmDict_t)d1;
pPmDict_t pd2 = (pPmDict_t)d2;
pPmObj_t pkey1;
pPmObj_t pval1;
pPmObj_t pval2;
uint16_t i;
PmReturn_t retval;
/* Return if lengths are not equal */
if (pd1->length != pd2->length)
{
return C_DIFFER;
}
for (i = 0; i < pd1->length; i++)
{
/* Get the key,val from one dict */
retval = seglist_getItem(pd1->d_keys, i, &pkey1);
PM_RETURN_IF_ERROR(retval);
retval = seglist_getItem(pd1->d_vals, i, &pval1);
PM_RETURN_IF_ERROR(retval);
/* Return if the key,val pair is not in the other dict */
retval = dict_getItem(d2, pkey1, &pval2);
if (retval != PM_RET_OK)
{
return C_DIFFER;
}
if (obj_compare(pval1, pval2) != C_SAME)
{
return C_DIFFER;
}
}
/* All key,values match */
return C_SAME;
}
int main(void)
{
uint8_t heap[HEAP_SIZE];
PmReturn_t retval;
retval = pm_init(heap, HEAP_SIZE, MEMSPACE_PROG, usrlib_img);
PM_RETURN_IF_ERROR(retval);
retval = pm_run((uint8_t *)"t376");
C_ASSERT((int)retval == PM_RET_EX_TYPE);
if (retval == PM_RET_EX_TYPE) return (int)PM_RET_OK;
return (int)retval;
}
int main(void)
{
PmReturn_t retval;
/* Init board (don't overwrite PyMite's AVR UART config) */
mmb_init(0, ADC_CK_DIV_128, PWM_CK_DIV_8, 2, 16);
/* Init and run PyMite */
retval = pm_init(MEMSPACE_PROG, usrlib_img);
PM_RETURN_IF_ERROR(retval);
retval = pm_run((uint8_t *)"main");
return (int)retval;
}
int main(void)
{
#ifdef HAVE_PRINT
PmReturn_t retval;
retval = pm_init(MEMSPACE_PROG, usrlib_img);
PM_RETURN_IF_ERROR(retval);
retval = pm_run((uint8_t *)"t076");
return (int)retval;
#else
printf("HAVE_PRINT is not defined. Skipping test.\n");
return 0;
#endif /* !HAVE_PRINT */
}
/*
* Allocates chunk of memory.
* Filters out invalid sizes.
* Rounds the size up to the next multiple of 4.
* Obtains a chunk of at least the desired size.
*/
PmReturn_t
heap_getChunk(uint16_t requestedsize, uint8_t **r_pchunk)
{
PmReturn_t retval;
uint16_t adjustedsize;
/* Ensure size request is valid */
if (requestedsize > HEAP_MAX_LIVE_CHUNK_SIZE)
{
PM_RAISE(retval, PM_RET_EX_MEM);
return retval;
}
else if (requestedsize < HEAP_MIN_CHUNK_SIZE)
{
requestedsize = HEAP_MIN_CHUNK_SIZE;
}
/*
* Round up the size to a multiple of 4 bytes.
* This maintains alignment on 32-bit platforms (required).
*/
adjustedsize = ((requestedsize + 3) & ~3);
/* Attempt to get a chunk */
retval = heap_getChunkImpl(adjustedsize, r_pchunk);
#ifdef HAVE_GC
/* Perform GC if out of memory, gc is enabled and not in native session */
if ((retval == PM_RET_EX_MEM) && (pmHeap.auto_gc == C_TRUE)
&& (gVmGlobal.nativeframe.nf_active == C_FALSE))
{
retval = heap_gcRun();
PM_RETURN_IF_ERROR(retval);
/* Attempt to get a chunk */
retval = heap_getChunkImpl(adjustedsize, r_pchunk);
}
#endif /* HAVE_GC */
/* Ensure that the pointer is 4-byte aligned */
if (retval == PM_RET_OK)
{
C_ASSERT(((intptr_t)*r_pchunk & 3) == 0);
}
return retval;
}
