← Back to branch summary

~registry/codeblocks/trunk

« back to all changes in this revision

Viewing changes to src/sdk/scripting/sqplus/SqPlusConst.h

  • Committer: mandrav
  • Date: 2007-02-12 14:55:28 UTC
  • Revision ID: svn-v4:98b59c6a-2706-0410-b7d6-d2fa1a1880c9:trunk:3594
* First part of directories layout re-organization: moved all sdk header files to a new dir named "include".

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/sdk/scripting/sqplus/SqPlusConst.h
1
 
// SqPlusConst.h
2
 
// SqPlus constant type and constant member function support created by Simon Michelmore.
3
 
// Modular integration 11/14/05 jcs.
4
 
 
5
 
#ifdef SQPLUS_DECLARE_INSTANCE_TYPE_CONST
6
 
#undef SQPLUS_DECLARE_INSTANCE_TYPE_CONST
7
 
 
8
 
// Kamaitati's NULL_INSTANCE support. 5/28/06 jcs
9
 
 
10
 
#ifdef SQPLUS_SUPPORT_NULL_INSTANCES
11
 
 
12
 
#define DECLARE_INSTANCE_TYPE_NAME_CONST(TYPE,NAME) \
13
 
DECLARE_INSTANCE_TYPE_NAME_(TYPE,NAME) \
14
 
namespace SqPlus { \
15
 
inline void Push(HSQUIRRELVM v,const TYPE * value) { \
16
 
  if (!value) sq_pushnull(v); \
17
 
  else if (!CreateNativeClassInstance(v,GetTypeName(*value),(TYPE*)value,0)) \
18
 
    throw SquirrelError(sqT("Push(): could not create INSTANCE (check registration name)")); } \
19
 
inline void Push(HSQUIRRELVM v,const TYPE & value) { if (!CreateCopyInstance(GetTypeName(value),value)) throw SquirrelError(sqT("Push(): could not create INSTANCE copy (check registration name)")); } \
20
 
inline bool Match(TypeWrapper<const TYPE &>,HSQUIRRELVM v,int idx) { return  GetInstance<TYPE>(v,idx) != NULL; } \
21
 
inline const TYPE & Get(TypeWrapper<const TYPE &>,HSQUIRRELVM v,int idx) { return *GetInstance<TYPE>(v,idx); } \
22
 
} // nameSpace SqPlus
23
 
 
24
 
#else
25
 
 
26
 
#define DECLARE_INSTANCE_TYPE_NAME_CONST(TYPE,NAME) \
27
 
DECLARE_INSTANCE_TYPE_NAME_(TYPE,NAME) \
28
 
namespace SqPlus { \
29
 
inline void Push(HSQUIRRELVM v,const TYPE * value) { if (!CreateNativeClassInstance(v,GetTypeName(*value),(TYPE*)value,0)) throw SquirrelError(sqT("Push(): could not create INSTANCE (check registration name)")); } \
30
 
inline void Push(HSQUIRRELVM v,const TYPE & value) { if (!CreateCopyInstance(GetTypeName(value),value)) throw SquirrelError(sqT("Push(): could not create INSTANCE copy (check registration name)")); } \
31
 
inline bool     Match(TypeWrapper<const TYPE &>,HSQUIRRELVM v,int idx) { return  GetInstance<TYPE>(v,idx) != NULL; } \
32
 
inline const TYPE & Get(TypeWrapper<const TYPE &>,HSQUIRRELVM v,int idx) { return *GetInstance<TYPE>(v,idx); } \
33
 
} // nameSpace SqPlus
34
 
 
35
 
#endif
36
 
 
37
 
#define DECLARE_INSTANCE_TYPE(TYPE) DECLARE_INSTANCE_TYPE_NAME_CONST(TYPE,TYPE)
38
 
#define DECLARE_INSTANCE_TYPE_NAME(TYPE,NAME) DECLARE_INSTANCE_TYPE_NAME_CONST(TYPE,NAME)
39
 
#endif
40
 
 
41
 
#ifdef SQPLUS_CALL_CONST_MFUNC_RET0
42
 
