source: neercs/trunk/src/interpreter.c @ 4033

/* 
 *  neercs        console-based window manager
 *  Copyright (c) 2009 Jean-Yves Lamoureux <jylam@lnxscene.org>
 *                All Rights Reserved
 *
 *  $Id: help.c 3996 2009-11-22 12:41:45Z jylam $
 *
 *  This program is free software. It comes without any warranty, to
 *  the extent permitted by applicable law. You can redistribute it
 *  and/or modify it under the terms of the Do What The Fuck You Want
 *  To Public License, Version 2, as published by Sam Hocevar. See
 *  http://sam.zoy.org/wtfpl/COPYING for more details.
 */

#include "config.h"

#ifdef USE_PYTHON

#include <Python.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <fcntl.h>
#include <signal.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/time.h>

#include <caca.h>
#include <caca.h>
#include <time.h>
#include <sys/wait.h>
#include <sys/types.h>

#include "neercs.h"

static void add_char(struct screen_list *sl, unsigned int c);
static void del_char(struct screen_list *sl);
static int python_execute(struct screen_list *sl);
static char *getStringFromPyObject(PyObject * p);
static char *getPythonError(void);

static void add_char(struct screen_list *sl, unsigned int c)
{
    /* FIXME handle return values */
    if (!sl->interpreter_props.command)
    {
        sl->interpreter_props.size = 1;
        sl->interpreter_props.x = 0;
        sl->interpreter_props.command = (char *)malloc(2);
        sl->interpreter_props.command[0] = 0;
    }
    else
    {
        sl->interpreter_props.command =
            (char *)realloc(sl->interpreter_props.command,
                            sl->interpreter_props.size + 1);
    }
    memmove(&sl->interpreter_props.command[sl->interpreter_props.x + 1],
            &sl->interpreter_props.command[sl->interpreter_props.x],
            (sl->interpreter_props.size - sl->interpreter_props.x));

    sl->interpreter_props.command[sl->interpreter_props.x] = c;
    sl->interpreter_props.x++;
    sl->interpreter_props.size++;
}

static void del_char(struct screen_list *sl)
{
    if (sl->interpreter_props.x < 1)
        return;
    if (sl->interpreter_props.size > 1)
        sl->interpreter_props.size--;
    else
        return;

    memcpy(&sl->interpreter_props.command[sl->interpreter_props.x - 1],
           &sl->interpreter_props.command[sl->interpreter_props.x],
           sl->interpreter_props.size - sl->interpreter_props.x);

    sl->interpreter_props.command =
        (char *)realloc(sl->interpreter_props.command,
                        sl->interpreter_props.size);

    if (sl->interpreter_props.x)
        sl->interpreter_props.x--;
    sl->interpreter_props.command[sl->interpreter_props.size - 1] = 0;
}


int python_command_handle_key(struct screen_list *screen_list, unsigned int c)
{
    if (c == CACA_KEY_ESCAPE)
    {
        if (screen_list->interpreter_props.command)
        {
            free(screen_list->interpreter_props.command);
            screen_list->interpreter_props.command = NULL;
        }
        screen_list->python_command = 0;
        screen_list->changed = 1;
        return 1;
    }
    else if (c == CACA_KEY_LEFT)
    {
        if (screen_list->interpreter_props.x)
            screen_list->interpreter_props.x--;
    }
    else if (c == CACA_KEY_RIGHT)
    {
        if (screen_list->interpreter_props.x <
            screen_list->interpreter_props.size - 1)
            screen_list->interpreter_props.x++;
    }
    else if (c == CACA_KEY_RETURN)
    {
        python_execute(screen_list);
    }
    else
    {
        if (c >= ' ' && c < 127)
            add_char(screen_list, c);
        else if (c == 8)
        {
            del_char(screen_list);
        }
        screen_list->changed = 1;
        return 0;
    }
    return 0;
}

