bool Lexer::skipComments()
{
// We need to ensure that we have enough characters in the buffer.
switch (buffer_size()) {
case 0:
buffer_put(m_input->get());
case 1:
buffer_put(m_input->get());
case 2:
buffer_put(m_input->get());
case 3:
buffer_put(m_input->get());
}
// We have a comment iff it begins with '<!--' sequence.
if (!(buffer_at(0) == '<' &&
buffer_at(1) == '!' &&
buffer_at(2) == '-' &&
buffer_at(3) == '-'))
{
return false;
}
buffer_pop();
buffer_pop();
buffer_pop();
buffer_pop();
for (;;) {
// TODO: Handle unclosed comments.
// As above, we enusre that we have enough characters available.
switch (buffer_size()) {
case 0:
buffer_put(m_input->get());
case 1:
buffer_put(m_input->get());
case 2:
buffer_put(m_input->get());
}
// The comment ends only with the '-->' sequence.
if (buffer_at(0) == '-' &&
buffer_at(1) == '-' &&
buffer_at(2) == '>')
{
buffer_pop();
buffer_pop();
buffer_pop();
break;
}
buffer_pop();
}
return true;
}
static int luastream_copy (lua_State *L)
{
lua_Stream *self, *other;
int index = 1;
size_t pos, total, size;
self = (lua_Stream *)luaL_checkudata(L, index, LUA_STREAM);
luaL_check(self->buf, "%s (released) #1", LUA_STREAM);
if (lua_isnumber(L, index))
pos = lua_tonumber(L, ++index);
else
pos = buffer_tell(&self->buf);
other = (lua_Stream *)luaL_checkudata(L, ++index, LUA_STREAM);
luaL_check(pos <= buffer_tell(&self->buf), "out of range #2");
luaL_check(other->buf, "%s (released) #%d", LUA_STREAM, index);
total = buffer_tell(&other->buf);
size = luaL_optint(L, ++index, total > other->pos ? total - other->pos : 0);
luaL_check(other->pos + size <= total, "size overflow #%d", index);
if (size)
buffer_insert(&self->buf, pos, buffer_at(&other->buf, other->pos), size);
lua_pushnumber(L, pos);
lua_pushnumber(L, pos + size);
return 2;
}
void
DelayNode::run(ProcessContext& context)
{
Buffer* const delay_buf = _delay_port->buffer(0).get();
Buffer* const in_buf = _in_port->buffer(0).get();
Buffer* const out_buf = _out_port->buffer(0).get();
DelayNode* plugin_data = this;
const float* const in = in_buf->samples();
float* const out = out_buf->samples();
const float delay_time = delay_buf->samples()[0];
const uint32_t buffer_mask = plugin_data->_buffer_mask;
const SampleRate sample_rate = context.engine().driver()->sample_rate();
float delay_samples = plugin_data->_delay_samples;
int64_t write_phase = plugin_data->_write_phase;
const uint32_t sample_count = context.nframes();
if (write_phase == 0) {
_last_delay_time = delay_time;
_delay_samples = delay_samples = CALC_DELAY(delay_time);
}
if (delay_time == _last_delay_time) {
const int64_t idelay_samples = (int64_t)delay_samples;
const float frac = delay_samples - idelay_samples;
for (uint32_t i = 0; i < sample_count; i++) {
int64_t read_phase = write_phase - (int64_t)delay_samples;
const float read = cube_interp(frac,
buffer_at(read_phase - 1),
buffer_at(read_phase),
buffer_at(read_phase + 1),
buffer_at(read_phase + 2));
buffer_at(write_phase++) = in[i];
out[i] = read;
}
} else {
const float next_delay_samples = CALC_DELAY(delay_time);
const float delay_samples_slope = (next_delay_samples - delay_samples) / sample_count;
for (uint32_t i = 0; i < sample_count; i++) {
delay_samples += delay_samples_slope;
write_phase++;
const int64_t read_phase = write_phase - (int64_t)delay_samples;
const int64_t idelay_samples = (int64_t)delay_samples;
const float frac = delay_samples - idelay_samples;
const float read = cube_interp(frac,
buffer_at(read_phase - 1),
buffer_at(read_phase),
buffer_at(read_phase + 1),
buffer_at(read_phase + 2));
buffer_at(write_phase) = in[i];
out[i] = read;
}
_last_delay_time = delay_time;
_delay_samples = delay_samples;
}
_write_phase = write_phase;
}
void
DelayNode::process(ProcessContext& context)
{
AudioBuffer* const delay_buf = (AudioBuffer*)_delay_port->buffer(0).get();
AudioBuffer* const in_buf = (AudioBuffer*)_in_port->buffer(0).get();
AudioBuffer* const out_buf = (AudioBuffer*)_out_port->buffer(0).get();
NodeImpl::pre_process(context);
DelayNode* plugin_data = this;
const float* const in = in_buf->data();
float* const out = out_buf->data();
const float delay_time = delay_buf->data()[0];
const uint32_t buffer_mask = plugin_data->_buffer_mask;
const unsigned int sample_rate = plugin_data->_srate;
float delay_samples = plugin_data->_delay_samples;
long write_phase = plugin_data->_write_phase;
const uint32_t sample_count = context.nframes();
if (write_phase == 0) {
_last_delay_time = delay_time;
_delay_samples = delay_samples = CALC_DELAY(delay_time);
}
if (delay_time == _last_delay_time) {
const long idelay_samples = (long)delay_samples;
const float frac = delay_samples - idelay_samples;
for (uint32_t i = 0; i < sample_count; i++) {
long read_phase = write_phase - (long)delay_samples;
const float read = cube_interp(frac,
buffer_at(read_phase - 1),
buffer_at(read_phase),
buffer_at(read_phase + 1),
buffer_at(read_phase + 2));
buffer_at(write_phase++) = in[i];
out[i] = read;
}
} else {
const float next_delay_samples = CALC_DELAY(delay_time);
const float delay_samples_slope = (next_delay_samples - delay_samples) / sample_count;
for (uint32_t i = 0; i < sample_count; i++) {
delay_samples += delay_samples_slope;
write_phase++;
const long read_phase = write_phase - (long)delay_samples;
const long idelay_samples = (long)delay_samples;
const float frac = delay_samples - idelay_samples;
const float read = cube_interp(frac,
buffer_at(read_phase - 1),
buffer_at(read_phase),
buffer_at(read_phase + 1),
buffer_at(read_phase + 2));
buffer_at(write_phase) = in[i];
out[i] = read;
}
_last_delay_time = delay_time;
_delay_samples = delay_samples;
}
_write_phase = write_phase;
NodeImpl::post_process(context);
}
int16_t buffer_int16_at(struct buffer* buffer, uint16_t pos) {
return *((int16_t*) buffer_at(buffer, pos));
}
static const char *special_commands(void *userdata, char letter, float value,
const char *remaining) {
GCodeMachineControl_t *state = (GCodeMachineControl_t*)userdata;
const int code = (int)value;
if (letter == 'M') {
int pin = -1;
int aux_bit = -1;
switch (code) {
case 0: set_gpio(ESTOP_SW_GPIO); break;
case 3:
case 4:
for (;;) {
const char* after_pair = gcodep_parse_pair(remaining, &letter, &value,
state->msg_stream);
if (after_pair == NULL) break;
else if (letter == 'S') state->spindle_rpm = round2int(value);
else break;
remaining = after_pair;
}
if (state->spindle_rpm) {
state->aux_bits |= AUX_BIT_SPINDLE_ON;
if (code == 3) state->aux_bits &= ~AUX_BIT_SPINDLE_DIR;
else state->aux_bits |= AUX_BIT_SPINDLE_DIR;
}
break;
case 5: state->aux_bits &= ~(AUX_BIT_SPINDLE_ON | AUX_BIT_SPINDLE_DIR); break;
case 7: state->aux_bits |= AUX_BIT_MIST; break;
case 8: state->aux_bits |= AUX_BIT_FLOOD; break;
case 9: state->aux_bits &= ~(AUX_BIT_MIST | AUX_BIT_FLOOD); break;
case 10: state->aux_bits |= AUX_BIT_VACUUM; break;
case 11: state->aux_bits &= ~AUX_BIT_VACUUM; break;
case 42:
case 62:
case 63:
case 64:
case 65:
for (;;) {
const char* after_pair = gcodep_parse_pair(remaining, &letter, &value,
state->msg_stream);
if (after_pair == NULL) break;
if (letter == 'P') pin = round2int(value);
else if (letter == 'S' && code == 42) aux_bit = round2int(value);
else break;
remaining = after_pair;
}
if (code == 62 || code == 64)
aux_bit = 1;
else if (code == 63 || code == 65)
aux_bit = 0;
if (pin >= 0 && pin <= MAX_AUX_PIN) {
if (aux_bit >= 0 && aux_bit <= 1) {
if (aux_bit) state->aux_bits |= 1 << pin;
else state->aux_bits &= ~(1 << pin);
} else if (code == 42 && state->msg_stream) { // Just read operation.
mprintf(state, "%d\n", (state->aux_bits >> pin) & 1);
}
}
break;
case 80: set_gpio(MACHINE_PWR_GPIO); break;
case 81: clr_gpio(MACHINE_PWR_GPIO); break;
case 105: mprintf(state, "T-300\n"); break; // no temp yet.
case 114:
if (buffer_available(&state->buffer)) {
struct AxisTarget *current = buffer_at(&state->buffer, 0);
const int *mpos = current->position_steps;
const float x = 1.0f * mpos[AXIS_X] / state->cfg.steps_per_mm[AXIS_X];
const float y = 1.0f * mpos[AXIS_Y] / state->cfg.steps_per_mm[AXIS_Y];
const float z = 1.0f * mpos[AXIS_Z] / state->cfg.steps_per_mm[AXIS_Z];
const float e = 1.0f * mpos[AXIS_E] / state->cfg.steps_per_mm[AXIS_E];
const float *origin = state->coordinate_display_origin;
mprintf(state, "X:%.3f Y:%.3f Z:%.3f E:%.3f",
x - origin[AXIS_X], y - origin[AXIS_Y], z - origin[AXIS_Z],
e - origin[AXIS_E]);
mprintf(state, " [ABS. MACHINE CUBE X:%.3f Y:%.3f Z:%.3f]", x, y, z);
switch (state->homing_state) {
case HOMING_STATE_NEVER_HOMED:
mprintf(state, " (Unsure: machine never homed!)\n");
break;
case HOMING_STATE_HOMED_BUT_MOTORS_UNPOWERED:
mprintf(state, " (Lower confidence: motor power off at "
"least once after homing)\n");
break;
case HOMING_STATE_HOMED:
mprintf(state, " (confident: machine was homed)\n");
break;
}
} else {
mprintf(state, "// no current pos\n");
}
break;
case 115: mprintf(state, "%s\n", VERSION_STRING); break;
case 117:
mprintf(state, "// Msg: %s\n", remaining); // TODO: different output ?
remaining = NULL; // consume the full line.
break;
case 119: {
char any_enstops_found = 0;
for (int axis = 0; axis < GCODE_NUM_AXES; ++axis) {
struct EndstopConfig config = state->min_endstop[axis];
if (config.endstop_number) {
int value = get_gpio(get_endstop_gpio_descriptor(config));
mprintf(state, "%c_min:%s ",
tolower(gcodep_axis2letter(axis)),
value == config.trigger_value ? "TRIGGERED" : "open");
any_enstops_found = 1;
}
config = state->max_endstop[axis];
if (config.endstop_number) {
int value = get_gpio(get_endstop_gpio_descriptor(config));
mprintf(state, "%c_max:%s ",
tolower(gcodep_axis2letter(axis)),
value == config.trigger_value ? "TRIGGERED" : "open");
any_enstops_found = 1;
}
}
if (any_enstops_found) {
mprintf(state, "\n");
} else {
mprintf(state, "// This machine has no endstops configured.\n");
}
}
break;
case 999: clr_gpio(ESTOP_SW_GPIO); break;
default:
mprintf(state, "// BeagleG: didn't understand ('%c', %d, '%s')\n",
letter, code, remaining);
remaining = NULL; // In this case, let's just discard remainig block.
break;
}
static int luastream_readf (lua_State *L)
{
lua_Stream *self = (lua_Stream *)luaL_checkudata(L, 1, LUA_STREAM);
size_t len, nb = 0;
const char *f, *e;
f = luaL_checklstring(L, 2, &len);
e = f + len;
luaL_check(self->buf, "%s (released) #1", LUA_STREAM);
for (; f < e; f = getnext(++f, e))
{
luaL_check(self->pos + getsize(f, e) <= buffer_tell(&self->buf), "read '%c' overflow", *f);
switch(*f)
{
case F_SIGNED_BYTE:
{
char n = 0;
buffer_read(&self->buf, self->pos, &n, sizeof(n));
correctbytes(&n, sizeof(n));
lua_pushnumber(L, n);
self->pos += sizeof(n);
break;
}
case F_UNSIGNED_BYTE:
{
unsigned char n = 0;
buffer_read(&self->buf, self->pos, &n, sizeof(n));
correctbytes(&n, sizeof(n));
lua_pushnumber(L, n);
self->pos += sizeof(n);
break;
}
case F_SIGNED_WORD:
{
short n = 0;
buffer_read(&self->buf, self->pos, &n, sizeof(n));
correctbytes(&n, sizeof(n));
lua_pushnumber(L, n);
self->pos += sizeof(n);
break;
}
case F_UNSIGNED_WORD:
{
unsigned short n = 0;
buffer_read(&self->buf, self->pos, &n, sizeof(n));
correctbytes(&n, sizeof(n));
lua_pushnumber(L, n);
self->pos += sizeof(n);
break;
}
case F_SIGNED_DWORD:
{
long n = 0;
buffer_read(&self->buf, self->pos, &n, sizeof(n));
correctbytes(&n, sizeof(n));
lua_pushnumber(L, n);
self->pos += sizeof(n);
break;
}
case F_UNSIGNED_DWORD:
{
unsigned long n = 0;
buffer_read(&self->buf, self->pos, &n, sizeof(n));
correctbytes(&n, sizeof(n));
lua_pushnumber(L, n);
self->pos += sizeof(n);
break;
}
case F_FLOAT:
{
lua_Number n = 0;
buffer_read(&self->buf, self->pos, &n, sizeof(n));
correctbytes(&n, sizeof(n));
lua_pushnumber(L, n);
self->pos += sizeof(n);
break;
}
case F_ZSTRING:
{
const char *s = buffer_at(&self->buf, self->pos);
size_t sz = strlen(s);
lua_pushlstring(L, s, sz);
self->pos += sz + 1;
break;
}
case F_STRING:
{
const char *s = buffer_at(&self->buf, self->pos);
size_t sz = getsize(f, e);
lua_pushlstring(L, s, sz);
self->pos += sz;
break;
}
case F_OBJECT:
{
size_t i;
struct reader_t R;
R.count = 0;
R.pos = self->pos;
self->pos = buffer_readobject(L, buffer_ptr(&self->buf), self->pos, buffer_tell(&self->buf), &R);
for (i = 0; i < R.count; ++i)
luaL_unref(L, LUA_REGISTRYINDEX, R.refs[i].idx);
break;
}
default:
luaL_error(L, "unsupport format '%c'", *(--f));
break;
}
++nb;
}
return nb;
}
static int buffer_writeobject(lua_State *L, buffer_t *buf, int idx, struct writer_t *W)
{
int top = lua_gettop(L);
int type = lua_type(L, idx);
switch(type)
{
case LUA_TNIL:
buffer_writebyte(buf, OP_NIL);
break;
case LUA_TBOOLEAN:
buffer_writebyte(buf, lua_toboolean(L, idx) ? OP_TRUE : OP_FALSE);
break;
case LUA_TNUMBER:
{
lua_Number n = lua_tonumber(L, idx);
if (n == 0)
buffer_writebyte(buf, OP_ZERO);
else if (floor(n) == n)
{
size_t size, pos = buffer_tell(buf);
buffer_writebyte(buf, OP_INT);
size = buffer_writeint(buf, n);
*buffer_at(buf, pos) |= size << 4;
}
else
{
size_t size, pos = buffer_tell(buf);
buffer_writebyte(buf, OP_FLOAT);
size = buffer_writefloat(buf, n);
*buffer_at(buf, pos) |= size << 4;
}
break;
}
case LUA_TSTRING:
{
size_t len;
const char* str = lua_tolstring(L, idx, &len);
size_t size, pos = buffer_tell(buf);
buffer_writebyte(buf, OP_STRING);
size = buffer_writeint(buf, len);
*buffer_at(buf, pos) |= size << 4;
buffer_write(buf, str, len);
break;
}
case LUA_TTABLE:
{
const void *ptr = lua_topointer(L, idx);
size_t i;
for (i = 0; i < W->count; ++i)
{
if (W->refs[i].ptr == ptr)
{
buffer_writebyte(buf, OP_TABLE_REF);
buffer_writebyte(buf, W->refs[i].pos);
goto end;
}
}
luaL_check(W->count < REFS_SIZE, "table refs overflow %d", REFS_SIZE);
W->refs[W->count].ptr = ptr;
W->refs[W->count++].pos = buffer_tell(buf) - W->pos;
buffer_writebyte(buf, OP_TABLE);
lua_pushnil(L);
i = 1;
while (lua_next(L, idx))
{
if (lua_isnumber(L, -2) && lua_tonumber(L, -2) == i++)
{
buffer_writeobject(L, buf, lua_gettop(L), W);
lua_pop(L, 1);
}
else break;
}
buffer_writebyte(buf, OP_TABLE_DELIMITER);
if (lua_gettop(L) > top)
{
do
{
buffer_writeobject(L, buf, lua_gettop(L) - 1, W);
buffer_writeobject(L, buf, lua_gettop(L), W);
lua_pop(L, 1);
}
while (lua_next(L, idx));
}
buffer_writebyte(buf, OP_TABLE_END);
break;
}
default:
lua_settop(L, top);
luaL_error(L, "unexpected type:%s", lua_typename(L, type));
return 0;
}
end:
lua_settop(L, top);
return 1;
}
