100 lines
3.1 KiB
C++
100 lines
3.1 KiB
C++
// Copyright 2022 Bradley D. Nelson
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
static char filename[PATH_MAX];
|
|
static char filename2[PATH_MAX];
|
|
|
|
{{bits}}
|
|
{{core}}
|
|
{{interp}}
|
|
{{boot}}
|
|
|
|
// Work around lack of ftruncate
|
|
static cell_t ResizeFile(cell_t fd, cell_t size) {
|
|
struct stat st;
|
|
char buf[256];
|
|
cell_t t = fstat(fd, &st);
|
|
if (t < 0) { return errno; }
|
|
if (size < st.st_size) {
|
|
// TODO: Implement truncation
|
|
return ENOSYS;
|
|
}
|
|
cell_t oldpos = lseek(fd, 0, SEEK_CUR);
|
|
if (oldpos < 0) { return errno; }
|
|
t = lseek(fd, 0, SEEK_END);
|
|
if (t < 0) { return errno; }
|
|
memset(buf, 0, sizeof(buf));
|
|
while (st.st_size < size) {
|
|
cell_t len = sizeof(buf);
|
|
if (size - st.st_size < len) {
|
|
len = size - st.st_size;
|
|
}
|
|
t = write(fd, buf, len);
|
|
if (t != len) {
|
|
return errno;
|
|
}
|
|
st.st_size += t;
|
|
}
|
|
t = lseek(fd, oldpos, SEEK_SET);
|
|
if (t < 0) { return errno; }
|
|
return 0;
|
|
}
|
|
|
|
#ifdef ENABLE_INTERRUPTS_SUPPORT
|
|
struct handle_interrupt_args {
|
|
cell_t xt;
|
|
cell_t arg;
|
|
};
|
|
|
|
static void IRAM_ATTR HandleInterrupt(void *arg) {
|
|
struct handle_interrupt_args *args = (struct handle_interrupt_args *) arg;
|
|
cell_t code[2];
|
|
code[0] = args->xt;
|
|
code[1] = g_sys->YIELD_XT;
|
|
cell_t fstack[INTERRUPT_STACK_CELLS];
|
|
cell_t rstack[INTERRUPT_STACK_CELLS];
|
|
cell_t stack[INTERRUPT_STACK_CELLS];
|
|
stack[0] = args->arg;
|
|
cell_t *rp = rstack;
|
|
*++rp = (cell_t) (fstack + 1);
|
|
*++rp = (cell_t) (stack + 1);
|
|
*++rp = (cell_t) code;
|
|
forth_run(rp);
|
|
}
|
|
|
|
static cell_t EspIntrAlloc(cell_t source, cell_t flags, cell_t xt, cell_t arg, void *ret) {
|
|
// NOTE: Leaks memory.
|
|
struct handle_interrupt_args *args = (struct handle_interrupt_args *) malloc(sizeof(struct handle_interrupt_args));
|
|
args->xt = xt;
|
|
args->arg = arg;
|
|
return esp_intr_alloc(source, flags, HandleInterrupt, args, (intr_handle_t *) ret);
|
|
}
|
|
|
|
static cell_t GpioIsrHandlerAdd(cell_t pin, cell_t xt, cell_t arg) {
|
|
// NOTE: Leaks memory.
|
|
struct handle_interrupt_args *args = (struct handle_interrupt_args *) malloc(sizeof(struct handle_interrupt_args));
|
|
args->xt = xt;
|
|
args->arg = arg;
|
|
return gpio_isr_handler_add((gpio_num_t) pin, HandleInterrupt, args);
|
|
}
|
|
|
|
static cell_t TimerIsrRegister(cell_t group, cell_t timer, cell_t xt, cell_t arg, cell_t flags, void *ret) {
|
|
// NOTE: Leaks memory.
|
|
struct handle_interrupt_args *args = (struct handle_interrupt_args *) malloc(sizeof(struct handle_interrupt_args));
|
|
args->xt = xt;
|
|
args->arg = arg;
|
|
return timer_isr_register((timer_group_t) group, (timer_idx_t) timer, HandleInterrupt, args, flags, (timer_isr_handle_t *) ret);
|
|
}
|
|
#endif
|