C:\home\SVGCats_src\src\strx.h
1|/**************************************************************************
2|* 1. <<< 文字列の拡張 (StrX) >>>
3|*【補足】
4|*・StrX では、文字列を格納する領域のサイズを指定するときは、
5|* 格納できる最大の文字列数＋１、つまりメモリサイズを指定します。
6|***************************************************************************/
7|
8|#ifndef __STRX_H
9|#define __STRX_H
10|
11|/*----------------------------------------------------------------------
12|[Module Property]
13|name = StrX
14|title = 文字列
15|category = 基本型
16|src = strx.c
17|depend = Types, Errors
18|priority =
19|accord =
20|----------------------------------------------------------------------*/
21|
22|
23|
24|
25|/**************************************************************************
26|* 2. <<< 優先ヘッダ >>>
27|***************************************************************************/
28|#ifndef USES_PRIORITY_HEADER
29|/*[START_OF_PRIORITY_HEADER]*/
30|
31|#ifndef USES_STRX
32|#define USES_STRX
33|
34|typedef struct _StrX_ListElem StrX_ListElem;
35|typedef struct _StrX_ListElem2 StrX_ListElem2;
36|typedef struct _StrX_Mem StrX_Mem;
37|typedef struct _StrX_Set StrX_Set;
38|typedef struct _StrX_MemV StrX_MemV;
39|typedef struct _StrX_MemV2 StrX_MemV2;
40|typedef struct _StrX_MemV2E StrX_MemV2E;
41|typedef struct _StrX_SetV StrX_SetV;
42|typedef struct _StrX_MemVE StrX_MemVE;
43|typedef struct _StrX_Pathes StrX_Pathes;
44|typedef void StrX_ConvFunc( void* obj, char* s, int s_size );
45|typedef char StrX_Path[260];
46|
47|typedef int (*StrX_HashFunc)( const char* s, int width );
48|
49|#endif
50|
51|/*[END_OF_PRIORITY_HEADER]*/
52|#endif /* USES_PRIORITY_HEADER */
53|
54|#define StrX_Err_MemEmpty 3180 /* StrX_Mem empty */
55|#define StrX_Err_MallocEmpty 3181
56|#define StrX_Err_NoMoreParentDir 3182
57|
58|/**************************************************************************
59|* 3. <<< モジュール設定 >>>
60|***************************************************************************/
61|#ifndef STDX_SETTING
62|
63| /*#define STRX_USES_MALLOC*/ /* malloc を使用する関数を有効にする */
64|
65|#endif
66|
67|
68|#if _MAX_PATH > 260 /* StrX_Path のサイズチェック */
69| #error
70|#endif
71|
72|#ifdef _STDLIB
73|#include "stdlib.h"
74|#endif
75|
76|
77|/*------------------------------------------------------------------------*/
78|/* 4. <<< Interface Area ----------------------------------------------- >>> */
79|/*------------------------------------------------------------------------*/
80|
81|#ifdef __cplusplus
82|extern "C" {
83|#endif
84|
85|
86|
87|/***********************************************************
88|* 5. <<< 文字★ >>>
89|*【一覧】
90|*・制御文字 [StrX_SI, StrX_SO, StrX_ESC]
91|*・ディレクトリ区切り文字 [StrX_DirMark_char, StrX_DirMark_str]
92|*・漢字コードの種類
93|* [StrX_CodeT, StrX_Ascii, StrX_Jis, StrX_ShiftJis, StrX_Euc]
94|* [StrX_JisIn, StrX_JisOut]
95|*
96|* 6. <<< [改行文字] >>>
97|*・Windows の改行は、0x0D '\r' + 0x0A '\n'
98|*・UNIX の改行は、0x0A '\n' のみ
99|************************************************************/
100|/*bool StrX_isMBBLeadNotTerm( char s ) */
101|
102|
103|/***********************************************************
104|* 7. <<< 制御文字 [StrX_SI, StrX_SO, StrX_ESC] >>>
105|************************************************************/
106|#define StrX_SI 14
107|#define StrX_SO 15
108|#define StrX_ESC 0x1B
109|
110|
111|
112|/**************************************************************************
113|* 8. <<< ディレクトリ区切り文字 [StrX_DirMark_char, StrX_DirMark_str] >>>
114|***************************************************************************/
115|#define StrX_DirMark_char '\\'
116|#define StrX_DirMark_str "\\"
117|
118|
119|
120|/***********************************************************************
121|* 9. <<< [StrX_CodeT] 漢字コードの種類 >>>
122|* 10. <<< [StrX_Ascii, StrX_Jis, StrX_ShiftJis, StrX_Euc] >>>
123|* 11. <<< [StrX_JisIn, StrX_JisOut] >>>
124|************************************************************************/
125|typedef enum _StrX_CodeT {
126| StrX_Ascii =0, StrX_Jis, StrX_ShiftJis, StrX_Euc,
127| StrX_JisIn, StrX_JisOut
128|} StrX_CodeT;
129|
130|
131|
132|/***********************************************************
133|* 12. <<< [StrX] char* 型の文字列 ★>>>
134|************************************************************/
135|extern const char* StrX_argv0; /* main() で argv[0] 引数をポイントすること */
136|
137|
138|/***********************************************************
139|* 13. <<< (StrX) char* 型の文字列（コピー・一部コピー・連結） >>>
140|************************************************************/
141|int StrX_getNLine( const char* s );
142|char* StrX_cpy( char* dst, const char* src, int dst_size );
143|char* StrX_ncpy( char* dst, char* src, int n, int dst_maxLen );
144|char* StrX_cpy1Line( char* dst, int dst_size, const char* src, int iLine );
145|void StrX_wordCpy( char* dec, int dec_len, const char* src, char term );
146|char* StrX_toCSV( char* dst, const char* src, int dst_maxLen );
147|char* StrX_meltCSV( char* t, const char* s );
148|char* StrX_cpyToCSymbol( char* dst, const char* src );
149|char* StrX_getCmdWord( char* t, const char* s );
150|char* StrX_cat( char* rcv, const char* add, int rcv_maxLen );
151|char* StrX_catR( const char* s1, char* s2, int s2_maxLen );
152|char* StrX_cpyWild( char* dst, const char* dst_wild, const char* src,
153| const char* src_wild );
154|char* StrX_ins( char* dst, const char* src );
155|char* StrX_setLast( char* s, char c );
156|
157|
158|/***********************************************************
159|* 14. <<< (StrX) char* 型の文字列（削除） >>>
160|************************************************************/
161|char* StrX_bs( char* );
162|char* StrX_bs2( char*, int n );
163|void StrX_del( char* s, int n );
164|char* StrX_trim( char* s );
165|char* StrX_trim2( char* s );
166|void StrX_cutHtmlTag( char* );
167|char* StrX_cutRet( char* s );
168|char* StrX_cutLastOf( char* s, char c );
169|char* StrX_cutLastOf2( char* s, char c );
170|char* StrX_cutLastOf_2byteFirst( char* s );
171|
172|
173|/***********************************************************
174|* 15. <<< (StrX) char* 型の文字列（検索・参照） >>>
175|************************************************************/
176|char StrX_getLast( const char* s );
177|char* StrX_strchrs( const char* s, const char* key );
178|char* StrX_strchr2( const char* s, int k );
179|char* StrX_strchrs2( const char* s, const char* key );
180|char* StrX_strchrs_not( const char* s, const char* key );
181|char* StrX_RSearchC( const char* s, char key );
182|char* StrX_RSearchC2( const char* s, int key );
183|char* StrX_RSearch( char* s, char* key );
184|char* StrX_stristr( const char* s, const char* key );
185|char* StrX_stristr3( const char* s, const char* key, bool bCase,
186| int* hitCount );
187|char* StrX_stristr3r( const char* s, int startOffset,
188| const char* key, bool bCase, int* hitCount );
189|char* StrX_searchWord( const char* s, const char* k );
190|char* StrX_getWordTop( char* s, char* p, char term );
191|char* StrX_getCmdParam( const char* cmdline, char* param, int param_size );
192|char* StrX_getCSV( const char* s, int iColumn, char* out, int out_size );
193|int StrX_findInCSV( const char* s, const char* key, bool bCase );
194|int StrX_getCSVColumn( const char* s, const char* pos );
195|int StrX_getCSVNColumn( const char* s, bool bCountSpace );
196|char* StrX_refTopOfLine( const char* s, int iLine );
197|int StrX_getILine( const char* s, const char* p );
198|char* StrX_getCIdent( const char* src, char* ident, int ident_sizeof );
199|char* StrX_getCIdent2( const char* src, char* ident, int ident_sizeof );
200|char* StrX_getToken( const char* src, char* token, int token_sizeof );
201|bool StrX_isTokenFirst( const char* s );
202|bool StrX_getCSSValueOfInt( const char* css, const char* attr_name,
203| int* pValue );
204|bool StrX_getCSSValueOfDouble( const char* css, const char* attr_name,
205| double* pValue );
206|bool StrX_getCSSValueOfStr( const char* css, const char* attr_name,
207| char* str, int str_size );
208|#ifdef USES_COLOR
209|bool StrX_getCSSValueOfColor( const char* css, const char* attr_name,
210| Color_WinRGB* pColor );
211|#endif
212|int StrX_getNumOfKWord( const char* s, const char* kword, bool bCase );
213|int StrX_getSVGPoints( const char* points, int* xs, int* ys, int n );
214|char* StrX_getIdiom2( const char* src, int mWord, int* nWord,
215| char* idiom, int idiom_size );
216|char** StrX_searchInArr( const char* s, char** arr, int arr_n );
217|char** StrX_searchInArr2( const char* s, const char** arr, int arr_size );
218|/*char** StrX_searchInArrX( const char* s, ArrX* arrx, type );*/
219|
220|
221|/***********************************************************
222|* 16. <<< (StrX) char* 型の文字列（置換・文字コード変換） >>>
223|************************************************************/
224|char* StrX_rep1( char* s, char f, char t );
225|char* StrX_rep1b( char* s, char f, char t );
226|char* StrX_rep( char* s, int s_sizeof, const char* f, const char* t );
227|char* StrX_repi( char* s, int s_sizeof, const char* f, int t );
228|char* StrX_repEx( char* s, int s_sizeof, const char* f, const char* t,
229| StrX_ConvFunc term_conv_func, void* obj, char* work, int work_size );
230|char* StrX_repSharp( char* s, int s_sizeof, int n );
231|
232|#if !defined(_ismbblead) && !defined(_MBLEADTRAIL_DEFINED)
233|int _ismbblead( unsigned int c );
234|#define _MBLEADTRAIL_DEFINED
235|#endif
236|unsigned short StrX_mbc2sjis( char* str );
237|unsigned short StrX_sjis2jis( unsigned short code );
238|int StrX_getCodeT( const unsigned char* s );
239|char* StrX_toSJIS( char* out, const char* in );
240|int StrX_jis2sjis( unsigned char* out, const unsigned char* in,
241| bool* bSISO, bool* bKanji );
242|int StrX_euc2sjis( unsigned char* out, const unsigned char* in,
243| bool* bSISO );
244|int StrX_getJisIOType( const char* s );
245|void StrX_sjis2unicode( unsigned short* unicodeStr, const char* shiftJisStr,
246| int unicodeStr_size );
247|void StrX_unicode2sjis( unsigned char* shiftJisStr, const unsigned short* unicodeStr,
248| int shiftJisStr_size );
249|int StrX_convIdxEdit2SJis( const char* sjis_str, int uniIdx, unsigned short* work,
250| int work_size );
251|int StrX_convSJis2IdxEdit( const char* sjis_str, int sjisIdx );
252|int StrX_getHash( const char* s, int width );
253|int StrX_getHashI( const char* s, int width );
254|char* StrX_toHtmlTxt( const char* src, char* dst, int dst_size );
255|char* StrX_resumeFromHtmlTxt( const char* src, char* dst, int dst_size );
256|void StrX_cpyLower( char* dst, const char* src );
257|void StrX_cpyUpper( char* dst, const char* src );
258|void StrX_getTableXY( const char* xy, int* x, int* y );
259|void StrX_separateByByteInLine( char* s, int s_size, int mByteInLine,
260| const char* retStr );
261|
262|void StrX_encodeBase64( char* base64, void* bin, int bin_size, const char* retCh );
263|int StrX_decodeBase64( const char* base64, void* bin );
264|int StrX_getEncodedSizeOfBase64( int bin_size, const char* retCh );
265|int StrX_getDecodedSizeOfBase64( int base64_strlen );
266|
267|#define StrX_unitOfBase64 57
268|
269|
270|
271|
272|/***********************************************************
273|* 17. <<< (StrX) char* 型の文字列（判断・正規化） >>>
274|************************************************************/
275|int StrX_isSJis1byte( const char* char_top, const char* pChar );
276|int StrX_isSJis2byte( const char* char_top, const char* pChar );
277|int StrX_isExist2byte( const char* s );
278|bool StrX_isSpace( int c );
279|bool StrX_isSpcTabRet( int c );
280|bool StrX_isAlpha( int c );
281|bool StrX_isDigit( int c );
282|int StrX_isSpaceStr( const char* c );
283|int StrX_isTerm( char c );
284|bool StrX_isFName( const char* name );
285|int StrX_cmpHead( const char* str, const char* head );
286|int StrX_cmpWild( const char* wild, const char* str );
287|int StrX_cmpWildI( const char* wild, const char* str );
288|bool StrX_isMatchMask( const char* target, const char* wildcard );
289|
290|
291|/***********************************************************
292|* 18. <<< (StrX) char* 型の文字列（ファイル名、ファイルパス） >>>
293|************************************************************/
294|#if ( defined(_MSC_VER) || defined(__BORLANDC__) ) && !defined(FOR_WINCE)
295|char* StrX_getRunFullPath( char* absPath, const char* stepPath,
296| int absPath_len );
297|#endif
298|
299|char* StrX_getExeFullPath( char* absPath, char* stepPath,
300| int absPath_len );
301|bool StrX_isAbsPath( const char* path );
302|bool StrX_isUrl( const char* url );
303|char* StrX_chgPathToUrl( char* url, const char* path );
304|char* StrX_toRegularPath( char* s );
305|char* StrX_toAbsPath( char* path, int path_maxlen, const char* base );
306|char* StrX_toAbsPath2( char* path, int path_maxlen, const char* base );
307|char* StrX_cpyAbsPath( char* absp, const char* stepp, int absp_maxlen, const char* base );
308|char* StrX_cpyAbsPath2( char* absp, const char* stepp, int absp_maxlen, const char* base );
309|char* StrX_cpyAbsPath2CSV( char* absp, const char* stepp, int absp_size,
310| const char* base );
311|char* StrX_toStepPath( char* path, int path_maxlen, const char* base );
312|char* StrX_toStepPath2( char* path, int path_maxlen, const char* file );
313|char* StrX_cpyStepPath( char* stepp, const char* absp, int stepp_maxlen, const char* base );
314|char* StrX_cpyStepPath2( char* stepp, const char* absp, int stepp_maxlen, const char* base );
315|char* StrX_cpyStepPath2CSV( char* stepp, const char* absp, int stepp_size,
316| const char* base );
317|
318|char* StrX_toStepURL( char* url, int url_maxlen, const char* base );
319|
320|void StrX_movePath( const char* src,
321| const char* from_folder, const char* to_folder,
322| char* dst, int dst_size );
323|char* StrX_toLongPath( char* longPath, const char* shortPath );
324|#ifdef USES_FILEX
325| void StrX_getSpacedPath( const char* str, char* path, char** param );
326|#endif
327|char* StrX_refFName( const char* path );
328|char* StrX_cpyFName( char* fname, const char* path );
329|char* StrX_cpyFolder( char* fname, const char* path );
330|char* StrX_cutFName( char* path );
331|char* StrX_addFName( char* path, const char* fname );
332|char* StrX_insLastOfFName( char* path, char* ins );
333|char* StrX_cdFName( char* path, const char* cd );
334|char* StrX_refExt( const char* path );
335|char* StrX_chgExt( char* path, const char* ext );
336|char* StrX_setExt( char* path, const char* ext );
337|char* StrX_addNumInFName( char* path, const char* src_path, int num );
338|int StrX_cmpNoExt( const char* path1, const char* path2 );
339|
340|char* StrX_cpyWithoutURLSubName( char* path, const char* url );
341|char* StrX_refURLSubName( const char* url );
342|
343|
344|/***********************************************************
345|* 19. <<< (StrX) char* 型の文字列（変換・ｎ進数） >>>
346|************************************************************/
347|void StrX_initByInt16s( char* str, unsigned int n );
348|void StrX_initByInt16s_2( char* str, unsigned int n );
349|void StrX_initByInt( char* str, int str_len, int n );
350|char* StrX_scanInt( const char* str, int* n );
351|void StrX_initByLong16s( char* str, unsigned long n );
352|char* StrX_get2s_fromLong( char* s, unsigned long n, char term );
353|long StrX_getLong_from2s( char* s );
354|
355|#ifdef USES_COLOR
356|Color_WinRGB StrX_getColorValue( const char* color_str );
357|void StrX_getColorStr( char* color_str, Color_WinRGB value );
358|#endif
359|
360|void StrX_getFontValue( const char* font_str, char* face, int* size,
361| bool* bBold, bool* bItalic );
362|void StrX_getFontStr( char* font_str, const char* face, int size,
363| bool bBold, bool bItalic );
364|
365|
366|/***********************************************************
367|* 20. <<< [StrX_ListElem] リストの要素になる文字列 >>>
368|* 21. <<< [StrX_ListElem2] リストの要素になる文字列（補助番号付き） >>>
369|*【補足】
370|*・文字列 str をヒープにとっている場合、StrX_ListElem_finish2
371|* を呼び出す必要があります。
372|************************************************************/
373|#ifdef USES_LISTX
374|
375|struct _StrX_ListElem {
376| ListX_Elem inherit_ListX_Elem;
377| char* p;
378|};
379|void StrX_ListElem_finish2( StrX_ListElem* );
380|
381|struct _StrX_ListElem2 {
382| ListX_Elem inherit_ListX_Elem;
383| char* p;
384| void* data;
385|};
386|void StrX_ListElem2_finish2( StrX_ListElem2* );
387|
388|#ifdef USES_SYM
389|extern Sym_Struct* StrX_ListElem_registSymStruct( Sym* );
390|extern Sym_Struct StrX_ListElem_symStruct;
391|#endif
392|
393|#endif
394|
395|/**************************************************************************
396|* 22. <<< [StrX_Mem] 文字列の記憶領域 >>>
397|*【役割】
398|*・大量の文字列定数を扱う場合、最も効率よく詰めて格納するようにメモリを
399|* 割り振ります。
400|*・格納した文字列の長さを後で変えることはできません。
401|**************************************************************************/
402|struct _StrX_Mem {
403| char* buf; /* 記憶領域の先頭アドレス */
404| char* buf_over; /* 記憶領域の最終アドレスの次 */
405| char* pBuf; /* 認識している空き領域の先頭アドレス */
406| bool checked; /* pBuf が適当な位置にあるかチェックしたかどうか */
407|};
408|void StrX_Mem_init( StrX_Mem*, char* buf, size_t buf_sizeof );
409|void* StrX_Mem_getTopAdr( StrX_Mem* );
410|void StrX_Mem_toEmpty( StrX_Mem* );
411|char* StrX_Mem_alloc( StrX_Mem* );
412|char* StrX_Mem_alloc2( StrX_Mem*, const char* str );
413|char* StrX_Mem_alloc3( StrX_Mem*, const char* str );
414|char* StrX_Mem_copyAlloc( StrX_Mem*, const char* str );
415|void StrX_Mem_free( StrX_Mem*, const char* adr );
416|size_t StrX_Mem_getLeftSize( StrX_Mem* );
417|char* StrX_Mem_getFirst( StrX_Mem* );
418|char* StrX_Mem_getNext( StrX_Mem*, char* cur );
419|/* StrX_Mem_forEach( StrX_Mem*, char** ); */
420|
421|#ifndef ERRORS_CUT_DEBUG_TOOL
422|void StrX_Mem_print( StrX_Mem*, const char* title );
423|void StrX_Mem_printAll( StrX_Mem* );
424|#endif
425|
426|
427|
428|
429|/**************************************************************************
430|* 23. <<< [StrX_Set] 文字列の記憶領域の部分集合 >>>
431|*【役割】
432|*・StrX_Mem に格納した文字列の部分集合です。
433|*・１つの StrX_Mem 領域に対して、複数の集合を表現できます。
434|*・参照した文字列の長さを変えることはできません。
435|**************************************************************************/
436|#ifdef USES_STDLIBS
437|
438|struct _StrX_Set {
439| char* first; /* 最初の文字列の先頭アドレス */
440| char* last; /* 最後の次の文字列の先頭アドレス */
441|};
442|void StrX_Set_init1( StrX_Set*, StrX_Mem* );
443|void StrX_Set_init2( StrX_Set*, StrX_Mem* );
444|void StrX_Set_initEmpty( StrX_Set* );
445|/* StrX_Set_forEach( StrX_Set*, char** ); */
446|int StrX_Set_searchWild( StrX_Set*, const char* wildkey );
447|int StrX_Set_searchWild2( StrX_Set* wilds, const char* key );
448|
449|#ifndef ERRORS_CUT_DEBUG_TOOL
450|void StrX_Set_printAll( StrX_Set* );
451|#endif
452|
453|#endif /* USES_STDLIBS */
454|
455|
456|/**************************************************************************
457|* 24. <<< [StrX_MemV] 文字列の記憶領域（malloc 使用） >>>
458|*【補足】
459|*・malloc を使用するので、ヒープメモリ領域が許す限り無限に領域を確保する
460|* ことができます。
461|*・格納した文字列の長さを後で変えることはできません。
462|*・StrX_MemV_alloc で確保した領域は、char* 型か StrX_SetV 型で管理します。
463|**************************************************************************/
464|#ifdef STRX_USES_MALLOC
465|#ifdef USES_LISTX
466|
467|#define StrX_MemV_unitSize 2048 /* 増加する単位（バイト） */
468|#define StrX_MemV_maxLen 256 /* 一度に確保できる文字列領域(\0含む)サイズ */
469|
470|void StrX_MemV_init( StrX_MemV* );
471|void StrX_MemV_finish( StrX_MemV* );
472|void StrX_MemV_setMax( StrX_MemV*, int x );
473|char* StrX_MemV_alloc( StrX_MemV* );
474|
475|
476|struct _StrX_MemV {
477| ListX mems; /* StrX_MemVE 型リスト */
478| StrX_MemVE* mem_last;
479| int maxLen; /* →StrX_MemV_maxLen */
480|};
481|
482|struct _StrX_MemVE { /* リスト要素：StrX_Mem のリスト */
483| StrX_Mem mem;
484| ListX_Elem ListX_Elem_extend;
485|};
486|
487|#endif
488|#endif
489|
490|
491|/***********************************************************************
492|* 25. <<< [StrX_MemV2] 文字列の記憶領域（malloc & ハッシュ 使用） >>>
493|*【補足】
494|*・同じ内容の文字列は同じ領域を使うように検索を行う文字列領域管理です。
495|************************************************************************/
496|#if defined(USES_INF) && defined(USES_ARRX) && defined(USES_LISTX) && defined(USES_STDPLUS)
497|struct _StrX_MemV2 {
498| ListX_Dic dic;
499| Offset_Key key;
500| ListX symbols; /* StrX_MemV2E 型、→StrX_MemV2_setSymbol() */
501| ERRORS_INITCHK_VAR
502|};
503|
504|void StrX_MemV2_init( StrX_MemV2*, int width, StrX_HashFunc hash,
505| bool bCase );
506|void StrX_MemV2_finish( StrX_MemV2* );
507|void StrX_MemV2_toEmpty( StrX_MemV2* );
508|void StrX_MemV2_setSymbol( StrX_MemV2*, const char* setStr );
509|char* StrX_MemV2_alloc( StrX_MemV2*, const char* str );
510|int StrX_MemV2_getN( StrX_MemV2* );
511|void StrX_MemV2_print( StrX_MemV2*, const char* title );
512|
513|
514|/* 以下は内部用です */
515|struct _StrX_MemV2E {
516| ListX_Elem inherit_ListX_Elem;
517| char* p;
518|};
519|
520|void StrX_MemV2E_init( StrX_MemV2E*, const char* str );
521|void StrX_MemV2E_finish( StrX_MemV2E* );
522|
523|#endif
524|
525|/**************************************************************************
526|* 26. <<< [StrX_SetV] 文字列の記憶領域の部分集合（StrX_MemV用） >>>
527|*【役割】
528|*・StrX_MemV に格納した文字列の部分集合です。
529|*・１つの StrX_Mem 領域に対して、複数の集合を表現できます。
530|*・参照した文字列の長さを変えることはできません。
531|**************************************************************************/
532|#ifdef STRX_USES_MALLOC
533|#ifdef USES_LISTX
534|
535|struct _StrX_SetV {
536| char* first; /* 最初の文字列の先頭アドレス */
537| char* last; /* 最後の次の文字列の先頭アドレス */
538| StrX_MemVE* firstVE; /* first の StrX_MemVE 型リストの参照 */
539| StrX_MemVE* pVE; /* StrX_SetV_forEach 用ポインタ */
540|};
541|void StrX_SetV_init1( StrX_Set*, StrX_MemV* );
542|void StrX_SetV_init2( StrX_Set*, StrX_MemV* );
543|/* StrX_SetV_forEach( StrX_Set*, char** ); */
544|
545|#endif
546|#endif
547|
548|
549|/***********************************************************************
550|* 27. <<< [StrX_Pathes] 右クリック『送る』のファイルパス >>>
551|*【補足】
552|*・スペースによる区切りの短いファイル名をそれぞれ長いファイル名で参照します。
553|*・.exe ファイルにドラッグ＆ドロップしたときも同じ AfxGetApp()->m_lpCmdLine
554|* からファイルパスを取得できます。
555|************************************************************************/
556|#ifdef USES_STDLIBS
557|struct _StrX_Pathes {
558| char* pathes; /* 先頭のファイルパス（短いファイル名の列挙） */
559| char* curPath; /* 現在のファイルパス（pathes の中へのアドレス） */
560| char longPath[_MAX_PATH]; /* 現在のファイルパス（長いファイル名） */
561|};
562|
563|void StrX_Pathes_init( StrX_Pathes*, const char* );
564|void StrX_Pathes_reset( StrX_Pathes* );
565|char* StrX_Pathes_getCurPath( StrX_Pathes* );
566|bool StrX_Pathes_next( StrX_Pathes* );
567|int StrX_Pathes_getN( StrX_Pathes* );
568|#endif
569|
570|/***********************************************************************
571|* 28. <<< [StrX_ConvFunc] 文字列を変換するコールバック関数の型 >>>
572|*【引数】
573|* ・void* obj; オブジェクト（任意アドレス）
574|* ・char* s; 変換する文字列のアドレス
575|* ・int s_size; s のメモリサイズ
576|*【補足】
577|*・定義は優先ヘッダにあります
578|*************************************************************************/
579|
580|/**************************************************************************
581| 29. <<< [STRX_DECLARE_ID_CONV_FUNC_START] 番号と文字列の変換関数の定義をする >>>
582| 30. <<< [STRX_DECLARE_ID_CONV_FUNC_END]（同） >>>
583|【補足】
584|・IDS 型の enum を定義したとき、ヘッダファイルには、次のように記述します。
585| typedef enum { IDS_A, IDS_B, IDS_C, IDS_over } IDS;
586| char* IDS_getStr( IDS );
587| IDS IDS_getID( const char* str );
588|
589|・〜_over は、「非」正規の番号（番兵）です。名前は _over にする必要はありませんが、
590| 必ず定義してください。
591|
592|・ソースファイル(.c)には、次のように記述します。
593| //-------------------------------------------------------------
594| // [IDS_getStr, IDS_getID] IDS 型の番号と文字列を変換する
595| //【補足】
596| //・STRX_... マクロは、IDS_getStr, IDS_getID 関数を実装しています。
597| //-------------------------------------------------------------
598| STRX_DECLARE_ID_CONV_FUNC_START( IDS )
599| "String-A", "String-B", "String-C"
600| STRX_DECLARE_ID_CONV_FUNC_END( IDS, IDS_over, "NotFound" )
601|
602|・〜END の第２第３引数は、番兵の番号（兼 IDS_getID で見つからなかったときの番号）と、
603| IDS_getStr で見つからなかったときの文字列です。
604|***************************************************************************/
605|#define STRX_DECLARE_ID_CONV_FUNC_START( ID ) \
606| char* ID##_getStr( ID self ) \
607| { \
608| static char* s[] = {
609|
610|
611|#define STRX_DECLARE_ID_CONV_FUNC_END( ID, overID, overString ) \
612| }; \
613| if ( self < 0 || self >= overID ) return overString; \
614| else return s[self]; \
615| } \
616| \
617| ID ID##_getID( const char* str ) \
618| { \
619| int i; \
620| \
621| for ( i = 0; i < ID##_over; i++ ) { \
622| if ( strcmp( ID##_getStr( i ), str ) == 0 ) \
623| return i; \
624| } \
625| return overID; \
626| }
627|
628|
629|/*------------------------------------------------------------------------*/
630|/* 31. <<< Mapping Area ------------------------------------------------- >>> */
631|/*------------------------------------------------------------------------*/
632|
633|
634|/*-------------------------------------------------------------------------*/
635|/* ◆32. <<<< (StrX) char* 型の文字列 >>>> */
636|/*-------------------------------------------------------------------------*/
637|
638|/**************************************************************************
639| 32-1. <<< [_ismbblead] 1byte 文字コード c が、2 byte 文字コードの1 byte 目か判断する >>>
640| Microsoft #include <mbctype.h> と互換
641|***************************************************************************/
642|#ifndef _ismbblead
643|#ifndef _MSC_VER
644|#define _ismbblead( c ) \
645| ( ( (unsigned char)(c) >= 0x81 && (unsigned char)(c) <= 0x9F ) || \
646| ( (unsigned char)(c) >= 0xE0 && (unsigned char)(c) <= 0xFC ) )
647|#endif
648|#endif
649|
650|
651|/***********************************************************
652| 32-2. <<< [StrX_isMBBLeadNotTerm] 区切り文字以外の全角文字か判断する >>>
653|************************************************************/
654|#define StrX_isMBBLeadNotTerm( c ) \
655| (_ismbblead(c) && ((char)(c)) != (char)0x81)
656|
657|
658|
659|/**************************************************************************
660| 32-3. <<< [StrX_mbc2jsis] マルチバイト文字から Shift JIS コードを得る >>>
661| ・str : マルチバイト文字へのポインタ
662| ・返り値 : Shift JIS コードの値
663|***************************************************************************/
664|#define StrX_mbc2sjis( str ) \
665| ( *((unsigned char*)(str)+1) | (*(unsigned char*)(str)<<8) )
666|
667|
668|
669|/**************************************************************************
670| 32-4. <<< [StrX_isTokenFirst] 指定文字列の先頭がトークンの先頭かどうかを返す >>>
671|【引数】
672| ・char* s; トークンの先頭かどうかを調べる文字列
673| ・bool 返り値; 判定結果
674|【補足】
675|・トークンについては、StrX_getToken を参照。
676|**************************************************************************/
677|#define StrX_isTokenFirst( s ) \
678| ( (unsigned char)*(s) > ' ' )
679|
680|/**************************************************************************
681| 32-5. <<< [StrX_searchInArrX] 文字列配列の中から検索する >>>
682|【引数】
683| ・ArrX* arrx; 文字列配列（char* 型の配列）
684| ・char** 返り値; 見つかった文字列へのアドレス（arr 配列内）, NULL=ない
685|***************************************************************************/
686|#define StrX_searchInArrX( s, arrx ) \
687| StrX_searchInArr( s, (char**)(arrx)->first, ArrX_getN( arrx, char* ) )
688|
689|
690|/**************************************************************************
691| 32-6. <<< [StrX_cmpHead] 頭文字列を比較する >>>
692|【機能】
693|・str のうち、先頭の n バイトが head と同じか比較する。
694| ただし、n は head のバイト数とする。
695|【引数】
696| ・char* str; 比較対象の文字列
697| ・char* head; 頭文字列
698| ・int 返り値; 標準関数の strncmp と同じ
699|***************************************************************************/
700|#define StrX_cmpHead( str, head ) \
701| strncmp( str, head, strlen(head) )
702|
703|
704|/**************************************************************************
705| 32-7. <<< [StrX_cpyAbsPath] StrX_toAbsPath のコピー版 >>>
706|***************************************************************************/
707|#define StrX_cpyAbsPath( absp, stepp, absp_maxlen, base ) \
708| ( strcpy( absp, stepp ), StrX_toAbsPath( absp, absp_maxlen, base ) )
709|
710|
711|/**************************************************************************
712| 32-8. <<< [StrX_cpyAbsPath2] StrX_toAbsPath2 のコピー版 >>>
713|***************************************************************************/
714|#define StrX_cpyAbsPath2( absp, stepp, absp_maxlen, base ) \
715| ( strcpy( absp, stepp ), StrX_toAbsPath2( absp, absp_maxlen, base ) )
716|
717|
718|/**************************************************************************
719| 32-9. <<< [StrX_cpyStepPath] StrX_toStepPath のコピー版 >>>
720|***************************************************************************/
721|#define StrX_cpyStepPath( stepp, absp, stepp_maxlen, base ) \
722| ( strcpy( stepp, absp ), StrX_toStepPath( stepp, stepp_maxlen, base ) )
723|
724|
725|/**************************************************************************
726| 32-10. <<< [StrX_cpyStepPath2] StrX_toStepPath2 のコピー版 >>>
727|***************************************************************************/
728|#define StrX_cpyStepPath2( stepp, absp, stepp_maxlen, base ) \
729| ( strcpy( stepp, absp ), StrX_toStepPath2( stepp, stepp_maxlen, base ) )
730|
731|
732|/*-------------------------------------------------------------------------*/
733|/* ◆33. <<<< (StrX_ListElem2) リストの要素になる文字列（補助番号付き） >>>> */
734|/*-------------------------------------------------------------------------*/
735|
736|/***********************************************************************
737| 33-1. <<< [StrX_ListElem2_finish2] リスト要素の文字列を後始末する >>>
738|************************************************************************/
739|#define StrX_ListElem2_finish2( this ) \
740| StrX_ListElem_finish2( (StrX_ListElem*)(this) )
741|
742|/*-------------------------------------------------------------------------*/
743|/* ◆34. <<<< (StrX_Mem) 文字列の記憶領域 >>>> */
744|/*-------------------------------------------------------------------------*/
745|
746|
747|/**************************************************************************
748| 34-1. <<< [StrX_Mem_getTopAdr] メモリ領域の先頭アドレスを取得する >>>
749|【引数】
750| ・StrX_Mem* this; 文字列の記憶領域
751| ・void* 返り値; メモリ領域の先頭アドレス
752|【補足】
753|・buf に malloc したアドレスを指定した場合、本関数で取得したアドレスを
754| free することを忘れないでください。
755|**************************************************************************/
756|#define StrX_Mem_getTopAdr( this ) \
757| ((void*)(this)->buf)
758|
759|
760|
761|/**************************************************************************
762| 34-2. <<< [StrX_Mem_getFirst] 最初の文字列を返す >>>
763|【引数】
764| ・StrX_Mem* this; 文字列の記憶領域
765| ・char** 返り値; 最初の文字列
766|**************************************************************************/
767|#define StrX_Mem_getFirst( this ) \
768| ( (this)->buf + 1 )
769|
770|/**************************************************************************
771| 34-3. <<< [StrX_Mem_forEach] 先頭から文字列を列挙しながらループする >>>
772|【引数】
773| ・char** pp; 要素文字列(char*ポインタ)を格納するアドレス
774| ・StrX_Mem* this; 文字列の記憶領域
775|【補足】
776|・for 文の中で使用します。
777| for ( StrX_Mem_forEach( &mem, &p ) );
778|***************************************************************************/
779|#if 0
780|
781|#define StrX_Mem_forEach( this, pp ) \
782| *(pp) = StrX_Mem_getNext( this, NULL ); \
783| *(pp) != NULL; *(pp) = StrX_Mem_getNext( this, *(pp) )
784|
785|#else
786|
787|#define StrX_Mem_forEach( this, pp ) \
788| *(pp) = ( (this)->pBuf == (this)->buf ? NULL : (this)->buf + 1 ); \
789| *(pp) != NULL; \
790| *(pp) = ( *(pp) >= (this)->pBuf ? NULL : strchr( *(pp), '\0' ) + 1 )
791|
792|#endif
793|
794|/*-------------------------------------------------------------------------*/
795|/* ◆35. <<<< (StrX_Set) 文字列の記憶領域の部分集合 >>>> */
796|/*-------------------------------------------------------------------------*/
797|
798|
799|/**************************************************************************
800| 35-1. <<< [StrX_Set_init1] 集合を定義する(step-1) >>>
801| 35-2. <<< [StrX_Set_init2] 集合を定義する(step-2) >>>
802|【補足】
803|・StrX_Set_init1 から StrX_Set_init2 の間に
804| mem に StrX_Mem_alloc した文字列の集合に初期化します。
805|・StrX_Set_init2 を呼び出す前に、集合の最後の要素に相当する
806| 文字列を格納しておいてください。
807|***************************************************************************/
808|#ifdef USES_STDLIBS
809|
810|#define StrX_Set_init1( this, mem ) \
811| ( (this)->first = strchr( (mem)->pBuf, '\0' ) + 1 )
812|
813|#define StrX_Set_init2( this, mem ) \
814| ( (this)->last = strchr( (mem)->pBuf, '\0' ) + 1 )
815|
816|#endif /* USES_STDLIBS */
817|
818|
819|/**************************************************************************
820| 35-3. <<< [StrX_Set_initEmpty] 空の集合に初期化する >>>
821|***************************************************************************/
822|#ifdef USES_STDLIBS
823|
824|#define StrX_Set_initEmpty( this ) \
825| ( (this)->first = NULL, (this)->last = NULL )
826|
827|#endif
828|
829|/**************************************************************************
830| 35-4. <<< [StrX_Set_forEach] 集合に含まれる文字列を列挙しながらループする >>>
831|【引数】
832| ・char** pp; 要素文字列(char*ポインタ)を格納するアドレス
833| ・StrX_Set* set; 文字列の記憶領域
834|【補足】
835|・for 文の中で使用します。
836| for ( StrX_Set_forEach( &set, &p ) );
837|***************************************************************************/
838|#ifdef USES_STDLIBS
839|
840|#define StrX_Set_forEach( set, pp ) \
841| *(pp) = (set)->first; \
842| *(pp) < (set)->last; \
843| *(pp) = strchr( *(pp), '\0' ) + 1
844|
845|#endif
846|
847|/*-------------------------------------------------------------------------*/
848|/* ◆36. <<<< (StrX_MemV) 文字列の記憶領域（malloc 使用） >>>> */
849|/*-------------------------------------------------------------------------*/
850|
851|
852|/***********************************************************************
853| 36-1. <<< [StrX_MemV_setMax] 一度に確保できる文字列領域のサイズを設定する >>>
854|【補足】
855|・StrX_MemV_alloc 関数で得られたアドレスから文字列を格納することが
856| できると保証する長さ（'\0'文字含む）を設定します。
857|************************************************************************/
858|#ifdef USES_LISTX
859|
860|#define StrX_MemV_setMax( this, x ) \
861| (this)->maxLen = (x)
862|
863|#endif
864|
865|
866|/***********************************************************************
867| 36-2. <<< [StrX_MemV2_finish] 後始末する >>>
868|************************************************************************/
869|#define StrX_MemV2_finish( this ) \
870| ListX_Dic_finish( &(this)->dic, StrX_MemV2E, (Inf_FinishFunc)StrX_MemV2E_finish ), \
871| ListX_finish2( &(this)->symbols, StrX_MemV2E, NULL )
872|
873|/***********************************************************************
874| 36-3. <<< [StrX_MemV2_toEmpty] 領域をすべて開放する >>>
875|************************************************************************/
876|#define StrX_MemV2_toEmpty( this ) \
877| ListX_Dic_toEmpty( &(this)->dic, StrX_MemV2E, (Inf_FinishFunc)StrX_MemV2E_finish )
878|
879|/***********************************************************************
880| 36-4. <<< [StrX_MemV2_getN] 確保している文字列の要素数を返す >>>
881|************************************************************************/
882|#define StrX_MemV2_getN( this ) \
883| ListX_Dic_getN( &(this)->dic )
884|
885|/***********************************************************************
886| 36-5. <<< [StrX_MemV2E_init] 文字列領域をヒープから確保する >>>
887|************************************************************************/
888|#define StrX_MemV2E_init( this, str ) \
889| strcpy( (char*)( (this)->p = malloc( strlen( str ) + 1 ) ), str )
890|
891|
892|/*-------------------------------------------------------------------------*/
893|/* ◆37. <<<< (StrX_SetV) 文字列の記憶領域の部分集合（StrX_MemV用） >>>> */
894|/*-------------------------------------------------------------------------*/
895|
896|
897|/**************************************************************************
898| 37-1. <<< [StrX_SetV_init1] 集合を定義する(step-1) >>>
899| 37-2. <<< [StrX_SetV_init2] 集合を定義する(step-2) >>>
900|【補足】
901|・StrX_SetV_init1 から StrX_SetV_init2 の間に
902| mem に StrX_MemV_alloc した文字列の集合に初期化します。
903|・StrX_SetV_init2 を呼び出す前に、集合の最後の要素に相当する
904| 文字列を格納しておいてください。
905|***************************************************************************/
906|#ifdef USES_STDLIBS
907|#ifdef USES_LISTX
908|
909|#define StrX_SetV_init1( this, _mem ) \
910|( \
911| ( (this)->first = strchr( (_mem)->mem_last->mem.pBuf, '\0' ) + 1 ), \
912| (this)->firstVE = (_mem)->mem_last \
913|)
914|
915|#define StrX_SetV_init2( this, _mem ) \
916| ( (this)->last = strchr( (_mem)->mem_last->mem.pBuf, '\0' ) + 1 )
917|
918|
919|#endif
920|#endif /* USES_STDLIBS */
921|
922|
923|/**************************************************************************
924| 37-3. <<< [StrX_SetV_forEach] 集合に含まれる文字列を列挙しながらループする >>>
925|【引数】
926| ・char** pp; 要素文字列(char*ポインタ)を格納するアドレス
927| ・StrX_SetV* set; 文字列の記憶領域
928|【補足】
929|・for 文の中で使用します。
930| for ( StrX_SetV_forEach( &set, &p ) );
931|***************************************************************************/
932|#ifdef USES_STDLIBS
933|#ifdef USES_LISTX
934|
935|#define StrX_SetV_forEach( set, pp ) \
936| *(pp) = ((set)->first==(set)->last ? NULL : (set)->first), \
937| (set)->pVE = (set)->firstVE; \
938| *(pp) != NULL ; \
939| *(pp) = StrX_SetV_forEach_imp( set, *(pp) )
940|
941|/* 内部用 */
942|char* StrX_SetV_forEach_imp( StrX_SetV*, char* p );
943|
944|
945|#endif
946|#endif /* USES_STDLIBS */
947|
948|#ifdef __cplusplus
949|}
950|#endif
951|
952|#endif
953|
954|