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