source: neercs/trunk/src/python/interpreter.c @ 4064 Tweet

/* 
 *  neercs        console-based window manager
 *  Copyright (c) 2009 Jean-Yves Lamoureux <jylam@lnxscene.org>
 *                All Rights Reserved
 *
 *  $Id: interpreter.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 <time.h>
#include <sys/wait.h>
#include <sys/types.h>

#include <caca.h>

#include "neercs.h"
#include "py_module.h"

static int python_execute(struct screen_list *sl);
char *getStringFromPyObject(PyObject * p);
static char *getPythonError(void);



int python_command_handle_key(struct screen_list *screen_list, unsigned int c)
{
    int ret = widget_ibox_handle_key(screen_list->interpreter_props.box, c);

    if (ret == INPUT_BOX_ESC)
    {
        widget_ibox_destroy(screen_list->interpreter_props.box);
        screen_list->interpreter_props.box = NULL;
        screen_list->modals.python_command = 0;
    }
    else if (ret == INPUT_BOX_RET)
    {
        python_execute(screen_list);
    }
    screen_list->changed = 1;

    return 1;
}

void draw_python_command(struct screen_list *screen_list)
{
    if (!screen_list->interpreter_props.box)
    {
        screen_list->interpreter_props.box =
            widget_ibox_init(screen_list->cv, 65, 6);
        debug("py Init %p\n", screen_list->interpreter_props.box);
    }
    debug("py Drawing !\n");
    widget_ibox_draw(screen_list->interpreter_props.box);
}

/* Actual Python interpreter stuff */
int python_init(struct screen_list *sl)
{
    Py_Initialize();
    initNeercsModule(sl);

    return 0;
}

int python_close(struct screen_list *sl)
{
    widget_ibox_destroy(sl->interpreter_props.box);
    sl->interpreter_props.box = NULL;

    Py_Finalize();
    return 0;
}


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

    debug("py Executing '%s'\n", command);


    PyObject *pModule, *pName, *pFunc;

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

    pModule = PyImport_Import(pName);
    Py_DECREF(pName);

    if (pModule != NULL)
    {
        PyObject *dictionary = PyModule_GetDict(pModule);

        getExportedValues(dictionary);

        PyObject *o =
            PyRun_String(command, Py_single_input,
                         dictionary, NULL);
        if (!o)
        {
            widget_ibox_set_error(sl->interpreter_props.box, getPythonError());
            err = 1;
        }
        else
        {
            setExportedValues(dictionary);

            widget_ibox_set_msg(sl->interpreter_props.box, getStringFromPyObject(o));
            err = 1;
        }
        goto end;

    }
    else
    {
        widget_ibox_set_error(sl->interpreter_props.box, getPythonError());
        err = 1;
        goto end;
    }

  end:

    Py_XDECREF(pFunc);
    Py_DECREF(pModule);

    if (!err)
    {
        widget_ibox_destroy(sl->interpreter_props.box);
        sl->interpreter_props.box = NULL;
        sl->modals.python_command = 0;
    }
    sl->changed = 1;

    return 0;
}



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

    char *evalue = getStringFromPyObject(value);

    int r = asprintf(&err, "%s", evalue);
    (void)r;
    return err;
}

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

    char *ret = strdup(err);
    return ret;
}


#endif