예제 #1
0
/*----------------------------------------------------------------------------*/
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;
}
예제 #2
0
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;
}
예제 #3
0
파일: float.c 프로젝트: 01iv3r/OpenPilot
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;
}
예제 #4
0
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;
}
예제 #5
0
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;
}
예제 #6
0
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;
}
예제 #7
0
파일: seq.c 프로젝트: rumjack/megapython
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;
}
예제 #8
0
파일: seq.c 프로젝트: rumjack/megapython
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;
}
예제 #9
0
파일: seq.c 프로젝트: rumjack/megapython
/* Returns the length of the sequence */
PmReturn_t
seq_getLength(pPmObj_t pobj, int16_t *r_index)
{
    PmReturn_t retval = PM_RET_OK;

    switch (OBJ_GET_TYPE(pobj))
    {
    case OBJ_TYPE_STR:
        *r_index = ((pPmString_t)pobj)->length;
        break;

    case OBJ_TYPE_TUP:
        *r_index = ((pPmTuple_t)pobj)->length;
        break;

    case OBJ_TYPE_LST:
        *r_index = ((pPmList_t)pobj)->length;
        break;

    default:
        /* Raise TypeError, non-sequence object */
        PM_RAISE(retval, PM_RET_EX_TYPE);
        break;
    }

    return retval;
}
예제 #10
0
파일: class.c 프로젝트: renlexing/projects
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;
}
예제 #11
0
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;
}
예제 #12
0
파일: seq.c 프로젝트: rumjack/megapython
/* Returns the object sequence[index] */
PmReturn_t
seq_getSubscript(pPmObj_t pobj, int16_t index, pPmObj_t *r_pobj)
{
    PmReturn_t retval;
    uint8_t c;

    switch (OBJ_GET_TYPE(pobj))
    {
    case OBJ_TYPE_STR:
        /* Adjust for negative index */
        if (index < 0)
        {
            index += ((pPmString_t)pobj)->length;
        }

        /* Raise IndexError if index is out of bounds */
        if ((index < 0) || (index > ((pPmString_t)pobj)->length))
        {
            PM_RAISE(retval, PM_RET_EX_INDX);
            break;
        }

        /* Get the character from the string */
        c = ((pPmString_t)pobj)->val[index];

        /* Create a new string from the character */
        retval = string_newFromChar(c, r_pobj);
        break;

    case OBJ_TYPE_TUP:
        /* Get the tuple item */
        retval = tuple_getItem(pobj, index, r_pobj);
        break;

    case OBJ_TYPE_LST:
        /* Get the list item */
        retval = list_getItem(pobj, index, r_pobj);
        break;

    default:
        /* Raise TypeError, unsubscriptable object */
        PM_RAISE(retval, PM_RET_EX_TYPE);
        break;
    }

    return retval;
}
예제 #13
0
PmReturn_t
dict_getItem(pPmObj_t pdict, pPmObj_t pkey, pPmObj_t *r_pobj)
{
    PmReturn_t retval = PM_RET_OK;
    int16_t indx = 0;

/*    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;
    }

    /* if dict is empty, raise KeyError */
    if (((pPmDict_t)pdict)->length <= 0)
    {
        PM_RAISE(retval, PM_RET_EX_KEY);
        return retval;
    }

    /* #147: Change boolean keys to integers */
    if (pkey == PM_TRUE)
    {
        pkey = PM_ONE;
    }
    else if (pkey == PM_FALSE)
    {
        pkey = PM_ZERO;
    }

    /* check for matching key */
    retval = seglist_findEqual(((pPmDict_t)pdict)->d_keys, pkey, &indx);
    /* if key not found, raise KeyError */
    if (retval == PM_RET_NO)
    {
        PM_RAISE(retval, PM_RET_EX_KEY);
    }
    /* return any other error */
    PM_RETURN_IF_ERROR(retval);

    /* key was found, get obj from vals */
    retval = seglist_getItem(((pPmDict_t)pdict)->d_vals, indx, r_pobj);
    return retval;
}
예제 #14
0
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;
}
예제 #15
0
파일: obj.c 프로젝트: Nonpython/projects
PmReturn_t
obj_loadFromImg(PmMemSpace_t memspace,
                uint8_t const **paddr, pPmObj_t *r_pobj)
{
    PmReturn_t retval = PM_RET_OK;
    PmObj_t obj;


    /* Get the object descriptor */
    obj.od = (PmObjDesc_t)0x0000;
    OBJ_SET_TYPE(&obj, mem_getByte(memspace, paddr));

    switch (OBJ_GET_TYPE(&obj))
    {
        case OBJ_TYPE_NON:
            /* If it's the None object, return global None */
            *r_pobj = PM_NONE;
            break;

        case OBJ_TYPE_INT:
            /* Read an integer and create an integer object with the value */
            retval = int_new(mem_getInt(memspace, paddr), r_pobj);
            break;

#ifdef HAVE_FLOAT
        case OBJ_TYPE_FLT:
            /* Read a float and create an float object with the value */
            retval = float_new(mem_getFloat(memspace, paddr), r_pobj);
            break;
#endif /* HAVE_FLOAT */

        case OBJ_TYPE_STR:
            retval = string_loadFromImg(memspace, paddr, r_pobj);
            break;

        case OBJ_TYPE_TUP:
            retval = tuple_loadFromImg(memspace, paddr, r_pobj);
            break;

        case OBJ_TYPE_NIM:
            /* If it's a native code img, load into a code obj */
            retval = no_loadFromImg(memspace, paddr, r_pobj);
            break;

        case OBJ_TYPE_CIM:
            /* If it's a code img, load into a code obj */
            retval = co_loadFromImg(memspace, paddr, r_pobj);
            break;

        default:
            /* All other types should not be in an img obj */
            PM_RAISE(retval, PM_RET_EX_SYS);
            break;
    }
    return retval;
}
예제 #16
0
PmReturn_t
mod_import(pPmObj_t pstr, pPmObj_t *pmod)
{
    pPmImgInfo_t pii = C_NULL;
    uint8_t const *imgaddr = C_NULL;
    pPmCo_t pco = C_NULL;
    PmReturn_t retval = PM_RET_OK;
    pPmObj_t pobj;

    /* If it's not a string obj, raise SyntaxError */
    if (OBJ_GET_TYPE(pstr) != OBJ_TYPE_STR)
    {
        PM_RAISE(retval, PM_RET_EX_SYNTAX);
        return retval;
    }

    /* Iterate through the global img list */
    pii = gVmGlobal.pimglist;

    /* Scan until end of list or string matches */
    while ((pii != C_NULL)
           && (string_compare((pPmString_t)pstr, pii->ii_name) == C_DIFFER))
    {
        pii = pii->next;
    }

    /* If img was not found, raise ImportError */
    if (pii == C_NULL)
    {
        PM_RAISE(retval, PM_RET_EX_IMPRT);
        return retval;
    }

    /* Make copy of addr so image list pointer isn't modified */
    imgaddr = pii->ii_addr;

    /* Load img into code obj */
    retval = obj_loadFromImg(pii->ii_memspace, &imgaddr, &pobj);
    PM_RETURN_IF_ERROR(retval);
    pco = (pPmCo_t)pobj;

    return mod_new((pPmObj_t)pco, pmod);
}
예제 #17
0
/*----------------------------------------------------------------------------*/
PmReturn_t
tres_pm_state_pop(pPmFrame_t *ppframe)
{
  PmReturn_t retv = PM_RET_OK;
  pPmObj_t r_pflt;
  pPmObj_t pa;
  float fval;
  int32_t ival;
  int pop_retv;

  /* Raise TypeError if wrong number of args */
  pa = NATIVE_GET_LOCAL(0);
  if(NATIVE_GET_NUM_ARGS() != 1) {
    PM_RAISE(retv, PM_RET_EX_TYPE);
    return retv;
  }
  switch (OBJ_GET_TYPE(pa)) {
    //case OBJ_TYPE_STR:
    //  ptr = (char const *)&(((pPmString_t)pa)->val);
    //  // TODO: unimplemented
    //  break;
  case OBJ_TYPE_INT:
    pop_retv = pop_int(&ival);
    if(pop_retv != TRES_ERR_NONE) {
      ival = ((pPmInt_t) pa)->val;
    }
    retv = int_new(ival, &r_pflt);
    break;
  case OBJ_TYPE_FLT:
    pop_retv = pop_float(&fval);
    if(pop_retv != TRES_ERR_NONE) {
      fval = ((pPmFloat_t) pa)->val;
    }
    retv = float_new(fval, &r_pflt);
    break;
  default:
    /* Raise TypeError */
    PM_RAISE(retv, PM_RET_EX_TYPE);
  }
  NATIVE_SET_TOS(r_pflt);

  return retv;
}
예제 #18
0
/*----------------------------------------------------------------------------*/
PmReturn_t
tres_pm_set_output(pPmFrame_t *ppframe)
{
  const char *ptr;
  int32_t ival;
  float fval;
  PmReturn_t retv = PM_RET_OK;
  pPmObj_t pa;

  /* Raise TypeError if wrong number of args */
  if(NATIVE_GET_NUM_ARGS() != 1) {
    PM_RAISE(retv, PM_RET_EX_TYPE);
    return retv;
  }
  pa = NATIVE_GET_LOCAL(0);
  switch (OBJ_GET_TYPE(pa)) {
  case OBJ_TYPE_STR:
    ptr = (char const *)&(((pPmString_t) pa)->val);
    snprintf(tres_pm_io.out, REST_MAX_CHUNK_SIZE, "%s", ptr);
    break;
  case OBJ_TYPE_INT:
    ival = ((pPmInt_t) pa)->val;
    snprintf(tres_pm_io.out, REST_MAX_CHUNK_SIZE, "%" PRId32, ival);
    break;
  case OBJ_TYPE_FLT:
    fval = ((pPmFloat_t) pa)->val;
    // we cannot use snprintf: float are not supported
    //snprintf(tres_pm_io.out, REST_MAX_CHUNK_SIZE, "%f", fval);
    //therefore we use pymite sli_ftoa, which, however requires a buffer => 15
    if(REST_MAX_CHUNK_SIZE >= 15) {
      sli_ftoa(fval, (uint8_t *)tres_pm_io.out, REST_MAX_CHUNK_SIZE);
    }
    break;
  default:
    /* Raise TypeError */
    PM_RAISE(retv, PM_RET_EX_TYPE);
  }
  tres_pm_io.output_set = 1;
  NATIVE_SET_TOS(PM_NONE);

  return retv;
}
예제 #19
0
/*----------------------------------------------------------------------------*/
PmReturn_t
tres_pm_save_state(pPmFrame_t *ppframe)
{
  PmReturn_t retv = PM_RET_OK;
  pPmObj_t pobj;
  pPmInstance_t pcli;
  pPmDict_t pdict;
  uint16_t index;

  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;

  // store each attribute of the object
  for(index = 0; index < pdict->length; 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:
      push_int(((pPmInt_t) pobj)->val);
      break;
    case OBJ_TYPE_FLT:
      push_float(((pPmFloat_t) pobj)->val);
      break;
    }
  }
  NATIVE_SET_TOS(PM_NONE);
  return retv;
}
예제 #20
0
파일: plat.c 프로젝트: MatiasNAmendola/OS
/* Desktop target shall use stdio for I/O routines */
PmReturn_t plat_putByte(uint8_t b) {
    int i;
    PmReturn_t retval = PM_RET_OK;

    i = putchar(b);
    fflush(stdout);

    if ((i != b) || (i == EOF))
    {
        PM_RAISE(retval, PM_RET_EX_IO);
    }

    return retval;
}
예제 #21
0
/*
 * UART send char routine MUST send exactly and only the given char;
 * it should not translate \n to \r\n.
 * This is because the interactive interface uses binary transfers.
 */
