sys-pc.cpp

// Support for PCs

#include "c3.h"

#ifdef isPC

enum { SYSTEM=100, FOPEN, FCLOSE, FREAD, FWRITE, FGETS, FLOAD, BLOAD, EDIT_BLK };

#ifdef IS_WINDOWS

    #include <time.h>
    #include <conio.h>
    int qKey() { return _kbhit(); }
    int key() { return _getch(); }
    void ttyInit() {}

#elif (defined IS_LINUX)

#include <time.h>
#include <unistd.h>
#include <termios.h>
static struct termios normT, rawT;
static int isRaw = 0;
void ttyInit() {
    tcgetattr(STDIN_FILENO, &normT);
    cfmakeraw(&rawT);
    isRaw = 0;
}
void ttyModeNorm() {
    if (isRaw) {
        tcsetattr(STDIN_FILENO, TCSANOW, &normT);
        isRaw = 0;
    }
}
void ttyModeRaw() {
    if (!isRaw) {
        tcsetattr(STDIN_FILENO, TCSANOW, &rawT);
        isRaw = 1;
    }
}
int qKey() {
    ttyModeRaw();
    struct timeval tv;
    tv.tv_sec = 0;
    tv.tv_usec = 0;
    fd_set rdfs;
    FD_ZERO(&rdfs);
    FD_SET(STDIN_FILENO, &rdfs);
    select(STDIN_FILENO+1, &rdfs, NULL, NULL, &tv);
    int x = FD_ISSET(STDIN_FILENO, &rdfs);
    ttyModeNorm();
    return x;
}
int key() {
    ttyModeRaw();
    int x = getchar();
    ttyModeNorm();
    return x;
}

#endif // IS_LINUX

void emit(const char c) { fputc(c, output_fp ? (FILE*)output_fp : stdout); }
void zType(const char* s) { fputs(s, output_fp ? (FILE*)output_fp : stdout); }
cell_t sysTime() { return clock(); }
void Store(char *loc, cell_t x) { *(cell_t*)loc = x; }
cell_t Fetch(const char *loc) { return *(cell_t*)loc; }

void getInput() {
    fill(tib, 0, sizeof(tib));
    if ((state == STOP_LOAD) && input_fp) {
        fClose(input_fp);
        input_fp = ipop();
        state = 0;
        return;
    }
    if (input_fp) {
        if (fgets(tib, 190, (FILE*)input_fp) != tib) {
            fClose(input_fp);
            input_fp = ipop();
        }
    }
    if (! input_fp) {
        cell_t tmp = output_fp;
        output_fp = 0;
        zType((state) ? "... > " : " ok\n");
        fgets(tib, sizeof(tib), stdin);
        output_fp = tmp;
    }
}

int tryLoad(const char *fn) {
    cell_t fp = fOpen(fn, "rb");
    if (!fp) { return 0; }
    if (input_fp) { ipush(input_fp); }
    input_fp = fp;
    return 1;
}

char *doUser(char *pc, int ir) {
    cell_t t1, t2, t3;
    switch (ir) {
    case SYSTEM:  system(cpop());
    RCASE FOPEN:  t2=pop(); t1=pop(); push(fOpen((char*)t1, (char*)t2));
    RCASE FCLOSE: fClose(pop());
    RCASE FREAD:  t3=pop(); t2=pop(); t1=pop(); push(fRead((char*)t1, 1, (int)t2, t3));
    RCASE FWRITE: t3=pop(); t2=pop(); t1=pop(); push(fWrite((char*)t1, 1, (int)t2, t3));
    RCASE FGETS:  t3=pop(); t2=pop(); t1=pop(); push(fGets(t3, (char*)t1, (int)t2));
    RCASE FLOAD:  tryLoad(cpop());
    RCASE BLOAD:  tryLoad(getBlockFN((int)pop()));
    RCASE EDIT_BLK: t1=pop(); editBlock(t1);
    return pc; default: return 0;
    }
}

void loadUserWords() {
    parseF("-ML- SYSTEM %d 3 -MLX- inline", SYSTEM);
    parseF("-ML- FOPEN  %d 3 -MLX- inline", FOPEN);
    parseF("-ML- FCLOSE %d 3 -MLX- inline", FCLOSE);
    parseF("-ML- FREAD  %d 3 -MLX- inline", FREAD);
    parseF("-ML- FWRITE %d 3 -MLX- inline", FWRITE);
    parseF("-ML- FGETS  %d 3 -MLX- inline", FGETS);
    parseF("-ML- (LOAD) %d 3 -MLX- inline", FLOAD);
    parseF("-ML- LOAD   %d 3 -MLX- inline", BLOAD);
    parseF("-ML- EDIT   %d 3 -MLX- inline", EDIT_BLK);
    ParseLine(": isPC 1 ;");
    parseF(": BYE %d STATE !  ;", ALL_DONE);
}

int main(int argc, char *argv[]) {
    input_fp = output_fp = 0;
    c3Init();
    ttyInit();

    for (int i=1; i<argc; i++) {
        if ((i==1) && tryLoad(argv[i])) { continue; }
        if (isNum(argv[i])) { reg[i] = pop(); }
        else { reg[i] = (cell_t)argv[i]; }
    }
#ifndef _SYS_LOAD_
    tryLoad(getBlockFN(1));
#endif
    while (state != ALL_DONE) {
        getInput();
        ParseLine(tib);
    }
    return 0;
}

#endif // isPC