BPython:
[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 #include "PIL_time.h"
34
35 #include "Sys.h"
36
37 static PyObject *g_sysmodule = NULL; /* pointer to Blender.sys module */
38
39 PyObject *sys_Init (void)
40 {
41         PyObject        *submodule, *dict, *sep;
42
43         submodule = Py_InitModule3("Blender.sys", M_sys_methods, M_sys_doc);
44
45         g_sysmodule = submodule;
46
47         dict = PyModule_GetDict(submodule);
48
49 #ifdef WIN32
50         sep = Py_BuildValue("s", "\\");
51 #else
52         sep = Py_BuildValue("s", "/");
53 #endif
54
55         if (sep) {
56                 Py_INCREF(sep);
57                 PyDict_SetItemString(dict, "dirsep" , sep);
58                 PyDict_SetItemString(dict, "sep" , sep);
59         }
60
61         return submodule;
62 }
63
64 static PyObject *M_sys_basename (PyObject *self, PyObject *args)
65 {
66         PyObject *c;
67
68         char *name, *p, basename[FILE_MAXFILE];
69         char sep;
70         int n, len;
71
72         if (!PyArg_ParseTuple(args, "s", &name))
73                 return EXPP_ReturnPyObjError (PyExc_TypeError,
74                                                         "expected string argument");
75
76         len = strlen(name);
77
78         c = PyObject_GetAttrString (g_sysmodule, "dirsep");
79         sep = PyString_AsString(c)[0];
80         Py_DECREF(c);
81
82         p = strrchr(name, sep);
83
84         if (p) {
85                 n = name + len - p - 1; /* - 1 because we don't want the sep */
86
87                 if (n > FILE_MAXFILE)
88                         return EXPP_ReturnPyObjError(PyExc_RuntimeError, "path too long");
89
90                 strncpy(basename, p+1, n); /* + 1 to skip the sep */
91                 basename[n] = 0;
92                 return Py_BuildValue("s", basename);
93         }
94
95         return Py_BuildValue("s", name);
96 }
97
98 static PyObject *M_sys_dirname (PyObject *self, PyObject *args)
99 {
100         PyObject *c;
101
102         char *name, *p, dirname[FILE_MAXDIR];
103         char sep;
104         int n;
105
106         if (!PyArg_ParseTuple(args, "s", &name))
107                 return EXPP_ReturnPyObjError (PyExc_TypeError,
108                                                         "expected string argument");
109
110         c = PyObject_GetAttrString (g_sysmodule, "dirsep");
111         sep = PyString_AsString(c)[0];
112         Py_DECREF(c);
113
114         p = strrchr(name, sep);
115
116         if (p) {
117                 n = p - name;
118
119                 if (n > FILE_MAXDIR)
120                         return EXPP_ReturnPyObjError (PyExc_RuntimeError, "path too long");
121
122                 strncpy(dirname, name, n);
123                 dirname[n] = 0;
124                 return Py_BuildValue("s", dirname);
125         }
126
127         return Py_BuildValue("s", "."); /* XXX need to fix this? (is crossplatform?)*/
128 }
129
130 static PyObject *M_sys_splitext (PyObject *self, PyObject *args)
131 {
132         PyObject *c;
133
134         char *name, *dot, *p, path[FILE_MAXFILE], ext[FILE_MAXFILE];
135         char sep;
136         int n, len;
137
138         if (!PyArg_ParseTuple(args, "s", &name))
139                 return EXPP_ReturnPyObjError (PyExc_TypeError,
140                                                         "expected string argument");
141
142         len = strlen(name);
143
144         c = PyObject_GetAttrString (g_sysmodule, "dirsep");
145         sep = PyString_AsString(c)[0];
146         Py_DECREF(c);
147
148         dot = strrchr(name, '.');
149
150         if (!dot) return Py_BuildValue("ss", name, "");
151
152         p = strrchr(name, sep);
153
154         if (p) {
155                 if (p > dot) return Py_BuildValue("ss", name, "");
156         }
157
158         n = name + len - dot;
159
160         /* loong extensions are supported -- foolish, but Python's os.path.splitext
161          * supports them, so ... */
162         if (n > FILE_MAXFILE || (len - n ) > FILE_MAXFILE)
163                 EXPP_ReturnPyObjError(PyExc_RuntimeError, "path too long");
164
165         strncpy(ext, dot, n);
166         ext[n] = 0;
167         strncpy(path, name, dot - name);
168         path[dot - name] = 0;
169
170         return Py_BuildValue("ss", path, ext);
171 }
172
173 static PyObject *M_sys_time (PyObject *self)
174 {
175         double t = PIL_check_seconds_timer();
176         return Py_BuildValue("d", t);
177 }
178