void draw_python_command(struct screen_list *screen_list)
{
    int w = 65, h = 6;
    int x = (caca_get_canvas_width(screen_list->cv) - w) / 2;
    int y = (caca_get_canvas_height(screen_list->cv) - h) / 2;

    caca_set_color_ansi(screen_list->cv, CACA_BLUE, CACA_BLUE);
    caca_fill_box(screen_list->cv, x, y, w, h, '#');
    caca_set_color_ansi(screen_list->cv, CACA_DEFAULT, CACA_BLUE);
    caca_draw_cp437_box(screen_list->cv, x, y, w, h);
    caca_printf(screen_list->cv, x, y, "Execute command");

    caca_printf(screen_list->cv, x + 2, y + 2,
                "[___________________________________________________________]");

    if (screen_list->interpreter_props.command)
    {
        caca_printf(screen_list->cv, x + 3, y + 2,
                    "%s", screen_list->interpreter_props.command);
        caca_gotoxy(screen_list->cv,
                    x + 3 + screen_list->interpreter_props.x, y + 2);
    }
    else
    {
        caca_gotoxy(screen_list->cv, x + 3, y + 2);
    }

    if (screen_list->interpreter_props.output)
    {
        caca_set_color_ansi(screen_list->cv, CACA_RED, CACA_BLUE);
        caca_printf(screen_list->cv, x + 2, y + 4,
                    screen_list->interpreter_props.output);
    }

}

/* Actual Python interpreter stuff */
int python_init(struct screen_list *sl)
{
    sl->interpreter_props.output = NULL;
    Py_Initialize();
    return 0;
}

int python_close(struct screen_list *sl)
{
    if (sl->interpreter_props.output)
        free(sl->interpreter_props.output);
    sl->interpreter_props.output = NULL;
    Py_Finalize();
    return 0;
}


static int python_execute(struct screen_list *sl)
{
    if (!sl->interpreter_props.command || sl->interpreter_props.size < 1)
        return -1;
    int err = 0;

    debug("py Executing '%s'\n", sl->interpreter_props.command);

    if (sl->interpreter_props.output)
    {
        free(sl->interpreter_props.output);
        sl->interpreter_props.output = NULL;
    }

    PyObject *pModule, *pName, *pFunc;

    /* Module from which to call the function */
    pName = PyUnicode_FromString("neercs");
    if (!pName)
    {
        sl->interpreter_props.output = getPythonError();
        err = 1;
        debug("py Error 1\n");
        goto end;
    }


    pModule = PyImport_Import(pName);
    Py_DECREF(pName);
    if (pModule != NULL)
    {
        pFunc = PyObject_GetAttrString(pModule, sl->interpreter_props.command);
        if (pFunc && PyCallable_Check(pFunc))
        {
            debug("py Can call !\n");
        }
        else
        {
            sl->interpreter_props.output = getPythonError();
            err = 1;
            debug("py Error 2\n");
            goto end;
        }
    }
    else
    {
        sl->interpreter_props.output = getPythonError();
        err = 1;
        debug("py: %s\n", sl->interpreter_props.output);
        goto end;
    }

  end:
    if (!err)
    {
        free(sl->interpreter_props.command);
        sl->interpreter_props.command = NULL;
        sl->interpreter_props.size = 0;
        sl->interpreter_props.x = 0;
        sl->python_command = 0;
    }
    sl->changed = 1;

    return 0;
}



static char *getPythonError(void)
{
    char *err;
    PyObject *type, *value, *traceback;
    PyErr_Fetch(&type, &value, &traceback);

    char *etype = getStringFromPyObject(type);
    char *evalue = getStringFromPyObject(value);

    asprintf(&err, "Error in %s : %s", etype, evalue);

    return err;
}

static char *getStringFromPyObject(PyObject * p)
{
    PyObject *str = PyObject_Repr(p);
    char *err = PyBytes_AS_STRING(PyUnicode_AsEncodedString(str, "utf-8",
                                                            "Error ~"));
    return err;
}


#endif