modules/pythonscript/pythonscript.c File Reference

#include <Python.h>
#include <structmember.h>
#include <eggdrop/eggdrop.h>
#include "pythonscript.h"

Go to the source code of this file.

Functions
static int	my_load_script (void *ignore, char *fname)
static int	my_link_var (void *ignore, script_linked_var_t *var)
static int	my_unlink_var (void *ignore, script_linked_var_t *var)
static int	my_create_command (void *ignore, script_raw_command_t *info)
static int	my_delete_command (void *ignore, script_raw_command_t *info)
static int	my_get_arg (void *ignore, script_args_t *args, int num, script_var_t *var, int type)
static int	my_python_cb_delete (event_owner_t *owner, void *client_data)
static event_owner_t *	GetContext ()
static int	my_python_callbacker (script_callback_t *me,...)
PyObject *	c_to_python_var (script_var_t *v)
int	python_to_c_var (PyObject *obj, script_var_t *var, int type)
static int	mls (partymember_t *p, char *nick, user_t *u, char *cmd, char *text)
static int	party_python (partymember_t *p, char *nick, user_t *u, char *cmd, char *text)
static int	Cleanup (void *client_data, script_args_t *args, script_var_t *retval)
static PyObject *	Help (PyObject *self, PyObject *Args)
static int	pythonscript_close (int why)
static void	pythonscript_unload (void)
EXPORT_SCOPE int	pythonscript_LTX_start (egg_module_t *modinfo)
Variables
static const char	rcsid [] = "$Id: pythonscript.c,v 1.6 2008-10-17 15:57:42 sven Exp $"
script_module_t	my_script_interface
static egg_module_t *	python_modinfo
static int	python_owners = 0
static event_owner_t *	python_owner = 0
static PyObject *	SysPath
static PyObject *	SysModules
static PyObject *	CommonModule
static PyObject *	PartylineModule
static PyObject *	PartylineDict
static PyObject *	RealHelper
static PyObject *	SysMod
static PyObject *	MinInt
static PyObject *	MaxInt
static PyObject *	MinUInt
static PyObject *	MaxUInt
static event_owner_t *	CurrentContext
static char *	CurrentContextString
static PyMethodDef	HelpMethod
static bind_list_t	party_commands []
static PyMethodDef *	methods

---

Function Documentation

PyObject* c_to_python_var

(

script_var_t *

v

)

Definition at line 293 of file pythonscript.c.

References byte_array_b::bytes, c_to_python_var(), byte_array_b::do_free, Egguser_Type, byte_array_b::len, script_var_b::len, NULL, SCRIPT_ARRAY, SCRIPT_BYTES, SCRIPT_FREE, SCRIPT_FREE_VAR, SCRIPT_INTEGER, SCRIPT_PARTIER, SCRIPT_POINTER, SCRIPT_STRING, SCRIPT_STRING_LIST, SCRIPT_TYPE_MASK, SCRIPT_UNSIGNED, SCRIPT_USER, SCRIPT_VAR, script_var_b::type, EgguserObject::user, and script_var_b::value.

