drone-micropython-raw 0.1.1

#include "py/compile.h"
#include "py/mperrno.h"
#include "py/repl.h"
#include "py/runtime.h"

#include "errnoport.h"
#include "io.h"

#if MICROPY_PY_IO

typedef struct _mp_reader_posix_t
{
  bool close_fd;
  int fd;
  size_t len;
  size_t pos;
  byte buf[20];
} mp_reader_posix_t;

STATIC mp_uint_t
mp_reader_posix_readbyte(void* data)
{
  mp_reader_posix_t* reader = (mp_reader_posix_t*)data;
  if (reader->pos >= reader->len) {
    if (reader->len == 0) {
      return MP_READER_EOF;
    } else {
      int n = read(reader->fd, reader->buf, sizeof(reader->buf));
      if (n <= 0) {
        reader->len = 0;
        return MP_READER_EOF;
      }
      reader->len = n;
      reader->pos = 0;
    }
  }
  return reader->buf[reader->pos++];
}

STATIC void
mp_reader_posix_close(void* data)
{
  mp_reader_posix_t* reader = (mp_reader_posix_t*)data;
  if (reader->close_fd) {
    close(reader->fd);
  }
  m_del_obj(mp_reader_posix_t, reader);
}

void
mp_reader_new_file_from_fd(mp_reader_t* reader, int fd, bool close_fd)
{
  mp_reader_posix_t* rp = m_new_obj(mp_reader_posix_t);
  rp->close_fd = close_fd;
  rp->fd = fd;
  int n = read(rp->fd, rp->buf, sizeof(rp->buf));
  if (n == -1) {
    if (close_fd) {
      close(fd);
    }
    mp_raise_OSError(errno);
  }
  rp->len = n;
  rp->pos = 0;
  reader->data = rp;
  reader->readbyte = mp_reader_posix_readbyte;
  reader->close = mp_reader_posix_close;
}

void
mp_reader_new_file(mp_reader_t* reader, const char* filename)
{
  int fd = open(filename, O_READ);
  if (fd < 0) {
    mp_raise_OSError(errno);
  }
  mp_reader_new_file_from_fd(reader, fd, true);
}

mp_lexer_t*
mp_lexer_new_from_file(const char* filename)
{
  mp_reader_t reader;
  mp_reader_new_file(&reader, filename);
  return mp_lexer_new(qstr_from_str(filename), reader);
}

#else // MICROPY_PY_IO

mp_lexer_t*
mp_lexer_new_from_file(const char* filename)
{
  mp_raise_OSError(MP_ENOENT);
}

mp_import_stat_t
mp_import_stat(const char* path)
{
  return MP_IMPORT_STAT_NO_EXIST;
}

#endif // MICROPY_PY_IO