Blender's debug mode only worked on startup:
[blender-staging.git] / source / blender / python / api2_2x / Sys.c
1 /* 
2  *
3  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version. The Blender
9  * Foundation also sells licenses for use in proprietary software under
10  * the Blender License.  See http://www.blender.org/BL/ for information
11  * about this.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 59 Temple Place - Suite 330, Boston, MA        02111-1307, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * This is a new part of Blender.
26  *
27  * Contributor(s): Willian P. Germano
28  *
29  * ***** END GPL/BL DUAL LICENSE BLOCK *****
30 */
31
32 #include "BKE_utildefines.h"
33
34 #include "Sys.h"
35
36 static PyObject *g_sysmodule = NULL; /* pointer to Blender.sys module */
37
38 PyObject *sys_Init (void)
39 {
40         PyObject        *submodule, *dict, *sep;
41
42         submodule = Py_InitModule3("Blender.sys", M_sys_methods, M_sys_doc);
43
44         g_sysmodule = submodule;
45
46         dict = PyModule_GetDict(submodule);
47
48 #ifdef WIN32
49         sep = Py_BuildValue("s", "\\");
50 #else
51         sep = Py_BuildValue("s", "/");
52 #endif
53
54         if (sep) {
55                 Py_INCREF(sep);
56                 PyDict_SetItemString(dict, "dirsep" , sep);
57                 PyDict_SetItemString(dict, "sep" , sep);
58         }
59
60         return submodule;
61 }
62
63 static PyObject *M_sys_basename (PyObject *self, PyObject *args)
64 {
65         PyObject *c;
66
67         char *name, *p, basename[FILE_MAXFILE];
68         char sep;
69         int n, len;
70
71         if (!PyArg_ParseTuple(args, "s", &name))
72                 return EXPP_ReturnPyObjError (PyExc_TypeError,
73                                                         "expected string argument");
74
75         len = strlen(name);
76
77         c = PyObject_GetAttrString (g_sysmodule, "dirsep");
78         sep = PyString_AsString(c)[0];
79         Py_DECREF(c);
80
81         p = strrchr(name, sep);
82
83         if (p) {
84                 n = name + len - p - 1; /* - 1 because we don't want the sep */
85
86                 if (n > FILE_MAXFILE)
87                         return EXPP_ReturnPyObjError(PyExc_RuntimeError, "path too long");
88
89                 strncpy(basename, p+1, n); /* + 1 to skip the sep */
90                 basename[n] = 0;
91                 return Py_BuildValue("s", basename);
92         }
93
94         return Py_BuildValue("s", name);
95 }
96
97 static PyObject *M_sys_dirname (PyObject *self, PyObject *args)
98 {
99         PyObject *c;
100
101         char *name, *p, dirname[FILE_MAXDIR];
102         char sep;
103         int n;
104
105         if (!PyArg_ParseTuple(args, "s", &name))
106                 return EXPP_ReturnPyObjError (PyExc_TypeError,
107                                                         "expected string argument");
108
109         c = PyObject_GetAttrString (g_sysmodule, "dirsep");
110         sep = PyString_AsString(c)[0];
111         Py_DECREF(c);
112
113         p = strrchr(name, sep);
114
115         if (p) {
116                 n = p - name;
117
118                 if (n > FILE_MAXDIR)
119                         return EXPP_ReturnPyObjError (PyExc_RuntimeError, "path too long");
120
121                 strncpy(dirname, name, n);
122                 dirname[n] = 0;
123                 return Py_BuildValue("s", dirname);
124         }
125
126         return Py_BuildValue("s", "."); /* XXX need to fix this? (is crossplatform?)*/
127 }
128
129 static PyObject *M_sys_splitext (PyObject *self, PyObject *args)
130 {
131         PyObject *c;
132
133         char *name, *dot, *p, path[FILE_MAXFILE], ext[FILE_MAXFILE];
134         char sep;
135         int n, len;
136
137         if (!PyArg_ParseTuple(args, "s", &name))
138                 return EXPP_ReturnPyObjError (PyExc_TypeError,
139                                                         "expected string argument");
140
141         len = strlen(name);
142
143         c = PyObject_GetAttrString (g_sysmodule, "dirsep");
144         sep = PyString_AsString(c)[0];
145         Py_DECREF(c);
146
147         dot = strrchr(name, '.');
148
149         if (!dot) return Py_BuildValue("ss", name, "");
150
151         p = strrchr(name, sep);
152
153         if (p) {
154                 if (p > dot) return Py_BuildValue("ss", name, "");
155         }
156
157         n = name + len - dot;
158
159         /* loong extensions are supported -- foolish, but Python's os.path.splitext
160          * supports them, so ... */
161         if (n > FILE_MAXFILE || (len - n ) > FILE_MAXFILE)
162                 EXPP_ReturnPyObjError(PyExc_RuntimeError, "path too long");
163
164         strncpy(ext, dot, n);
165         ext[n] = 0;
166         strncpy(path, name, dot - name);
167         path[dot - name] = 0;
168
169         return Py_BuildValue("ss", path, ext);
170 }