Referenced by c_to_python_var(), Get(), GetFlags(), GetIrcMasks(), GetVar(), my_command_handler(), and my_python_callbacker().

                                           {
  PyObject *result;

  result = NULL;
  /* If it's an array, we call ourselves recursively. */
  if (v->type & SCRIPT_ARRAY) {
    PyObject *element;
    int i;

    result = PyTuple_New(v->len);
    /* If it's an array of script_var_t's, then it's easy. */
    if ((v->type & SCRIPT_TYPE_MASK) == SCRIPT_VAR) {
      script_var_t **v_list;

      v_list = (script_var_t **)v->value;
      for (i = 0; i < v->len; i++) {
        element = c_to_python_var(v_list[i]);
        if (!element) {
          Py_DECREF(result);
          return 0;
        }
        PyTuple_SET_ITEM(result, i, element);
      }
    }
    else {
      /* Otherwise, we have to turn them into fake script_var_t's. */
      script_var_t v_sub;
      void **values;

      values = (void **)v->value;
      for (i = 0; i < v->len; i++) {
        v_sub.type = v->type & (~SCRIPT_ARRAY);
        v_sub.value = values[i];
        v_sub.len = -1;
        element = c_to_python_var(&v_sub);
        if (!element) {
          Py_DECREF(result);
          return 0;
        }
        PyTuple_SET_ITEM(result, i, element);
      }
    }
    /* Whew */
    if (v->type & SCRIPT_FREE) free(v->value);
    if (v->type & SCRIPT_FREE_VAR) free(v);
    return result;
  }

  /* Here is where we handle the basic types. */
  switch (v->type & SCRIPT_TYPE_MASK) {
    case SCRIPT_INTEGER:
      result = PyInt_FromLong((int) v->value);
      break;
    case SCRIPT_UNSIGNED:
      /* Python has no "unsigned" type. A Python "int" is a C "long".
       * So, if sizeof(int) == sizeof(long) like on IA32 a Python "int"
       * might be too short to store a C "unsigned".
       * Use a Python "long" in that case */
      if ((unsigned) v->value <= PyInt_GetMax()) {
        result = PyInt_FromLong((unsigned) v->value);
      } else {
        result = PyLong_FromUnsignedLong((unsigned) v->value);
      }
      break;
    case SCRIPT_STRING: {
      char *str = v->value;

      if (!str) str = "";
      if (v->len == -1) v->len = strlen(str);
      result = PyString_FromStringAndSize(str, v->len);
      if (v->value && v->type & SCRIPT_FREE) free(v->value);
      break;
    }
    case SCRIPT_STRING_LIST: {
      char **str = v->value;
      PyObject *element;

      result = PyList_New(0);
      for (str = v->value; str && *str; ++str) {
        element = PyString_FromString(*str);
        PyList_Append(result, element);
      }
      break;
    }
    case SCRIPT_BYTES: {
      byte_array_t *bytes = v->value;
      result = PyString_FromStringAndSize(bytes->bytes, bytes->len);
      if (bytes->do_free) free(bytes->bytes);
      if (v->type & SCRIPT_FREE) free(bytes);
      break;
    }
#if 0
    case SCRIPT_POINTER: {
      char str[32];

      sprintf(str, "#%u", (unsigned int) v->value);
      result = Tcl_NewStringObj(str, -1);
      break;
    }
    case SCRIPT_PARTIER: {
      partymember_t *p = v->value;
      int pid;

      if (p) pid = p->pid;
      else pid = -1;
      result = Tcl_NewIntObj(pid);
      break;
    }
#endif
    case SCRIPT_USER: {
      /* An eggdrop user record (struct userrec *). */
      user_t *u = v->value;

      if (u) {
        EgguserObject *O = (EgguserObject *) Egguser_Type.tp_new(&Egguser_Type, 0, 0);
        O->user = u;
        result = (PyObject *) O;
      } else {
        Py_INCREF(Py_None);
        result = Py_None;
      }
      break;
    }
    default:
      /* Default: just "None". */
      Py_INCREF(Py_None);
      result = Py_None;
  }
  if (v->type & SCRIPT_FREE_VAR) free(v);
  return result;
}

static int Cleanup	(	void *	client_data,
		script_args_t *	args,
		script_var_t *	retval
	)			[static]

Definition at line 586 of file pythonscript.c.

References event_owner_b::client_data, GetContext(), script_args_b::len, SCRIPT_ERROR, SCRIPT_INTEGER, script_remove_events_by_owner(), SCRIPT_STRING, script_var_b::type, and script_var_b::value.

Referenced by pythonscript_LTX_start().

                                                                                  {
  if (args->len) {
    retval->type = SCRIPT_ERROR | SCRIPT_STRING;
    retval->value = "This function does not accept any parameters.";
    return 0;
  }
  retval->type = SCRIPT_INTEGER;
  retval->value = (void *) script_remove_events_by_owner(python_modinfo, GetContext()->client_data);
  return 0;
}

static event_owner_t* GetContext

(

)

[static]

Definition at line 62 of file pythonscript.c.

References event_owner_b::client_data, CurrentContextString, event_owner_b::module, my_python_cb_delete(), event_owner_b::name, event_owner_b::on_delete, python_owners, event_owner_b::script, and SysModules.

Referenced by Cleanup(), and python_to_c_var().

