modules/pythonscript/pythonscript.h File Reference

Go to the source code of this file.

Data Structures
struct	CallableObject
struct	EgguserObject
struct	MyDictObject
Defines
#define	PYTHON_VAR   1
#define	PYTHON_FUNC   2
#define	Callable_Check(op)   PyObject_TypeCheck(op, &Callable_Type)
#define	Egguser_Check(op)   PyObject_TypeCheck(op, &Egguser_Type)
#define	FlushAll()
Functions
void	Flush (unsigned Target)
PyObject *	c_to_python_var (script_var_t *v)
int	python_to_c_var (PyObject *obj, script_var_t *var, int type)
int	MyModule_Init (void)
PyObject *	GetVar (script_linked_var_t *var)
int	SetVar (script_linked_var_t *var, PyObject *Value)
PyObject *	MyModule_Add (char *name, char *doc)
PyObject *	MyDict_New (PyTypeObject *Type, PyObject *args, PyObject *kwds)
Variables
partymember_t *	LogTarget
script_module_t	my_script_interface
PyTypeObject	Callable_Type
PyTypeObject	MyDict_Type
PyTypeObject	Stdio_Type
PyTypeObject	Egguser_Type
PyObject *	EggdropModule

---

Define Documentation

#define Callable_Check

(

op

)

PyObject_TypeCheck(op, &Callable_Type)

Definition at line 25 of file pythonscript.h.

Referenced by Help().

#define Egguser_Check

(

op

)

PyObject_TypeCheck(op, &Egguser_Type)

Definition at line 26 of file pythonscript.h.

Referenced by Compare(), Egguser_New(), and python_to_c_var().

 

#define FlushAll

(

)

Value:

do {\
  Flush(0);\
  Flush(1);\
} while (0)

Definition at line 28 of file pythonscript.h.

Referenced by Help(), my_create_command(), my_link_var(), my_load_script(), my_python_callbacker(), and party_python().

#define PYTHON_FUNC   2

Definition at line 23 of file pythonscript.h.

Referenced by GetDoc(), GetItem(), my_command_handler(), my_create_command(), and Repr().

#define PYTHON_VAR   1

Definition at line 22 of file pythonscript.h.

Referenced by my_link_var(), SetAttr(), and SetItem().

---

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;
}

void Flush

(

unsigned

Target

)

Definition at line 118 of file mystdio.c.

References Write().

Referenced by Stdio_Flush().

                            {
  if (LineBuf[Target].strlen) Write(Target, "\n", 1);
}

PyObject* GetVar

(

script_linked_var_t *

var

)

Definition at line 36 of file mydict.c.

References c_to_python_var(), script_linked_var_b::callbacks, script_var_b::len, script_linked_var_b::name, script_var_callbacks_b::on_read, SCRIPT_TYPE_MASK, script_linked_var_b::type, script_var_b::type, script_linked_var_b::value, and script_var_b::value.

Referenced by GetItem(), and Repr().

                                           {
  script_var_t newvalue = {0};

  newvalue.len = -1;
  if (var->callbacks && var->callbacks->on_read) {
    if (var->callbacks->on_read(var, &newvalue)) {
      PyErr_Format(PyExc_LookupError, "internal eggdrop error in 'on_read' function for '%s'", var->name);
      return 0;
    }
  } else {
    newvalue.type = var->type & SCRIPT_TYPE_MASK;;
    newvalue.value = *(void **)var->value;
  }
  return c_to_python_var(&newvalue);
}

PyObject* MyDict_New	(	PyTypeObject *	Type,
		PyObject *	args,
		PyObject *	kwds
	)

Definition at line 31 of file mydict.c.

Referenced by MyModule_New().

                                                                         {
  PyObject *O = PyDict_Type.tp_new(Type, args, kwds);
  return O;
}

PyObject* MyModule_Add	(	char *	name,
		char *	doc
	)

Definition at line 63 of file mymodule.c.

References MyModule_New().

Referenced by pythonscript_LTX_start().

                                              {
  PyObject *Modules, *ModuleObj;

  Modules = PyImport_GetModuleDict();        /* Warning: Borrowed reference */
  if ((ModuleObj = PyDict_GetItemString(Modules, name)) && PyModule_Check(ModuleObj)) return ModuleObj;
  ModuleObj = MyModule_New(name);            /* new reference */
  if (!ModuleObj) return 0;
  if (PyDict_SetItemString(Modules, name, ModuleObj)) {
    Py_DECREF(ModuleObj);
    return 0;
  }

  if (doc) {
    PyObject **DictPtr, *DocObj;

    DictPtr = _PyObject_GetDictPtr(ModuleObj);
    DocObj = PyString_FromString(doc);       /* new reference */
    if (DocObj) PyDict_SetItemString(*DictPtr, "__doc__", DocObj);
    Py_XDECREF(DocObj);
    PyErr_Clear();
  }

  Py_DECREF(ModuleObj); /* Yes, it still exists, in modules! */
  return ModuleObj;
}

int MyModule_Init

(

void

)

Definition at line 174 of file mymodule.c.

References DictString, and MyModule_Type.

Referenced by pythonscript_LTX_start().

                    {
  MyModule_Type.tp_basicsize = PyModule_Type.tp_basicsize;
  MyModule_Type.tp_dictoffset = PyModule_Type.tp_dictoffset;
  DictString = PyString_FromString("__dict__");
  return PyType_Ready(&MyModule_Type);
}

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;
}

int SetVar	(	script_linked_var_t *	var,
		PyObject *	Value
	)

Definition at line 52 of file mydict.c.

References python_to_c_var(), script_linked_var_on_write(), and script_linked_var_b::type.

Referenced by SetAttr(), and SetItem().

                                                      {
  script_var_t newvalue = {0};

  if (python_to_c_var(Value, &newvalue, var->type)) return 1;
  if (script_linked_var_on_write(var, &newvalue)) {
    PyErr_SetString(PyExc_RuntimeError, "set");
    return 1;
  }
  return 0;
}

---

Variable Documentation

PyTypeObject Callable_Type

Definition at line 61 of file pythonscript.h.

PyObject* EggdropModule

Definition at line 62 of file pythonscript.h.

Referenced by my_create_command(), my_delete_command(), my_link_var(), my_unlink_var(), and pythonscript_LTX_start().

PyTypeObject Egguser_Type

Definition at line 61 of file pythonscript.h.

partymember_t* LogTarget

Definition at line 48 of file pythonscript.h.

script_module_t my_script_interface

Definition at line 50 of file pythonscript.h.

PyTypeObject MyDict_Type

Definition at line 61 of file pythonscript.h.

PyTypeObject Stdio_Type

Definition at line 61 of file pythonscript.h.