path: root/src/lua.c

#ifdef XLUA
/*
  R.Pollak
  Lua Support for sc
  called from sc via "@lua(file,0)" command
  and interface for Lua Triggers

  how to use it see macro.lua or trigger.lua
  At initialization of LUA, init.lua is called, this way global variables could be set.
  Those are then accessible also  when called via @lua cmd or in triggers.
*/

#include <lua.h>                                /* Always include this when calling Lua */
#include <lauxlib.h>                            /* Always include this when calling Lua */
#include <lualib.h>                             /* Prototype for luaL_openlibs(),       */
                                                /* always include this when calling Lua */
#include <curses.h>
#include <ctype.h>
#include <unistd.h>
#include <stdlib.h>
#include <wchar.h>

#include "sc.h"
#include "cmds.h"
#include "trigger.h"
#include "utils/string.h"
#include "main.h"
#include "screen.h"
#include "conf.h"

extern FILE * fdoutput;
extern WINDOW * input_win;

#define LC_NUMBER2(n,v)                     \
    static int l_ ## n(lua_State *L)        \
    {                                       \
        lua_pushnumber(L, v);               \
        return 1;                           \
    }

lua_State *L;

void bail(lua_State *L, char * msg){
    /*
    volatile char *error=lua_tostring(L,-1);
    fprintf(stderr,"%s",error);
    */

    fprintf(stderr,"FATAL ERROR: %s: %s", msg, lua_tostring(L, -1));

    move(0, 0);
    clrtobot();
    wrefresh(stdscr);

    set_term(sstderr);
    move(0, 0);
    clrtobot();
    clearok(stdscr, TRUE);
    mvprintw(10, 0, "*%s*", stderr_buffer);
    stderr_buffer[0]='\0';
    fseek(stderr, 0, SEEK_END);

    refresh();
    getch();

    set_term(sstdout);
    clearok(stdscr, TRUE);
    refresh();
    update(TRUE);
}

static int l_getnum (lua_State *L) {
    int r,c;
    struct ent **pp;
    struct ent *p;
    c = lua_tointeger(L, 1);      /* get argument */
    r = lua_tointeger(L, 2);
    // sc_debug("getnum !!");
    pp = ATBL(tbl,r,c);

    p = *pp;
    if (p == 0) return 0;
    if (p->flags & is_valid) {
        lua_pushnumber(L, p->v);  /* push result */
        return 1;                 /* number of results */
    } else return 0;
}

static int l_setnum (lua_State *L) {
    int r,c;
    double val;
    //struct ent ** pp;
    struct ent *p;
    r = lua_tointeger(L, 1);  /* get argument */
    c = lua_tointeger(L, 2);
    val=lua_tonumber(L,3);
    sc_debug("getnum !!");

    p=lookat(r,c);
    p->v=val;
    p->flags |= is_changed |is_valid;
    p->flags &= ~iscleared;
    modflg++;
    p->cellerror =CELLOK;

    return 0;
}

static int l_setstr (lua_State *L) {
    int r,c;
    char * val;
    //struct ent ** pp;
    struct ent *p;
    r = lua_tointeger(L, 1);  /* get argument */
    c = lua_tointeger(L, 2);
    val=(char *) lua_tostring(L,3);
    //sc_debug("setstr !!");

    p=lookat(r,c);
    label(p,val,-1);

    return 0;
}

static int l_setform (lua_State *L) {
    int r,c;
    char * val;
    //struct ent ** pp;
    //struct ent * p;
    char buf[256];
    r = lua_tointeger(L, 1);  /* get argument */
    c = lua_tointeger(L, 2);
    val = (char *) lua_tostring(L,3);
    //sc_debug("setstr !!");

    sprintf(buf,"LET %s%d=%s",coltoa(c),r,val);
    send_to_interpp(buf);

    return 0;
}

static int l_sc (lua_State *L) {
    char * val;

    val=(char *) lua_tostring(L,1);
    //sc_debug("setstr !!");

    send_to_interpp(val);

    return 0;
}

static int l_colrow2a(lua_State *L) {
    int c, r;
    char buf[16];

    r = lua_tointeger(L, 1);  /* get argument */
    c = lua_tointeger(L, 2);
    sprintf(buf,"%s%d", coltoa(c),r);
    lua_pushstring(L,buf);
    return 1;
}

static int l_colrow(lua_State *L) {
    char buf[16];
    char *val;
    int c, r;
    int ret, len;
    val = (char *) lua_tostring(L,1);
    sc_debug(" %s ", val);
    ret = sscanf(val,"%49[a-za-Z]%d",buf,&r);
    sc_debug("scanf ret %d",ret);
    len=strlen(buf);
    c = (toupper((int)buf[0])) - 'A';
    if (len == 2)               /* has second char */
    c = ((c + 1) * 26) + ((toupper((int)buf[1])) - 'A');
    lua_pushnumber(L,c);
    lua_pushnumber(L,r);
    return 2;
}

char * query(char * initial_msg) {
    char * hline = (char *) malloc(sizeof(char) * BUFFERSIZE);
    hline[0]='\0';

    // curses is not enabled
    if ( atoi(get_conf_value("nocurses"))) {
        if (strlen(initial_msg)) wprintf(L"%s", initial_msg);

        if (fgets(hline, BUFFERSIZE-1, stdin) == NULL)
            hline[0]='\0';

        clean_carrier(hline);
        return hline;
    }

    // curses is enabled
    int loading_o;
    if (loading) {
        loading_o=loading;
        loading=0;
        update(0);
        loading=loading_o;
    }
    curs_set(1);

    // show initial message
    if (strlen(initial_msg)) sc_info(initial_msg);

    // ask for input
    wtimeout(input_win, -1);
    notimeout(input_win, TRUE);
    wmove(input_win, 0, rescol);
    wclrtoeol(input_win);
    wrefresh(input_win);
    int d = wgetch(input_win);

    while (d != OKEY_ENTER && d != OKEY_ESC) {
        if (d == OKEY_BS || d == OKEY_BS2) {
            del_char(hline, strlen(hline) - 1);
        } else {
            sprintf(hline + strlen(hline), "%c", d);
        }

        mvwprintw(input_win, 0, rescol, "%s", hline);
        wclrtoeol(input_win);
        wrefresh(input_win);
        d = wgetch(input_win);
    }
    if (d == OKEY_ESC) hline[0]='\0';

    // go back to spreadsheet
    noecho();
    curs_set(0);
    wtimeout(input_win, TIMEOUT_CURSES);
    wmove(input_win, 0,0);
    wclrtoeol(input_win);
    wmove(input_win, 1,0);
    wclrtoeol(input_win);
    wrefresh(input_win);
    return hline;
}

int l_query (lua_State *L) {
    char * val;
    char * ret;

    val = (char *)  lua_tostring(L,1);

    ret = query(val);
    //sc_debug("return of query:%s.\n", ret);
    if (ret == '\0') {
        free(ret);
        return 0;
    }
    lua_pushstring(L,ret);
    free(ret);
    return 1;
}

LC_NUMBER2(currow,currow)
LC_NUMBER2(curcol,curcol)
LC_NUMBER2(maxcols,maxcols)
LC_NUMBER2(maxrows,maxrows)

static const luaL_reg sclib[] = {
    { "lgetnum", l_getnum },
    { "lsetnum", l_setnum