Pull common files from pxt-common-packages (#1165)
This commit is contained in:
Michał Moskal
GitHub
@@ -1,356 +0,0 @@
|
||||
#include "pxtbase.h"
|
||||
#include <limits.h>
|
||||
|
||||
using namespace std;
|
||||
|
||||
//% indexerGet=BufferMethods::getByte indexerSet=BufferMethods::setByte
|
||||
namespace BufferMethods {
|
||||
//%
|
||||
uint8_t *getBytes(Buffer buf) {
|
||||
return buf->data;
|
||||
}
|
||||
|
||||
//%
|
||||
int getByte(Buffer buf, int off) {
|
||||
if (buf && 0 <= off && off < buf->length)
|
||||
return buf->data[off];
|
||||
return 0;
|
||||
}
|
||||
|
||||
//%
|
||||
void setByte(Buffer buf, int off, int v) {
|
||||
if (buf && 0 <= off && off < buf->length)
|
||||
buf->data[off] = v;
|
||||
}
|
||||
|
||||
int writeBuffer(Buffer buf, int dstOffset, Buffer src, int srcOffset = 0, int length = -1) {
|
||||
if (length < 0)
|
||||
length = src->length;
|
||||
|
||||
if (srcOffset < 0 || dstOffset < 0 || dstOffset > buf->length)
|
||||
return -1;
|
||||
|
||||
length = min(src->length - srcOffset, buf->length - dstOffset);
|
||||
|
||||
if (length < 0)
|
||||
return -1;
|
||||
|
||||
if (buf == src) {
|
||||
memmove(buf->data + dstOffset, src->data + srcOffset, length);
|
||||
} else {
|
||||
memcpy(buf->data + dstOffset, src->data + srcOffset, length);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Write a number in specified format in the buffer.
|
||||
*/
|
||||
//%
|
||||
void setNumber(Buffer buf, NumberFormat format, int offset, TNumber value) {
|
||||
if (offset < 0)
|
||||
return;
|
||||
setNumberCore(buf->data + offset, buf->length - offset, format, value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read a number in specified format from the buffer.
|
||||
*/
|
||||
//%
|
||||
TNumber getNumber(Buffer buf, NumberFormat format, int offset) {
|
||||
if (offset < 0)
|
||||
return fromInt(0);
|
||||
return getNumberCore(buf->data + offset, buf->length - offset, format);
|
||||
}
|
||||
|
||||
/** Returns the length of a Buffer object. */
|
||||
//% property
|
||||
int length(Buffer s) {
|
||||
return s->length;
|
||||
}
|
||||
|
||||
/**
|
||||
* Fill (a fragment) of the buffer with given value.
|
||||
*/
|
||||
//%
|
||||
void fill(Buffer buf, int value, int offset = 0, int length = -1) {
|
||||
if (offset < 0 || offset > buf->length)
|
||||
return; // DEVICE_INVALID_PARAMETER;
|
||||
if (length < 0)
|
||||
length = buf->length;
|
||||
length = min(length, buf->length - offset);
|
||||
memset(buf->data + offset, value, length);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return a copy of a fragment of a buffer.
|
||||
*/
|
||||
//%
|
||||
Buffer slice(Buffer buf, int offset = 0, int length = -1) {
|
||||
offset = min((int)buf->length, offset);
|
||||
if (length < 0)
|
||||
length = buf->length;
|
||||
length = min(length, buf->length - offset);
|
||||
return mkBuffer(buf->data + offset, length);
|
||||
}
|
||||
|
||||
/**
|
||||
* Shift buffer left in place, with zero padding.
|
||||
* @param offset number of bytes to shift; use negative value to shift right
|
||||
* @param start start offset in buffer. Default is 0.
|
||||
* @param length number of elements in buffer. If negative, length is set as the buffer length minus
|
||||
* start. eg: -1
|
||||
*/
|
||||
//%
|
||||
void shift(Buffer buf, int offset, int start = 0, int length = -1) {
|
||||
if (length < 0)
|
||||
length = buf->length - start;
|
||||
if (start < 0 || start + length > buf->length || start + length < start || length == 0 ||
|
||||
offset == 0 || offset == INT_MIN)
|
||||
return;
|
||||
if (offset <= -length || offset >= length) {
|
||||
fill(buf, 0);
|
||||
return;
|
||||
}
|
||||
|
||||
uint8_t *data = buf->data + start;
|
||||
if (offset < 0) {
|
||||
offset = -offset;
|
||||
memmove(data + offset, data, length - offset);
|
||||
memset(data, 0, offset);
|
||||
} else {
|
||||
length = length - offset;
|
||||
memmove(data, data + offset, length);
|
||||
memset(data + length, 0, offset);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a buffer to its hexadecimal representation.
|
||||
*/
|
||||
//%
|
||||
String toHex(Buffer buf) {
|
||||
const char *hex = "0123456789abcdef";
|
||||
auto res = mkString(NULL, buf->length * 2);
|
||||
for (int i = 0; i < buf->length; ++i) {
|
||||
res->data[i << 1] = hex[buf->data[i] >> 4];
|
||||
res->data[(i << 1) + 1] = hex[buf->data[i] & 0xf];
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
/**
|
||||
* Rotate buffer left in place.
|
||||
* @param offset number of bytes to shift; use negative value to shift right
|
||||
* @param start start offset in buffer. Default is 0.
|
||||
* @param length number of elements in buffer. If negative, length is set as the buffer length minus
|
||||
* start. eg: -1
|
||||
*/
|
||||
//%
|
||||
void rotate(Buffer buf, int offset, int start = 0, int length = -1) {
|
||||
if (length < 0)
|
||||
length = buf->length - start;
|
||||
if (start < 0 || start + length > buf->length || start + length < start || length == 0 ||
|
||||
offset == 0 || offset == INT_MIN)
|
||||
return;
|
||||
|
||||
if (offset < 0)
|
||||
offset += length << 8; // try to make it positive
|
||||
offset %= length;
|
||||
if (offset < 0)
|
||||
offset += length;
|
||||
|
||||
uint8_t *data = buf->data + start;
|
||||
|
||||
uint8_t *n_first = data + offset;
|
||||
uint8_t *first = data;
|
||||
uint8_t *next = n_first;
|
||||
uint8_t *last = data + length;
|
||||
|
||||
while (first != next) {
|
||||
uint8_t tmp = *first;
|
||||
*first++ = *next;
|
||||
*next++ = tmp;
|
||||
if (next == last) {
|
||||
next = n_first;
|
||||
} else if (first == n_first) {
|
||||
n_first = next;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Write contents of `src` at `dstOffset` in current buffer.
|
||||
*/
|
||||
//%
|
||||
void write(Buffer buf, int dstOffset, Buffer src) {
|
||||
// srcOff and length not supported, we only do up to 4 args :/
|
||||
writeBuffer(buf, dstOffset, src, 0, -1);
|
||||
}
|
||||
}
|
||||
|
||||
namespace control {
|
||||
/**
|
||||
* Create a new zero-initialized buffer.
|
||||
* @param size number of bytes in the buffer
|
||||
*/
|
||||
//%
|
||||
Buffer createBuffer(int size) {
|
||||
return mkBuffer(NULL, size);
|
||||
}
|
||||
}
|
||||
|
||||
namespace pxt {
|
||||
static int writeBytes(uint8_t *dst, uint8_t *src, int length, bool swapBytes, int szLeft) {
|
||||
if (szLeft < length) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (swapBytes) {
|
||||
uint8_t *p = dst + length;
|
||||
for (int i = 0; i < length; ++i)
|
||||
*--p = src[i];
|
||||
} else {
|
||||
if (length == 4 && ((uint32_t)dst & 3) == 0)
|
||||
*(uint32_t *)dst = *(uint32_t *)src;
|
||||
else if (length == 2 && ((uint32_t)dst & 1) == 0)
|
||||
*(uint16_t *)dst = *(uint16_t *)src;
|
||||
else
|
||||
memcpy(dst, src, length);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int readBytes(uint8_t *src, uint8_t *dst, int length, bool swapBytes, int szLeft) {
|
||||
if (szLeft < length) {
|
||||
memset(dst, 0, length);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (swapBytes) {
|
||||
uint8_t *p = src + length;
|
||||
for (int i = 0; i < length; ++i)
|
||||
dst[i] = *--p;
|
||||
} else {
|
||||
if (length == 4 && ((uint32_t)src & 3) == 0)
|
||||
*(uint32_t *)dst = *(uint32_t *)src;
|
||||
else if (length == 2 && ((uint32_t)src & 1) == 0)
|
||||
*(uint16_t *)dst = *(uint16_t *)src;
|
||||
else
|
||||
memcpy(dst, src, length);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void setNumberCore(uint8_t *buf, int szLeft, NumberFormat format, TNumber value) {
|
||||
int8_t i8;
|
||||
uint8_t u8;
|
||||
int16_t i16;
|
||||
uint16_t u16;
|
||||
int32_t i32;
|
||||
uint32_t u32;
|
||||
float f32;
|
||||
double f64;
|
||||
|
||||
// Assume little endian
|
||||
#define WRITEBYTES(isz, swap, toInt) \
|
||||
isz = toInt(value); \
|
||||
writeBytes(buf, (uint8_t *)&isz, sizeof(isz), swap, szLeft); \
|
||||
break
|
||||
|
||||
switch (format) {
|
||||
case NumberFormat::Int8LE:
|
||||
WRITEBYTES(i8, false, toInt);
|
||||
case NumberFormat::UInt8LE:
|
||||
WRITEBYTES(u8, false, toInt);
|
||||
case NumberFormat::Int16LE:
|
||||
WRITEBYTES(i16, false, toInt);
|
||||
case NumberFormat::UInt16LE:
|
||||
WRITEBYTES(u16, false, toInt);
|
||||
case NumberFormat::Int32LE:
|
||||
WRITEBYTES(i32, false, toInt);
|
||||
case NumberFormat::UInt32LE:
|
||||
WRITEBYTES(u32, false, toUInt);
|
||||
|
||||
case NumberFormat::Int8BE:
|
||||
WRITEBYTES(i8, true, toInt);
|
||||
case NumberFormat::UInt8BE:
|
||||
WRITEBYTES(u8, true, toInt);
|
||||
case NumberFormat::Int16BE:
|
||||
WRITEBYTES(i16, true, toInt);
|
||||
case NumberFormat::UInt16BE:
|
||||
WRITEBYTES(u16, true, toInt);
|
||||
case NumberFormat::Int32BE:
|
||||
WRITEBYTES(i32, true, toInt);
|
||||
case NumberFormat::UInt32BE:
|
||||
WRITEBYTES(u32, true, toUInt);
|
||||
|
||||
case NumberFormat::Float32LE:
|
||||
WRITEBYTES(f32, false, toFloat);
|
||||
case NumberFormat::Float32BE:
|
||||
WRITEBYTES(f32, true, toFloat);
|
||||
case NumberFormat::Float64LE:
|
||||
WRITEBYTES(f64, false, toDouble);
|
||||
case NumberFormat::Float64BE:
|
||||
WRITEBYTES(f64, true, toDouble);
|
||||
}
|
||||
}
|
||||
|
||||
TNumber getNumberCore(uint8_t *buf, int szLeft, NumberFormat format) {
|
||||
int8_t i8;
|
||||
uint8_t u8;
|
||||
int16_t i16;
|
||||
uint16_t u16;
|
||||
int32_t i32;
|
||||
uint32_t u32;
|
||||
float f32;
|
||||
double f64;
|
||||
|
||||
// Assume little endian
|
||||
#define READBYTES(isz, swap, conv) \
|
||||
readBytes(buf, (uint8_t *)&isz, sizeof(isz), swap, szLeft); \
|
||||
return conv(isz)
|
||||
|
||||
switch (format) {
|
||||
case NumberFormat::Int8LE:
|
||||
READBYTES(i8, false, fromInt);
|
||||
case NumberFormat::UInt8LE:
|
||||
READBYTES(u8, false, fromInt);
|
||||
case NumberFormat::Int16LE:
|
||||
READBYTES(i16, false, fromInt);
|
||||
case NumberFormat::UInt16LE:
|
||||
READBYTES(u16, false, fromInt);
|
||||
case NumberFormat::Int32LE:
|
||||
READBYTES(i32, false, fromInt);
|
||||
case NumberFormat::UInt32LE:
|
||||
READBYTES(u32, false, fromUInt);
|
||||
|
||||
case NumberFormat::Int8BE:
|
||||
READBYTES(i8, true, fromInt);
|
||||
case NumberFormat::UInt8BE:
|
||||
READBYTES(u8, true, fromInt);
|
||||
case NumberFormat::Int16BE:
|
||||
READBYTES(i16, true, fromInt);
|
||||
case NumberFormat::UInt16BE:
|
||||
READBYTES(u16, true, fromInt);
|
||||
case NumberFormat::Int32BE:
|
||||
READBYTES(i32, true, fromInt);
|
||||
case NumberFormat::UInt32BE:
|
||||
READBYTES(u32, true, fromUInt);
|
||||
|
||||
case NumberFormat::Float32LE:
|
||||
READBYTES(f32, false, fromFloat);
|
||||
case NumberFormat::Float32BE:
|
||||
READBYTES(f32, true, fromFloat);
|
||||
case NumberFormat::Float64LE:
|
||||
READBYTES(f64, false, fromDouble);
|
||||
case NumberFormat::Float64BE:
|
||||
READBYTES(f64, true, fromDouble);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
1137
libs/core/core.cpp
1137
libs/core/core.cpp
File diff suppressed because it is too large
Load Diff
13
libs/core/platform.h
Normal file
13
libs/core/platform.h
Normal file
@@ -0,0 +1,13 @@
|
||||
// helpful define to handle C++ differences in package
|
||||
#define PXT_MICROBIT_TAGGED_INT 1
|
||||
|
||||
// cross version compatible way of access data field
|
||||
#ifndef PXT_BUFFER_DATA
|
||||
#define PXT_BUFFER_DATA(buffer) buffer->data
|
||||
#endif
|
||||
|
||||
#ifndef PXT_CREATE_BUFFER
|
||||
#define PXT_CREATE_BUFFER(data, len) pxt::mkBuffer(data, len)
|
||||
#endif
|
||||
|
||||
#define PXT_POWI 1
|
||||
@@ -1,567 +0,0 @@
|
||||
#include "pxtbase.h"
|
||||
|
||||
using namespace std;
|
||||
|
||||
namespace pxt {
|
||||
|
||||
TValue incr(TValue e) {
|
||||
if (isRefCounted(e)) {
|
||||
getVTable((RefObject *)e);
|
||||
#if MEMDBG_ENABLED
|
||||
if (((RefObject *)e)->refcnt != 0xffff)
|
||||
MEMDBG("INCR: %p refs=%d", e, ((RefObject *)e)->refcnt);
|
||||
#endif
|
||||
((RefObject *)e)->ref();
|
||||
}
|
||||
return e;
|
||||
}
|
||||
|
||||
void decr(TValue e) {
|
||||
if (isRefCounted(e)) {
|
||||
#if MEMDBG_ENABLED
|
||||
if (((RefObject *)e)->refcnt != 0xffff)
|
||||
MEMDBG("DECR: %p refs=%d", e, ((RefObject *)e)->refcnt);
|
||||
#endif
|
||||
((RefObject *)e)->unref();
|
||||
}
|
||||
}
|
||||
|
||||
// TODO
|
||||
Action mkAction(int reflen, int totallen, int startptr) {
|
||||
check(0 <= reflen && reflen <= totallen, ERR_SIZE, 1);
|
||||
check(reflen <= totallen && totallen <= 255, ERR_SIZE, 2);
|
||||
check(bytecode[startptr] == 0xffff, ERR_INVALID_BINARY_HEADER, 3);
|
||||
check(bytecode[startptr + 1] == PXT_REF_TAG_ACTION, ERR_INVALID_BINARY_HEADER, 4);
|
||||
|
||||
uintptr_t tmp = (uintptr_t)&bytecode[startptr];
|
||||
|
||||
if (totallen == 0) {
|
||||
return (TValue)tmp; // no closure needed
|
||||
}
|
||||
|
||||
void *ptr = ::operator new(sizeof(RefAction) + totallen * sizeof(unsigned));
|
||||
RefAction *r = new (ptr) RefAction();
|
||||
r->len = totallen;
|
||||
r->reflen = reflen;
|
||||
r->func = (ActionCB)((tmp + 4) | 1);
|
||||
memset(r->fields, 0, r->len * sizeof(unsigned));
|
||||
|
||||
MEMDBG("mkAction: start=%p => %p", startptr, r);
|
||||
|
||||
return (Action)r;
|
||||
}
|
||||
|
||||
// TODO
|
||||
TValue runAction3(Action a, TValue arg0, TValue arg1, TValue arg2) {
|
||||
auto aa = (RefAction *)a;
|
||||
if (aa->vtable == PXT_REF_TAG_ACTION) {
|
||||
check(aa->refcnt == 0xffff, ERR_INVALID_BINARY_HEADER, 4);
|
||||
return ((ActionCB)(((uintptr_t)a + 4) | 1))(NULL, arg0, arg1, arg2);
|
||||
} else {
|
||||
check(aa->refcnt != 0xffff, ERR_INVALID_BINARY_HEADER, 4);
|
||||
return aa->runCore(arg0, arg1, arg2);
|
||||
}
|
||||
}
|
||||
|
||||
TValue runAction2(Action a, TValue arg0, TValue arg1) {
|
||||
return runAction3(a, arg0, arg1, 0);
|
||||
}
|
||||
|
||||
TValue runAction1(Action a, TValue arg0) {
|
||||
return runAction3(a, arg0, 0, 0);
|
||||
}
|
||||
|
||||
TValue runAction0(Action a) {
|
||||
return runAction3(a, 0, 0, 0);
|
||||
}
|
||||
|
||||
RefRecord *mkClassInstance(int vtableOffset) {
|
||||
VTable *vtable = (VTable *)&bytecode[vtableOffset];
|
||||
|
||||
intcheck(vtable->methods[0] == &RefRecord_destroy, ERR_SIZE, 3);
|
||||
intcheck(vtable->methods[1] == &RefRecord_print, ERR_SIZE, 4);
|
||||
|
||||
void *ptr = ::operator new(vtable->numbytes);
|
||||
RefRecord *r = new (ptr) RefRecord(PXT_VTABLE_TO_INT(vtable));
|
||||
memset(r->fields, 0, vtable->numbytes - sizeof(RefRecord));
|
||||
MEMDBG("mkClass: vt=%p => %p", vtable, r);
|
||||
return r;
|
||||
}
|
||||
|
||||
TValue RefRecord::ld(int idx) {
|
||||
// intcheck((reflen == 255 ? 0 : reflen) <= idx && idx < len, ERR_OUT_OF_BOUNDS, 1);
|
||||
return fields[idx];
|
||||
}
|
||||
|
||||
TValue RefRecord::ldref(int idx) {
|
||||
// DMESG("LD %p len=%d reflen=%d idx=%d", this, len, reflen, idx);
|
||||
// intcheck(0 <= idx && idx < reflen, ERR_OUT_OF_BOUNDS, 2);
|
||||
TValue tmp = fields[idx];
|
||||
incr(tmp);
|
||||
return tmp;
|
||||
}
|
||||
|
||||
void RefRecord::st(int idx, TValue v) {
|
||||
// intcheck((reflen == 255 ? 0 : reflen) <= idx && idx < len, ERR_OUT_OF_BOUNDS, 3);
|
||||
fields[idx] = v;
|
||||
}
|
||||
|
||||
void RefRecord::stref(int idx, TValue v) {
|
||||
// DMESG("ST %p len=%d reflen=%d idx=%d", this, len, reflen, idx);
|
||||
// intcheck(0 <= idx && idx < reflen, ERR_OUT_OF_BOUNDS, 4);
|
||||
decr(fields[idx]);
|
||||
fields[idx] = v;
|
||||
}
|
||||
|
||||
void RefObject::destroyVT() {
|
||||
((RefObjectMethod)getVTable(this)->methods[0])(this);
|
||||
::operator delete(this);
|
||||
}
|
||||
|
||||
void RefObject::printVT() {
|
||||
((RefObjectMethod)getVTable(this)->methods[1])(this);
|
||||
}
|
||||
|
||||
void RefRecord_destroy(RefRecord *r) {
|
||||
VTable *tbl = getVTable(r);
|
||||
uint8_t *refmask = (uint8_t *)&tbl->methods[tbl->userdata & 0xff];
|
||||
int len = (tbl->numbytes >> 2) - 1;
|
||||
for (int i = 0; i < len; ++i) {
|
||||
if (refmask[i])
|
||||
decr(r->fields[i]);
|
||||
r->fields[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void RefRecord_print(RefRecord *r) {
|
||||
DMESG("RefRecord %p r=%d size=%d bytes", r, r->refcnt, getVTable(r)->numbytes);
|
||||
}
|
||||
|
||||
TValue Segment::get(unsigned i) {
|
||||
#ifdef DEBUG_BUILD
|
||||
DMESG("In Segment::get index:%d", i);
|
||||
this->print();
|
||||
#endif
|
||||
|
||||
if (i < length) {
|
||||
return data[i];
|
||||
}
|
||||
return Segment::DefaultValue;
|
||||
}
|
||||
|
||||
void Segment::setRef(unsigned i, TValue value) {
|
||||
decr(get(i));
|
||||
set(i, value);
|
||||
}
|
||||
|
||||
void Segment::set(unsigned i, TValue value) {
|
||||
if (i < size) {
|
||||
data[i] = value;
|
||||
} else if (i < Segment::MaxSize) {
|
||||
growByMin(i + 1);
|
||||
data[i] = value;
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
if (length <= i) {
|
||||
length = i + 1;
|
||||
}
|
||||
|
||||
#ifdef DEBUG_BUILD
|
||||
DMESG("In Segment::set");
|
||||
this->print();
|
||||
#endif
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
ramint_t Segment::growthFactor(ramint_t size) {
|
||||
if (size == 0) {
|
||||
return 4;
|
||||
}
|
||||
if (size < 64) {
|
||||
return size * 2; // Double
|
||||
}
|
||||
if (size < 512) {
|
||||
return size * 5 / 3; // Grow by 1.66 rate
|
||||
}
|
||||
// Grow by constant rate
|
||||
if ((unsigned)size + 256 < MaxSize)
|
||||
return size + 256;
|
||||
else
|
||||
return MaxSize;
|
||||
}
|
||||
|
||||
void Segment::growByMin(ramint_t minSize) {
|
||||
growBy(max(minSize, growthFactor(size)));
|
||||
}
|
||||
|
||||
void Segment::growBy(ramint_t newSize) {
|
||||
#ifdef DEBUG_BUILD
|
||||
DMESG("growBy: %d", newSize);
|
||||
this->print();
|
||||
#endif
|
||||
if (size < newSize) {
|
||||
// this will throw if unable to allocate
|
||||
TValue *tmp = (TValue *)(::operator new(newSize * sizeof(TValue)));
|
||||
|
||||
// Copy existing data
|
||||
if (size) {
|
||||
memcpy(tmp, data, size * sizeof(TValue));
|
||||
}
|
||||
// fill the rest with default value
|
||||
memset(tmp + size, 0, (newSize - size) * sizeof(TValue));
|
||||
|
||||
// free older segment;
|
||||
::operator delete(data);
|
||||
|
||||
data = tmp;
|
||||
size = newSize;
|
||||
|
||||
#ifdef DEBUG_BUILD
|
||||
DMESG("growBy - after reallocation");
|
||||
this->print();
|
||||
#endif
|
||||
}
|
||||
// else { no shrinking yet; }
|
||||
return;
|
||||
}
|
||||
|
||||
void Segment::ensure(ramint_t newSize) {
|
||||
if (newSize < size) {
|
||||
return;
|
||||
}
|
||||
growByMin(newSize);
|
||||
}
|
||||
|
||||
void Segment::setLength(unsigned newLength) {
|
||||
if (newLength > size) {
|
||||
ensure(length);
|
||||
}
|
||||
length = newLength;
|
||||
return;
|
||||
}
|
||||
|
||||
void Segment::push(TValue value) {
|
||||
this->set(length, value);
|
||||
}
|
||||
|
||||
TValue Segment::pop() {
|
||||
#ifdef DEBUG_BUILD
|
||||
DMESG("In Segment::pop");
|
||||
this->print();
|
||||
#endif
|
||||
|
||||
if (length > 0) {
|
||||
--length;
|
||||
TValue value = data[length];
|
||||
data[length] = Segment::DefaultValue;
|
||||
return value;
|
||||
}
|
||||
return Segment::DefaultValue;
|
||||
}
|
||||
|
||||
// this function removes an element at index i and shifts the rest of the elements to
|
||||
// left to fill the gap
|
||||
TValue Segment::remove(unsigned i) {
|
||||
#ifdef DEBUG_BUILD
|
||||
DMESG("In Segment::remove index:%d", i);
|
||||
this->print();
|
||||
#endif
|
||||
if (i < length) {
|
||||
// value to return
|
||||
TValue ret = data[i];
|
||||
if (i + 1 < length) {
|
||||
// Move the rest of the elements to fill in the gap.
|
||||
memmove(data + i, data + i + 1, (length - i - 1) * sizeof(unsigned));
|
||||
}
|
||||
length--;
|
||||
data[length] = Segment::DefaultValue;
|
||||
#ifdef DEBUG_BUILD
|
||||
DMESG("After Segment::remove index:%d", i);
|
||||
this->print();
|
||||
#endif
|
||||
return ret;
|
||||
}
|
||||
return Segment::DefaultValue;
|
||||
}
|
||||
|
||||
// this function inserts element value at index i by shifting the rest of the elements right.
|
||||
void Segment::insert(unsigned i, TValue value) {
|
||||
#ifdef DEBUG_BUILD
|
||||
DMESG("In Segment::insert index:%d value:%d", i, value);
|
||||
this->print();
|
||||
#endif
|
||||
|
||||
if (i < length) {
|
||||
ensure(length + 1);
|
||||
|
||||
// Move the rest of the elements to fill in the gap.
|
||||
memmove(data + i + 1, data + i, (length - i) * sizeof(unsigned));
|
||||
|
||||
data[i] = value;
|
||||
length++;
|
||||
} else {
|
||||
// This is insert beyond the length, just call set which will adjust the length
|
||||
set(i, value);
|
||||
}
|
||||
#ifdef DEBUG_BUILD
|
||||
DMESG("After Segment::insert index:%d", i);
|
||||
this->print();
|
||||
#endif
|
||||
}
|
||||
|
||||
void Segment::print() {
|
||||
DMESG("Segment: %p, length: %d, size: %d", data, (unsigned)length, (unsigned)size);
|
||||
for (unsigned i = 0; i < size; i++) {
|
||||
DMESG("-> %d", (unsigned)(uintptr_t)data[i]);
|
||||
}
|
||||
}
|
||||
|
||||
bool Segment::isValidIndex(unsigned i) {
|
||||
if (i > length) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void Segment::destroy() {
|
||||
#ifdef DEBUG_BUILD
|
||||
DMESG("In Segment::destroy");
|
||||
this->print();
|
||||
#endif
|
||||
length = size = 0;
|
||||
::operator delete(data);
|
||||
data = nullptr;
|
||||
}
|
||||
|
||||
void RefCollection::push(TValue x) {
|
||||
incr(x);
|
||||
head.push(x);
|
||||
}
|
||||
|
||||
TValue RefCollection::pop() {
|
||||
TValue ret = head.pop();
|
||||
incr(ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
TValue RefCollection::getAt(int i) {
|
||||
TValue tmp = head.get(i);
|
||||
incr(tmp);
|
||||
return tmp;
|
||||
}
|
||||
|
||||
TValue RefCollection::removeAt(int i) {
|
||||
return head.remove(i);
|
||||
}
|
||||
|
||||
void RefCollection::insertAt(int i, TValue value) {
|
||||
head.insert(i, value);
|
||||
incr(value);
|
||||
}
|
||||
|
||||
void RefCollection::setAt(int i, TValue value) {
|
||||
incr(value);
|
||||
head.setRef(i, value);
|
||||
}
|
||||
|
||||
int RefCollection::indexOf(TValue x, int start) {
|
||||
#ifndef X86_64
|
||||
unsigned i = start;
|
||||
while (head.isValidIndex(i)) {
|
||||
if (pxt::eq_bool(head.get(i), x)) {
|
||||
return (int)i;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
#endif
|
||||
return -1;
|
||||
}
|
||||
|
||||
bool RefCollection::removeElement(TValue x) {
|
||||
int idx = indexOf(x, 0);
|
||||
if (idx >= 0) {
|
||||
decr(removeAt(idx));
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
namespace Coll0 {
|
||||
PXT_VTABLE_BEGIN(RefCollection, 0, 0)
|
||||
PXT_VTABLE_END
|
||||
} // namespace Coll0
|
||||
|
||||
RefCollection::RefCollection() : RefObject(0) {
|
||||
vtable = PXT_VTABLE_TO_INT(&Coll0::RefCollection_vtable);
|
||||
}
|
||||
|
||||
void RefCollection::destroy(RefCollection *t) {
|
||||
for (unsigned i = 0; i < t->head.getLength(); i++) {
|
||||
decr(t->head.get(i));
|
||||
}
|
||||
t->head.destroy();
|
||||
}
|
||||
|
||||
void RefCollection::print(RefCollection *t) {
|
||||
DMESG("RefCollection %p r=%d size=%d", t, t->refcnt, t->head.getLength());
|
||||
t->head.print();
|
||||
}
|
||||
|
||||
PXT_VTABLE_CTOR(RefAction) {}
|
||||
|
||||
// fields[] contain captured locals
|
||||
void RefAction::destroy(RefAction *t) {
|
||||
for (int i = 0; i < t->reflen; ++i) {
|
||||
decr(t->fields[i]);
|
||||
t->fields[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void RefAction::print(RefAction *t) {
|
||||
DMESG("RefAction %p r=%d pc=%X size=%d (%d refs)", t, t->refcnt,
|
||||
(const uint8_t *)t->func - (const uint8_t *)bytecode, t->len, t->reflen);
|
||||
}
|
||||
|
||||
void RefLocal::print(RefLocal *t) {
|
||||
DMESG("RefLocal %p r=%d v=%d", t, t->refcnt, t->v);
|
||||
}
|
||||
|
||||
void RefLocal::destroy(RefLocal *) {}
|
||||
|
||||
PXT_VTABLE_CTOR(RefLocal) {
|
||||
v = 0;
|
||||
}
|
||||
|
||||
PXT_VTABLE_CTOR(RefRefLocal) {
|
||||
v = 0;
|
||||
}
|
||||
|
||||
void RefRefLocal::print(RefRefLocal *t) {
|
||||
DMESG("RefRefLocal %p r=%d v=%p", t, t->refcnt, (void *)t->v);
|
||||
}
|
||||
|
||||
void RefRefLocal::destroy(RefRefLocal *t) {
|
||||
decr(t->v);
|
||||
}
|
||||
|
||||
PXT_VTABLE_BEGIN(RefMap, 0, RefMapMarker)
|
||||
PXT_VTABLE_END
|
||||
RefMap::RefMap() : PXT_VTABLE_INIT(RefMap) {}
|
||||
|
||||
void RefMap::destroy(RefMap *t) {
|
||||
for (unsigned i = 0; i < t->values.getLength(); ++i) {
|
||||
decr(t->values.get(i));
|
||||
t->values.set(i, 0);
|
||||
}
|
||||
t->keys.destroy();
|
||||
t->values.destroy();
|
||||
}
|
||||
|
||||
int RefMap::findIdx(unsigned key) {
|
||||
for (unsigned i = 0; i < keys.getLength(); ++i) {
|
||||
if ((uintptr_t)keys.get(i) == key)
|
||||
return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
void RefMap::print(RefMap *t) {
|
||||
DMESG("RefMap %p r=%d size=%d", t, t->refcnt, t->keys.getLength());
|
||||
}
|
||||
|
||||
#ifdef PXT_MEMLEAK_DEBUG
|
||||
std::set<TValue> allptrs;
|
||||
void debugMemLeaks() {
|
||||
DMESG("LIVE POINTERS:");
|
||||
for (std::set<TValue>::iterator itr = allptrs.begin(); itr != allptrs.end(); itr++) {
|
||||
anyPrint(*itr);
|
||||
}
|
||||
DMESG("LIVE POINTERS END.");
|
||||
dumpDmesg();
|
||||
}
|
||||
#else
|
||||
void debugMemLeaks() {}
|
||||
#endif
|
||||
|
||||
void error(PXT_ERROR code, int subcode) {
|
||||
DMESG("Error: %d [%d]", code, subcode);
|
||||
target_panic(42);
|
||||
}
|
||||
|
||||
uint16_t *bytecode;
|
||||
TValue *globals;
|
||||
|
||||
unsigned *allocate(ramint_t sz) {
|
||||
unsigned *arr = new unsigned[sz];
|
||||
memset(arr, 0, sz * sizeof(unsigned));
|
||||
return arr;
|
||||
}
|
||||
|
||||
void checkStr(bool cond, const char *msg) {
|
||||
if (!cond) {
|
||||
while (true) {
|
||||
// uBit.display.scroll(msg, 100);
|
||||
// uBit.sleep(100);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int templateHash() {
|
||||
return ((int *)bytecode)[4];
|
||||
}
|
||||
|
||||
int programHash() {
|
||||
return ((int *)bytecode)[6];
|
||||
}
|
||||
|
||||
int getNumGlobals() {
|
||||
return bytecode[16];
|
||||
}
|
||||
|
||||
#ifndef X86_64
|
||||
void exec_binary(unsigned *pc) {
|
||||
// XXX re-enable once the calibration code is fixed and [editor/embedded.ts]
|
||||
// properly prepends a call to [internal_main].
|
||||
// ::touch_develop::internal_main();
|
||||
|
||||
// unique group for radio based on source hash
|
||||
// ::touch_develop::micro_bit::radioDefaultGroup = programHash();
|
||||
|
||||
unsigned ver = *pc++;
|
||||
checkStr(ver == 0x4209, ":( Bad runtime version");
|
||||
|
||||
bytecode = *((uint16_t **)pc++); // the actual bytecode is here
|
||||
globals = (TValue *)allocate(getNumGlobals());
|
||||
|
||||
// can be any valid address, best in RAM for speed
|
||||
globals[0] = (TValue)&globals;
|
||||
|
||||
// just compare the first word
|
||||
// TODO
|
||||
checkStr(((uint32_t *)bytecode)[0] == 0x923B8E70 && (unsigned)templateHash() == *pc,
|
||||
":( Failed partial flash");
|
||||
|
||||
uintptr_t startptr = (uintptr_t)bytecode;
|
||||
|
||||
startptr += 48; // header
|
||||
startptr |= 1; // Thumb state
|
||||
|
||||
initRuntime();
|
||||
|
||||
((unsigned (*)())startptr)();
|
||||
|
||||
#ifdef PXT_MEMLEAK_DEBUG
|
||||
pxt::debugMemLeaks();
|
||||
#endif
|
||||
|
||||
pxt::releaseFiber();
|
||||
}
|
||||
|
||||
void start() {
|
||||
exec_binary((unsigned *)functionsAndBytecode);
|
||||
}
|
||||
#endif
|
||||
|
||||
} // namespace pxt
|
||||
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"name": "core",
|
||||
"description": "The microbit core library",
|
||||
"installedVersion": "tsmdvf",
|
||||
"additionalFilePath": "../../node_modules/pxt-common-packages/libs/base",
|
||||
"files": [
|
||||
"README.md",
|
||||
"pxt.cpp",
|
||||
@@ -105,4 +105,4 @@
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,713 +0,0 @@
|
||||
#ifndef __PXTBASE_H
|
||||
#define __PXTBASE_H
|
||||
|
||||
//#define PXT_MEMLEAK_DEBUG 1
|
||||
|
||||
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
||||
#pragma GCC diagnostic ignored "-Wformat"
|
||||
#pragma GCC diagnostic ignored "-Warray-bounds"
|
||||
|
||||
// helpful define to handle C++ differences in package
|
||||
#define PXT_MICROBIT_TAGGED_INT 1
|
||||
|
||||
// cross version compatible way of access data field
|
||||
#ifndef PXT_BUFFER_DATA
|
||||
#define PXT_BUFFER_DATA(buffer) buffer->data
|
||||
#endif
|
||||
|
||||
#ifndef PXT_CREATE_BUFFER
|
||||
#define PXT_CREATE_BUFFER(data, len) pxt::mkBuffer(data, len)
|
||||
#endif
|
||||
|
||||
// needed for gcc6; not sure why
|
||||
#undef min
|
||||
#undef max
|
||||
|
||||
#define NOLOG(...) \
|
||||
do { \
|
||||
} while (0)
|
||||
|
||||
#define MEMDBG_ENABLED 0
|
||||
#define MEMDBG NOLOG
|
||||
|
||||
#include "pxtconfig.h"
|
||||
|
||||
#define intcheck(...) check(__VA_ARGS__)
|
||||
//#define intcheck(...) do {} while (0)
|
||||
|
||||
#include <string.h>
|
||||
#include <stdint.h>
|
||||
#include <math.h>
|
||||
|
||||
#include <new>
|
||||
|
||||
#ifdef PXT_MEMLEAK_DEBUG
|
||||
#include <set>
|
||||
#endif
|
||||
|
||||
#include "pxtcore.h"
|
||||
|
||||
#ifndef PXT_VTABLE_SHIFT
|
||||
#define PXT_VTABLE_SHIFT 2
|
||||
#endif
|
||||
|
||||
#define CONCAT_1(a, b) a##b
|
||||
#define CONCAT_0(a, b) CONCAT_1(a, b)
|
||||
#define STATIC_ASSERT(e) enum { CONCAT_0(_static_assert_, __LINE__) = 1 / ((e) ? 1 : 0) };
|
||||
|
||||
#ifndef ramint_t
|
||||
// this type limits size of arrays
|
||||
#ifdef __linux__
|
||||
#define ramint_t uint32_t
|
||||
#else
|
||||
#define ramint_t uint16_t
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if 0
|
||||
inline void *operator new(size_t, void *p) {
|
||||
return p;
|
||||
}
|
||||
inline void *operator new[](size_t, void *p) {
|
||||
return p;
|
||||
}
|
||||
#endif
|
||||
|
||||
namespace pxt {
|
||||
|
||||
template <typename T> inline const T &max(const T &a, const T &b) {
|
||||
if (a < b)
|
||||
return b;
|
||||
return a;
|
||||
}
|
||||
|
||||
template <typename T> inline const T &min(const T &a, const T &b) {
|
||||
if (a < b)
|
||||
return a;
|
||||
return b;
|
||||
}
|
||||
|
||||
template <typename T> inline void swap(T &a, T &b) {
|
||||
T tmp = a;
|
||||
a = b;
|
||||
b = tmp;
|
||||
}
|
||||
|
||||
//
|
||||
// Tagged values (assume 4 bytes for now, Cortex-M0)
|
||||
//
|
||||
struct TValueStruct {};
|
||||
typedef TValueStruct *TValue;
|
||||
|
||||
typedef TValue TNumber;
|
||||
typedef TValue Action;
|
||||
typedef TValue ImageLiteral;
|
||||
|
||||
// To be implemented by the target
|
||||
extern "C" void target_panic(int error_code);
|
||||
extern "C" void target_reset();
|
||||
void sleep_ms(unsigned ms);
|
||||
void sleep_us(uint64_t us);
|
||||
void releaseFiber();
|
||||
int current_time_ms();
|
||||
void initRuntime();
|
||||
void sendSerial(const char *data, int len);
|
||||
int getSerialNumber();
|
||||
void registerWithDal(int id, int event, Action a, int flags = 16); // EVENT_LISTENER_DEFAULT_FLAGS
|
||||
void runInParallel(Action a);
|
||||
void runForever(Action a);
|
||||
void waitForEvent(int id, int event);
|
||||
//%
|
||||
unsigned afterProgramPage();
|
||||
//%
|
||||
void dumpDmesg();
|
||||
|
||||
// also defined DMESG macro
|
||||
// end
|
||||
|
||||
#define TAGGED_SPECIAL(n) (TValue)(void *)((n << 2) | 2)
|
||||
#define TAG_FALSE TAGGED_SPECIAL(2)
|
||||
#define TAG_TRUE TAGGED_SPECIAL(16)
|
||||
#define TAG_UNDEFINED (TValue)0
|
||||
#define TAG_NULL TAGGED_SPECIAL(1)
|
||||
#define TAG_NUMBER(n) (TNumber)(void *)((n << 1) | 1)
|
||||
|
||||
inline bool isTagged(TValue v) {
|
||||
return ((intptr_t)v & 3) || !v;
|
||||
}
|
||||
|
||||
inline bool isNumber(TValue v) {
|
||||
return (intptr_t)v & 1;
|
||||
}
|
||||
|
||||
inline bool isSpecial(TValue v) {
|
||||
return (intptr_t)v & 2;
|
||||
}
|
||||
|
||||
inline bool bothNumbers(TValue a, TValue b) {
|
||||
return (intptr_t)a & (intptr_t)b & 1;
|
||||
}
|
||||
|
||||
inline int numValue(TValue n) {
|
||||
return (intptr_t)n >> 1;
|
||||
}
|
||||
|
||||
#ifdef PXT_BOX_DEBUG
|
||||
inline bool canBeTagged(int) {
|
||||
return false;
|
||||
}
|
||||
#else
|
||||
inline bool canBeTagged(int v) {
|
||||
return (v << 1) >> 1 == v;
|
||||
}
|
||||
#endif
|
||||
|
||||
typedef enum {
|
||||
ERR_INVALID_BINARY_HEADER = 5,
|
||||
ERR_OUT_OF_BOUNDS = 8,
|
||||
ERR_REF_DELETED = 7,
|
||||
ERR_SIZE = 9,
|
||||
} PXT_ERROR;
|
||||
|
||||
extern const unsigned functionsAndBytecode[];
|
||||
extern TValue *globals;
|
||||
extern uint16_t *bytecode;
|
||||
class RefRecord;
|
||||
|
||||
// Utility functions
|
||||
|
||||
//%
|
||||
TValue runAction3(Action a, TValue arg0, TValue arg1, TValue arg2);
|
||||
//%
|
||||
TValue runAction2(Action a, TValue arg0, TValue arg1);
|
||||
//%
|
||||
TValue runAction1(Action a, TValue arg0);
|
||||
//%
|
||||
TValue runAction0(Action a);
|
||||
//%
|
||||
Action mkAction(int reflen, int totallen, int startptr);
|
||||
// allocate [sz] words and clear them
|
||||
//%
|
||||
unsigned *allocate(ramint_t sz);
|
||||
//%
|
||||
int templateHash();
|
||||
//%
|
||||
int programHash();
|
||||
//%
|
||||
unsigned programSize();
|
||||
//%
|
||||
int getNumGlobals();
|
||||
//%
|
||||
RefRecord *mkClassInstance(int vtableOffset);
|
||||
//%
|
||||
void debugMemLeaks();
|
||||
//%
|
||||
void anyPrint(TValue v);
|
||||
|
||||
int getConfig(int key, int defl = -1);
|
||||
|
||||
//%
|
||||
int toInt(TNumber v);
|
||||
//%
|
||||
unsigned toUInt(TNumber v);
|
||||
//%
|
||||
double toDouble(TNumber v);
|
||||
//%
|
||||
float toFloat(TNumber v);
|
||||
//%
|
||||
TNumber fromDouble(double r);
|
||||
//%
|
||||
TNumber fromFloat(float r);
|
||||
|
||||
//%
|
||||
TNumber fromInt(int v);
|
||||
//%
|
||||
TNumber fromUInt(unsigned v);
|
||||
//%
|
||||
TValue fromBool(bool v);
|
||||
//%
|
||||
bool eq_bool(TValue a, TValue b);
|
||||
//%
|
||||
bool eqq_bool(TValue a, TValue b);
|
||||
|
||||
void error(PXT_ERROR code, int subcode = 0);
|
||||
void exec_binary(unsigned *pc);
|
||||
void start();
|
||||
|
||||
struct HandlerBinding {
|
||||
HandlerBinding *next;
|
||||
int source;
|
||||
int value;
|
||||
Action action;
|
||||
};
|
||||
HandlerBinding *findBinding(int source, int value);
|
||||
void setBinding(int source, int value, Action act);
|
||||
|
||||
// The standard calling convention is:
|
||||
// - when a pointer is loaded from a local/global/field etc, and incr()ed
|
||||
// (in other words, its presence on stack counts as a reference)
|
||||
// - after a function call, all pointers are popped off the stack and decr()ed
|
||||
// This does not apply to the RefRecord and st/ld(ref) methods - they unref()
|
||||
// the RefRecord* this.
|
||||
//%
|
||||
TValue incr(TValue e);
|
||||
//%
|
||||
void decr(TValue e);
|
||||
|
||||
class RefObject;
|
||||
|
||||
static inline RefObject *incrRC(RefObject *r) {
|
||||
return (RefObject *)incr((TValue)r);
|
||||
}
|
||||
static inline void decrRC(RefObject *r) {
|
||||
decr((TValue)r);
|
||||
}
|
||||
|
||||
inline void *ptrOfLiteral(int offset) {
|
||||
return &bytecode[offset];
|
||||
}
|
||||
|
||||
// Checks if object is ref-counted, and has a custom PXT vtable in front
|
||||
// TODO
|
||||
inline bool isRefCounted(TValue e) {
|
||||
return !isTagged(e) && (*((unsigned *)e) & 1) == 1;
|
||||
}
|
||||
|
||||
inline void check(int cond, PXT_ERROR code, int subcode = 0) {
|
||||
if (!cond)
|
||||
error(code, subcode);
|
||||
}
|
||||
|
||||
inline void oops() {
|
||||
target_panic(47);
|
||||
}
|
||||
|
||||
class RefObject;
|
||||
#ifdef PXT_MEMLEAK_DEBUG
|
||||
extern std::set<TValue> allptrs;
|
||||
#endif
|
||||
|
||||
typedef void (*RefObjectMethod)(RefObject *self);
|
||||
typedef void *PVoid;
|
||||
typedef void **PPVoid;
|
||||
|
||||
typedef void *Object_;
|
||||
|
||||
const PPVoid RefMapMarker = (PPVoid)(void *)43;
|
||||
|
||||
struct VTable {
|
||||
uint16_t numbytes; // in the entire object, including the vtable pointer
|
||||
uint16_t userdata;
|
||||
PVoid *ifaceTable;
|
||||
PVoid methods[2]; // we only use up to two methods here; pxt will generate more
|
||||
// refmask sits at &methods[nummethods]
|
||||
};
|
||||
|
||||
const int vtableShift = PXT_VTABLE_SHIFT;
|
||||
|
||||
// A base abstract class for ref-counted objects.
|
||||
class RefObject {
|
||||
public:
|
||||
uint16_t refcnt;
|
||||
uint16_t vtable;
|
||||
|
||||
RefObject(uint16_t vt) {
|
||||
refcnt = 3;
|
||||
vtable = vt;
|
||||
#ifdef PXT_MEMLEAK_DEBUG
|
||||
allptrs.insert((TValue)this);
|
||||
#endif
|
||||
}
|
||||
|
||||
void destroyVT();
|
||||
void printVT();
|
||||
|
||||
// Call to disable pointer tracking on the current instance (in destructor or some other hack)
|
||||
inline void untrack() {
|
||||
#ifdef PXT_MEMLEAK_DEBUG
|
||||
allptrs.erase((TValue)this);
|
||||
#endif
|
||||
}
|
||||
|
||||
inline bool isReadOnly() { return refcnt == 0xffff; }
|
||||
|
||||
// Increment/decrement the ref-count. Decrementing to zero deletes the current object.
|
||||
inline void ref() {
|
||||
if (isReadOnly())
|
||||
return;
|
||||
check(refcnt > 1, ERR_REF_DELETED);
|
||||
// DMESG("INCR "); this->print();
|
||||
refcnt += 2;
|
||||
}
|
||||
|
||||
inline void unref() {
|
||||
if (isReadOnly())
|
||||
return;
|
||||
check(refcnt > 1, ERR_REF_DELETED);
|
||||
check((refcnt & 1), ERR_REF_DELETED);
|
||||
// DMESG("DECR "); this->print();
|
||||
refcnt -= 2;
|
||||
if (refcnt == 1) {
|
||||
untrack();
|
||||
destroyVT();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
class Segment {
|
||||
private:
|
||||
TValue *data;
|
||||
ramint_t length;
|
||||
ramint_t size;
|
||||
|
||||
// this just gives max value of ramint_t
|
||||
static constexpr ramint_t MaxSize = (((1U << (8 * sizeof(ramint_t) - 1)) - 1) << 1) + 1;
|
||||
static constexpr TValue DefaultValue = TAG_UNDEFINED;
|
||||
|
||||
static ramint_t growthFactor(ramint_t size);
|
||||
void growByMin(ramint_t minSize);
|
||||
void growBy(ramint_t newSize);
|
||||
void ensure(ramint_t newSize);
|
||||
|
||||
public:
|
||||
Segment() : data(nullptr), length(0), size(0){};
|
||||
|
||||
TValue get(unsigned i);
|
||||
void set(unsigned i, TValue value);
|
||||
void setRef(unsigned i, TValue value);
|
||||
|
||||
unsigned getLength() { return length; };
|
||||
void setLength(unsigned newLength);
|
||||
void resize(unsigned newLength) { setLength(newLength); }
|
||||
|
||||
void push(TValue value);
|
||||
TValue pop();
|
||||
|
||||
TValue remove(unsigned i);
|
||||
void insert(unsigned i, TValue value);
|
||||
|
||||
bool isValidIndex(unsigned i);
|
||||
|
||||
void destroy();
|
||||
|
||||
void print();
|
||||
};
|
||||
|
||||
// A ref-counted collection of either primitive or ref-counted objects (String, Image,
|
||||
// user-defined record, another collection)
|
||||
class RefCollection : public RefObject {
|
||||
private:
|
||||
Segment head;
|
||||
|
||||
public:
|
||||
RefCollection();
|
||||
|
||||
static void destroy(RefCollection *coll);
|
||||
static void print(RefCollection *coll);
|
||||
|
||||
unsigned length() { return head.getLength(); }
|
||||
void setLength(unsigned newLength) { head.setLength(newLength); }
|
||||
|
||||
void push(TValue x);
|
||||
TValue pop();
|
||||
TValue getAt(int i);
|
||||
void setAt(int i, TValue x);
|
||||
// removes the element at index i and shifts the other elements left
|
||||
TValue removeAt(int i);
|
||||
// inserts the element at index i and moves the other elements right.
|
||||
void insertAt(int i, TValue x);
|
||||
|
||||
int indexOf(TValue x, int start);
|
||||
bool removeElement(TValue x);
|
||||
};
|
||||
|
||||
class RefMap : public RefObject {
|
||||
public:
|
||||
Segment keys;
|
||||
Segment values;
|
||||
|
||||
RefMap();
|
||||
static void destroy(RefMap *map);
|
||||
static void print(RefMap *map);
|
||||
int findIdx(unsigned key);
|
||||
};
|
||||
|
||||
// A ref-counted, user-defined JS object.
|
||||
class RefRecord : public RefObject {
|
||||
public:
|
||||
// The object is allocated, so that there is space at the end for the fields.
|
||||
TValue fields[];
|
||||
|
||||
RefRecord(uint16_t v) : RefObject(v) {}
|
||||
|
||||
TValue ld(int idx);
|
||||
TValue ldref(int idx);
|
||||
void st(int idx, TValue v);
|
||||
void stref(int idx, TValue v);
|
||||
};
|
||||
|
||||
//%
|
||||
VTable *getVTable(RefObject *r);
|
||||
|
||||
// these are needed when constructing vtables for user-defined classes
|
||||
//%
|
||||
void RefRecord_destroy(RefRecord *r);
|
||||
//%
|
||||
void RefRecord_print(RefRecord *r);
|
||||
|
||||
class RefAction;
|
||||
typedef TValue (*ActionCB)(TValue *captured, TValue arg0, TValue arg1, TValue arg2);
|
||||
|
||||
// Ref-counted function pointer.
|
||||
class RefAction : public RefObject {
|
||||
public:
|
||||
// This is the same as for RefRecord.
|
||||
uint8_t len;
|
||||
uint8_t reflen;
|
||||
ActionCB func; // The function pointer
|
||||
// fields[] contain captured locals
|
||||
TValue fields[];
|
||||
|
||||
static void destroy(RefAction *act);
|
||||
static void print(RefAction *act);
|
||||
|
||||
RefAction();
|
||||
|
||||
inline void stCore(int idx, TValue v) {
|
||||
// DMESG("ST [%d] = %d ", idx, v); this->print();
|
||||
intcheck(0 <= idx && idx < len, ERR_OUT_OF_BOUNDS, 10);
|
||||
intcheck(fields[idx] == 0, ERR_OUT_OF_BOUNDS, 11); // only one assignment permitted
|
||||
fields[idx] = v;
|
||||
}
|
||||
|
||||
inline TValue runCore(TValue arg0, TValue arg1,
|
||||
TValue arg2) // internal; use runAction*() functions
|
||||
{
|
||||
this->ref();
|
||||
TValue r = this->func(&this->fields[0], arg0, arg1, arg2);
|
||||
this->unref();
|
||||
return r;
|
||||
}
|
||||
};
|
||||
|
||||
// These two are used to represent locals written from inside inline functions
|
||||
class RefLocal : public RefObject {
|
||||
public:
|
||||
TValue v;
|
||||
static void destroy(RefLocal *l);
|
||||
static void print(RefLocal *l);
|
||||
RefLocal();
|
||||
};
|
||||
|
||||
class RefRefLocal : public RefObject {
|
||||
public:
|
||||
TValue v;
|
||||
static void destroy(RefRefLocal *l);
|
||||
static void print(RefRefLocal *l);
|
||||
RefRefLocal();
|
||||
};
|
||||
|
||||
typedef int color;
|
||||
|
||||
// note: this is hardcoded in PXT (hexfile.ts)
|
||||
|
||||
#define PXT_REF_TAG_STRING 1
|
||||
#define PXT_REF_TAG_BUFFER 2
|
||||
#define PXT_REF_TAG_IMAGE 3
|
||||
#define PXT_REF_TAG_NUMBER 32
|
||||
#define PXT_REF_TAG_ACTION 33
|
||||
|
||||
class BoxedNumber : public RefObject {
|
||||
public:
|
||||
double num;
|
||||
BoxedNumber() : RefObject(PXT_REF_TAG_NUMBER) {}
|
||||
} __attribute__((packed));
|
||||
|
||||
class BoxedString : public RefObject {
|
||||
public:
|
||||
uint16_t length;
|
||||
char data[0];
|
||||
BoxedString() : RefObject(PXT_REF_TAG_STRING) {}
|
||||
};
|
||||
|
||||
class BoxedBuffer : public RefObject {
|
||||
public:
|
||||
// data needs to be word-aligned, so we use 32 bits for length
|
||||
int length;
|
||||
uint8_t data[0];
|
||||
BoxedBuffer() : RefObject(PXT_REF_TAG_BUFFER) {}
|
||||
};
|
||||
|
||||
|
||||
// the first byte of data indicates the format - currently 0xE1 or 0xE4 to 1 or 4 bit bitmaps
|
||||
// second byte indicates width in pixels
|
||||
// third byte indicates the height (which should also match the size of the buffer)
|
||||
// just like ordinary buffers, these can be layed out in flash
|
||||
class RefImage : public RefObject {
|
||||
uintptr_t _buffer;
|
||||
uint8_t _data[0];
|
||||
|
||||
public:
|
||||
RefImage(BoxedBuffer *buf);
|
||||
RefImage(uint32_t sz);
|
||||
|
||||
bool hasBuffer() { return !(_buffer & 1); }
|
||||
BoxedBuffer *buffer() { return hasBuffer() ? (BoxedBuffer *)_buffer : NULL; }
|
||||
void setBuffer(BoxedBuffer *b);
|
||||
bool isDirty() { return (_buffer & 3) == 3; }
|
||||
void clearDirty() { if (isDirty()) _buffer &= ~2; }
|
||||
|
||||
uint8_t *data() { return hasBuffer() ? buffer()->data : _data; }
|
||||
int length() { return hasBuffer() ? buffer()->length : (_buffer >> 2); }
|
||||
int pixLength() { return length() - 4; }
|
||||
|
||||
int height();
|
||||
int width();
|
||||
int byteHeight();
|
||||
int wordHeight();
|
||||
int bpp();
|
||||
|
||||
bool hasPadding() { return (height() & 0x1f) != 0; }
|
||||
|
||||
uint8_t *pix() { return data() + 4; }
|
||||
uint8_t *pix(int x, int y);
|
||||
uint8_t fillMask(color c);
|
||||
bool inRange(int x, int y);
|
||||
void clamp(int *x, int *y);
|
||||
void makeWritable();
|
||||
|
||||
static void destroy(RefImage *t);
|
||||
static void print(RefImage *t);
|
||||
};
|
||||
|
||||
RefImage *mkImage(int w, int h, int bpp);
|
||||
|
||||
|
||||
typedef BoxedBuffer *Buffer;
|
||||
typedef BoxedString *String;
|
||||
typedef RefImage *Image_;
|
||||
|
||||
// keep in sync with github/pxt/pxtsim/libgeneric.ts
|
||||
enum class NumberFormat {
|
||||
Int8LE = 1,
|
||||
UInt8LE,
|
||||
Int16LE,
|
||||
UInt16LE,
|
||||
Int32LE,
|
||||
Int8BE,
|
||||
UInt8BE,
|
||||
Int16BE,
|
||||
UInt16BE,
|
||||
Int32BE,
|
||||
|
||||
UInt32LE,
|
||||
UInt32BE,
|
||||
Float32LE,
|
||||
Float64LE,
|
||||
Float32BE,
|
||||
Float64BE,
|
||||
};
|
||||
|
||||
// data can be NULL in both cases
|
||||
String mkString(const char *data, int len = -1);
|
||||
Buffer mkBuffer(const uint8_t *data, int len);
|
||||
|
||||
TNumber getNumberCore(uint8_t *buf, int size, NumberFormat format);
|
||||
void setNumberCore(uint8_t *buf, int size, NumberFormat format, TNumber value);
|
||||
|
||||
TNumber mkNaN();
|
||||
|
||||
void seedRandom(unsigned seed);
|
||||
// max is inclusive
|
||||
unsigned getRandom(unsigned max);
|
||||
|
||||
extern const VTable string_vt;
|
||||
extern const VTable image_vt;
|
||||
extern const VTable buffer_vt;
|
||||
extern const VTable number_vt;
|
||||
extern const VTable RefAction_vtable;
|
||||
|
||||
enum class ValType {
|
||||
Undefined,
|
||||
Boolean,
|
||||
Number,
|
||||
String,
|
||||
Object,
|
||||
Function,
|
||||
};
|
||||
|
||||
ValType valType(TValue v);
|
||||
} // namespace pxt
|
||||
|
||||
#define PXT_DEF_STRING(name, val) \
|
||||
static const char name[] __attribute__((aligned(4))) = "\xff\xff\x01\x00" val;
|
||||
|
||||
using namespace pxt;
|
||||
|
||||
namespace pins {
|
||||
Buffer createBuffer(int size);
|
||||
}
|
||||
|
||||
namespace String_ {
|
||||
int compare(String s, String that);
|
||||
}
|
||||
|
||||
// The ARM Thumb generator in the JavaScript code is parsing
|
||||
// the hex file and looks for the magic numbers as present here.
|
||||
//
|
||||
// Then it fetches function pointer addresses from there.
|
||||
//
|
||||
// The vtable pointers are there, so that the ::emptyData for various types
|
||||
// can be patched with the right vtable.
|
||||
//
|
||||
#define PXT_SHIMS_BEGIN \
|
||||
namespace pxt { \
|
||||
const unsigned functionsAndBytecode[] \
|
||||
__attribute__((aligned(0x20))) = {0x08010801, 0x42424242, 0x08010801, 0x8de9d83e,
|
||||
|
||||
#define PXT_SHIMS_END \
|
||||
} \
|
||||
; \
|
||||
}
|
||||
|
||||
#ifndef X86_64
|
||||
#pragma GCC diagnostic ignored "-Wpmf-conversions"
|
||||
#endif
|
||||
|
||||
#define PXT_VTABLE_TO_INT(vt) ((uintptr_t)(vt) >> vtableShift)
|
||||
#define PXT_VTABLE_BEGIN(classname, flags, iface) \
|
||||
const VTable classname##_vtable __attribute__((aligned(1 << vtableShift))) = { \
|
||||
sizeof(classname), flags, iface, {(void *)&classname::destroy, (void *)&classname::print,
|
||||
|
||||
#define PXT_VTABLE_END \
|
||||
} \
|
||||
} \
|
||||
;
|
||||
|
||||
#define PXT_VTABLE_INIT(classname) RefObject(PXT_VTABLE_TO_INT(&classname##_vtable))
|
||||
|
||||
#define PXT_VTABLE_CTOR(classname) \
|
||||
PXT_VTABLE_BEGIN(classname, 0, 0) \
|
||||
PXT_VTABLE_END classname::classname() : PXT_VTABLE_INIT(classname)
|
||||
|
||||
#define PXT_MAIN \
|
||||
int main() { \
|
||||
pxt::start(); \
|
||||
return 0; \
|
||||
}
|
||||
|
||||
#define PXT_FNPTR(x) (unsigned)(void *)(x)
|
||||
|
||||
#define PXT_ABI(...)
|
||||
|
||||
#define JOIN(a, b) a##b
|
||||
/// Defines getClassName() function to fetch the singleton
|
||||
#define SINGLETON(ClassName) \
|
||||
static ClassName *JOIN(inst, ClassName); \
|
||||
ClassName *JOIN(get, ClassName)() { \
|
||||
if (!JOIN(inst, ClassName)) \
|
||||
JOIN(inst, ClassName) = new ClassName(); \
|
||||
return JOIN(inst, ClassName); \
|
||||
}
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user