#undef SQPLUS_CALL_CONST_MFUNC_RET0
43
 
template <typename Callee>
44
 
static int Call(Callee & callee,RT (Callee::*func)() const,HSQUIRRELVM v,int /*index*/) {
45
 
  RT ret = (callee.*func)();
46
 
  Push(v,ret);
47
 
  return 1;
48
 
}
49
 
 
50
 
template <typename Callee,typename P1>
51
 
static int Call(Callee & callee,RT (Callee::*func)(P1) const,HSQUIRRELVM v,int index) {
52
 
  sq_argassert(1,index + 0);
53
 
  RT ret = (callee.*func)(
54
 
    Get(TypeWrapper<P1>(),v,index + 0)
55
 
    );
56
 
  Push(v,ret);
57
 
  return 1;
58
 
}
59
 
 
60
 
template<typename Callee,typename P1,typename P2>
61
 
static int Call(Callee & callee,RT (Callee::*func)(P1,P2) const,HSQUIRRELVM v,int index) {
62
 
  sq_argassert(1,index + 0);
63
 
  sq_argassert(2,index + 1);
64
 
  RT ret = (callee.*func)(
65
 
    Get(TypeWrapper<P1>(),v,index + 0),
66
 
    Get(TypeWrapper<P2>(),v,index + 1)
67
 
    );
68
 
  Push(v,ret);
69
 
  return 1;
70
 
}
71
 
 
72
 
template<typename Callee,typename P1,typename P2,typename P3>
73
 
static int Call(Callee & callee,RT (Callee::*func)(P1,P2,P3) const,HSQUIRRELVM v,int index) {
74
 
  sq_argassert(1,index + 0);
75
 
  sq_argassert(2,index + 1);
76
 
  sq_argassert(3,index + 2);
77
 
  RT ret = (callee.*func)(
78
 
    Get(TypeWrapper<P1>(),v,index + 0),
79
 
    Get(TypeWrapper<P2>(),v,index + 1),
80
 
    Get(TypeWrapper<P3>(),v,index + 2)
81
 
    );
82
 
  Push(v,ret);
83
 
  return 1;
84
 
}
85
 
 
86
 
template<typename Callee,typename P1,typename P2,typename P3,typename P4>
87
 
static int Call(Callee & callee,RT (Callee::*func)(P1,P2,P3,P4) const,HSQUIRRELVM v,int index) {
88
 
  sq_argassert(1,index + 0);
89
 
  sq_argassert(2,index + 1);
90
 
  sq_argassert(3,index + 2);
91
 
  sq_argassert(4,index + 3);
92
 
  RT ret = (callee.*func)(
93
 
    Get(TypeWrapper<P1>(),v,index + 0),
94
 
    Get(TypeWrapper<P2>(),v,index + 1),
95
 
    Get(TypeWrapper<P3>(),v,index + 2),
96
 
    Get(TypeWrapper<P4>(),v,index + 3)
97
 
    );
98
 
  Push(v,ret);
99
 
  return 1;
100
 
}
101
 
 
102
 
template<typename Callee,typename P1,typename P2,typename P3,typename P4,typename P5>
103
 
static int Call(Callee & callee,RT (Callee::*func)(P1,P2,P3,P4,P5) const,HSQUIRRELVM v,int index) {
104
 
  sq_argassert(1,index + 0);
105
 
  sq_argassert(2,index + 1);
106
 
  sq_argassert(3,index + 2);
107
 
  sq_argassert(4,index + 3);
108
 
  sq_argassert(5,index + 4);
109
 
  RT ret = (callee.*func)(
110
 
    Get(TypeWrapper<P1>(),v,index + 0),
111
 
    Get(TypeWrapper<P2>(),v,index + 1),
112
 
    Get(TypeWrapper<P3>(),v,index + 2),
113
 
    Get(TypeWrapper<P4>(),v,index + 3),
114
 
    Get(TypeWrapper<P5>(),v,index + 4)
115
 
    );
116
 
  Push(v,ret);
117
 
  return 1;
118
 
}
119
 
 
120
 
template<typename Callee,typename P1,typename P2,typename P3,typename P4,typename P5,typename P6>
121
 
