1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
|
/*
py/pyext - python script object for PD and MaxMSP
Copyright (c)2002-2005 Thomas Grill (gr@grrrr.org)
For information on usage and redistribution, and for a DISCLAIMER OF ALL
WARRANTIES, see the file, "license.txt," in this distribution.
*/
#ifndef __PYBASE_H
#define __PYBASE_H
#include "main.h"
#include "pysymbol.h"
#include "pybuffer.h"
class pybase
: public flext
{
public:
pybase();
virtual ~pybase();
void Exit();
static PyObject *MakePyArgs(const t_symbol *s,int argc,const t_atom *argv,int inlet = -1);
static PyObject *MakePyArg(const t_symbol *s,int argc,const t_atom *argv);
static const t_symbol *GetPyArgs(AtomList &lst,PyObject *pValue,int offs = 0);
static const t_symbol *GetPyAtom(AtomList &lst,PyObject *pValue);
static void lib_setup();
protected:
virtual void DumpOut(const t_symbol *sym,int argc,const t_atom *argv) = 0;
void m__dir(PyObject *obj);
void m__doc(PyObject *obj);
void m_dir() { m__dir(module); }
void mg_dir(AtomList &lst) { m__dir(module); }
void m_doc() { m__doc(dict); }
std::string modname; // module name
PyObject *module,*dict; // object module and associated dictionary
static const char *py_doc;
void GetDir(PyObject *obj,AtomList &lst);
AtomList args;
void AddCurrentPath(t_canvas *cnv);
void GetModulePath(const char *mod,char *dir,int len);
void AddToPath(const char *dir);
void SetArgs();
bool OutObject(flext_base *ext,int o,PyObject *obj);
// reload module and all connected objects
void Reload();
bool ImportModule(const char *name);
void UnimportModule();
bool ReloadModule();
// Get module registry
PyObject *GetRegistry(const char *regname);
// Set module registry
void SetRegistry(const char *regname,PyObject *reg);
// Register object
void Register(PyObject *reg);
// Unregister object
void Unregister(PyObject *reg);
virtual void LoadModule() = 0;
virtual void UnloadModule() = 0;
virtual void Load() = 0;
virtual void Unload() = 0;
void OpenEditor();
void Respond(bool b);
void Report() { while(PyErr_Occurred()) PyErr_Print(); }
static bool IsAnything(const t_symbol *s) { return s && s != sym_float && s != sym_int && s != sym_symbol && s != sym_list && s != sym_pointer; }
static bool IsAtom(const t_symbol *s) { return s == sym_float || s == sym_int || s == sym_symbol || s == sym_pointer; }
// enum retval { nothing,atom,sequ };
// --- module stuff -----
static PyObject *module_obj,*module_dict;
static PyObject *builtins_obj,*builtins_dict;
static PyMethodDef func_tbl[];
static PyObject *py__doc__(PyObject *,PyObject *args);
static PyObject *py_send(PyObject *,PyObject *args);
#ifdef FLEXT_THREADS
static PyObject *py_priority(PyObject *,PyObject *args);
#endif
static PyObject *py_arraysupport(PyObject *,PyObject *args);
static PyObject *py_samplerate(PyObject *,PyObject *args);
static PyObject *py_blocksize(PyObject *,PyObject *args);
#if FLEXT_SYS == FLEXT_SYS_PD
static PyObject *py_getvalue(PyObject *,PyObject *args);
static PyObject *py_setvalue(PyObject *,PyObject *args);
#endif
#ifdef PY_NUMARRAY
static void setupNumarray();
static PyObject *py_import(PyObject *,PyObject *args);
static PyObject *py_export(PyObject *,PyObject *args);
#endif
// ----thread stuff ------------
virtual void m_stop(int argc,const t_atom *argv);
bool respond;
#ifdef FLEXT_THREADS
bool shouldexit;
int thrcount;
int stoptick;
Timer stoptmr;
void tick(void *);
#endif
int detach;
bool xlate;
bool gencall(PyObject *fun,PyObject *args);
bool docall(PyObject *fun,PyObject *args)
{
callpy(fun,args);
if(PyErr_Occurred()) {
exchandle();
return false;
}
else
return true;
}
// virtual bool thrcall(void *data) = 0;
virtual void callpy(PyObject *fun,PyObject *args) = 0;
void exchandle();
#if FLEXT_SYS == FLEXT_SYS_MAX
static short patcher_myvol(t_patcher *x);
#endif
static bool collect();
protected:
#ifdef FLEXT_THREADS
static void thrworker(thr_params *data);
bool qucall(PyObject *fun,PyObject *args);
static void quworker(thr_params *);
void erasethreads();
static PyFifo qufifo;
static ThrCond qucond;
static PyThreadState *pythrsys;
static PyThreadState *FindThreadState();
static void FreeThreadState();
#else
static PyThreadState *FindThreadState() { return NULL; }
#endif
static const t_symbol *sym_fint; // float or int symbol, depending on native number message type
static const t_symbol *getone(t_atom &at,PyObject *arg);
static const t_symbol *getlist(t_atom *lst,PyObject *seq,int cnt,int offs = 0);
public:
#ifdef FLEXT_THREADS
ThrMutex mutex;
inline void Lock() { mutex.Unlock(); }
inline void Unlock() { mutex.Unlock(); }
// this is especially needed when one py/pyext object calls another one
// we don't want the message to be queued, but otoh we have to avoid deadlock
// (recursive calls can only happen in the system thread)
static int lockcount;
static PyThreadState *PyLock(PyThreadState *st = FindThreadState())
{
if(!IsSystemThread() || !lockcount++) PyEval_AcquireLock();
return PyThreadState_Swap(st);
}
static PyThreadState *PyLockSys()
{
if(!lockcount++) PyEval_AcquireLock();
return PyThreadState_Swap(pythrsys);
}
static void PyUnlock(PyThreadState *st)
{
PyThreadState *old = PyThreadState_Swap(st);
if(old != pythrsys || !--lockcount) PyEval_ReleaseLock();
}
#else
inline void Lock() {}
inline void Unlock() {}
static PyThreadState *PyLock(PyThreadState * = NULL) { return NULL; }
static PyThreadState *PyLockSys() { return NULL; }
static void PyUnlock(PyThreadState *st) {}
#endif
static PyObject* StdOut_Write(PyObject* Self, PyObject* Args);
};
#endif
|
