Arrx.h
[目次 | 型・クラス・構造体 | マクロ]
1|/****************************************************************
2| 1. <<< 固定要素数配列 (ArrX) >>>
3|*****************************************************************/
4|
5|#ifndef __ARRX_H
6|#define __ARRX_H
7|
8|
9|
10|/****************************************************************
11| 2. <<< モジュール設定／優先ヘッダ >>>
12|【補足】
13|・ここに記述してある内容は、本ヘッダファイルより前にインクルード
14| されるファイル（*.ah$ ファイル、または *-all.h ファイルなど）
15| にコピーされます。
16|*****************************************************************/
17|#ifndef USES_PRIORITY_HEADER
18|/*[START_OF_PRIORITY_HEADER]*/
19|
20|#ifndef USES_ARRX
21|#define USES_ARRX
22|
23|typedef struct _ArrX ArrX;
24|typedef struct _ArrX_Buf ArrX_Buf;
25|typedef struct _ArrX_Able ArrX_Able;
26|#ifdef __cplusplus
27| typedef bool ArrX_AbleElem;
28|#else
29| typedef char ArrX_AbleElem;
30|#endif
31|typedef struct _ArrX_AbleElemP ArrX_AbleElemP;
32|#define ArrX_St void* ArrX_St_imp /* 最後の配列要素の次のアドレス */
33|typedef struct _ArrX_StList ArrX_StList;
34|typedef struct _ArrX_Sort ArrX_Sort;
35|typedef struct _ArrX_Dic ArrX_Dic;
36|typedef struct _ArrX_DicIter ArrX_DicIter;
37|typedef struct _ArrX_DicDupIter ArrX_DicDupIter;
38|
39| /* #define ARRX_OPTI_SIZE */ /* サイズ最適化 */
40|
41|#ifndef STDLIBS_INCLUDE
42| #define STDLIBS_INCLUDE
43|#endif
44|#ifndef STDLIBS_INCLUDE_STDDEF_H
45| #define STDLIBS_INCLUDE_STDDEF_H
46|#endif
47|#ifndef STDLIBS_INCLUDE_SETJMP_H
48| #define STDLIBS_INCLUDE_SETJMP_H
49|#endif
50|
51|
52|#endif
53|
54|/*[END_OF_PRIORITY_HEADER]*/
55|#endif
56|
57|
58|
59|/*************************************************************************
60| 3. <<< エラーコード, リターンコード >>>
61|**************************************************************************/
62|
63|#define ArrX_Err_Full 901 /* [Compone_GID:Errors_Code] */
64|
65|/*-----------------------------------------------------------------*/
66|/* 4. <<< Interface Area ---------------------------------------- >>> */
67|/*-----------------------------------------------------------------*/
68|
69|#ifdef __cplusplus
70|extern "C" {
71|#endif
72|
73|/******************************************************************
74| 5. <<< [ArrX_C] C言語配列 >>>
75|*******************************************************************/
76|/* int ArrX_C_getN( arr, type ); */
77|void ArrX_C_shaffle( void* arr_adr, int elem_size, int nElem, int seed );
78|
79|
80|
81|/******************************************************************
82| 6. <<< [ArrX] 最小固定要素配列 >>>
83|【補足】
84|・集合を定義します。
85|・すでに配列として値が入っているものに適しています。
86|・全ての要素を走査することが出来ます。
87|・メモリサイズは、以下の式で計算します。
88| size = sizeof(ArrX) + sizeof(配列要素) * 配列要素数の最大
89|*******************************************************************/
90|struct _ArrX {
91| void* first; /* 配列の先頭要素のアドレス（型は要素の型のポインタ型）*/
92| void* last; /* 配列の末尾要素の次のアドレス */
93| ERRORS_INITCHK_VAR
94|};
95|
96|void ArrX_init( ArrX*, void* first, int arr_sizeof );
97|void ArrX_init2( ArrX*, void* first, void* over );
98|void ArrX_initByStr( ArrX*, char* );
99|void ArrX_init_byBuf1( ArrX*, ArrX_Buf* );
100|void ArrX_init_byBuf2( ArrX*, ArrX_Buf* );
101|/*void ArrX_initPtrArr( ArrX*, ArrX_Buf*, ArrX*, type );*/
102|
103|/* int ArrX_getN( ArrX*, type ); */
104|int ArrX_getSize( ArrX* );
105|/* type* ArrX_get( ArrX*, int i, type ); */
106|ArrX* ArrX_castFrom_ArrX_Buf( ArrX* arr, ArrX_Buf* buf );
107|int ArrX_chk( ArrX* );
108|/* ArrX_forEach( arrx, pp, type ) */
109|void ArrX_setStrs( ArrX*, ... );
110|/*void ArrX_memrot( void* ball, void* target, type );*/
111|
112|#ifdef USES_ERRORS
113|#ifndef ERRORS_CUT_DEBUG_TOOL
114|void ArrX_print( ArrX*, char* types );
115|#endif
116|#endif
117|
118|#ifdef USES_OFFSET
119|/*type* ArrX_search_i( ArrX*, Offset_Key* key, int val, type );*/
120|/*type* ArrX_search_d( ArrX*, Offset_Key* key, double val, type );*/
121|/*type* ArrX_search_s( ArrX*, Offset_Key* key, char* val, type );*/
122|/*type* ArrX_search_ps( ArrX*, Offset_Key* key, char* val, type );*/
123|#endif /* USES_OFFSET */
124|
125|#ifdef USES_SYM
126| bool ArrX_doLoopFunc( Sym_Ref* container, Sym_Ref* elem );
127| extern Sym_Struct* ArrX_registSymStruct( Sym* );
128| extern Sym_Struct ArrX_symStruct;
129| #define ArrX_SymElem_new( container_type, elem_type ) sizeof(elem_type)
130| #define ArrX_SymElem_delete NULL
131|#endif
132|
133|/* 内部用 */
134|void ArrX_initPtrArr_imp( ArrX*, ArrX_Buf*, ArrX*, int );
135|ArrX* ArrX_castFrom_ArrX_Buf_imp( ArrX* arr, ArrX_Buf* buf );
136|int ArrX_getN_imp( ArrX*, int size );
137|void* ArrX_get_imp( ArrX*, int i, int size );
138|void ArrX_memrot_imp( void* ball, void* target, void* work, int ball_size );
139|
140|#ifdef USES_OFFSET
141|void* ArrX_search_i_imp( ArrX*, Offset_Key* key, int val,
142| int elem_sizeof );
143|void* ArrX_search_d_imp( ArrX*, Offset_Key* key, double val,
144| int elem_sizeof );
145|void* ArrX_search_s_imp( ArrX*, Offset_Key* key, const char* val,
146| int elem_sizeof );
147|void* ArrX_search_ps_imp( ArrX*, Offset_Key* key, const char* val );
148|#endif /* USES_OFFSET */
149|
150|
151|/******************************************************************
152| 7. <<< [ArrX_Buf] 配列を使用したバッファ >>>
153|【補足】
154|・集合を作成していくときに用いる配列兼スタック領域です。
155|・スタックなので開放する順番に制限があります。その制限を無くしたい場合は、
156| それぞれの開放単位ごとにスタック領域(ArrX_Buf)を用意する必要があります。
157|・双方向リストを使用したバッファは DList2_Buf を用います。
158|・メモリサイズは、以下の式で計算します。
159| size = sizeof(ArrX_Buf) + sizeof(配列要素) * 配列要素数の最大
160|
161| 8. <<< [ArrX_Buf を用いたツリー用スタック領域] >>>
162|
163|・ツリー構造の領域として使う場合、それぞれのレベル（型）ごとの
164| ArrX_Buf を『メンバ』に持つ構造体を用意します。ユーザに公開する関数は、
165| 以下のものを用意するとよいでしょう。
166| ・ArrX_Buf_getMemSize を用いた [St_getMemSize 関数]
167| ・各メンバに ArrX_Buf_inits を用いた [St_init 関数]
168| ・各メンバに ArrX_Buf_toEmpty を用いた [St_reset 関数]
169| ・各メンバに ArrX_Buf_setMark（予定）を用いた [St_alloc 関数]
170| ・各メンバに ArrX_Buf_freeToMark（予定）を用いた [St_free 関数]
171|・こうすることで、以下の図のように開放単位の要素ごとにプッシュ(alloc)・
172| ポップ(free)することができます（開放単位ごとに色分しています）。
173| また、開放単位の要素を（２つの）グループに分け、それらはスタックの
174| 制限無く開放(reset)することができます。どのようにグループ分けするかは、
175| エンドユーザに任せたほうがよいでしょう。
176| ↓次の図は無くしてしまいました (^^;
177| 
178|*******************************************************************/
179|struct _ArrX_Buf {
180| void* first; /* 配列の先頭要素のアドレス */
181| void* last; /* 使用状態にある末尾要素の次のアドレス */
182| void* bufLast; /* バッファの末尾の次のアドレス */
183| ERRORS_INITCHK_VAR
184|};
185|
186|void ArrX_Buf_init( ArrX_Buf*, void* mem, int mem_sizeof );
187|void* ArrX_Buf_inits( void* mem, int* mp, int n, ... );
188|int ArrX_Buf_getMemSize( int* ms, int n, ... );
189|/*int ArrX_Buf_getLeftSize( ArrX_Buf*, type ); */
190|int ArrX_Buf_chk( ArrX_Buf* );
191|/* ArrX_Buf_forEach( arrx, pp, type ) */
192|/* ArrX_Buf_forEachReverse( arrx, pp, type ) */
193|void ArrX_Buf_toEmpty( ArrX_Buf* );
194|/* bool ArrX_Buf_isEmpty( ArrX_Buf* ); */
195|/* int ArrX_Buf_getN( ArrX_Buf*, type ); */
196|/* type* ArrX_Buf_get( ArrX_Buf*, int i, type ); */
197|/*type* ArrX_Buf_alloc( ArrX_Buf*, type );*/
198|/*type* ArrX_Buf_allocs( ArrX_Buf*, type, int nElem );*/
199|void ArrX_Buf_addCopy( ArrX_Buf*, ArrX* plus );
200|void ArrX_Buf_addChr( ArrX_Buf*, unsigned char c );
201|void ArrX_Buf_addStr( ArrX_Buf*, const char* s );
202|void ArrX_Buf_addMem( ArrX_Buf*, const void* s, int s_size );
203|void ArrX_Buf_addEndOfC( ArrX_Buf* );
204|/*type* ArrX_Buf_getLast( ArrX_Buf*, type ); */
205|/*void ArrX_Buf_free( ArrX_Buf*, void* p, type );*/
206|#ifdef USES_OFFSET
207|/*type* ArrX_Buf_search_i( ArrX_Buf*, Offset_Key* key, int val, type );*/
208|/*type* ArrX_Buf_search_d( ArrX_Buf*, Offset_Key* key, double val, type );*/
209|/*type* ArrX_Buf_search_s( ArrX_Buf*, Offset_Key* key, const char* val, type );*/
210|/*type* ArrX_Buf_searchNext_s( ArrX_Buf*, Offset_Key* key, type* prev, type );*/
211|#endif /* USES_OFFSET */
212|/*void ArrX_Buf_print( ArrX_Buf*, const char* title );*/
213|/*void ArrX_Buf_printElem( ArrX_Buf*, type, const char* title );*/
214|#if defined(USES_ERRORS) && ! defined(ERRORS_CUT_DEBUG_TOOL)
215|void ArrX_Buf_print2( ArrX_Buf*, char* types );
216|#endif
217|
218|#ifdef USES_SYM
219| bool ArrX_Buf_doLoopFunc( Sym_Ref* container, Sym_Ref* elem );
220| extern Sym_Struct* ArrX_Buf_registSymStruct( Sym* );
221| extern Sym_Struct ArrX_Buf_symStruct;
222| #define ArrX_Buf_SymElem_new( container_type, elem_type ) sizeof(elem_type)
223| #define ArrX_Buf_SymElem_delete NULL
224|#endif
225|
226|/* 内部用 */
227|void* ArrX_Buf_get_imp( ArrX_Buf*, int i, int size );
228|void* ArrX_Buf_alloc_imp( ArrX_Buf*, int alloc_sizeof );
229|void* ArrX_Buf_allocs_imp( ArrX_Buf*, int alloc_sizeof, int nElem );
230|void ArrX_Buf_free_imp( ArrX_Buf*, void* p, int free_sizeof );
231|void* ArrX_Buf_getLast_f_imp( ArrX_Buf*, int size );
232|
233|#ifdef USES_OFFSET
234|void* ArrX_Buf_search_i_imp( ArrX_Buf*, Offset_Key* key, int val,
235| int elem_sizeof );
236|void* ArrX_Buf_search_d_imp( ArrX_Buf*, Offset_Key* key, double val,
237| int elem_sizeof );
238|void* ArrX_Buf_search_s_imp( ArrX_Buf* m, void* start, Offset_Key* key,
239| const char* val, int elem_sizeof );
240|void* ArrX_Buf_search_ps_imp( ArrX_Buf*, Offset_Key* key, const char* val );
241|#endif /* USES_OFFSET */
242|
243|void ArrX_Buf_print_imp( ArrX_Buf*, const char* title );
244|void ArrX_Buf_printElem_imp( ArrX_Buf*, int elem_size, const char* title );
245|
246|/******************************************************************
247| 9. <<< [ArrX_Able] 有効フラグ付き配列 >>>
248| 10. <<< [有効フラグ] >>>
249|【役割】
250|・配列の各要素に有効フラグを付けて、有効無効の管理を行います。
251|・配列の要素は、有効フラグは（次に示すメンバ変数）を持つ必要があります。
252| ArrX_AbleElem inherit_ArrX_AbleElem;
253|・メモリサイズは、以下の式で計算します。
254| size = sizeof(ArrX_Able) + sizeof(配列要素) * 配列要素数の最大
255|
256| 11. <<< [ArrX_AbleElem] 有効フラグ付き配列の要素（抽象クラス） >>>
257|【補足】
258|・COOL の多重継承をサポートしています。
259|
260| 12. <<< [ArrX_AbleElemP] 有効フラグ付きポインタ配列の要素 >>>
261|******************************************************************/
262|#ifdef USES_OFFSET
263|
264|struct _ArrX_Able {
265| ArrX arr; /* extend */
266| ERRORS_INITCHK_VAR
267|};
268|
269|struct _ArrX_AbleElemP {
270| ArrX_AbleElem inherit_ArrX_AbleElem;
271| void* p;
272|};
273|
274|/* void ArrX_Able_init( ArrX_Able*, void* arr_adr, int arr_size, type ); */
275|void ArrX_Able_getMem( ArrX_Able* );
276|/* int ArrX_Able_getN( ArrX_Able*, type ); */
277|/* int ArrX_Able_getM( ArrX_Able*, type ); */
278|/* int ArrX_Able_getI( ArrX_Able*, type*, type ); */
279|/* type* ArrX_Able_get( ArrX_Able*, int i, type ); */
280|/* type* ArrX_Able_getFirst( ArrX_Able*, type ); */
281| void* ArrX_Able_getOver( ArrX_Able* );
282|/* type* ArrX_Able_getNext( ArrX_Able*, type* base, type ); */
283|/* type* ArrX_Able_getFirstDisabled( ArrX_Able*, type ); */
284|#ifdef USES_OFFSET
285| /*type* ArrX_Able_search_s( ArrX_Able*, Offset_Key* key, const char* val, type );*/
286| /* ArrX_Able_forEach( ArrX_Able*, type**, type ); */
287| /* ArrX_Able_forEachDisabled( ArrX_Able*, type**, type ); */
288| /* ArrX_Able_forEachAll( ArrX_Able*, type**, type ); */
289|#endif /* USES_OFFSET */
290|/* bool ArrX_Able_getAble( ArrX_Able*, int i, type ); */
291|/* void ArrX_Able_setAble( ArrX_Able*, int i, bool flag, type ); */
292|/* void ArrX_Able_setAbleAll( ArrX_Able*, bool flag, type ); */
293|
294|
295|void ArrX_AbleElem_setAble( ArrX_AbleElem*, bool flag );
296|bool ArrX_AbleElem_getAble( ArrX_AbleElem* );
297|void ArrX_AbleElem_print( ArrX_AbleElem* );
298|
299|/* 内部用 */
300|void ArrX_Able_init_imp( ArrX_Able*, void* arr_adr, int arr_size,
301| int elem_size, Offset ofsFlag );
302|#ifdef USES_OFFSET
303|void ArrX_Able_forEach_imp( void* pp, int size, Offset ofs, void* over );
304|void ArrX_Able_forEachDisabled_imp( void* pp, int size, Offset ofs, void* over );
305|#endif
306|int ArrX_Able_getN_imp( ArrX_Able*, int elem_size, Offset ofsFlag );
307|void* ArrX_Able_getFirst_imp( ArrX_Able*, int elem_size, Offset ofsFlag );
308|void* ArrX_Able_getFirstDis_imp( ArrX_Able*, int elem_size, Offset ofsFlag );
309|void* ArrX_Able_getNext_imp( ArrX_Able*, void* base, int elem_size,
310| Offset elem_inherit );
311|#ifdef USES_OFFSET
312| void* ArrX_Able_search_s_imp( ArrX_Able*, Offset_Key* key, const char* val,
313| int elem_sizeof, Offset elem_ofs );
314|#endif /* USES_OFFSET */
315|
316|
317|#endif /* USES_OFFSET */
318|
319|
320|/***********************************************************************
321| 13. <<< [ArrX_St] 構造体内配列 >>>
322| 14. <<< [可変長構造体, 構造体内配列] >>>
323|【役割】
324|・構造体の末尾に任意要素数の配列を作成し管理します。
325|【補足】
326|・次のように構造体の末尾に ArrX_St を記述して宣言します。
327| メンバ変数名は必要ありません。配列要素の型は、関数の引数に
328| 随時指定する必要があるので、コメントしておくとよいでしょう。
329| struct { // 可変長構造体（構造体内配列を持つ配列）
330| int member;
331| int member2;
332| ArrX_St; // 〜型の任意要素数の配列
333| };
334| （ArrX_St の定義は、優先ヘッダの中にあります。）
335|・可変長構造体のサイズは、sizeof 演算子で取得することができません。
336| ArrX_St_getSize マクロで取得します。
337|・メモリの配置は次のようになっています。
338| 
339|・配列に対する操作の関数の第１引数は、ArrX_St メンバのアドレスではなく、
340| 可変長構造体の先頭アドレスを指定します。
341|・文字列の集合は、StrX_Mem だけでもできます。
342|************************************************************************/
343|void ArrX_St_initSub( void* ); /* ArrX_St のみの初期化 */
344|/* void ArrX_St_setSubN( void*, int n, type ); */
345|/* int ArrX_St_getSubN( void*, type ); */
346|/* type* ArrX_St_getSub( void*, int i, type ); */
347|/* ArrX_St_forEachSub( void*, type** ptr, type ); */
348|int ArrX_St_getSize( void* );
349|/* int ArrX_St_getSizeN( void*, int n, type ); */
350|void* ArrX_St_getNext( void* );
351|
352|
353|/******************************************************************
354| 15. <<< [ArrX_Sort] ソート・バッファ >>>
355|【補足】
356|・ソートされた順番を求めるときに用います。
357|・ソート・バッファは、要素へのポインタの配列です。つまり、
358| 集合としての配列とは別に、ソート・バッファの配列が必要になります。
359|*******************************************************************/
360|#ifdef USES_OFFSET
361|struct _ArrX_Sort {
362| void** first; /* ソート・バッファの先頭アドレス */
363| void** last; /* ポインタが格納されている末尾の次のアドレス */
364| void** bufLast; /* ソート・バッファの末尾の次のアドレス */
365| Offset_Key* key; /* キー、Offset_Key 型の配列 */
366| ERRORS_INITCHK_VAR
367|};
368|void ArrX_Sort_init( ArrX_Sort*, void** mem, int mem_sizeof,
369| Offset_Key* key );
370|int ArrX_Sort_chk( ArrX_Sort* );
371|void ArrX_Sort_print( ArrX_Sort*, const char* title );
372|void ArrX_Sort_toEmpty( ArrX_Sort* );
373|int ArrX_Sort_isEmpty( ArrX_Sort* );
374|void ArrX_Sort_pushPQ( ArrX_Sort*, void* plus );
375|void* ArrX_Sort_popPQ( ArrX_Sort* );
376|
377|#endif /* USES_OFFSET */
378|
379|
380|
381|/**************************************************************************
382| 16. <<< [ArrX_Dic] ハッシュテーブルを用いた辞書 >>>
383|【補足】
384|・任意の型の構造体（データ）配列から、配列要素を検索します。
385|・検索キーは、その構造体に含まれる文字列型の要素です。
386| その検索キーを内部でハッシュ値に変換してハッシュテーブルにデータを
387| 分配しています。
388|・ハッシュテーブルは次のような構成になっています。
389| 
390|・サブ辞書 subDics は、要素数が width の ArrX_Buf 型の固定長配列です。
391|・配列（辞書要素）は、任意の構造体（データ）を格納する固定長配列です。
392| ただし、内部で指定した固定長配列を、それぞれのサブ辞書に等分に分配します。
393|***************************************************************************/
394|#ifdef USES_OFFSET
395|#ifdef USES_STRX
396|struct _ArrX_Dic {
397| ArrX_Buf* subDics; /* ArrX_Buf 型配列の先頭アドレス */
398| int width; /* ハッシュテーブルの幅, subDics の要素数 */
399| Offset_Key* key; /* キー、Offset_Key 型のアドレス */
400|};
401|
402|void ArrX_Dic_init( ArrX_Dic*,
403| int width, ArrX_Buf* subDics, int subDics_sizeof,
404| Offset_Key* key, void* elems, int elems_sizeof );
405|/*type ArrX_Dic_search( ArrX_Dic*, const char* word, type );*/
406|/*type ArrX_Dic_searchNext( ArrX_Dic*, type* prev, type );*/
407|/*type ArrX_Dic_alloc( ArrX_Dic*, const char* word, type );*/
408|/*type ArrX_Dic_allocDup( ArrX_Dic*, const char* word, type );*/
409|void ArrX_Dic_allocFromFile( ArrX_Dic*,
410| const char* path, StrX_Mem* mem );
411|
412|void ArrX_Dic_print( ArrX_Dic* m, const char* title, int elem_size,
413| void (*elem_print)(void*,const char*) );
414|
415|/* for ( ArrX_Dic_forEachDup( ArrX_Dic* m, ArrX_DicDupIter* p, type ) ); */
416|
417|
418|/* 内部 */
419|void* ArrX_Dic_search_imp( ArrX_Dic*, const char* word,
420| int elem_sizeof );
421|void* ArrX_Dic_searchNext_imp( ArrX_Dic*, const void* prev,
422| int elem_sizeof );
423|void* ArrX_Dic_alloc_imp( ArrX_Dic*, const char* word,
424| int alloc_sizeof );
425|void* ArrX_Dic_allocDup_imp( ArrX_Dic*, const char* word,
426| int alloc_sizeof );
427|bool ArrX_Dic_forEachDup_imp( ArrX_Dic* m, ArrX_DicDupIter* dup, int elem_size );
428|
429|#endif /* USES_STRX */
430|#endif /* USES_OFFSET */
431|
432|
433|
434|
435|/**************************************************************************
436| 17. <<< [ArrX_DicIter] ハッシュテーブルを用いた辞書の走査子 >>>
437|***************************************************************************/
438|#ifdef USES_OFFSET
439|#ifdef USES_STRX
440|struct _ArrX_DicIter {
441| ArrX_Dic* dic; /* 走査対象の辞書 */
442| ArrX_Buf* curBuf; /* 現在のサブ辞書 */
443| void* curData; /* 現在のデータのアドレス */
444| int iBuf; /* サブ辞書の配列番号 */
445| int size; /* 辞書要素のサイズ */
446|};
447|/*void ArrX_DicIter_init( ArrX_DicIter*, ArrX_Dic*, type );*/
448|int ArrX_DicIter_next( ArrX_DicIter* );
449|/*type* ArrX_DicIter_ref( ArrX_DicIter*, type );*/
450|
451|/* 内部用 */
452|void ArrX_DicIter_init_imp( ArrX_DicIter*, ArrX_Dic* dic, int size );
453|
454|#endif /* USES_STRX */
455|#endif /* USES_OFFSET */
456|
457|/**************************************************************************
458| 18. <<< [ArrX_DicDupIter] 重複している辞書要素の走査子 >>>
459|【補足】
460|・ArrX_Dic_forEachDup を使うときに使われます。
461|***************************************************************************/
462|struct _ArrX_DicDupIter {
463| ArrX_Dic* dic;
464| ArrX_Buf* pSubDic; /* 現在 ArrX_Dic_forEachDup でポイントしているサブ辞書 */
465| void* first; /* 現在 ArrX_Dic_forEachDup でポイントしている辞書要素（重複の先頭） */
466| void* p; /* 現在 ArrX_DicDupIter_forEach でポイントしている辞書要素 */
467|};
468|
469|/* for ( ArrX_DicDupIter_forEach( ArrX_DicDupIter* m, type* p, type ) ); */
470|
471|
472|/* 内部用 */
473|bool ArrX_DicDupIter_forEach_imp( ArrX_DicDupIter* dup, int elem_size );
474|
475|
476|/******************************************************************
477| 19. <<< [Offset_Key] キー >>>
478|【補足】
479|・検索したりソートしたりする際に対象となるキーについての情報です。
480|・キーの型の意味は次の通りです。
481| ・ArrX_Key_Int int 型
482| ・ArrX_Key_Double double 型
483| ・ArrX_Key_CString char[] 型、要素（構造体）に文字が格納されている
484| ・ArrX_Key_CStringP char* 型、要素（構造体）にポインタが格納されている
485| ・ArrX_Key_CStringPI 大文字と小文字を区別しない CStringP
486| ・ArrX_Key_CStringPW ワイルドカード付き CStringP
487|*******************************************************************/
488|#ifdef USES_OFFSET
489|struct _ArrX_Key {
490| Offset ofs; /* 要素（構造体）中のキーのバイト位置 */
491| int type; /* キーの型、下記の ArrX_Key_... 定数 */
492| int direc; /* ソート方向, 下記の ArrX_Key_... 定数 */
493| ERRORS_INITCHK_VAR
494|};
495|enum { ArrX_Key_Int, ArrX_Key_Double, ArrX_Key_CString, ArrX_Key_CStringP,
496| ArrX_Key_CStringPI, ArrX_Key_CStringPW, ArrX_Key_StrV };
497|enum { ArrX_Key_Up = -1, ArrX_Key_Down = +1, ArrX_Key_NoDirec = 0 };
498|
499|void ArrX_Key_init( Offset_Key*, Offset ofs, int type, int direc );
500|int ArrX_Key_chk( Offset_Key* );
501|int ArrX_Key_cmp( Offset_Key*, void* data1, void* data2 );
502|void ArrX_Key_print( Offset_Key*, const char* title );
503|void ArrX_Key_printData( Offset_Key*, void* data, const char* title );
504|
505|#endif /* USES_OFFSET */
506|
507|
508|/***********************************************************************
509| 20. <<< [ArrX_Attr] 構造体配列のメンバ変数アクセス・ツール >>>
510|【補足】
511|・構造体の配列があるとき、すべての配列要素構造体のメンバ変数を走査する
512| ポインタを管理します。
513|【例】
514| ArrX points; // XYZ 型構造体の配列
515| ArrX_Attr xpp; // メンバ変数アクセス・ツール
516| int* xp; // メンバ変数(int x;)へのポインタ
517| xp = ArrX_Attr_init_byArrX( &xpp, &points, x, XYZ );
518| while ( ArrX_Attr_isContinue( &xpp, xp ) ) {
519| // do something using xp
520| xp = ArrX_Attr_next( &xpp, xp ); // xp++; の代わり
521| }
522|************************************************************************/
523|typedef struct _ArrX_Attr ArrX_Attr;
524|struct _ArrX_Attr {
525| void* over;
526| int size;
527|};
528|
529|/* void* ArrX_Attr_init_byArrX( ArrX_Attr*, ArrX* arrx,
530| attr, arrx_type ); */
531|bool ArrX_Attr_isContinue( ArrX_Attr*, void* adr );
532|void ArrX_Attr_next( ArrX_Attr*, void* adr );
533|
534|
535|
536|/***********************************************************************
537| 21. <<< [ArrX_ArrsPtrI] int 型配列のはしごポインタ >>>
538|【役割】
539|・メモリ的につながっていない複数の int 型配列の要素を走査します。
540|【補足】
541|・ArrX_ArrsPtrI は、Arrays Pointer on Integer の略です。
542|************************************************************************/
543|typedef struct {
544| int* p; /* ポインタ, *this->p として参照可能 */
545| int* pOver; /* p が arr[iArr] より外のアドレス */
546| int iArr; /* arr の配列番号 */
547| int** arr; /* p が走査する配列へのポインタの配列 */
548| int* arr_n; /* p が走査する配列の要素数の配列 */
549| int nArr; /* p が走査する配列の数 */
550|} ArrX_ArrsPtrI;
551|
552|void ArrX_ArrsPtrI_init( ArrX_ArrsPtrI*, int* arr[], int arr_n[], int nArr,
553| int iArr, int p );
554|void ArrX_ArrsPtrI_set( ArrX_ArrsPtrI*, int iArr, int p );
555|void ArrX_ArrsPtrI_plus( ArrX_ArrsPtrI*, unsigned int plus );
556|
557|
558|/******************************************************************
559| 22. <<< [ArrX_Imp, ArrX_CmpF] 実装 >>>
560|【役割】
561|・内部用
562|・他のモジュールを使わないで基本型のみを用いた機能の実現
563|・ArrX_CmpF は、比較に用いる関数ポインタの型です。
564| 返り値は、標準関数の strcmp と同じです。
565| a は、配列要素へのアドレスです。b は、キーのアドレスです。
566| (ArrX_Imp_linearSearchF 関数を参照)
567|*******************************************************************/
568|typedef int (*ArrX_CmpF)( void* a, void* b, void* param );
569|
570|void* ArrX_Imp_linearSearch( void* start, void* last, int elem_size,
571| const void* key, int key_offset, int key_type, int key_size );
572|void* ArrX_Imp_linearSearchF( void* start, void* last, int elem_size,
573| const void* key, int key_offset, void* param, ArrX_CmpF func );
574|void* ArrX_Imp_linearSearchP( void** start, void** last,
575| const void* key, int key_offset, int key_type, int key_size );
576|void* ArrX_Imp_linearSearchPF( void** start, void** last,
577| const void* key, int key_offset, void* param, ArrX_CmpF func );
578|int ArrX_Imp_cmpMatchMask( char** a, char* b, void* dummy );
579|int ArrX_Imp_cmpIStr( char** a, char* b, void* dummy );
580|
581|#ifdef __cplusplus
582|}
583|#endif
584|
585|/*-----------------------------------------------------------------*/
586|/* 23. <<< Mapping Area ------------------------------------------ >>> */
587|/*-----------------------------------------------------------------*/
588|
589|/****************************************************************
590| 24. <<< [ArrX_C_getN] 要素数を返す >>>
591|*****************************************************************/
592|#define ArrX_C_getN( arr, type ) \
593| ( sizeof( arr ) / sizeof( type ) )
594|
595|
596|
597|/*-------------------------------------------------------------------------*/
598|/* 25. <<<< ◆(ArrX) 最小固定要素配列 >>>> */
599|/*-------------------------------------------------------------------------*/
600|
601|
602|
603|/***********************************************************************
604| 25-1. <<< [ArrX_init_byBuf1, ArrX_init_byBuf2] ArrX_Buf から初期化する >>>
605|【引数】
606| ・ArrX* arrx; 初期化する固定要素数配列
607| ・ArrX_Buf* buf; 配列領域の元
608|【補足】
609|・ArrX_init_byBuf1 と ArrX_init_byBuf2 の間で、buf から取得した
610| （例：ArrX_Buf_alloc など）配列領域を arrx に設定します。
611|************************************************************************/
612|#define ArrX_init_byBuf1( arrx, buf ) \
613| (arrx)->first = (buf)->last
614|
615|#define ArrX_init_byBuf2( arrx, buf ) \
616| { (arrx)->last = (buf)->last; \
617| ERRORS_INITCHK( arrx, 0 ); }
618|
619|
620|
621|
622|
623|/***********************************************************************
624| 25-2. <<< [ArrX_initPtrArr] ポインタ配列を作る >>>
625|【補足】
626|・type 型の配列 arr に格納されているすべての要素のアドレスを
627| ポインタ配列 this に格納します。ただし、メモリ領域は buf から
628| 取得します。
629|************************************************************************/
630|#define ArrX_initPtrArr( this, buf, arr, type ) \
631| ArrX_initPtrArr_imp( this, buf, arr, sizeof(type) )
632|
633|
634|/***********************************************************************
635| 25-3. <<< [ArrX_forEach] 全ての要素を走査する >>>
636|【補足】
637|・for 文の中に入れてください（下記の例を参照）
638|【例】
639| Any* p; ArrX arrx;
640| for ( ArrX_forEach( arrx, &p, Any ) ) {
641| // for 内では、p を要素へのポインタとして使用可能
642| }
643|************************************************************************/
644|#define ArrX_forEach( arrx, pp, type ) \
645| *(pp) = (type*)(arrx)->first; *(pp) < (type*)(arrx)->last; (*(pp))++
646|
647|
648|
649|/****************************************************************
650| 25-4. <<< [ArrX_getN] 要素数を返す >>>
651|*****************************************************************/
652|#ifdef NDEBUG
653| #define ArrX_getN( arr, type ) \
654| ( ( (char*)(arr)->last - (char*)(arr)->first ) / sizeof(type) )
655|#else
656| #define ArrX_getN( arr, type ) \
657| ArrX_getN_imp( arr, sizeof(type) )
658|#endif
659|
660|
661|
662|/****************************************************************
663| 25-5. <<< [ArrX_getSize] 要素サイズ（バイト）を返す >>>
664|*****************************************************************/
665|#define ArrX_getSize( this ) \
666| ( (char*)(this)->last - (char*)(this)->first )
667|
668|/****************************************************************
669| 25-6. <<< [ArrX_get] 配列番号から要素を返す >>>
670|【引数】
671| ・ArrX* this; 配列
672| ・int i; 配列番号
673| ・type; 配列の型
674|【補足】
675|・デバッグ時は、関数版 ArrX_get_imp を呼び出します。
676|*****************************************************************/
677|#ifdef NDEBUG
678| #define ArrX_get( this, i, type ) \
679| ( (type*)((this)->first) + (i) )
680|#else
681| #define ArrX_get( this, i, type ) \
682| ( (type*)ArrX_get_imp( this, i, sizeof(type) ) )
683|#endif
684|
685|
686|
687|/****************************************************************
688| 25-7. <<< [ArrX_castFrom_ArrX_Buf] ArrX 型にキャストする >>>
689|【補足】
690|・buf が参照される間、arr が存在するようにしてください。
691|・NDEBUG が define されている場合、arr は変数宣言する必要は、
692| ありません。（引数にダミーは指定しておいてください）
693|*****************************************************************/
694|#ifdef NDEBUG
695| #define ArrX_castFrom_ArrX_Buf( arr, buf ) ((ArrX*)(buf))
696|#else
697| #define ArrX_castFrom_ArrX_Buf( arr, buf ) \
698| ArrX_castFrom_ArrX_Buf_imp( arr, buf )
699|#endif
700|
701|/***********************************************************************
702| 25-8. <<< [ArrX_memrot] 配列の要素をローテーションする >>>
703|【引数】
704| ・void* ball; ローテーションする配列要素へのアドレス
705| ・void* target; 移動先のアドレス
706| ・type; 配列要素の型
707|【補足】
708|・
709|・移動は右方向にも左方向にもできます。
710|・ArrX 型の変数は必要ありません。
711|************************************************************************/
712|#define ArrX_memrot( ball, target, type ) \
713| {\
714| type work; \
715| ArrX_memrot_imp( ball, target, &work, sizeof(type) ); \
716| }
717|
718|
719|
720|/****************************************************************
721| 25-9. <<< [ArrX_search_i] int 型のキーで要素を検索する >>>
722|*****************************************************************/
723|#define ArrX_search_i( this, key, val, type ) \
724| ( (type*)ArrX_search_i_imp(this, key, val, sizeof(type)) )
725|
726|
727|/****************************************************************
728| 25-10. <<< [ArrX_search_d] double 型のキーで要素を検索する >>>
729|*****************************************************************/
730|#define ArrX_search_d( this, key, val, type ) \
731| ( (type*)ArrX_search_d_imp(this, key, val, sizeof(type)) )
732|
733|
734|/****************************************************************
735| 25-11. <<< [ArrX_search_s] 文字列型のキーで要素を検索する >>>
736|【引数】
737| ・ArrX* this; 配列
738| ・Offset_Key* key; 要素中のキーのタイプ
739| ・char* val; 検索するキー値
740| ・type; 要素の型
741| ・type* 返り値; 見つかった要素、または NULL
742|*****************************************************************/
743|#define ArrX_search_s( this, key, val, type ) \
744| ( (type*)ArrX_search_s_imp(this, key, val, sizeof(type)) )
745|
746|
747|/****************************************************************
748| 25-12. <<< [ArrX_search_ps] 文字列型のキーでポインタ配列の要素を検索する >>>
749|【引数】
750| ・ArrX* this; ポインタ配列
751| ・Offset_Key* key; 要素中のキーのタイプ
752| ・char* val; 検索するキー値
753| ・type; 要素の型
754| ・type* 返り値; 見つかった要素、または NULL
755|*****************************************************************/
756|#define ArrX_search_ps( this, key, val, type ) \
757| ( (type**)ArrX_search_ps_imp(this, key, val ) )
758|
759|
760|/*-------------------------------------------------------------------------*/
761|/* 26. <<<< ◆(ArrX_Buf) バッファ >>>> */
762|/*-------------------------------------------------------------------------*/
763|
764|
765|
766|/****************************************************************
767| 26-1. <<< [ArrX_Buf_getLeftSize] 残りのメモリサイズを返す >>>
768|【引数】
769| ・ArrX* this; ポインタ配列
770| ・Offset_Key* key; 要素中のキーのタイプ
771| ・char* val; 検索するキー値
772| ・type; 要素の型
773| ・type* 返り値; 見つかった要素、または NULL
774|*****************************************************************/
775|#define ArrX_Buf_getLeftSize( this, type ) \
776| ((type*)(this)->bufLast - (type*)(this)->last)
777|
778|
779|
780|/***********************************************************************
781| 26-2. <<< [ArrX_Buf_forEach] 全ての要素を走査する >>>
782|【補足】
783|・for 文の中に入れてください（下記の例を参照）
784|【例】
785| Any* p; ArrX_Buf arrx;
786| for ( ArrX_Buf_forEach( arrx, &p, Any ) ) {
787| // for 内では、p を要素へのポインタとして使用可能
788| }
789|************************************************************************/
790|#define ArrX_Buf_forEach( arrx, pp, type ) \
791| *(pp) = (type*)(arrx)->first; *(pp) < (type*)(arrx)->last; (*(pp))++
792|
793|
794|
795|/***********************************************************************
796| 26-3. <<< [ArrX_Buf_forEach_imp] パラメータ化された型の全ての要素を走査する >>>
797|【引数】
798| ・void** pp; ループポインタ変数のアドレス
799| ・int size; 配列要素のサイズ
800|************************************************************************/
801|#define ArrX_Buf_forEach_imp( m, pp, type_size ) \
802| *(pp) = (m)->first; \
803| (char*)*(pp) < (char*)(m)->last; \
804| *(pp) = (void*)( (char*)*(pp) + (type_size) )
805|
806|/***********************************************************************
807| 26-4. <<< [ArrX_Buf_forEachReverse] 全ての要素を逆順で走査する >>>
808|【補足】
809|・for 文の中に入れてください（下記の例を参照）
810|【例】
811| Any* p; ArrX_Buf arrx;
812| for ( ArrX_Buf_forEachReverse( arrx, &p, Any ) ) {
813| // for 内では、p を要素へのポインタとして使用可能
814| }
815|************************************************************************/
816|#define ArrX_Buf_forEachReverse( arrx, pp, type ) \
817| *(pp) = (type*)(arrx)->last - 1; *(pp) >= (type*)(arrx)->first; (*(pp))--
818|
819|/****************************************************************
820| 26-5. <<< [ArrX_Buf_toEmpty] バッファを空にする >>>
821|*****************************************************************/
822|#define ArrX_Buf_toEmpty( this ) \
823| ((this)->last = (this)->first)
824|
825|
826|/****************************************************************
827| 26-6. <<< [ArrX_Buf_isEmpty] バッファを空かどうかを返す >>>
828|*****************************************************************/
829|#define ArrX_Buf_isEmpty( this ) \
830| ((this)->first == (this)->last)
831|
832|/****************************************************************
833| 26-7. <<< [ArrX_Buf_getN] 要素数を返す >>>
834|*****************************************************************/
835|#define ArrX_Buf_getN( arr, type ) \
836| ( ( (char*)(arr)->last - (char*)(arr)->first ) / sizeof(type) )
837|
838|
839|/****************************************************************
840| 26-8. <<< [ArrX_Buf_getN_imp] パラメータ化された型の要素数を返す >>>
841|*****************************************************************/
842|#define ArrX_Buf_getN_imp( arr, type_size ) \
843| ( ( (char*)(arr)->last - (char*)(arr)->first ) / type_size )
844|
845|
846|/****************************************************************
847| 26-9. <<< [ArrX_Buf_get] 配列番号から要素を返す >>>
848|【引数】
849| ・ArrX_Buf* this; 配列
850| ・int i; 配列番号
851| ・type; 配列の型
852|【補足】
853|・デバッグ時は、関数版 ArrX_Buf_get_imp を呼び出します。
854|*****************************************************************/
855|#ifdef NDEBUG
856| #define ArrX_Buf_get( this, i, type ) \
857| ( (type*)((this)->first) + (i) )
858|#else
859| #define ArrX_Buf_get( this, i, type ) \
860| ( (type*)ArrX_Buf_get_imp( this, i, sizeof(type) ) )
861|#endif
862|
863|
864|
865|/**********************************************************************
866| 26-10. <<< [ArrX_Buf_alloc] 指定サイズのバッファをアロケートする >>>
867|【補足】
868|・末尾の有効な要素の次に追加します。
869|***********************************************************************/
870|#ifdef ARRX_OPTI_SIZE
871| #define ArrX_Buf_alloc( this, type ) \
872| ( (type*)ArrX_Buf_allocs_imp( this, sizeof(type), 1 ) )
873|#else
874| #define ArrX_Buf_alloc( this, type ) \
875| ( (type*)ArrX_Buf_alloc_imp( this, sizeof(type) ) )
876|#endif
877|
878|
879|/**********************************************************************
880| 26-11. <<< [ArrX_Buf_allocs] 指定サイズのバッファを複数アロケートする >>>
881|【補足】
882|・末尾の有効な要素の次に追加します。
883|***********************************************************************/
884|#define ArrX_Buf_allocs( this, type, nElem ) \
885| ( (type*)ArrX_Buf_allocs_imp( this, sizeof(type), nElem ) )
886|
887|
888|/**********************************************************************
889| 26-12. <<< [ArrX_Buf_getLast] 末尾の要素を返す >>>
890| 26-13. <<< [ArrX_Buf_getLast_m, ArrX_Buf_getLast_f] >>>
891|【補足】
892|・type* ArrX_Buf_getLast( ArrX_Buf*, type )
893|・要素が１つも無いときは、ASSERT に引っかかります。
894|***********************************************************************/
895|#ifdef NDEBUG
896| #define ArrX_Buf_getLast ArrX_Buf_getLast_m
897|#else
898| #define ArrX_Buf_getLast ArrX_Buf_getLast_f
899|#endif
900|
901|#define ArrX_Buf_getLast_m( this, type ) \
902| ( ((type*)(this)->last) - 1 )
903|
904|#define ArrX_Buf_getLast_f( this, type ) \
905| ( (type*)ArrX_Buf_getLast_f_imp( this, sizeof(type) ) )
906|
907|/**********************************************************************
908| 26-14. <<< [ArrX_Buf_free] 指定サイズのバッファを解放する >>>
909|【補足】
910|・参照：ArrX_Buf_free_imp
911|***********************************************************************/
912|#define ArrX_Buf_free( this, p, type ) \
913| ArrX_Buf_free_imp( this, p, sizeof(type) )
914|
915|
916|/****************************************************************
917| 26-15. <<< [ArrX_Buf_search_i] int 型のキーで要素を検索する >>>
918|*****************************************************************/
919|#define ArrX_Buf_search_i( this, key, val, type ) \
920| ((type*)ArrX_Buf_search_i_imp( this, key, val, sizeof(type) ))
921|
922|
923|/****************************************************************
924| 26-16. <<< [ArrX_Buf_search_d] double 型のキーで要素を検索する >>>
925|*****************************************************************/
926|#define ArrX_Buf_search_d( this, key, val, type ) \
927| ((type*)ArrX_Buf_search_d_imp( this, key, val, sizeof(type) ))
928|
929|
930|/****************************************************************
931| 26-17. <<< [ArrX_Buf_search_s] 文字列型のキーで要素を検索する >>>
932|【引数】
933| ・ArrX_Buf* this; 配列
934| ・Offset_Key* key; 要素中のキーのタイプ
935| ・char* val; 検索するキー値
936| ・type; 要素の型
937| ・type* 返り値; 見つかった要素、または NULL
938|*****************************************************************/
939|#define ArrX_Buf_search_s( this, key, val, type ) \
940| ((type*)ArrX_Buf_search_s_imp( this, (this)->first, key, val, sizeof(type) ))
941|
942|
943|/****************************************************************
944| 26-18. <<< [ArrX_Buf_searchNext_s] 文字列型のキーで続きの要素を検索する >>>
945|【引数】
946| ・ArrX_Buf* this; 配列
947| ・Offset_Key* key; 要素中のキーのタイプ
948| ・char* val; 検索するキー値
949| ・type; 要素の型
950| ・type* 返り値; 見つかった要素、または NULL
951|*****************************************************************/
952|#define ArrX_Buf_search_s( this, key, val, type ) \
953| ((type*)ArrX_Buf_search_s_imp( this, (this)->first, key, val, sizeof(type) ))
954|
955|
956|/****************************************************************
957| 26-19. <<< [ArrX_Buf_print] デバッグ表示 >>>
958|*****************************************************************/
959|#define ArrX_Buf_print( this, title ) \
960| ArrX_Buf_print_imp( this, title )
961|
962|/****************************************************************
963| 26-20. <<< [ArrX_Buf_printElem] デバッグ表示 >>>
964|*****************************************************************/
965|#define ArrX_Buf_printElem( this, type, title ) \
966| ArrX_Buf_printElem_imp( this, sizeof(type), title )
967|
968|
969|/*-------------------------------------------------------------------------*/
970|/* 27. <<<< ◆(ArrX_Able) 有効フラグ付き配列 >>>> */
971|/*-------------------------------------------------------------------------*/
972|
973|
974|
975|/***********************************************************************
976| 27-1. <<< [ArrX_Able_init] 初期化する（すべての要素を無効にする） >>>
977|【引数】
978| ・type* arr_adr; 配列の先頭アドレス
979| ・int arr_size; 配列のメモリサイズ
980| ・type; 配列の要素の型
981|【補足】
982|・arr_adr には、直接 malloc を指定しないでください。
983|************************************************************************/
984|#ifdef USES_OFFSET
985|
986|#define ArrX_Able_init( this, arr_adr, arr_size, type ) \
987| ArrX_Able_init_imp( this, (arr_adr), (arr_size), \
988| sizeof(type), Offset_init( type, inherit_ArrX_AbleElem ) )
989|
990|#endif
991|
992|/***********************************************************************
993| 27-2. <<< [ArrX_Able_getMem] 使用しているメモリ領域の先頭アドレスを返す >>>
994|【引数】
995| ・void* 返り値; 使用しているメモリ領域の先頭アドレス
996|【補足】
997|・malloc で確保した領域を使用しているとき、free するために使用します。
998|************************************************************************/
999|#define ArrX_Able_getMem( this ) \
1000| ((this)->arr.first)
1001|
1002|
1003|
1004|/***********************************************************************
1005| 27-3. <<< [ArrX_Able_getN] 有効な要素数を返す >>>
1006|************************************************************************/
1007|#ifdef USES_OFFSET
1008|
1009|#define ArrX_Able_getN( this, type ) \
1010| ArrX_Able_getN_imp( (this), sizeof( type ), \
1011| Offset_init( type, inherit_ArrX_AbleElem ) )
1012|
1013|#endif
1014|
1015|
1016|/***********************************************************************
1017| 27-4. <<< [ArrX_Able_getM] 最大の要素数を返す >>>
1018|************************************************************************/
1019|#define ArrX_Able_getM( this, type ) \
1020| ArrX_getN( &(this)->arr, type )
1021|
1022|
1023|/***********************************************************************
1024| 27-5. <<< [ArrX_Able_getI] 要素番号を返す >>>
1025|【引数】
1026| ・type* p; 要素のアドレス
1027| ・int 返り値; 要素番号（０〜）
1028|************************************************************************/
1029|#define ArrX_Able_getI( this, p, type ) \
1030| ( ( (char*)(p) - (char*)(this)->arr.first ) / sizeof(type) )
1031|
1032|
1033|/***********************************************************************
1034| 27-6. <<< [ArrX_Able_get] 要素のアドレスを返す >>>
1035|【引数】
1036| ・int i; 要素番号（無効の要素も数える）
1037| ・type; 要素の型
1038|************************************************************************/
1039|#define ArrX_Able_get( this, i, type ) \
1040| ( (type*)( (char*)(this)->arr.first + (i) * sizeof(type) ) )
1041|
1042|
1043|/***********************************************************************
1044| 27-7. <<< [ArrX_Able_getFirst] 最初の有効な要素を返す >>>
1045|【引数】
1046| ・type; 要素の型
1047| ・void* 返り値; 最初の要素、NULL=要素が１つも無い
1048|************************************************************************/
1049|#ifdef USES_OFFSET
1050|
1051|#define ArrX_Able_getFirst( this, type ) \
1052| ( (type*)ArrX_Able_getFirst_imp( (this), sizeof( type ), \
1053| Offset_init( type, inherit_ArrX_AbleElem ) ) )
1054|
1055|#endif
1056|
1057|
1058|/***********************************************************************
1059| 27-8. <<< [ArrX_Able_getOver] 配列の外（次）のアドレスを返す >>>
1060|【引数】
1061| ・ArrX_Able* this; 有効フラグ付き配列
1062| ・void* 返り値; 配列の外（次）のアドレス
1063|************************************************************************/
1064|#define ArrX_Able_getOver( this ) \
1065| ( (this)->arr.last )
1066|
1067|/***********************************************************************
1068| 27-9. <<< [ArrX_Able_getFirstDisabled] 最初の無効な要素を返す >>>
1069|【引数】
1070| ・type; 要素の型
1071| ・void* 返り値; 最初の要素、NULL=要素が１つも無い
1072|************************************************************************/
1073|#ifdef USES_OFFSET
1074|
1075|#define ArrX_Able_getFirstDisabled( this, type ) \
1076| (type*)ArrX_Able_getFirstDis_imp( (this), sizeof( type ), \
1077| Offset_init( type, inherit_ArrX_AbleElem ) )
1078|
1079|#endif
1080|
1081|
1082|/***********************************************************************
1083| 27-10. <<< [ArrX_Able_getNext] 次の有効な要素のアドレスを返す >>>
1084|【引数】
1085| ・type* base; 基準となる要素
1086| ・type* 返り値; 次の有効な要素（base が最後なら NULL が返ります）
1087| ・type; 要素の型
1088|************************************************************************/
1089|#define ArrX_Able_getNext( this, base, type ) \
1090| ( (type*)ArrX_Able_getNext_imp( this, base, \
1091| sizeof(type), Offset_init( type, inherit_ArrX_AbleElem ) ) )
1092|
1093|/***********************************************************************
1094| 27-11. <<< [ArrX_Able_search_s] 文字列型のキーで要素を検索する >>>
1095|【引数】
1096| ・Offset_Key* key; 検索するキーの型
1097| ・char* val; 検索するキー
1098| ・type; 要素の型
1099| ・type* 返り値; 最初に見つかった要素のアドレス（NULL＝見つからない）
1100|************************************************************************/
1101|#ifdef USES_OFFSET
1102| #define ArrX_Able_search_s( this, key, val, type ) \
1103| ( (type*) ArrX_Able_search_s_imp( this, key, val, sizeof(type), \
1104| Offset_init( type, inherit_ArrX_AbleElem ) ) )
1105|#endif /* USES_OFFSET */
1106|
1107|/***********************************************************************
1108| 27-12. <<< [ArrX_Able_forEach] 有効な全ての要素を走査する >>>
1109|【補足】
1110|・for 文の中に入れてください（下記の例を参照）
1111|【例】
1112| Any* p; ArrX_Able arrx;
1113| for ( ArrX_Able_forEach( &arrx, &p, Any ) ) {
1114| // for 内では、p を要素へのポインタとして使用可能
1115| }
1116|************************************************************************/
1117|#ifdef USES_OFFSET
1118|
1119|#ifdef NDEBUG
1120|
1121|#define ArrX_Able_forEach( arrx, pp, type ) \
1122| *(pp) = (type*)(arrx)->arr.first, \
1123| ArrX_Able_forEach_imp( pp, sizeof(type), \
1124| Offset_init( type, inherit_ArrX_AbleElem ), (arrx)->arr.last ); \
1125| *(pp) < (type*)(arrx)->arr.last; \
1126| *(pp) = (type*)( (char*)*(pp) + sizeof(type) ), \
1127| ArrX_Able_forEach_imp( pp, sizeof(type), \
1128| Offset_init( type, inherit_ArrX_AbleElem ), (arrx)->arr.last )
1129|
1130|#else
1131|
1132|#define ArrX_Able_forEach( arrx, pp, type ) \
1133| ERRORS_INITCHK( arrx, 1 ), \
1134| *(pp) = (type*)(arrx)->arr.first, \
1135| ArrX_Able_forEach_imp( pp, sizeof(type), \
1136| Offset_init( type, inherit_ArrX_AbleElem ), (arrx)->arr.last ); \
1137| *(pp) < (type*)(arrx)->arr.last; \
1138| *(pp) = (type*)( (char*)*(pp) + sizeof(type) ), \
1139| ArrX_Able_forEach_imp( pp, sizeof(type), \
1140| Offset_init( type, inherit_ArrX_AbleElem ), (arrx)->arr.last )
1141|
1142|#endif
1143|
1144|#endif
1145|
1146|
1147|
1148|/***********************************************************************
1149| 27-13. <<< [ArrX_Able_forEachDisabled] 無効な全ての要素を走査する >>>
1150|【補足】
1151|・for 文の中に入れてください（下記の例を参照）
1152|【例】
1153| Any* p; ArrX_Able arrx;
1154| for ( ArrX_Able_forEachDisabled( &arrx, &p, Any ) ) {
1155| // for 内では、p を要素へのポインタとして使用可能
1156| }
1157|************************************************************************/
1158|#ifdef USES_OFFSET
1159|
1160|#ifdef NDEBUG
1161|
1162|#define ArrX_Able_forEachDisabled( arrx, pp, type ) \
1163| *(pp) = (type*)(arrx)->arr.first, \
1164| ArrX_Able_forEachDisabled_imp( pp, sizeof(type), \
1165| Offset_init( type, inherit_ArrX_AbleElem ), (arrx)->arr.last ); \
1166| *(pp) < (type*)(arrx)->arr.last; \
1167| *(pp) = (type*)( (char*)*(pp) + sizeof(type) ), \
1168| ArrX_Able_forEachDisabled_imp( pp, sizeof(type), \
1169| Offset_init( type, inherit_ArrX_AbleElem ), (arrx)->arr.last )
1170|
1171|#else
1172|
1173|#define ArrX_Able_forEachDisabled( arrx, pp, type ) \
1174| ERRORS_INITCHK( arrx, 1 ), \
1175| *(pp) = (type*)(arrx)->arr.first, \
1176| ArrX_Able_forEachDisabled_imp( pp, sizeof(type), \
1177| Offset_init( type, inherit_ArrX_AbleElem ), (arrx)->arr.last ); \
1178| *(pp) < (type*)(arrx)->arr.last; \
1179| *(pp) = (type*)( (char*)*(pp) + sizeof(type) ), \
1180| ArrX_Able_forEachDisabled_imp( pp, sizeof(type), \
1181| Offset_init( type, inherit_ArrX_AbleElem ), (arrx)->arr.last )
1182|
1183|#endif
1184|
1185|#endif
1186|
1187|
1188|
1189|/***********************************************************************
1190| 27-14. <<< [ArrX_Able_forEachAll] 有効でない要素も全て走査する >>>
1191|【補足】
1192|・for 文の中に入れてください（下記の例を参照）
1193|【例】
1194| Any* p; ArrX_Able arrx;
1195| for ( ArrX_Able_forEach( &arrx, &p,, Any ) ) {
1196| // for 内では、p を要素へのポインタとして使用可能
1197| }
1198|************************************************************************/
1199|#define ArrX_Able_forEachAll( arrx, pp, type ) \
1200| *(pp) = (type*)(arrx)->arr.first; *(pp) < (type*)(arrx)->arr.last; (*(pp))++
1201|
1202|
1203|/***********************************************************************
1204| 27-15. <<< [ArrX_Able_getAble] 要素が有効かどうかを返す >>>
1205|【引数】
1206| ・int i; 要素番号（無効の要素も数える）
1207|************************************************************************/
1208|#define ArrX_Able_getAble( this, i, type ) \
1209| ((type*)( (char*)(this)->arr.first + i * sizeof(type) ))->inherit_ArrX_AbleElem
1210|
1211|
1212|/***********************************************************************
1213| 27-16. <<< [ArrX_Able_setAble] 要素が有効かどうかを設定する >>>
1214|【引数】
1215| ・int i; 要素番号（無効の要素も数える）
1216| ・int flag; 要素が有効かどうか
1217|【補足】
1218|・本マクロを使用しないで、要素の inherit_ArrX_AbleElem メンバ変数に、
1219| 有効かどうかのフラグ値を直接代入しても構いません。
1220|************************************************************************/
1221|#define ArrX_Able_setAble( this, i, flag, type ) \
1222| ((type*)( (char*)(this)->arr.first + i * sizeof(type) )) \
1223| ->inherit_ArrX_AbleElem = (flag)
1224|
1225|
1226|/***********************************************************************
1227| 27-17. <<< [ArrX_Able_setAbleAll] 全要素に対して有効かどうか設定する >>>
1228|【引数】
1229| ・int flag; 全要素が有効かどうか
1230|************************************************************************/
1231|#define ArrX_Able_setAbleAll( this, flag, type ) \
1232| { \
1233| type* _pp; \
1234| for ( ArrX_Able_forEachAll( this, &_pp, type ) ) { \
1235| ArrX_AbleElem_setAble( _pp, flag ); \
1236| } \
1237| }
1238|
1239|/*-------------------------------------------------------------------------*/
1240|/* 28. <<<< ◆(ArrX_AbleElem) 有効フラグ付き配列の要素 >>>> */
1241|/*-------------------------------------------------------------------------*/
1242|
1243|
1244|
1245|/***********************************************************************
1246| 28-1. <<< [ArrX_AbleElem_getAble] 要素が有効かどうかを返す >>>
1247|【引数】
1248| ・ArrX_AbleElem* this; 有効フラグ付き配列の要素
1249| ・bool 帰り値; 要素が有効かどうか
1250|************************************************************************/
1251|#define ArrX_AbleElem_getAble( this ) \
1252| ( (this)->inherit_ArrX_AbleElem )
1253|
1254|
1255|/***********************************************************************
1256| 28-2. <<< [ArrX_AbleElem_setAble] 要素が有効かどうかを設定する >>>
1257|【引数】
1258| ・ArrX_AbleElem* this; 有効フラグ付き配列の要素
1259| ・bool flag; 要素が有効かどうか
1260|************************************************************************/
1261|#define ArrX_AbleElem_setAble( this, flag ) \
1262| (this)->inherit_ArrX_AbleElem = (flag)
1263|
1264|
1265|/***********************************************************************
1266| 28-3. <<< [ArrX_AbleElem_print] 有効かどうかを表示する >>>
1267|【引数】
1268| ・ArrX_AbleElem* this; 有効フラグ付き配列の要素
1269|************************************************************************/
1270|#define ArrX_AbleElem_print( this ) \
1271| Errors_printf( "able = %d", (this)->inherit_ArrX_AbleElem )
1272|
1273|
1274|/*-------------------------------------------------------------------------*/
1275|/* 29. <<<< ◆(ArrX_St) 構造体内配列 >>>> */
1276|/*-------------------------------------------------------------------------*/
1277|
1278|
1279|
1280|/***********************************************************************
1281| 29-1. <<< [ArrX_St_initSub] 初期化する（要素数を０にする） >>>
1282|【補足】
1283|・可変長構造体の初期化関数の中で呼び出してください。
1284|************************************************************************/
1285|#define ArrX_St_init( this ) \
1286| (this)->ArrX_St_imp = &(this)->ArrX_St_imp + sizeof(int)
1287|
1288|
1289|
1290|/***********************************************************************
1291| 29-2. <<< [ArrX_St_setSubN] 配列の要素数を指定する（指定の要素数を確保する） >>>
1292|************************************************************************/
1293|#define ArrX_St_setSubN( this, n, type ) \
1294| (this)->ArrX_St_imp = &(this)->ArrX_St_imp + sizeof(int) + (n) * sizeof(type)
1295|
1296|
1297|
1298|/***********************************************************************
1299| 29-3. <<< [ArrX_St_getSubN] （確保してある）配列の要素数を返す >>>
1300|************************************************************************/
1301|#define ArrX_St_getSubN( this, type ) \
1302| ( (this)->ArrX_St_imp - &(this)->ArrX_St_imp - sizeof(int) ) / sizeof(type)
1303|
1304|
1305|
1306|/***********************************************************************
1307| 29-4. <<< [ArrX_St_getSub] 指定番号の配列要素のアドレスを返す >>>
1308|************************************************************************/
1309|#define ArrX_St_getSub( this, i, type ) \
1310| (type*)(&(this)->ArrX_St_imp + sizeof(int) + (i) * sizeof(type))
1311|
1312|
1313|
1314|/***********************************************************************
1315| 29-5. <<< [ArrX_St_forEachSub] すべての配列要素を走査する >>>
1316|【補足】
1317|・次のように for 文の中で使用します。
1318| type* ptr;
1319| for ( ArrX_St_forEachSub( this, &ptr, type ) ) {
1320| ptr->member = 0;
1321| }
1322|************************************************************************/
1323|#define ArrX_St_forEachSub( this, ptr, type ) \
1324| *(ptr) = (type*)(&(this)->ArrX_St_imp + sizeof(int)); \
1325| *(ptr) < (type*)(this)->ArrX_St_imp; \
1326| ptr ++
1327|
1328|
1329|
1330|/***********************************************************************
1331| 29-6. <<< [ArrX_St_getSize] 可変長構造体のサイズを返す >>>
1332|【補足】
1333|・返り値は、ワード単位のサイズでないこともあります。（未確認）
1334|************************************************************************/
1335|#define ArrX_St_getSize( this ) \
1336| ( (char*)(this)->ArrX_St_imp - (char*)(this) )
1337|
1338|
1339|
1340|/***********************************************************************
1341| 29-7. <<< [ArrX_St_getSizeN] 要素数を指定してみて、その可変長構造体のサイズを返す >>>
1342|【補足】
1343|・返り値は、ワード単位のサイズでないこともあります。（未確認）
1344|・配列の要素数は変化しません。
1345|************************************************************************/
1346|#define ArrX_St_getSizeN( this, n, type ) \
1347| ( (char*)(&(this)->ArrX_St_imp + sizeof(int) + (n) * sizeof(type)) - \
1348| (char*)(this) )
1349|
1350|
1351|
1352|/***********************************************************************
1353| 29-8. <<< [ArrX_St_getNext] 可変長構造体の次のアドレスを返す >>>
1354|【引数】
1355| ・void* 返り値; 可変長構造体の次のアドレス
1356|************************************************************************/
1357|#define ArrX_St_getNext( this ) \
1358| (this)->ArrX_St_imp
1359|
1360|
1361|/*-------------------------------------------------------------------------*/
1362|/* 30. <<<< ◆(ArrX_Sort) ソート・バッファ >>>> */
1363|/*-------------------------------------------------------------------------*/
1364|
1365|
1366|
1367|
1368|/****************************************************************
1369| 30-1. <<< [ArrX_Sort_toEmpty] ソート・バッファを空にする >>>
1370|*****************************************************************/
1371|#ifdef USES_OFFSET
1372|
1373|#define ArrX_Sort_toEmpty( this ) \
1374| ((this)->last = (this)->first)
1375|
1376|#endif
1377|
1378|
1379|/****************************************************************
1380| 30-2. <<< [ArrX_Sort_isEmpty] 空かどうか調べる >>>
1381|*****************************************************************/
1382|#ifdef USES_OFFSET
1383|
1384|#define ArrX_Sort_isEmpty( this ) \
1385| ( (this)->first == (this)->last )
1386|
1387|#endif
1388|
1389|/****************************************************************
1390| 30-3. <<< [ArrX_Sort_forEachPQ] ソート・バッファが空になるまで取得ループする >>>
1391|【補足】
1392|・for 文の中に入れてください（下記の例を参照）
1393|・バッファが空の場合はエラーになるので if 文で分岐してください。
1394|【例】
1395| Any* p; ArrX_Sort arrx;
1396| if ( ! ArrX_Sort_isEmpty( &arrx ) ) {
1397| for ( ArrX_Sort_forEachPQ( &arrx, &p, Any ) ) {
1398| // for 内では、p を要素へのポインタとして使用可能
1399| }
1400| }
1401|*****************************************************************/
1402|#ifdef USES_OFFSET
1403|
1404|#define ArrX_Sort_forEachPQ( arrx, pp, type ) \
1405| *(pp) = ( ArrX_Sort_isEmpty( arrx ) ? NULL : (type*)ArrX_Sort_popPQ( arrx ) ); \
1406| *(pp) != NULL; \
1407| *(pp) = ( ArrX_Sort_isEmpty( arrx ) ? NULL : (type*)ArrX_Sort_popPQ( arrx ) )
1408|
1409|#endif
1410|
1411|
1412|/*-------------------------------------------------------------------------*/
1413|/* 31. <<<< ◆(ArrX_Dic) ハッシュテーブルを用いた辞書 >>>> */
1414|/*-------------------------------------------------------------------------*/
1415|
1416|
1417|/**************************************************************************
1418| 31-1. <<< [ArrX_Dic_search] 検索する >>>
1419|【引数】
1420| ・char* word; ワード
1421| ・type; 検索対象の型
1422| ・type* 返り値; 検索された領域のアドレス、または NULL
1423|【補足】
1424|・指定したワードが辞書に登録されていない場合、NULL を返します。
1425|***************************************************************************/
1426|#ifdef USES_OFFSET
1427|
1428|#define ArrX_Dic_search( this, word, type ) \
1429| ( (type*)ArrX_Dic_search_imp( this, word, sizeof(type) ) )
1430|
1431|#endif
1432|
1433|
1434|/**************************************************************************
1435| 31-2. <<< [ArrX_Dic_searchNext] 同じキーワードの次の領域を検索する >>>
1436|【引数】
1437| ・type* prev; 前回見つかった領域のアドレス
1438| ・type; 検索対象の型
1439| ・type* 返り値; 検索された領域のアドレス、または NULL
1440|【補足】
1441|・次の領域が辞書に登録されていない場合、NULL を返します。
1442|***************************************************************************/
1443|#ifdef USES_OFFSET
1444|
1445|#define ArrX_Dic_searchNext( this, prev, type ) \
1446| ( (type*)ArrX_Dic_searchNext_imp( this, prev, sizeof(type) ) )
1447|
1448|#endif
1449|
1450|
1451|/**************************************************************************
1452| 31-3. <<< [ArrX_Dic_alloc] 指定したワードの項目を確保する >>>
1453|【引数】
1454| ・char* word; ワード
1455| ・type; 検索対象の型
1456| ・type* 返り値; 確保した領域のアドレス、または NULL
1457|【補足】
1458|・指定したワードがすでに辞書に登録されている場合、NULL を返します。
1459|***************************************************************************/
1460|#ifdef USES_OFFSET
1461|
1462|#define ArrX_Dic_alloc( this, word, type ) \
1463| ( (type*)ArrX_Dic_alloc_imp( this, word, sizeof(type) ) )
1464|
1465|#endif
1466|
1467|/**************************************************************************
1468| 31-4. <<< [ArrX_Dic_allocDup] 指定したワードの項目を確保する（重複許可） >>>
1469|【引数】
1470| ・char* word; ワード
1471| ・type; 検索対象の型
1472| ・type* 返り値; 確保した領域のアドレス
1473|【補足】
1474|・指定したワードがすでに辞書に登録されている場合でも、確保した領域のアドレス
1475| を返します。
1476|***************************************************************************/
1477|#ifdef USES_OFFSET
1478|
1479|#define ArrX_Dic_allocDup( this, word, type ) \
1480| ( (type*)ArrX_Dic_allocDup_imp( this, word, sizeof(type) ) )
1481|
1482|#endif
1483|
1484|/**************************************************************************
1485| 31-5. <<< [ArrX_DicIter_init] 走査子を初期化する >>>
1486|【補足】
1487|・初期化しただけでは、辞書要素にアクセスできません。
1488| 一度 ArrX_DicIter_next してから ArrX_DicIter_ref します。
1489|・途中で、辞書要素の構成を変更したら、動作保証しません。
1490|【例】
1491| ArrX_DicIter i;
1492| STRUCT* data;
1493|
1494| ArrX_DicIter_init( &i, dic, STRUCT );
1495| while ( ArrX_DicIter_next( &i ) == 0 ) {
1496| data = ArrX_DicIter_ref( &i, STRUCT );
1497| // ここで data にアクセス
1498| }
1499|***************************************************************************/
1500|#define ArrX_DicIter_init( this, dic, type ) \
1501| ArrX_DicIter_init_imp( this, dic, sizeof(type) )
1502|
1503|/**************************************************************************
1504| 31-6. <<< [ArrX_DicIter_ref] 走査子からデータを参照する >>>
1505|***************************************************************************/
1506|#define ArrX_DicIter_ref( this, type ) \
1507| ((type*)((this)->curData))
1508|
1509|/**************************************************************************
1510| 31-7. <<< [ArrX_Dic_forEachDup] 重複要素集合を走査する >>>
1511| 31-8. <<< [ArrX_DicDupIter_forEach] 重複要素集合の個々の要素を走査する >>>
1512|【引数】
1513| ・ArrX_Dic* m; 辞書
1514| ・ArrX_DicDupIter* p; 重複要素の操作子（ (type*)p->first で参照可能）
1515| ・type; 辞書要素の型
1516|【補足】
1517|・次のように使います。
1518| ArrX_DicDupIter dup;
1519| for ( ArrX_Dic_forEachDup( &dic, &dup, ElemType ) ) {
1520| dup.first; // 重複している辞書要素のうち最初の辞書要素[*1]
1521| for ( ArrX_DicDupIter_forEach( &dup, ElemType ) ) {
1522| dup.p; // 辞書要素（１回目のループは dup->first と同じ）[*2]
1523| }
1524| }
1525|・辞書の中身が a, b-1, c-1, b-2, c-2, c-3,d（ただし、キーはa,b,c,d）
1526| のとき、( dup->first, dup->p ) は、
1527| *1 の地点では、( b-1, NULL ), ( c-1, NULL ) と変化し、
1528| *2 の地点では、( b-1, b-1 ), ( b-1, b-2 ), ( c-1, c-1 ), ( c-1, c-2 ),
1529| ( c-1, c-3 ) と変化します。
1530|***************************************************************************/
1531|#define ArrX_Dic_forEachDup( m, dup, type ) \
1532| (dup)->first = NULL; \
1533| ArrX_Dic_forEachDup_imp( m, dup, sizeof(type) );
1534|
1535|#define ArrX_DicDupIter_forEach( dup, type ) \
1536| ; \
1537| ArrX_DicDupIter_forEach_imp( dup, sizeof(type) );
1538|
1539|
1540|/*-------------------------------------------------------------------------*/
1541|/* 32. <<<< ◆(ArrX_Attr) 構造体配列のメンバ変数アクセス・ツール >>>> */
1542|/*-------------------------------------------------------------------------*/
1543|
1544|
1545|/***********************************************************************
1546| 32-1. <<< [ArrX_Attr_init_byArrX] ArrX 型配列から初期化する >>>
1547|【引数】
1548| ・ArrX_Attr* this; 構造体配列のメンバ変数アクセス・ツール
1549| ・ArrX* arrx; 配列
1550| ・attr; メンバ変数名
1551| ・arrx_type; 配列の型（attr を含む構造体の型）
1552| ・void* 返り値; 最初にアクセスするメンバ変数のアドレス
1553|************************************************************************/
1554|#define ArrX_Attr_init_byArrX( this, arrx, attr, arrx_type ) \
1555| ( (this)->over = (arrx)->last, \
1556| (this)->size = sizeof(arrx_type), \
1557| (void*)&((arrx_type*)(arrx)->first)->attr )
1558|
1559|
1560|
1561|/***********************************************************************
1562| 32-2. <<< [ArrX_Attr_isContinue] ループを続けるかどうかを返す >>>
1563|【引数】
1564| ・ArrX_Attr* this; 構造体配列のメンバ変数アクセス・ツール
1565| ・void* adr; 前回アクセスしたメンバ変数のアドレス
1566| ・bool 返り値; ループを続けるかどうか（adr が有効かどうか）
1567|【補足】
1568|・通常、while 文の中に入れます。
1569|************************************************************************/
1570|#define ArrX_Attr_isContinue( this, adr ) \
1571| ( (adr) < (this)->over )
1572|
1573|
1574|
1575|/***********************************************************************
1576| 32-3. <<< [ArrX_Attr_next] 次にアクセスするメンバ変数のアドレスを返す >>>
1577|【引数】
1578| ・ArrX_Attr* this; 構造体配列のメンバ変数アクセス・ツール
1579| ・void* adr; メンバ変数へのポインタ
1580| ・bool 返り値; 次にアクセスするメンバ変数のアドレス
1581|************************************************************************/
1582|#define ArrX_Attr_next( this, adr ) \
1583| ( (void*)( (char*)adr + (this)->size ) )
1584|
1585|
1586|
1587|
1588|#endif /* ARRX_H */
1589|
1590|