{
  PyObject *Mod;

  if (CurrentContext) return CurrentContext;
  if (!(python_owners & 7)) python_owner = realloc(python_owner, (python_owners + 8) * sizeof(*python_owner));

  Mod = PyDict_GetItemString(SysModules, CurrentContextString); /* Borrowed reference */
  Py_INCREF(Mod);

  python_owner[python_owners].name = "pythonscript";
  python_owner[python_owners].module = python_modinfo;
  python_owner[python_owners].script = strdup(CurrentContextString);
  python_owner[python_owners].client_data = Mod;
  python_owner[python_owners].on_delete = my_python_cb_delete;
  CurrentContext = &python_owner[python_owners++];
  return CurrentContext;
}

static PyObject* Help	(	PyObject *	self,
		PyObject *	Args
	)			[static]

Definition at line 597 of file pythonscript.c.

References Callable_Check, FlushAll, RealHelper, SysMod, and Write().

                                                      {
  PyObject *O = 0, *Stdout, *Write, *DocStr, *HelpStr;

  PyArg_ParseTuple(Args, "|O", &O);
  if (!O || !Callable_Check(O)) return PyObject_CallObject(RealHelper, Args);
  Stdout = PyObject_GetAttrString(SysMod, "stdout");
  if (!Stdout || !(Write = PyObject_GetAttrString(Stdout, "write"))) return 0;
  Py_DECREF(Stdout);
  DocStr = PyObject_GetAttrString(O, "__doc__");
  if (!(HelpStr = Py_BuildValue("(O)", DocStr))) {
    Py_DECREF(Write);
    return 0;
  }
  Py_DECREF(DocStr);
  PyObject_CallObject(Write, HelpStr);
  Py_DECREF(HelpStr);
  FlushAll();
  Py_INCREF(Py_None);
  return Py_None;
}

static int mls	(	partymember_t *	p,
		char *	nick,
		user_t *	u,
		char *	cmd,
		char *	text
	)			[static]

Definition at line 555 of file pythonscript.c.

References LogTarget, and my_load_script().

                                                                               {
  LogTarget = p;
  my_load_script(0, text);
  LogTarget = 0;
  return 0;
}

static int my_create_command	(	void *	ignore,
		script_raw_command_t *	info
	)			[static]

Definition at line 255 of file pythonscript.c.

References Callable_Type, script_raw_command_t::class, CallableObject::client_data, egg_mprintf(), EggdropModule, FlushAll, script_raw_command_t::name, PYTHON_FUNC, and CallableObject::type.

                                                                       {
  char *cmdname;
  CallableObject *O = PyObject_New(CallableObject, &Callable_Type);

  if (info->class && strlen(info->class)) {
    cmdname = egg_mprintf("%s_%s", info->class, info->name);
  }
  else {
    cmdname = strdup(info->name);
  }
  O->type = PYTHON_FUNC;
  O->client_data = info;
  if (PyModule_AddObject(EggdropModule, cmdname, (PyObject *)O)) {
    free(cmdname);
    PyErr_Print();
    FlushAll();
    return 1;
  }
  free(cmdname);
  return 0;
}

static int my_delete_command	(	void *	ignore,
		script_raw_command_t *	info
	)			[static]

Definition at line 278 of file pythonscript.c.

References CallableObject::client_data, EggdropModule, and script_raw_command_t::name.

{
  PyObject *Dict = *_PyObject_GetDictPtr(EggdropModule);
  CallableObject *Callable;

  Callable = (CallableObject *) PyDict_GetItemString(Dict, info->name);
                           /* Warning! Borrowed reference */
  if (!Callable) return 0;                   /* It never existed, that's the same as deleting it */
  Callable->client_data = 0;
  PyDict_DelItemString(Dict, info->name);
  return 0;
}

static int my_get_arg	(	void *	ignore,
		script_args_t *	args,
		int	num,
		script_var_t *	var,
		int	type
	)			[static]

Definition at line 541 of file pythonscript.c.

References script_args_b::client_data, and python_to_c_var().

                                                                                               {
  PyObject *ParameterTuple, *Parameter;

  ParameterTuple = args->client_data;
  Parameter = PyTuple_GetItem(ParameterTuple, num);
  if (!Parameter) {
    // XXX: write some kind of error log?
    PyErr_Clear();
    return 1;
  }

  return python_to_c_var(Parameter, var, type);
}

static int my_link_var	(	void *	ignore,
		script_linked_var_t *	var
	)			[static]