static int Call(Callee & callee,RT (Callee::*func)(P1,P2,P3,P4,P5,P6) const,HSQUIRRELVM v,int index) {
122
 
  sq_argassert(1,index + 0);
123
 
  sq_argassert(2,index + 1);
124
 
  sq_argassert(3,index + 2);
125
 
  sq_argassert(4,index + 3);
126
 
  sq_argassert(5,index + 4);
127
 
  sq_argassert(6,index + 5);
128
 
  RT ret = (callee.*func)(
129
 
    Get(TypeWrapper<P1>(),v,index + 0),
130
 
    Get(TypeWrapper<P2>(),v,index + 1),
131
 
    Get(TypeWrapper<P3>(),v,index + 2),
132
 
    Get(TypeWrapper<P4>(),v,index + 3),
133
 
    Get(TypeWrapper<P5>(),v,index + 4),
134
 
    Get(TypeWrapper<P6>(),v,index + 5)
135
 
    );
136
 
  Push(v,ret);
137
 
  return 1;
138
 
}
139
 
 
140
 
template<typename Callee,typename P1,typename P2,typename P3,typename P4,typename P5,typename P6,typename P7>
141
 
static int Call(Callee & callee,RT (Callee::*func)(P1,P2,P3,P4,P5,P6,P7) const,HSQUIRRELVM v,int index) {
142
 
  sq_argassert(1,index + 0);
143
 
  sq_argassert(2,index + 1);
144
 
  sq_argassert(3,index + 2);
145
 
  sq_argassert(4,index + 3);
146
 
  sq_argassert(5,index + 4);
147
 
  sq_argassert(6,index + 5);
148
 
  sq_argassert(7,index + 6);
149
 
  RT ret = (callee.*func)(
150
 
    Get(TypeWrapper<P1>(),v,index + 0),
151
 
    Get(TypeWrapper<P2>(),v,index + 1),
152
 
    Get(TypeWrapper<P3>(),v,index + 2),
153
 
    Get(TypeWrapper<P4>(),v,index + 3),
154
 
    Get(TypeWrapper<P5>(),v,index + 4),
155
 
    Get(TypeWrapper<P6>(),v,index + 5),
156
 
    Get(TypeWrapper<P7>(),v,index + 6)
157
 
    );
158
 
  Push(v,ret);
159
 
  return 1;
160
 
}
161
 
#endif
162
 
 
163
 
#ifdef SQPLUS_CALL_CONST_MFUNC_NORET
164
 
#undef SQPLUS_CALL_CONST_MFUNC_NORET
165
 
template<typename Callee>
166
 
static int Call(Callee & callee,void (Callee::*func)() const,HSQUIRRELVM,int /*index*/) {
167
 
  (callee.*func)();
168
 
  return 0;
169
 
}
170
 
 
171
 
template<typename Callee,typename P1>
172
 
static int Call(Callee & callee,void (Callee::*func)(P1) const,HSQUIRRELVM v,int index) {
173
 
  sq_argassert(1,index + 0);
174
 
  (callee.*func)(
175
 
    Get(TypeWrapper<P1>(),v,index + 0)
176
 
    );
177
 
  return 0;
178
 
}
179
 
 
180
 
template<typename Callee,typename P1,typename P2>
181
 
static int Call(Callee & callee,void (Callee::*func)(P1,P2) const,HSQUIRRELVM v,int index) {
182
 
  sq_argassert(1,index + 0);
183
 
  sq_argassert(2,index + 1);
184
 
  (callee.*func)(
185
 
    Get(TypeWrapper<P1>(),v,index + 0),
186
 
    Get(TypeWrapper<P2>(),v,index + 1)
187
 
    );
188
 
  return 0;
189
 
}
190
 
 
191
 
template<typename Callee,typename P1,typename P2,typename P3>
192
 
