summaryrefslogtreecommitdiff
path: root/libguile/scm_validate.h
blob: 54b529b43a348262361638c0938e29d5331474f3 (plain)
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
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
/* $Id: scm_validate.h,v 1.1 1999-12-12 02:36:16 gjb Exp $
 * scm_validate.h
 * Copyright (C) 1999, Greg J. Badros
 *
 */

#ifndef SCM_VALIDATE_H__
#define SCM_VALIDATE_H__

#define SCM_BOOL(f) ((f)? SCM_BOOL_T : SCM_BOOL_F)
#define SCM_NEGATE_BOOL(f) ((f)? SCM_BOOL_F : SCM_BOOL_T)

#define SCM_FUNC_NAME (scm_makfrom0str(FUNC_NAME))

#define SCM_SYSERROR do { scm_syserror(FUNC_NAME); } while (0)

#define SCM_MEMORY_ERROR do { scm_memory_error(FUNC_NAME); } while (0)

#define SCM_SYSERROR_MSG(str,args,val) \
  do { scm_syserror_msg(FUNC_NAME,(str),(args),(val)); } while (0)

#define SCM_SYSMISSING \
  do { scm_sysmissing(FUNC_NAME); } while (0)

#define SCM_WTA(pos,scm) \
  do { scm_wta(scm,(char *)pos,FUNC_NAME); } while (0)

#define RETURN_SCM_WTA(pos,scm) \
  do { return scm_wta(scm,(char *)pos,FUNC_NAME); } while (0)

#define SCM_MISC_ERROR(str,args) \
  do { scm_misc_error(FUNC_NAME,str,args); } while (0)

#define SCM_WRONG_TYPE_ARG(pos,obj) \
  do { scm_wrong_type_arg(FUNC_NAME,pos,obj); } while (0)

#define SCM_NUM2ULONG(pos,arg) (scm_num2ulong(arg, (char *) pos, FUNC_NAME))

#define SCM_NUM2LONG(pos,arg) (scm_num2long(arg, (char *) pos, FUNC_NAME))

#define SCM_NUM2LONG_LONG(pos,arg) (scm_num2long_long(arg, (char *) pos, FUNC_NAME))

#define SCM_OUT_OF_RANGE(pos,arg) do { scm_out_of_range(FUNC_NAME,arg); } while (0)

#define SCM_ASSERT_RANGE(pos,arg,f) do { SCM_ASSERT(f,arg,SCM_OUTOFRANGE,FUNC_NAME); } while (0)

#define SCM_MUST_MALLOC_TYPE(type) ((type *) scm_must_malloc(sizeof(type), FUNC_NAME))

#define SCM_MUST_MALLOC_TYPE_NUM(type,num) ((type *) scm_must_malloc(sizeof(type)*(num), FUNC_NAME))

#define SCM_MUST_MALLOC(size) (scm_must_malloc((size), FUNC_NAME))