Definition at line 153 of file pythonscript.c.

References Callable_Type, script_linked_var_b::class, CallableObject::client_data, egg_mprintf(), EggdropModule, FlushAll, script_linked_var_b::name, PYTHON_VAR, and CallableObject::type.

                                                               {
  CallableObject *O;
  char *cmdname;

  O = PyObject_New(CallableObject, &Callable_Type);       /* new reference */
  if (!O) {
    PyErr_Print();
    FlushAll();
    return -1;
  }

  if (var->class && strlen(var->class)) {
    cmdname = egg_mprintf("%s_%s", var->class, var->name);
  }
  else {
    cmdname = strdup(var->name);
  }
  O->type = PYTHON_VAR;
  O->client_data = var;
  PyModule_AddObject(EggdropModule, cmdname, (PyObject *) O); /* EggdropModule steals a reference to O */
  free(cmdname);
  return 0;
}

static int my_load_script	(	void *	ignore,
		char *	fname
	)			[static]

Definition at line 82 of file pythonscript.c.

References CommonModule, CurrentContextString, FlushAll, python_owners, SCRIPT_ERR_CODE, SCRIPT_ERR_NOT_RESPONSIBLE, SCRIPT_OK, and SysPath.

{
  int len, i;
  char *fullname, *name, *path;
  PyObject *PathString, *CommonDict, *NewMod;

  /* Check the filename and make sure it ends in .py */
  len = strlen(fname);
  if (len < 4 || fname[len-1] != 'y' || fname[len-2] != 'p' || fname[len-3] != '.') {
    /* Nope, let someone else load it. */
    return SCRIPT_ERR_NOT_RESPONSIBLE;
  }
  fullname = strdup(fname);
  name = rindex(fullname, '/');
  if (!name) {
    name = fullname;
    path = "";
  } else {
    *name++ = 0;
    path = fullname;
  }
  name[strlen(name) - 3] = 0;

  for (i = 1; i < python_owners; ++i) {
    if (!strcmp(python_owner[i].script, name)) {
      CurrentContext = &python_owner[i];
      if (!PyImport_ReloadModule(python_owner[i].client_data)) {
        PyErr_Print();
        FlushAll();
        free(fullname);
        CurrentContext = 0;
        return SCRIPT_ERR_CODE;
      }
      CurrentContext = 0;
      return SCRIPT_OK;
    }
  }
  
  CurrentContext = 0;
  CurrentContextString = name;
  PathString = PyString_FromString(path);
  PyList_Insert(SysPath, 0, PathString);
  Py_DECREF(PathString);
  if (!(NewMod = PyImport_ImportModule(name))) {
    PyErr_Print();
    FlushAll();
    free(fullname);
    CurrentContextString = 0;
    return SCRIPT_ERR_CODE;
  }

  CommonDict = PyObject_GetAttrString(CommonModule, name);
  if (!CommonDict) {
    PyErr_Clear();
    CommonDict = PyDict_New();
    PyModule_AddObject(CommonModule, name, CommonDict);   /* CommonModule steals a reference to CommonDict */
  } else {
    Py_DECREF(CommonDict);
  }
  PyDict_SetItemString(CommonDict, "module", NewMod);
  /* XXX: We just leaked a reference to the new module.
   * I guess we should save this to do something with it at
   * a later time but i don't have a solid idea, what ... */
  PyList_SetSlice(SysPath, 0, 0, 0);
  free(fullname);
  CurrentContextString = 0;
  CurrentContext = 0;
  return SCRIPT_OK;
}

static int my_python_callbacker	(	script_callback_t *	me,
			...
	)			[static]

Definition at line 192 of file pythonscript.c.

References c_to_python_var(), script_callback_b::callback_data, cmd, FlushAll, script_var_b::len, script_callback_b::owner, SCRIPT_INTEGER, SCRIPT_UNSIGNED, script_callback_b::syntax, script_var_b::type, and script_var_b::value.

Referenced by python_to_c_var().