static int Call(Callee & callee,void (Callee::*func)(P1,P2,P3) const,HSQUIRRELVM v,int index) {
193
 
  sq_argassert(1,index + 0);
194
 
  sq_argassert(2,index + 1);
195
 
  sq_argassert(3,index + 2);
196
 
  (callee.*func)(
197
 
    Get(TypeWrapper<P1>(),v,index + 0),
198
 
    Get(TypeWrapper<P2>(),v,index + 1),
199
 
    Get(TypeWrapper<P3>(),v,index + 2)
200
 
    );
201
 
  return 0;
202
 
}
203
 
 
204
 
template<typename Callee,typename P1,typename P2,typename P3,typename P4>
205
 
static int Call(Callee & callee,void (Callee::*func)(P1,P2,P3,P4) const,HSQUIRRELVM v,int index) {
206
 
  sq_argassert(1,index + 0);
207
 
  sq_argassert(2,index + 1);
208
 
  sq_argassert(3,index + 2);
209
 
  sq_argassert(4,index + 3);
210
 
  (callee.*func)(
211
 
    Get(TypeWrapper<P1>(),v,index + 0),
212
 
    Get(TypeWrapper<P2>(),v,index + 1),
213
 
    Get(TypeWrapper<P3>(),v,index + 2),
214
 
    Get(TypeWrapper<P4>(),v,index + 3)
215
 
    );
216
 
  return 0;
217
 
}
218
 
 
219
 
template<typename Callee,typename P1,typename P2,typename P3,typename P4,typename P5>
220
 
static int Call(Callee & callee,void (Callee::*func)(P1,P2,P3,P4,P5) const,HSQUIRRELVM v,int index) {
221
 
  sq_argassert(1,index + 0);
222
 
  sq_argassert(2,index + 1);
223
 
  sq_argassert(3,index + 2);
224
 
  sq_argassert(4,index + 3);
225
 
  sq_argassert(5,index + 4);
226
 
  (callee.*func)(
227
 
    Get(TypeWrapper<P1>(),v,index + 0),
228
 
    Get(TypeWrapper<P2>(),v,index + 1),
229
 
    Get(TypeWrapper<P3>(),v,index + 2),
230
 
    Get(TypeWrapper<P4>(),v,index + 3),
231
 
    Get(TypeWrapper<P5>(),v,index + 4)
232
 
    );
233
 
  return 0;
234
 
}
235
 
 
236
 
template<typename Callee,typename P1,typename P2,typename P3,typename P4,typename P5,typename P6>
237
 
static int Call(Callee & callee,void (Callee::*func)(P1,P2,P3,P4,P5,P6) const,HSQUIRRELVM v,int index) {
238
 
  sq_argassert(1,index + 0);
239
 
  sq_argassert(2,index + 1);
240
 
  sq_argassert(3,index + 2);
241
 
  sq_argassert(4,index + 3);
242
 
  sq_argassert(5,index + 4);
243
 
  sq_argassert(6,index + 5);
244
 
  (callee.*func)(
245
 
    Get(TypeWrapper<P1>(),v,index + 0),
246
 
    Get(TypeWrapper<P2>(),v,index + 1),
247
 
    Get(TypeWrapper<P3>(),v,index + 2),
248
 
    Get(TypeWrapper<P4>(),v,index + 3),
249
 
    Get(TypeWrapper<P5>(),v,index + 4),
250
 
    Get(TypeWrapper<P6>(),v,index + 5)
251
 
    );
252
 
  return 0;
253
 
}
254
 
 
255
 
template<typename Callee,typename P1,typename P2,typename P3,typename P4,typename P5,typename P6,typename P7>
256
 
static int Call(Callee & callee,void (Callee::*func)(P1,P2,P3,P4,P5,P6,P7) const,HSQUIRRELVM v,int index) {
257
 
  sq_argassert(1,index + 0);
258
 
  sq_argassert(2,index + 1);
259
 
  sq_argassert(3,index + 2);
260
 
  sq_argassert(4,index + 3);
261
 
  sq_argassert(5,index + 4);
262
 
  sq_argassert(6,index + 5);
263
 
  sq_argassert(7,index + 6);
264
 
  (callee.*func)(
265
 
    Get(TypeWrapper<P1>(),v,index + 0),
266
 
    Get(TypeWrapper<P2>(),v,index + 1),
267
 
    Get(TypeWrapper<P3>(),v,index + 2),
268
 
    Get(TypeWrapper<P4>(),v,index + 3),
269
 
    Get(TypeWrapper<P5>(),v,index + 4),
270
 
    Get(TypeWrapper<P6>(),v,index + 5),
271
 
    Get(TypeWrapper<P7>(),v,index + 6)
272
 
    );
273
 
  return 0;
274
 
}
275
 