#define SCM_VALIDATE_NIMP(pos,scm) \
  do { SCM_ASSERT(SCM_NIMP(scm), scm, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_BOOL(pos,flag) \
  do { SCM_ASSERT(SCM_BOOL_T == flag || SCM_BOOL_F == flag, flag, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_BOOL_COPY(pos,flag,cvar) \
  do { SCM_ASSERT(SCM_BOOL_T == flag || SCM_BOOL_F == flag, flag, pos, FUNC_NAME); \
       cvar = (SCM_BOOL_T == flag)? 1: 0; } while (0)

#define SCM_VALIDATE_CHAR(pos,scm) \
  do { SCM_ASSERT(SCM_ICHRP(scm), scm, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_CHAR_COPY(pos,scm,cvar) \
  do { SCM_ASSERT(SCM_ICHRP(scm), scm, pos, FUNC_NAME); \
       cvar = SCM_ICHR(scm); } while (0)

#define SCM_VALIDATE_ROSTRING(pos,str) \
  do { SCM_ASSERT(SCM_NIMP (str) && SCM_ROSTRINGP (str), str, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_ROSTRING_COPY(pos,str,cvar) \
  do { SCM_ASSERT(SCM_NIMP (str) && SCM_ROSTRINGP (str), str, pos, FUNC_NAME); \
       cvar = SCM_ROCHARS(str); } while (0)

#define SCM_VALIDATE_NULLORROSTRING_COPY(pos,str,cvar) \
  do { SCM_ASSERT(SCM_FALSEP(str) || (SCM_NIMP (str) && SCM_ROSTRINGP (str)), str, pos, FUNC_NAME); \
       if (SCM_FALSEP(str)) cvar = NULL; else cvar = SCM_ROCHARS(str); } while (0)

#define SCM_VALIDATE_STRING(pos,str) \
  do { SCM_ASSERT(SCM_NIMP (str) && SCM_STRINGP (str), str, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_STRINGORSUBSTR(pos,str) \
  do { SCM_ASSERT(SCM_NIMP (str) && (SCM_STRINGP (str) || SCM_SUBSTRP(str)), str, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_STRING_COPY(pos,str,cvar) \
  do { SCM_ASSERT(SCM_NIMP (str) && SCM_STRINGP (str), str, pos, FUNC_NAME); \
       cvar = SCM_CHARS(str); } while (0)

#define SCM_VALIDATE_RWSTRING(pos,str) \
  do { SCM_ASSERT(SCM_NIMP (str) && SCM_STRINGP (str), str, pos, FUNC_NAME); \
       if (!SCM_RWSTRINGP(str)) scm_misc_error(FUNC_NAME, "argument is a read-only string", str);  } while (0)

#define SCM_VALIDATE_REAL(pos,z) \
  do { SCM_ASSERT (SCM_NIMP (z) && SCM_REALP (z), z, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_INT(pos,k) \
  do { SCM_ASSERT(SCM_INUMP(k), k, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_INT_COPY(pos,k,cvar) \
  do { cvar = scm_num2ulong(k,(char *)pos,FUNC_NAME); } while (0)

#define SCM_VALIDATE_BIGINT(pos,k) \
  do { SCM_ASSERT(SCM_NIMP(k) && SCM_BIGP(k), k, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_INT_MIN(pos,k,min) \
  do { SCM_ASSERT(SCM_INUMP(k), k, pos, FUNC_NAME); \
       SCM_ASSERT(SCM_INUM(k) >= min, k, SCM_OUTOFRANGE, FUNC_NAME); } while (0)

#define SCM_VALIDATE_INT_MIN_COPY(pos,k,min,cvar) \
  do { SCM_ASSERT(SCM_INUMP(k), k, pos, FUNC_NAME); \
       cvar = SCM_INUM(k); \
       SCM_ASSERT(cvar >= min, k, SCM_OUTOFRANGE, FUNC_NAME); } while (0)

#define SCM_VALIDATE_INT_MIN_DEF_COPY(pos,k,min,default,cvar) \
  do { if (SCM_UNBNDP(k)) k = SCM_MAKINUM(default); \
       SCM_ASSERT(SCM_INUMP(k), k, pos, FUNC_NAME); \
       cvar = SCM_INUM(k); \
       SCM_ASSERT(cvar >= min, k, SCM_OUTOFRANGE, FUNC_NAME); } while (0)


#define SCM_VALIDATE_INT_DEF(pos,k,default) \
  do { if (SCM_UNDEFINED==k) k = SCM_MAKINUM(default); else SCM_ASSERT(SCM_INUMP(k), k, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_INT_DEF_COPY(pos,k,default,cvar) \
  do { if (SCM_UNDEFINED==k) { k = SCM_MAKINUM(default); cvar=default; } \
       else { SCM_ASSERT(SCM_INUMP(k), k, pos, FUNC_NAME); cvar = SCM_INUM(k); } } while (0)

/* [low,high) */
#define SCM_VALIDATE_INT_RANGE(pos,k,low,high) \
  do { SCM_ASSERT(SCM_INUMP(k), k, pos, FUNC_NAME); \
       SCM_ASSERT(SCM_INUM (k) >= low && ((unsigned) SCM_INUM (k)) < high, \
                  k, SCM_OUTOFRANGE, FUNC_NAME); } while (0)

#define SCM_VALIDATE_NULL(pos,scm) \
  do { SCM_ASSERT(SCM_NULLP(scm), scm, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_CONS(pos,scm) \
  do { SCM_ASSERT(SCM_CONSP(scm), scm, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_NIMCONS(pos,scm) \
  do { SCM_ASSERT(SCM_CONSP(scm), scm, pos, FUNC_NAME); } while (0)


#define SCM_VALIDATE_LIST(pos,lst) \
  do { SCM_ASSERT (scm_ilength (lst) >= 0, lst, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_LIST_COPYLEN(pos,lst,cvar) \
  do { cvar = scm_ilength(lst); SCM_ASSERT(cvar >= 0,lst,pos,FUNC_NAME); } while (0)

#define SCM_VALIDATE_NONEMPTYLIST_COPYLEN(pos,lst,cvar) \
  do { cvar = scm_ilength(lst); SCM_ASSERT(cvar >= 1,lst,pos,FUNC_NAME); } while (0)

#define SCM_VALIDATE_ALISTCELL(pos,alist) \
  do { \
    SCM_ASSERT(SCM_CONSP(alist), alist, pos, FUNC_NAME); \
    { SCM tmp = SCM_CAR(alist); \
      SCM_ASSERT(SCM_NIMP(tmp) && SCM_CONSP(tmp), alist, pos, FUNC_NAME); } } while (0)

#define SCM_VALIDATE_ALISTCELL_COPYSCM(pos,alist,tmp) \
  do { \
    SCM_ASSERT(SCM_CONSP(alist), alist, pos, FUNC_NAME); \
    tmp = SCM_CAR(alist); \
    SCM_ASSERT(SCM_NIMP(tmp) && SCM_CONSP(tmp), alist, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_OPORT_VALUE(pos,port) \
  do { SCM_ASSERT (scm_valid_oport_value_p (port), port, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_PRINTSTATE(pos,a) \
  do { SCM_ASSERT (SCM_NIMP (a) && SCM_PRINT_STATE_P (a), a, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_SMOB(pos,obj,type) \
  do { SCM_ASSERT ((SCM_NIMP(obj) && SCM_TYP16 (obj) == scm_tc16_ ## type), obj, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_ASYNC(pos,a) \
  do { SCM_ASSERT (SCM_NIMP (a) && SCM_ASYNCP (a), a, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_ASYNC_COPY(pos,a,cvar) \
  do { SCM_ASSERT (SCM_NIMP (a) && SCM_ASYNCP (a), a, pos, FUNC_NAME); \
       cvar = SCM_ASYNC(a); } while (0)

#define SCM_VALIDATE_THUNK(pos,thunk) \
  do { SCM_ASSERT (SCM_NFALSEP (scm_thunk_p (thunk)), thunk, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_SYMBOL(pos,sym) \
  do { SCM_ASSERT (SCM_NIMP(sym) && SCM_SYMBOLP(sym), sym, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_VARIABLE(pos,var) \
  do { SCM_ASSERT (SCM_NIMP(var) && SCM_VARIABLEP(var), var, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_MEMOIZED(pos,obj) \
  do { SCM_ASSERT (SCM_NIMP(obj) && SCM_MEMOIZEDP(obj), obj, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_CLOSURE(pos,obj) \
  do { SCM_ASSERT (SCM_NIMP(obj) && SCM_CLOSUREP(obj), obj, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_PROC(pos,proc) \
  do { SCM_ASSERT ( SCM_BOOL_T == scm_procedure_p(proc), proc, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_NULLORCONS(pos,env) \
  do { SCM_ASSERT (SCM_NULLP (env) || (SCM_NIMP (env) && SCM_CONSP (env)), env, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_HOOK(pos,a) \
  do { SCM_ASSERT (SCM_NIMP (a) && SCM_HOOKP (a), a, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_RGXP(pos,a) \
  do { SCM_ASSERT (SCM_NIMP (a) && SCM_RGXP (a), a, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_OPDIR(pos,port) \
  do { SCM_ASSERT (SCM_NIMP (port) && SCM_OPDIRP (port), port, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_DIR(pos,port) \
  do { SCM_ASSERT (SCM_NIMP (port) && SCM_DIRP (port), port, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_PORT(pos,port) \
  do { SCM_ASSERT (SCM_NIMP (port) && SCM_PORTP (port), port, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_FPORT(pos,port) \
  do { SCM_ASSERT (SCM_NIMP (port) && SCM_FPORTP (port), port, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_OPFPORT(pos,port) \
  do { SCM_ASSERT (SCM_NIMP (port) && SCM_OPFPORTP (port), port, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_OPINPORT(pos,port) \
  do { SCM_ASSERT (SCM_NIMP (port) && SCM_OPINPORTP (port), port, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_OPENPORT(pos,port) \
  do { SCM_ASSERT (SCM_NIMP (port) && SCM_PORTP (port) && SCM_OPENP(port), port, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_OPPORT(pos,port) \
  do { SCM_ASSERT (SCM_NIMP (port) && SCM_OPPORTP (port), port, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_OPOUTPORT(pos,port) \
  do { SCM_ASSERT (SCM_NIMP (port) && SCM_OPOUTPORTP (port), port, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_FLUID(pos,fluid) \
  do { SCM_ASSERT (SCM_NIMP (fluid) && SCM_FLUIDP (fluid), fluid, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_KEYWORD(pos,v) \
  do { SCM_ASSERT (SCM_NIMP (v) && SCM_KEYWORDP (v), v, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_STACK(pos,v) \
  do { SCM_ASSERT (SCM_NIMP (v) && SCM_STACKP (v), v, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_FRAME(pos,v) \
  do { SCM_ASSERT (SCM_NIMP (v) && SCM_FRAMEP (v), v, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_RSTATE(pos,v) \
  do { SCM_ASSERT (SCM_NIMP (v) && SCM_RSTATEP (v), v, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_ARRAY(pos,v) \
  do { SCM_ASSERT (SCM_NIMP (v) && SCM_BOOL_F != scm_array_p(v,SCM_UNDEFINED), v, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_VECTOR(pos,v) \
  do { SCM_ASSERT (SCM_NIMP (v) && SCM_VECTORP (v), v, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_STRUCT(pos,v) \
  do { SCM_ASSERT (SCM_NIMP (v) && SCM_STRUCTP (v), v, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_VTABLE(pos,v) \
  do { SCM_ASSERT (SCM_NIMP (v) && SCM_NFALSEP(scm_struct_vtable_p(v)), v, pos, FUNC_NAME); } while (0)

#define SCM_VALIDATE_VECTOR_LEN(pos,v,len) \
  do { SCM_ASSERT (SCM_NIMP (v) && SCM_VECTORP (v) && len == SCM_LENGTH(v), v, pos, FUNC_NAME); } while (0)

#endif