{
  script_var_t var;
  int i, n, retval;
  PyObject *cmd, *param, *arg, *RetObj;
  va_list va;

  cmd = me->callback_data;

  if (me->syntax) n = strlen(me->syntax);
  else n = 0;

  if (n) param = PyTuple_New(n);
  else param = 0;

  va_start(va, me);
  for (i = 0; i < n; i++) {
    var.type = me->syntax[i];
    if (var.type == SCRIPT_UNSIGNED || var.type == SCRIPT_INTEGER) var.value = (void *) (va_arg(va, int));
    else var.value = va_arg(va, void *);
    var.len = -1;
    arg = c_to_python_var(&var);       /* New reference */
    if (!arg) {
      Py_DECREF(param);
      PyErr_Print();
      FlushAll();
      return 0;
    }
    PyTuple_SET_ITEM(param, i, arg);   /* param steals the reference from arg */
  }
  va_end(va);

  CurrentContext = me->owner;
  RetObj = PyObject_CallObject(cmd, param);
  FlushAll();
  CurrentContext = 0;

  if (!RetObj) {
    PyErr_Print();
    FlushAll();
    return 0;
  }
  if (PyInt_Check(RetObj)) retval = PyInt_AS_LONG(RetObj);
  else retval = !PyObject_Not(RetObj);
  
  Py_DECREF(RetObj);

  return retval;
}

static int my_python_cb_delete	(	event_owner_t *	owner,
		void *	client_data
	)			[static]

Definition at line 243 of file pythonscript.c.

References script_callback_b::callback_data, script_callback_b::name, and script_callback_b::syntax.

Referenced by GetContext(), and pythonscript_LTX_start().

                                                                        {
  script_callback_t *me = client_data;
  PyObject *Callback = me->callback_data;

  Py_DECREF(Callback);
  if (me->syntax) free(me->syntax);
  if (me->name) free(me->name);
  free(me);
  return 0;
}

static int my_unlink_var	(	void *	ignore,
		script_linked_var_t *	var
	)			[static]

Definition at line 178 of file pythonscript.c.

References CallableObject::client_data, EggdropModule, and script_linked_var_b::name.

                                                                 {
  PyObject *Dict = *_PyObject_GetDictPtr(EggdropModule);
  CallableObject *Callable;

  Callable = (CallableObject *) PyDict_GetItemString(Dict, var->name); /* Warning! Borrowed reference */
  if (!Callable) return 0;                   /* It never existed, that's the same as deleting it */
  Callable->client_data = 0;
  PyDict_DelItemString(Dict, var->name);
  /* at this point the Callable object might (should!) be gone. Don't try to access it */
  return 0;
}

static int party_python	(	partymember_t *	p,
		char *	nick,
		user_t *	u,
		char *	cmd,
		char *	text
	)			[static]

Definition at line 562 of file pythonscript.c.

References _, BIND_RET_LOG, egg_isowner(), FlushAll, user::handle, LogTarget, PartylineDict, and partymember_write().

{
  PyObject *ret;

  if (!u || !egg_isowner(u->handle)) {
    partymember_write(p, _("You must be a permanent owner (defined in the config file) to use this command.\n"), -1);
    return BIND_RET_LOG;
  }

  if (!text) {
    partymember_write(p, _("Syntax: .python <pythonexpression>"), -1);
    return 0;
  }

  CurrentContext = python_owner;
  LogTarget = p;
  ret = PyRun_String(text, Py_single_input, PartylineDict, PartylineDict);
  CurrentContext = 0;
  if (!ret) PyErr_Print();
  FlushAll();
  LogTarget = 0;
  return 0;
}

int python_to_c_var	(	PyObject *	obj,
		script_var_t *	var,
		int	type
	)

Definition at line 429 of file pythonscript.c.

References byte_array_b::bytes, script_callback_b::callback, script_callback_b::callback_data, script_callback_b::delete_data, Egguser_Check, user::flags, script_callback_b::flags, GetContext(), byte_array_b::len, script_var_b::len, MaxInt, MaxUInt, MinInt, MinUInt, my_python_callbacker(), script_callback_b::name, NULL, script_callback_b::owner, SCRIPT_BYTES, SCRIPT_CALLBACK, SCRIPT_FREE, SCRIPT_INTEGER, SCRIPT_PARTIER, SCRIPT_STRING, SCRIPT_TYPE_MASK, SCRIPT_UNSIGNED, SCRIPT_USER, script_callback_b::syntax, script_var_b::type, EgguserObject::user, USER_DELETED, and script_var_b::value.

