SYM.H
[目次 | 型・クラス・構造体 | マクロ]
1|/***************************************************************************
2|* 1. <<< 動的参照シンボル (Sym) >>>
3|****************************************************************************/
4|
5|#if !defined(__SYM_H) && defined(__LISTX_H)
6|//#ifndef __SYM_H
7|#define __SYM_H
8|
9|
10|/***********************************************************************
11|* 2. <<< 優先ヘッダ >>>
12|************************************************************************/
13|
14|#ifndef USES_PRIORITY_HEADER
15|/*[START_OF_PRIORITY_HEADER]*/
16|
17|#define USES_SYM
18|
19|typedef struct _Sym Sym;
20|typedef struct _Sym_Var Sym_Var;
21|typedef union _Sym_LocalVar Sym_LocalVar;
22|typedef struct _Sym_Ref Sym_Ref;
23|typedef struct _Sym_Struct Sym_Struct;
24|typedef struct _Sym_Member Sym_Member;
25|typedef enum _Sym_Type Sym_Type;
26|typedef struct _Sym_Func Sym_Func;
27|typedef void (*Sym_FuncF)( void** arg_adrs, void* ret_adr );
28|typedef void (*Sym_ReadMembF)( Sym_Ref* obj, char* name, Sym_Ref* ret );
29|typedef void (*Sym_ReadPropF)( void* this_adr, void* ret_adr );
30|typedef void (*Sym_WritePropF)( void* this_adr, void* arg_adr );
31|typedef void (*Sym_ElemPaDelF)( void* elem_param );
32|
33|#define STDLIBS_INCLUDE
34|#define STDLIBS_INCLUDE_STRING_H
35|
36|/*[END_OF_PRIORITY_HEADER]*/
37|#endif /* USES_PRIORITY_HEADER */
38|
39|typedef bool (*Sym_LoopF)( Sym_Ref* container, Sym_Ref* loopRef );
40|
41|/***********************************************************************
42|* 3. <<< モジュール設定 >>>
43|************************************************************************/
44|#ifndef SYM_SETTING
45|#define SYM_SETTING
46|
47|#endif
48|
49|/***********************************************************************
50|* 4. <<< エラーコード >>>
51|************************************************************************/
52|
53|#define Sym_Err_NotFindSymbol 16211
54|#define Sym_Err_ManyNest 16212
55|#define Sym_Err_NotFindType 16213
56|#define Sym_Err_NullAsign 16214
57|
58|/*-----------------------------------------------------------------*/
59|/* 5. <<< Interface Area ----------------------------------------->>> */
60|/*-----------------------------------------------------------------*/
61|
62|#ifdef __cplusplus
63|extern "C" {
64|#endif
65|
66|
67|
68|/***********************************************************************
69|* 6. <<< [Sym] 動的参照エンジン >>>
70|*【補足】
71|*・通常、Sym クラスの関数と、SYM_STRUCT, SYM_FUNC マクロをだけで
72|* 利用できます。
73|************************************************************************/
74|struct _Sym {
75| ListX vars; /* Sym_Var 型リスト, malloc 所有 */
76| ListX structs; /* Sym_Struct 型リスト, 非所有 */
77| ListX funcs; /* Sym_Func 型リスト, 非所有 */
78| StrX_MemV2 sym; /* 文字列メモリ領域 */
79|
80| ERRORS_INITCHK_VAR
81|};
82|extern Sym sym;
83|
84|/* 操作関数 */
85|void Sym_init( Sym* );
86|void Sym_finish( Sym* );
87|void Sym_print( Sym*, const char* title );
88|Sym_Var* Sym_registVar( Sym*, const char* type, const char* name, void* adr );
89|Sym_Var* Sym_registBasicVar( Sym*, Sym_Type type, const char* name, void* adr );
90|Sym_Var* Sym_registStructVar( Sym*, Sym_Struct* st, const char* name, void* adr );
91|void Sym_unregistVar( Sym*, const char* name );
92|
93|/* 参照 */
94|void Sym_getRef( Sym*, const char* href, Sym_Ref* out );
95|Sym_Func* Sym_getFunc( Sym*, const char* name );
96|
97|/* 詳細操作用 */
98|Sym_Var* Sym_getVar( Sym*, const char* name );
99|Sym_Struct* Sym_getStruct( Sym*, const char* name );
100|
101|/***********************************************************************
102|* 7. <<< [Sym_Var] 動的参照変数 >>>
103|*【補足】
104|*・シンボルと先頭アドレスを対応付けして、そのメモリ領域の変数や構造体と
105|* 対応付けします。
106|*・通常、Sym_Var_init を使わずに、Sym_registVar を使います。
107|************************************************************************/
108|struct _Sym_Var {
109| ListX_Elem inherit_ListX_Elem;
110| char* name; /* シンボル名 */
111| void* adr; /* オブジェクトの先頭アドレス */
112| Sym_Type type; /* 型(1) */
113| Sym_Struct* st; /* 型(2) */
114|};
115|void Sym_Var_init( Sym_Var*, const char* type,
116| const char* name, void* adr );
117|void Sym_Var_initBasic( Sym_Var*, Sym_Type type,
118| const char* name, void* adr );
119|void Sym_Var_initStruct( Sym_Var*, Sym_Struct* st,
120| const char* name, void* adr );
121|void Sym_Var_print( Sym_Var*, const char* title );
122|
123|/***********************************************************************
124|* 8. <<< [Sym_LocalVar] ローカル変数 >>>
125|*【補足】
126|*・プロパティの read 関数の出力のメモリ領域として使われます。
127|************************************************************************/
128|union _Sym_LocalVar {
129| double d;
130| void* p;
131|};
132|
133|/***********************************************************************
134|* 9. <<< [Sym_Ref] 変数リファレンス >>>
135|*【補足】
136|*・特定の変数や構造体のメンバに関する情報を参照するために使われます。
137|*・elem_type, elem_st, elem_param は、参照している変数が集合型のとき
138|* のみ有効です。そうでないときは、Sym_NoID, NULL, NULL を設定します。
139|************************************************************************/
140|struct _Sym_Ref {
141| void* adr; /* アドレス */
142| Sym_Type type; /* 型(1) */
143| Sym_Struct* st; /* 型(2) */
144| Sym_Type elem_type; /* 集合の要素の型(1) */
145| Sym_Struct* elem_st; /* 集合の要素の型(2) */
146| void* elem_param; /* 集合アクセス用パラメータ（→Sym_Member の補足） */
147| Sym_LocalVar localVar;
148|};
149|
150|void Sym_Ref_init( Sym_Ref*, void* adr, Sym_Type type, Sym_Struct* st,
151| Sym_Type elem_type, Sym_Struct* elem_st, void* elem_param );
152|void Sym_Ref_copy( Sym_Ref* dst, Sym_Ref* src );
153|/* void Sym_Ref_castBasic( Sym_Ref*, type ); */
154|/* void Sym_Ref_castStruct( Sym_Ref*, type ); */
155|/* void Sym_Ref_castStructP( Sym_Ref*, type ); */
156|void* Sym_Ref_getAdr( Sym_Ref* );
157|void Sym_Ref_getRef( Sym_Ref* base, const char* href, Sym_Ref* out );
158|void Sym_Ref_writeString( Sym_Ref*, FILE* out );
159|
160|/* 基本型変数アクセス */
161|void* Sym_Ref_getPtr( Sym_Ref* );
162|void Sym_Ref_getString( Sym_Ref*, char* s, int s_size );
163|int Sym_Ref_getStringSize( Sym_Ref* );
164|int Sym_Ref_getInt( Sym_Ref* );
165|long Sym_Ref_getLong( Sym_Ref* );
166|short Sym_Ref_getShort( Sym_Ref* );
167|char Sym_Ref_getChar( Sym_Ref* );
168|char* Sym_Ref_getCharP( Sym_Ref* );
169|float Sym_Ref_getFloat( Sym_Ref* );
170|double Sym_Ref_getDouble( Sym_Ref* );
171|unsigned int Sym_Ref_getUInt( Sym_Ref* );
172|unsigned long Sym_Ref_getULong( Sym_Ref* );
173|unsigned short Sym_Ref_getUShort( Sym_Ref* );
174|unsigned char Sym_Ref_getUChar( Sym_Ref* );
175|
176|/* 集合走査 */
177|bool Sym_Ref_getFirst( Sym_Ref* container, Sym_Ref* loopRef );
178|bool Sym_Ref_getNext( Sym_Ref* container, Sym_Ref* loopRef );
179|/* Sym_Ref_forEach( Sym_Ref* container, Sym_Ref* loopRef ) */
180|
181|/***********************************************************************
182|* 10. <<< [Sym_Struct] 動的参照構造体型 >>>
183|*【補足】
184|*・通常、Sym_Struct_init を使わずに、SYM_STRUCT を使います。
185|************************************************************************/
186|struct _Sym_Struct {
187| ListX_Elem inherit_ListX_Elem;
188| char* name; /* シンボル名 */
189| ListX members; /* メンバ, Sym_Member 型 */
190| Sym_LoopF loopFunc;
191| Sym_ReadMembF readMembFunc;
192| /* Sym_WriteMembF writeMembFunc; */
193|};
194|void Sym_Struct_init( Sym_Struct*, const char* name );
195|void Sym_Struct_finish( Sym_Struct* );
196|void Sym_Struct_print( Sym_Struct*, const char* title );
197|Sym_Member* Sym_Struct_getMember( Sym_Struct*, const char* name );
198|
199|
200|/***********************************************************************
201|* 11. <<< [Sym_Member] 動的参照構造体のメンバ変数 >>>
202|*【補足】
203|*・通常、Sym_Member_init を使わずに、SYM_STRUCT を使います。
204|*・offset は、構造体がネストしている場合、サブの構造体の先頭からの
205|* オフセットになります。
206|*・st は、type=Sym_StructType, Sym_StructTypeP のときに有効です。
207|*・readFunc, writeFunc は、NULL でないときに使われます。
208|*・elem_param は、（構造体名＋_SymElem_new）マクロの返り値が格納されます。
209|* void* Struct_SymElem_new( container_type, elem_type );
210|* 基本型要素のときは、その型のメモリサイズ(int) を void* にキャストした
211|* のが格納されます。
212|*・elem_param_delete は、（構造体名＋_SymElem_delete）関数のアドレスが
213|* 格納され、NULL でなければ Sym_Member_finish で呼び出されます。
214|* 基本型要素のときは、NULL が格納されます。
215|* void Struct_SymElem_delete( void* elem_param );
216|************************************************************************/
217|struct _Sym_Member {
218| ListX_Elem inherit_ListX_Elem;
219| char* name; /* シンボル名 */
220| Offset offset; /* 構造体の先頭からのオフセット（→補足） */
221| Sym_Type type; /* メンバ変数の型(1) */
222| Sym_Struct* st; /* メンバ変数の型(2)（→補足） */
223| Sym_ReadPropF readFunc; /* プロパティ読み込み関数（→補足） */
224| Sym_WritePropF writeFunc; /* プロパティ書き込み関数（→補足） */
225| Sym_Type elem_type; /* メンバ集合の要素の型(1) */
226| Sym_Struct* elem_st; /* メンバ集合の要素の型(2) */
227| void* elem_param; /* 集合アクセス用パラメータ（→補足） */
228| Sym_ElemPaDelF elem_param_delete; /* elem_param 後始末関数（→補足）*/
229|};
230|void Sym_Member_init( Sym_Member*, const char* name, Offset offset,
231| Sym_Type type, Sym_Struct* st, Sym_ReadPropF readFunc,
232| Sym_WritePropF writeFunc );
233|void Sym_Member_finish( Sym_Member* );
234|void Sym_Member_print( Sym_Member*, const char* title );
235|
236|
237|/***********************************************************************
238|* 12. <<< [Sym_Type] 変数の型 >>>
239|************************************************************************/
240|enum _Sym_Type {
241| Sym_NoID,
242| Sym_Void,
243| Sym_Int, Sym_UInt, Sym_Float, Sym_Double,
244| Sym_Long, Sym_ULong, Sym_Short, Sym_UShort, Sym_Char, Sym_UChar,
245| Sym_VoidP,
246| Sym_IntP, Sym_UIntP, Sym_FloatP, Sym_DoubleP,
247| Sym_LongP, Sym_ULongP, Sym_ShortP, Sym_UShortP, Sym_CharP, Sym_UCharP,
248| Sym_CharArr,
249| Sym_StructType, Sym_StructTypeP,
250| Sym_Type_over
251|};
252|
253|char* Sym_Type_getStr( Sym_Type );
254|char* Sym_Type_getStr2( Sym_Type );
255|Sym_Type Sym_Type_getID2( const char* s );
256|
257|/***********************************************************************
258|* 13. <<< [SYM_STRUCT] 動的参照構造体を登録する関数を定義するマクロ >>>
259|*【補足】
260|*・sym.htm の「SYM_STRUCT マクロの説明」を参照
261|************************************************************************/
262|/* SYM_STRUCT_START( Struct ) */
263|/* SYM_STRUCT_LOOP_FUNC( Struct, loopfunc ) */
264|/* SYM_STRUCT_MEMB_FUNC( Struct, readfunc, writefunc ) */
265|/* SYM_STRUCT_MEMB( Struct, member_type, member_name ) */
266|/* SYM_STRUCT_ST( Struct, member_type, member_name ) */
267|/* SYM_STRUCT_ST_MEMB( Struct, member_type, elem_type, member_name ) */
268|/* SYM_STRUCT_ST_ST( Struct, member_type, elem_type, member_name ) */
269|/* SYM_STRUCT_ST_STP( Struct, member_type, elem_type, member_name ) */
270|/* SYM_STRUCT_STP( Struct, member_type, member_name ) */
271|/* SYM_STRUCT_STP_MEMB( Struct, member_type, elem_type, member_name ) */
272|/* SYM_STRUCT_STP_ST( Struct, member_type, elem_type, member_name ) */
273|/* SYM_STRUCT_STP_STP( Struct, member_type, elem_type, member_name ) */
274|/* SYM_STRUCT_PROP_MEMB( Struct, member_type, member_name, readfunc, writefunc ) */
275|/* SYM_STRUCT_PROP_STP( Struct, member_type, member_name, readfunc, writefunc ) */
276|/* SYM_STRUCT_ADD_ELEM_MEMB( Struct, elem_type, member_name ) */
277|/* SYM_STRUCT_ADD_ELEM_ST( Struct, elem_type, member_name ) */
278|/* SYM_STRUCT_ADD_ELEM_STP( Struct, elem_type, member_name ) */
279|/* SYM_STRUCT_END( Struct ) */
280|
281|
282|/***********************************************************************
283|* 14. <<< [Sym_Func] 動的参照関数 >>>
284|*【補足】
285|*・通常、Sym_Func_init を使わずに、SYM_FUNC を使います。
286|************************************************************************/
287|
288|/* Sym_FuncF 型の定義は優先ヘッダにあります */
289|
290|struct _Sym_Func {
291| ListX_Elem inherit_ListX_Elem;
292| char* name; /* シンボル名 */
293| Sym_FuncF func; /* 関数ポインタ */
294| int nArg; /* 引数の数 */
295| Sym_Type* types; /* 返り値や引数の型の配列（０＝返り値、１〜＝引数）*/
296| Sym_Struct** sts; /* 返り値や引数の型の配列（０＝返り値、１〜＝引数） */
297|};
298|
299|
300|void Sym_Func_init( Sym_Func*, const char* name, Sym_FuncF func, int nArg );
301|void Sym_Func_finish( Sym_Func* );
302|void Sym_Func_print( Sym_Func*, const char* title );
303|
304|void Sym_Func_call( Sym_Func*, void** arg_adrs, void* ret_adr );
305|
306|
307|
308|/***********************************************************************
309|* 15. <<< [SYM_FUNC] 動的参照関数を登録する関数を定義するマクロ >>>
310|*【引数】
311|* ・Sym* sym; トップ
312|* ・symbol; シンボル名（通常、関数名と同じ）
313|* ・ret_type; 返り値の型
314|* ・func; 関数（アドレス）
315|* ・argX_type; 引数の型
316|* ・int iArg; ０＝返り値、１〜引数の番号
317|* ・Sym_Type sym_type; 引数または返り値の型(1)
318|* ・Sym_Struct* st; 引数または返り値の型(2)（NULL可）
319|*【補足】
320|*・sym.htm の「SYM_FUNC マクロの説明」を参照
321|************************************************************************/
322|/* SYM_FUNC_START_0( symbol, ret_type, func ) */
323|/* SYM_FUNC_START_1( symbol, ret_type, func, arg1_type ) */
324|/* SYM_FUNC_START_2( symbol, ret_type, func, arg1_type, arg2_type ) */
325|/* SYM_FUNC_START_R0( symbol, ret_type, func ) */
326|/* SYM_FUNC_START_R1( symbol, ret_type, func, arg1_type ) */
327|/* SYM_FUNC_START_R2( symbol, ret_type, func, arg1_type, arg2_type ) */
328|
329|/* SYM_FUNC_STRUCT_ARG( symbol, iArg, type ) */
330|/* SYM_FUNC_STRUCT_P_ARG( symbol, iArg, type ) */
331|
332|/* SYM_FUNC_END( symbol ) */
333|
334|#ifdef __cplusplus
335|}
336|#endif
337|
338|/*-----------------------------------------------------------------*/
339|/* 16. <<< Mapping Area ------------------------------------------->>> */
340|/*-----------------------------------------------------------------*/
341|
342|
343|
344|/***********************************************************************
345|* 17. <<< [Sym_Ref_init] 初期化する >>>
346|************************************************************************/
347|#define Sym_Ref_init( this, _adr, _type, _st, _elem_type, _elem_st, _elem_param ) \
348| ( (this)->adr = (_adr), (this)->type = (_type), (this)->st = (_st), \
349| (this)->elem_type = (_elem_type), (this)->elem_st = (_elem_st), \
350| (this)->elem_param = (_elem_param) )
351|
352|/***********************************************************************
353|* 18. <<< [Sym_Ref_castBasic] 基本型にキャストする >>>
354|************************************************************************/
355|#define Sym_Ref_castBasic( this, _type ) \
356| ( (this)->type = Sym_Type_getID2(#_type), (this)->st = NULL )
357|
358|/***********************************************************************
359|* 19. <<< [Sym_Ref_castStruct] 構造体型にキャストする >>>
360|************************************************************************/
361|#define Sym_Ref_castStruct( this, _type ) \
362| ( (this)->type = Sym_StructType, (this)->st = &_type##_symStruct )
363|
364|/***********************************************************************
365|* 20. <<< [Sym_Ref_castStructP] 構造体ポインタ型にキャストする >>>
366|************************************************************************/
367|#define Sym_Ref_castStructP( this, _type ) \
368| ( (this)->type = Sym_StructTypeP, (this)->st = &_type##_symStruct )
369|
370|/***********************************************************************
371|* 21. <<< [Sym_Ref_getPtr] 変数の値を返す >>>
372|************************************************************************/
373|#define Sym_Ref_getAdr( this ) ( (this)->adr )
374|#define Sym_Ref_getPtr( this ) ( *(void**)(this)->adr )
375|#define Sym_Ref_getInt( this ) ( *(int*)(this)->adr )
376|#define Sym_Ref_getLong( this ) ( *(long*)(this)->adr )
377|#define Sym_Ref_getShort( this ) ( *(short*)(this)->adr )
378|#define Sym_Ref_getChar( this ) ( *(char*)(this)->adr )
379|#define Sym_Ref_getCharP( this ) ( *(char**)(this)->adr )
380|#define Sym_Ref_getFloat( this ) ( *(float*)(this)->adr )
381|#define Sym_Ref_getDouble( this ) ( *(double*)(this)->adr )
382|#define Sym_Ref_getUInt( this ) ( *(unsigned int*)(this)->adr )
383|#define Sym_Ref_getULong( this ) ( *(unsigned long*)(this)->adr )
384|#define Sym_Ref_getUShort( this ) ( *(unsigned short*)(this)->adr )
385|#define Sym_Ref_getUChar( this ) ( *(unsigned char*)(this)->adr )
386|#define Sym_Ref_getCharArr( this ) ( (char*)(this)->adr )
387|
388|
389|/***********************************************************************
390|* 22. <<< [Sym_Ref_getFirst] 集合の最初の要素を取得する >>>
391|*【引数】
392|* ・Sym_Ref* container; 集合クラスの参照、または配列の先頭アドレス
393|* ・Sym_Ref* loopRef; 最初の要素を格納するアドレス（出力）
394|* ・bool 返り値; 最初の要素があるかどうか
395|*【補足】
396|*・container で指定した型に対して、SYM_STRUCT_LOOP を使って、集合を
397|* 走査する関数（Sym_LoopF型）が登録してある必要があります。
398|************************************************************************/
399|#define Sym_Ref_getFirst( container, loopRef ) \
400| ( (loopRef)->adr = NULL, \
401| (loopRef)->type = (container)->elem_type, \
402| (loopRef)->st = (container)->elem_st, \
403| (container)->st->loopFunc( container, loopRef ) )
404|
405|
406|
407|/***********************************************************************
408|* 23. <<< [Sym_Ref_getNext] 集合の次の要素を取得する >>>
409|*【引数】
410|* ・Sym_Ref* container; 集合クラスの参照、または配列の先頭アドレス
411|* ・Sym_Ref* loopRef; 前の要素（入力）、次の要素（出力）
412|* ・bool 返り値; 次の要素があるかどうか
413|*【補足】
414|*・container で指定した型に対して、SYM_STRUCT_LOOP を使って、集合を
415|* 走査する関数（Sym_LoopF型）が登録してある必要があります。
416|************************************************************************/
417|#define Sym_Ref_getNext( container, loopRef ) \
418| ( (container)->st->loopFunc( container, loopRef ) )
419|
420|
421|
422|/***********************************************************************
423|* 24. <<< [Sym_Ref_forEach] 集合を走査する >>>
424|*【引数】
425|* ・Sym_Ref* container; 集合クラスの参照、または配列の先頭アドレス
426|* ・Sym_Ref* loopRef; ループ変数のアドレス（要素の参照）
427|*【補足】
428|*・for ( Sym_Ref_forEach( con, ref ) ); のように for 文の中で使用します。
429|*・container で指定した型に対して、SYM_STRUCT_LOOP を使って、集合を
430|* 走査する関数（Sym_LoopF型）が登録してある必要があります。
431|************************************************************************/
432|#define Sym_Ref_forEach( container, loopRef ) \
433| (loopRef)->adr = NULL, \
434| (loopRef)->type = (container)->elem_type, \
435| (loopRef)->st = (container)->elem_st; \
436| (container)->st->loopFunc( container, loopRef );
437|
438|
439|
440|/***********************************************************************
441|* 25. <<< [SYM_STRUCT_START] SYM_STRUCT の開始宣言 >>>
442|* 26. <<< [SYM_STRUCT_LOOP_FUNC] Struct 集合型に対する集合アクセス関数の宣言 >>>
443|* 27. <<< [SYM_STRUCT_MEMB_FUNC] 動的メンバ変数アクセス関数の宣言 >>>
444|* 28. <<< [SYM_STRUCT_MEMB] SYM_STRUCT の基本型メンバ変数宣言 >>>
445|* 29. <<< [SYM_STRUCT_ST] SYM_STRUCT の構造体型メンバ変数宣言 >>>
446|* 30. <<< [SYM_STRUCT_ST_MEMB] 構造体型集合メンバ変数＋基本型要素宣言 >>>
447|* 31. <<< [SYM_STRUCT_ST_ST] 構造体型集合メンバ変数＋構造体型要素宣言 >>>
448|* 32. <<< [SYM_STRUCT_ST_STP] 構造体型集合メンバ変数＋構造体ポインタ型要素宣言 >>>
449|* 33. <<< [SYM_STRUCT_STP] SYM_STRUCT の構造体へのポインタ型メンバ変数宣言 >>>
450|* 34. <<< [SYM_STRUCT_STP_MEMB] 構造体ポインタ型集合メンバ変数＋基本型要素宣言 >>>
451|* 35. <<< [SYM_STRUCT_STP_ST] 構造体ポインタ型集合メンバ変数＋構造体型要素宣言 >>>
452|* 36. <<< [SYM_STRUCT_STP_STP] 構造体ポインタ型集合メンバ変数＋構造体ポインタ型要素宣言 >>>
453|* 37. <<< [SYM_STRUCT_PROP_MEMB] SYM_STRUCT の基本型プロパティ宣言 >>>
454|* 38. <<< [SYM_STRUCT_PROP_MEMB_W] 読み込みは変数、書き込みは関数のプロパティ宣言 >>>
455|* 39. <<< [SYM_STRUCT_PROP_STP] SYM_STRUCT の構造体型プロパティ宣言 >>>
456|* 40. <<< [SYM_STRUCT_ADD_ELEM_MEMB] コンテナの要素の型（基本型）を追加指定する >>>
457|* 41. <<< [SYM_STRUCT_ADD_ELEM_ST] コンテナの要素の型（構造体型）を追加指定する >>>
458|* 42. <<< [SYM_STRUCT_ADD_ELEM_STP] コンテナの要素の型（構造体ポインタ型）を追加指定する >>>
459|* 43. <<< [SYM_STRUCT_END] SYM_STRUCT の終了宣言 >>>
460|************************************************************************/
461|#define SYM_STRUCT_START( Struct ) \
462| Sym_Struct Struct##_symStruct; \
463| Sym_Struct* Struct##_registSymStruct( Sym* sym ) \
464| { \
465| Sym_Member* memb; \
466| Sym_Struct* st;\
467| \
468| if ( Struct##_symStruct.name != NULL ) { \
469| if ( Sym_getStruct( sym, Struct##_symStruct.name ) != NULL ) \
470| return &Struct##_symStruct; \
471| } \
472| ListX_addLast( &sym->structs, &Struct##_symStruct ); \
473| st = &Struct##_symStruct; \
474| Sym_Struct_init( st, #Struct );
475|
476|
477|#define SYM_STRUCT_LOOP_FUNC( Struct, loopfunc ) \
478| st->loopFunc = (loopfunc);
479|
480|
481|#define SYM_STRUCT_MEMB_FUNC( Struct, readfunc, writefunc ) \
482| st->readMembFunc = (Sym_ReadMembF)(readfunc);
483|
484|#define SYM_STRUCT_MEMB( Struct, member_type, member_name ) \
485| memb = ListX_addLastMalloc( &st->members, Sym_Member ); \
486| Sym_Member_init( memb, #member_name, Offset_init( Struct, member_name ), \
487| Sym_Type_getID2( #member_type ), NULL, NULL, NULL );
488|
489|
490|#define SYM_STRUCT_ST( Struct, member_type, member_name ) \
491| memb = ListX_addLastMalloc( &st->members, Sym_Member ); \
492| Sym_Member_init( memb, #member_name, Offset_init( Struct, member_name ), \
493| Sym_StructType, &member_type##_symStruct, NULL, NULL ); \
494| member_type##_registSymStruct( sym );
495|
496|#define SYM_STRUCT_ST_MEMB( Struct, member_type, _elem_type, member_name ) \
497| SYM_STRUCT_ST( Struct, member_type, member_name ) \
498| SYM_STRUCT_ADD_ELEM_MEMB( Struct, _elem_type, member_name )
499|
500|
501|#define SYM_STRUCT_ST_ST( Struct, member_type, _elem_type, member_name ) \
502| SYM_STRUCT_ST( Struct, member_type, member_name ) \
503| SYM_STRUCT_ADD_ELEM_ST( Struct, member_type, _elem_type, member_name )
504|
505|
506|#define SYM_STRUCT_ST_STP( Struct, member_type, _elem_type, member_name ) \
507| SYM_STRUCT_ST( Struct, member_type, member_name ) \
508| SYM_STRUCT_ADD_ELEM_STP( Struct, member_type, _elem_type, member_name )
509|
510|
511|#define SYM_STRUCT_STP( Struct, member_type, member_name ) \
512| memb = ListX_addLastMalloc( &st->members, Sym_Member ); \
513| Sym_Member_init( memb, #member_name, Offset_init( Struct, member_name ), \
514| Sym_StructTypeP, &member_type##_symStruct, NULL, NULL ); \
515| member_type##_registSymStruct( sym );
516|
517|
518|#define SYM_STRUCT_STP_MEMB( Struct, member_type, _elem_type, member_name ) \
519| SYM_STRUCT_STP( Struct, member_type, member_name ) \
520| SYM_STRUCT_ADD_ELEM_MEMB( Struct, _elem_type, member_name )
521|
522|
523|#define SYM_STRUCT_STP_ST( Struct, member_type, _elem_type, member_name ) \
524| SYM_STRUCT_STP( Struct, member_type, member_name ) \
525| SYM_STRUCT_ADD_ELEM_ST( Struct, member_type, _elem_type, member_name )
526|
527|
528|#define SYM_STRUCT_STP_STP( Struct, member_type, _elem_type, member_name ) \
529| SYM_STRUCT_STP( Struct, member_type, member_name ) \
530| SYM_STRUCT_ADD_ELEM_STP( Struct, member_type, _elem_type, member_name )
531|
532|
533|#define SYM_STRUCT_PROP_MEMB( Struct, member_type, member_name, readfunc, writefunc ) \
534| memb = ListX_addLastMalloc( &st->members, Sym_Member ); \
535| Sym_Member_init( memb, #member_name, 0, \
536| Sym_Type_getID2( #member_type ), NULL, (Sym_ReadPropF)readfunc, (Sym_WritePropF)writefunc );
537|
538|
539|#define SYM_STRUCT_PROP_MEMB_W( Struct, member_type, member_name, writefunc ) \
540| memb = ListX_addLastMalloc( &st->members, Sym_Member ); \
541| Sym_Member_init( memb, #member_name, Offset_init( Struct, member_name ), \
542| Sym_Type_getID2( #member_type ), NULL, NULL, (Sym_WritePropF)writefunc );
543|
544|
545|#define SYM_STRUCT_PROP_STP( Struct, member_type, member_name, readfunc, writefunc ) \
546| memb = ListX_addLastMalloc( &st->members, Sym_Member ); \
547| Sym_Member_init( memb, #member_name, 0, \
548| Sym_StructTypeP, &member_type##_symStruct, (Sym_ReadPropF)readfunc, (Sym_WritePropF)writefunc ); \
549| member_type##_registSymStruct( sym );
550|
551|
552|#define SYM_STRUCT_ADD_ELEM_MEMB( Struct, _elem_type, member_name ) \
553| ASSERT( memb == Sym_Struct_getMember( st, #member_name ) ); \
554| memb->elem_type = Sym_Type_getID2( #_elem_type ); \
555| memb->elem_param = (void*)sizeof(_elem_type);
556|
557|
558|#define SYM_STRUCT_ADD_ELEM_ST( Struct, member_type, _elem_type, member_name ) \
559| ASSERT( memb == Sym_Struct_getMember( st, #member_name ) ); \
560| memb->elem_type = Sym_StructType; memb->elem_st = &_elem_type##_symStruct; \
561| memb->elem_param = (void*)member_type##_SymElem_new( member_type, _elem_type ); \
562| memb->elem_param_delete = member_type##_SymElem_delete; \
563| _elem_type##_registSymStruct( sym );
564|
565|
566|#define SYM_STRUCT_ADD_ELEM_STP( Struct, member_type, _elem_type, member_name ) \
567| ASSERT( memb == Sym_Struct_getMember( st, #member_name ) ); \
568| memb->elem_type = Sym_StructTypeP; memb->elem_st = &_elem_type##_symStruct; \
569| memb->elem_param = (void*)member_type##_SymElem_new( member_type, _elem_type ); \
570| memb->elem_param_delete = member_type##_SymElem_delete; \
571| _elem_type##_registSymStruct( sym );
572|
573|
574|#define SYM_STRUCT_END( Struct ) \
575| return st; \
576| memb; /* avoid warning */ \
577| }
578|
579|/***********************************************************************
580|* 44. <<< [SYM_FUNC_START_0] SYM_FUNC マクロの開始（返り値なし） >>>
581|* 45. <<< [SYM_FUNC_START_1, SYM_FUNC_START_2] >>>
582|* 46. <<< [SYM_FUNC_START_R0] SYM_FUNC マクロの開始（返り値あり） >>>
583|* 47. <<< [SYM_FUNC_START_R1, SYM_FUNC_START_R2] >>>
584|* 48. <<< [SYM_FUNC_STRUCT_ARG] 構造体型の引数の型情報を登録する >>>
585|* 49. <<< [SYM_FUNC_STRUCT_P_ARG] 構造体ポインタ型の引数の型情報を登録する >>>
586|* 50. <<< [SYM_FUNC_END] SYM_FUNC マクロの終了 >>>
587|************************************************************************/
588|#define SYM_FUNC_START_0( symbol, ret_type, func ) \
589| static void symbol##_FuncF( void** arg, void* ret ) \
590| { func(); arg, ret; } \
591| static Sym_Func symbol##_symFunc; \
592| Sym_Func* symbol##_registSymFunc( Sym* sym ) { \
593| Sym_Func* f = &symbol##_symFunc; \
594| ListX_addLast( &sym->funcs, f ); \
595| Sym_Func_init( f, #symbol, symbol##_FuncF, 0 ); \
596| f->types[0] = Sym_Type_getID2( #ret_type );
597|
598|
599|#define SYM_FUNC_START_1( symbol, ret_type, func, arg1_type ) \
600| static void symbol##_FuncF( void** arg, void* ret ) \
601| { func( *(arg1_type*)arg[0] ); ret; } \
602| static Sym_Func symbol##_symFunc; \
603| Sym_Func* symbol##_registSymFunc( Sym* sym ) { \
604| Sym_Func* f = &symbol##_symFunc; \
605| ListX_addLast( &sym->funcs, f ); \
606| Sym_Func_init( f, #symbol, symbol##_FuncF, 1 ); \
607| f->types[0] = Sym_Type_getID2( #ret_type ); \
608| f->types[1] = Sym_Type_getID2( #arg1_type );
609|
610|
611|#define SYM_FUNC_START_2( symbol, ret_type, func, arg1_type, arg2_type ) \
612| static void symbol##_FuncF( void** arg, void* ret ) \
613| { func( *(arg1_type*)arg[0], *(arg2_type*)arg[1] ); ret; } \
614| static Sym_Func symbol##_symFunc; \
615| Sym_Func* symbol##_registSymFunc( Sym* sym ) { \
616| Sym_Func* f = &symbol##_symFunc; \
617| ListX_addLast( &sym->funcs, f ); \
618| Sym_Func_init( f, #symbol, symbol##_FuncF, 2 ); \
619| f->types[0] = Sym_Type_getID2( #ret_type ); \
620| f->types[1] = Sym_Type_getID2( #arg1_type ); \
621| f->types[2] = Sym_Type_getID2( #arg2_type );
622|
623|
624|#define SYM_FUNC_START_R0( symbol, ret_type, func ) \
625| static void symbol##_FuncF( void** arg, void* ret ) \
626| { *(ret_type*)ret = func(); arg; } \
627| static Sym_Func symbol##_symFunc; \
628| Sym_Func* symbol##_registSymFunc( Sym* sym ) { \
629| Sym_Func* f = &symbol##_symFunc; \
630| ListX_addLast( &sym->funcs, f ); \
631| Sym_Func_init( f, #symbol, symbol##_FuncF, 0 ); \
632| f->types[0] = Sym_Type_getID2( #ret_type );
633|
634|
635|#define SYM_FUNC_START_R1( symbol, ret_type, func, arg1_type ) \
636| static void symbol##_FuncF( void** arg, void* ret ) \
637| { *(ret_type*)ret = func( *(arg1_type*)arg[0] ); } \
638| static Sym_Func symbol##_symFunc; \
639| Sym_Func* symbol##_registSymFunc( Sym* sym ) { \
640| Sym_Func* f = &symbol##_symFunc; \
641| ListX_addLast( &sym->funcs, f ); \
642| Sym_Func_init( f, #symbol, symbol##_FuncF, 1 ); \
643| f->types[0] = Sym_Type_getID2( #ret_type ); \
644| f->types[1] = Sym_Type_getID2( #arg1_type );
645|
646|
647|#define SYM_FUNC_START_R2( symbol, ret_type, func, arg1_type, arg2_type ) \
648| static void symbol##_FuncF( void** arg, void* ret ) \
649| { *(ret_type*)ret = func( *(arg1_type*)arg[0], *(arg1_type*)arg[1] ); } \
650| static Sym_Func symbol##_symFunc; \
651| Sym_Func* symbol##_registSymFunc( Sym* sym ) { \
652| Sym_Func* f = &symbol##_symFunc; \
653| ListX_addLast( &sym->funcs, f ); \
654| Sym_Func_init( f, #symbol, symbol##_FuncF, 2 ); \
655| f->types[0] = Sym_Type_getID2( #ret_type ); \
656| f->types[1] = Sym_Type_getID2( #arg1_type ); \
657| f->types[2] = Sym_Type_getID2( #arg2_type );
658|
659|
660|#define SYM_FUNC_STRUCT_ARG( symbol, iArg, type ) \
661| f->types[iArg] = Sym_StructType; \
662| f->sts[iArg] = &type##_symStruct;
663|
664|
665|#define SYM_FUNC_STRUCT_P_ARG( symbol, iArg, type ) \
666| f->types[iArg] = Sym_StructTypeP; \
667| f->sts[iArg] = &type##_symStruct;
668|
669|
670|#define SYM_FUNC_END( symbol ) \
671| return f; \
672| }
673|
674|
675|#endif
676|
677|