PmReturn_t
plat_putByte(uint8_t b)
{
    PmReturn_t retval = PM_RET_OK;
    if(usb_serial_putchar(b) == 0)
    {
        return retval;
    }
    else
    {
        PM_RAISE(retval, PM_RET_EX_IO);
        return retval;
    }
}
예제 #22
0
PmReturn_t
nat_placeholder_func(pPmFrame_t *ppframe)
{

    /*
     * Use placeholder because an index 
     * value of zero denotes the stdlib.
     * This function should not be called.
     */
    PmReturn_t retval;
    PM_RAISE(retval, PM_RET_EX_SYS);
    return retval;

}
예제 #23
0
/*
 * UART receive char routine MUST return exactly and only the received char;
 * it should not translate \n to \r\n.
 * This is because the interactive interface uses binary transfers.
 */
PmReturn_t
plat_getByte(uint8_t *b)
{
    PmReturn_t retval = PM_RET_OK;

    int c = usb_serial_getchar();
    if(c == -1)
    {
        PM_RAISE(retval, PM_RET_EX_IO);
        return retval;
    }
    *b = c;
    return retval;
}
예제 #24
0
/*----------------------------------------------------------------------------*/
PmReturn_t
tres_pm_state_push(pPmFrame_t *ppframe)
{
  //const char *ptr;
  int32_t ival;
  float fval;
  PmReturn_t retv = PM_RET_OK;
  pPmObj_t pa;

  /* Raise TypeError if wrong number of args */
  pa = NATIVE_GET_LOCAL(0);
  if(NATIVE_GET_NUM_ARGS() != 1) {
    PM_RAISE(retv, PM_RET_EX_TYPE);
    return retv;
  }
  switch (OBJ_GET_TYPE(pa)) {
    //case OBJ_TYPE_STR:
    //  ptr = (char const *)&(((pPmString_t)pa)->val);
    //  // TODO: unimplemented
    //  break;
  case OBJ_TYPE_INT:
    ival = ((pPmInt_t) pa)->val;
    push_int(ival);
    break;
  case OBJ_TYPE_FLT:
    fval = ((pPmFloat_t) pa)->val;
    push_float(fval);
    break;
  default:
    /* Raise TypeError */
    PM_RAISE(retv, PM_RET_EX_TYPE);
  }
  NATIVE_SET_TOS(PM_NONE);

  return retv;
}
예제 #25
0
파일: plat.c 프로젝트: 1heinz/TauLabs
PmReturn_t plat_getByte(uint8_t *b)
{
    int c;
    PmReturn_t retval = PM_RET_OK;

    c = getchar();
    *b = c & 0xFF;

    if (c == EOF)
    {
        PM_RAISE(retval, PM_RET_EX_IO);
    }

    return retval;
}
예제 #26
0
파일: heap.c 프로젝트: 01iv3r/OpenPilot
/*
 * 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;
}
예제 #27
0
/*
 * 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_CHUNK_SIZE)
    {
        PM_RAISE(retval, PM_RET_EX_MEM);
        return retval;
    }

    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);

    /* Perform GC if out of memory and auto-gc is enabled */
    if ((retval == PM_RET_EX_MEM) && (pmHeap.auto_gc == C_TRUE))
    {
        retval = heap_gcRun();
        PM_RETURN_IF_ERROR(retval);

        /* Attempt to get a chunk */
        retval = heap_getChunkImpl(adjustedsize, r_pchunk);
    }

    /* Ensure that the pointer is 4-byte aligned */
    if (retval == PM_RET_OK)
    {
        C_ASSERT(((int)*r_pchunk & 3) == 0);
    }

    return retval;
}
예제 #28
0
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('}');
}
예제 #29
0
파일: plat.c 프로젝트: Nonpython/projects
/*
 * UART receive char routine MUST return exactly and only the received char;
 * it should not translate \n to \r\n.
 * This is because the interactive interface uses binary transfers.
 */
PmReturn_t
plat_getByte(uint8_t *b)
{
    PmReturn_t retval = PM_RET_OK;

    /* Loop until serial receive is complete */
    loop_until_bit_is_set(UCSR0A, RXC0);

    /* If a framing error or data overrun occur, raise an IOException */
    if (UCSR0A & (_BV(FE0) | _BV(DOR0)))
    {
        PM_RAISE(retval, PM_RET_EX_IO);
        return retval;
    }
    *b = UDR0;

    return retval;
}
예제 #30
0
PmReturn_t
plat_getByte(uint8_t *b)
{
    int c;
    PmReturn_t retval = PM_RET_OK;

    while(!(U0LSR && 0x01)); //waits till the register to contain valid data

    c = U0RBR;

    *b = c & 0xFF;

    if (c > 0xFF)
    {
        PM_RAISE(retval, PM_RET_EX_IO);
    }

    return retval;
}