Referenced by my_get_arg(), and SetVar().

                                                                {
  var->type = type;
  var->len = -1;
  var->value = 0;

  switch (type & SCRIPT_TYPE_MASK) {
    case SCRIPT_STRING: {
      char *Str;

      Str = PyString_AsString(obj);
      if (!Str) return 1;
      var->value = strdup(Str);
      var->len = strlen(var->value);
      return 0;
    }
    case SCRIPT_CALLBACK: {
      script_callback_t *cback; /* Callback struct */
      PyObject *FunctionName, *ModuleName;
      char *CFuncName = 0, *CModName = 0;

      if (!PyCallable_Check(obj)) {
        PyErr_Format(PyExc_TypeError, "Object of type %s is not callable.", obj->ob_type->tp_name);
        return 1;
      }
      cback = malloc(sizeof(*cback));
      cback->callback = (Function) my_python_callbacker;
      cback->callback_data = obj;
      Py_INCREF(obj);

      ModuleName = PyObject_GetAttrString(obj, "__module__");
      FunctionName = PyObject_GetAttrString(obj, "__name__");
      if (ModuleName) CModName = PyString_AsString(ModuleName);
      if (FunctionName) CFuncName = PyString_AsString(FunctionName);
      PyErr_Clear();
      if (!CModName) CModName = "python";
      if (CFuncName) {
        cback->name = malloc(strlen(CModName) + strlen(CFuncName) + 2);
        sprintf(cback->name, "%s.%s", CModName, CFuncName);
      } else {
        cback->name = malloc(strlen(CModName) + 12);
        sprintf(cback->name, "%s.0x%08x", CModName, ((int) obj) & 0xFFFFFFFF);
      }
        
      Py_XDECREF(ModuleName);
      Py_XDECREF(FunctionName);

      cback->delete_data = 0;
      cback->syntax = 0;
      cback->flags = 0;
      cback->owner = GetContext();
//      putlog(LOG_MISC, "*", "Created Callback %s %p %s %p", cback->owner->name, cback->owner->module, cback->owner->script, cback->owner->client_data);

      var->value = cback;
      return 0;
    }
    case SCRIPT_BYTES: {
      byte_array_t *byte_array;

      byte_array = malloc(sizeof(*byte_array));

      var->value = byte_array;
      var->type |= SCRIPT_FREE;

      return PyString_AsStringAndSize(obj, (char **) &byte_array->bytes, &byte_array->len);
    }
    case SCRIPT_UNSIGNED:
    case SCRIPT_INTEGER: {
      if (!PyInt_Check(obj) && !PyLong_Check(obj)) {
        PyErr_SetString(PyExc_TypeError, "an integer is required");
        return 1;
      }
      PyErr_Clear();
      if ((((type & SCRIPT_TYPE_MASK) == SCRIPT_UNSIGNED) && (PyObject_Compare(obj, MinUInt) < 0 ||
                                                              PyObject_Compare(obj, MaxUInt) > 0)) ||
          (((type & SCRIPT_TYPE_MASK) == SCRIPT_INTEGER) && (PyObject_Compare(obj, MinInt) < 0 ||
                                                             PyObject_Compare(obj, MaxInt) > 0))) {
        PyErr_SetString(PyExc_OverflowError, "Python value does not fit in C type");
        return 1;
      }

      if (PyInt_Check(obj)) var->value = (void *) PyInt_AsLong(obj);
      else var->value = (void *) PyLong_AsUnsignedLong(obj);
      return 0;
    }
#if 0
    case SCRIPT_PARTIER: {
      int pid = -1;

      err = Tcl_GetIntFromObj(myinterp, obj, &pid);
      if (!err) var->value = partymember_lookup_pid(pid);
      else var->value = NULL;
      break;
    }
#endif
    case SCRIPT_USER: {
      EgguserObject *O = (EgguserObject *) obj;

      if (!Egguser_Check(obj)) {
        PyErr_Format(PyExc_TypeError, "Expected eggdrop.egguser, got %s", obj->ob_type->tp_name);
        return 1;
      }
      if (!O->user || (O->user->flags & USER_DELETED)) {
        PyErr_SetString(PyExc_RuntimeError, "This user has been deleted.");
        return 1;
      }
      var->value = O->user;
      return 0;
    }
  }
  return 1;
}

static int pythonscript_close

(

int

why

)

[static]

Definition at line 628 of file pythonscript.c.