#endif
276
 
 
277
 
#ifdef SQPLUS_CALL_CONST_MFUNC_RET1
278
 
#undef SQ_REG_CONST_STATIC_VAR
279
 
template<typename Callee,typename RT>
280
 
int Call(Callee & callee, RT (Callee::*func)() const,HSQUIRRELVM v,int index) {
281
 
  return ReturnSpecialization<RT>::Call(callee,func,v,index);
282
 
}
283
 
 
284
 
template<typename Callee,typename RT,typename P1>
285
 
int Call(Callee & callee,RT (Callee::*func)(P1) const,HSQUIRRELVM v,int index) {
286
 
  return ReturnSpecialization<RT>::Call(callee,func,v,index);
287
 
}
288
 
 
289
 
template<typename Callee,typename RT,typename P1,typename P2>
290
 
int Call(Callee & callee,RT (Callee::*func)(P1,P2) const,HSQUIRRELVM v,int index) {
291
 
  return ReturnSpecialization<RT>::Call(callee,func,v,index);
292
 
}
293
 
 
294
 
template<typename Callee,typename RT,typename P1,typename P2,typename P3>
295
 
int Call(Callee & callee,RT (Callee::*func)(P1,P2,P3) const,HSQUIRRELVM v,int index) {
296
 
  return ReturnSpecialization<RT>::Call(callee,func,v,index);
297
 
}
298
 
 
299
 
template<typename Callee,typename RT,typename P1,typename P2,typename P3,typename P4>
300
 
int Call(Callee & callee,RT (Callee::*func)(P1,P2,P3,P4) const,HSQUIRRELVM v,int index) {
301
 
  return ReturnSpecialization<RT>::Call(callee,func,v,index);
302
 
}
303
 
 
304
 
template<typename Callee,typename RT,typename P1,typename P2,typename P3,typename P4,typename P5>
305
 
int Call(Callee & callee,RT (Callee::*func)(P1,P2,P3,P4,P5) const,HSQUIRRELVM v,int index) {
306
 
  return ReturnSpecialization<RT>::Call(callee,func,v,index);
307
 
}
308
 
 
309
 
template<typename Callee,typename RT,typename P1,typename P2,typename P3,typename P4,typename P5,typename P6>
310
 
int Call(Callee & callee,RT (Callee::*func)(P1,P2,P3,P4,P5,P6) const,HSQUIRRELVM v,int index) {
311
 
  return ReturnSpecialization<RT>::Call(callee,func,v,index);
312
 
}
313
 
 
314
 
template<typename Callee,typename RT,typename P1,typename P2,typename P3,typename P4,typename P5,typename P6,typename P7>
315
 
int Call(Callee & callee,RT (Callee::*func)(P1,P2,P3,P4,P5,P6,P7) const,HSQUIRRELVM v,int index) {
316
 
  return ReturnSpecialization<RT>::Call(callee,func,v,index);
317
 
}
318
 
#undef SQPLUS_CALL_CONST_MFUNC_RET1
319
 
#endif
320
 
 
321
 
#ifdef SQ_REG_CONST_STATIC_VAR
322
 
template<typename VarType>
323
 
SQClassDef & staticVar(const VarType * pvar,const SQChar * name,VarAccessType access=VAR_ACCESS_READ_ONLY) {
324
 
  struct CV {
325
 
    const VarType * var;
326
 
  } cv; // Cast Variable helper.
327
 
  cv.var = pvar;
328
 
  RegisterInstanceVariable(newClass,ClassType<TClassType>::type(),*(VarType **)&cv,name,VarAccessType(access|VAR_ACCESS_STATIC));
329
 
  return *this;
330
 
} // staticVar
331
 
#endif
332
 
 
333
 
// SqPlusConst.h