References bind_rem_list(), and script_unregister_module().

Referenced by pythonscript_LTX_start().

{
  bind_rem_list("party", party_commands);

  script_unregister_module(&my_script_interface);

  return 0;
}

int pythonscript_LTX_start

(

egg_module_t *

modinfo

)

Definition at line 648 of file pythonscript.c.

References egg_module::author, bind_add_list(), Callable_Type, Cleanup(), event_owner_b::client_data, egg_module::close_func, CommonModule, egg_module::description, EggdropModule, Egguser_Type, HelpMethod, LOG_MISC, MaxInt, MaxUInt, MinInt, MinUInt, event_owner_b::module, my_create_command(), my_python_cb_delete(), MyDict_Type, MyModule_Add(), MyModule_Init(), event_owner_b::name, egg_module::name, event_owner_b::on_delete, PartylineDict, PartylineModule, putlog(), python_owners, pythonscript_close(), pythonscript_unload(), RealHelper, event_owner_b::script, script_playback(), script_register_module(), Stdio_Type, SysMod, SysModules, SysPath, egg_module::unload_func, and egg_module::version.

                                                  {
  PyObject *builtinModule, *Stdout, *Stderr, *Para, *Helper;
  static script_raw_command_t script_cleanup = {
    "python", "cleanup", Cleanup, 0
  };

  python_modinfo = modinfo;

  modinfo->name = "pythonscript";
  modinfo->author = "eggdev";
  modinfo->version = "0.0.1";
  modinfo->description = "provides python scripting support";
  modinfo->close_func = pythonscript_close;
  modinfo->unload_func = pythonscript_unload;

  /* Create the interpreter and let tcl load its init.tcl */
  Py_Initialize();

  MyModule_Init();
  PyType_Ready(&MyDict_Type);
  PyType_Ready(&Callable_Type);
  PyType_Ready(&Stdio_Type);
  PyType_Ready(&Egguser_Type);

  MinInt = PyInt_FromLong(INT_MIN);
  MaxInt = PyInt_FromLong(INT_MAX);
  MinUInt = PyInt_FromLong(0);
  MaxUInt = PyInt_FromLong(UINT_MAX);
  if (PyObject_Compare(MinUInt, MaxUInt) >= 0) MaxUInt = PyLong_FromUnsignedLong(UINT_MAX);

  SysMod = PyImport_ImportModule("sys");
  if (!SysMod || !(SysPath = PyObject_GetAttrString(SysMod, "path")) || !(SysModules = PyObject_GetAttrString(SysMod, "modules"))) {
    putlog(LOG_MISC, "*", "Module 'pythonscript' could not be initialized: Couldn't get sys.path");
    Py_Finalize();
    return -4;
  }

  EggdropModule = MyModule_Add("eggdrop", "this module contains the interface to the eggdrop bot");
  CommonModule = Py_InitModule3("common", methods, "this module is a kind of semipersistent storage space for scripts");
  PartylineModule = Py_InitModule3("partyline", methods, "this is the partyline mamespace");
  PartylineDict = PyModule_GetDict(PartylineModule);

  if (!EggdropModule || !CommonModule || !PartylineModule|| !PartylineDict) {
    putlog(LOG_MISC, "*", "Module 'pythonscript' could not be initialized: Failed to create modules");
    Py_Finalize();
    return -4;
  }

  Py_INCREF(&Stdio_Type);
  Py_INCREF(&Egguser_Type);
  PyModule_AddObject(EggdropModule, "stdio", (PyObject *) &Stdio_Type);
  PyModule_AddObject(EggdropModule, "egguser", (PyObject *) &Egguser_Type);

  Para = Py_BuildValue("(i)", 1);
  Stdout = Stdio_Type.tp_new(&Stdio_Type, Para, 0);
  Py_DECREF(Para);
  Para = Py_BuildValue("(i)", 2);
  Stderr = Stdio_Type.tp_new(&Stdio_Type, Para, 0);
  Py_DECREF(Para);
  PyModule_AddObject(SysMod, "stdout", Stdout);
  PyModule_AddObject(SysMod, "stderr", Stderr);
  
  builtinModule = PyImport_ImportModule("__builtin__");
  if (!builtinModule || PyModule_AddObject(PartylineModule, "__builtins__", builtinModule)) {
    putlog(LOG_MISC, "*", "Error inserting '__builtin__' module. builtin commands will not be available from the partyline");
  } else {
    Helper = PyCFunction_NewEx(&HelpMethod, 0, 0);
    RealHelper = PyObject_GetAttrString(builtinModule, "help");
    PyModule_AddObject(builtinModule, "help", Helper);
  }
  Py_XDECREF(builtinModule);
  PyErr_Clear();

  my_create_command(0, &script_cleanup);
  script_register_module(&my_script_interface);
  script_playback(&my_script_interface);

  bind_add_list("party", party_commands);

  python_owners = 1;
  python_owner = malloc(8 * sizeof(*python_owner));
  python_owner[0].name = "pythonscript";
  python_owner[0].module = python_modinfo;
  python_owner[0].script = "partyline";
  python_owner[0].client_data = PartylineModule;
  python_owner[0].on_delete = my_python_cb_delete;


  return 0;
}

static void pythonscript_unload

(

void

)

[static]

Definition at line 637 of file pythonscript.c.

Referenced by pythonscript_LTX_start().

{
  Py_Finalize();
}

---

Variable Documentation

PyObject * CommonModule [static]

Definition at line 56 of file pythonscript.c.

Referenced by my_load_script(), and pythonscript_LTX_start().

event_owner_t* CurrentContext [static]

Definition at line 59 of file pythonscript.c.

char* CurrentContextString [static]

Definition at line 60 of file pythonscript.c.

Referenced by GetContext(), and my_load_script().

PyMethodDef HelpMethod [static]

Initial value:

 {
  "help", Help, METH_VARARGS, 0
}

Definition at line 618 of file pythonscript.c.

Referenced by pythonscript_LTX_start().

PyObject * MaxInt [static]

Definition at line 57 of file pythonscript.c.

Referenced by python_to_c_var(), and pythonscript_LTX_start().

PyObject * MaxUInt [static]

Definition at line 57 of file pythonscript.c.

Referenced by python_to_c_var(), and pythonscript_LTX_start().

PyMethodDef* methods [static]

Initial value:

 {
  0
}

Definition at line 642 of file pythonscript.c.

PyObject* MinInt [static]

Definition at line 57 of file pythonscript.c.

Referenced by python_to_c_var(), and pythonscript_LTX_start().

PyObject * MinUInt [static]

Definition at line 57 of file pythonscript.c.

Referenced by python_to_c_var(), and pythonscript_LTX_start().

script_module_t my_script_interface

Initial value:

 {
  "Python", NULL,
  my_load_script,
  my_link_var, my_unlink_var,
  my_create_command, my_delete_command,
  my_get_arg
}

Definition at line 42 of file pythonscript.c.

bind_list_t party_commands[] [static]

Initial value:

 {
  {"n", "python", (Function) party_python},
  {"n", "load", (Function) mls},
  {0}
}

Definition at line 622 of file pythonscript.c.

PyObject * PartylineDict [static]

Definition at line 56 of file pythonscript.c.

Referenced by party_python(), and pythonscript_LTX_start().

PyObject * PartylineModule [static]

Definition at line 56 of file pythonscript.c.

Referenced by pythonscript_LTX_start().

egg_module_t* python_modinfo [static]

Definition at line 50 of file pythonscript.c.

static event_owner_t * python_owner = 0 [static]

Definition at line 53 of file pythonscript.c.

int python_owners = 0 [static]

Definition at line 52 of file pythonscript.c.

Referenced by GetContext(), my_load_script(), and pythonscript_LTX_start().

const char rcsid[] = "$Id: pythonscript.c,v 1.6 2008-10-17 15:57:42 sven Exp $" [static]

Definition at line 21 of file pythonscript.c.

PyObject * RealHelper [static]

Definition at line 56 of file pythonscript.c.

Referenced by Help(), and pythonscript_LTX_start().

PyObject * SysMod [static]

Definition at line 56 of file pythonscript.c.

Referenced by Help(), and pythonscript_LTX_start().

PyObject * SysModules [static]

Definition at line 56 of file pythonscript.c.

Referenced by GetContext(), and pythonscript_LTX_start().

PyObject* SysPath [static]

Definition at line 56 of file pythonscript.c.

Referenced by my_load_script(), and pythonscript_LTX_start().