Sym.c
[目次 | 関数]
1|/**************************************************************************
2|* 1. <<< 動的参照シンボル (Sym) >>>
3|***************************************************************************/
4|
5|#include "mixer_precomp.h" /* Auto precompiled header, Look at mixer-... folder */
6|
7|#ifdef USES_MXP_AUTOINC
8| #include "sym.ah" /* Auto include header, Look at mixer-... folder */
9|#endif
10|
11|
12|
13|/*-------------------------------------------------------------------------*/
14|/* 2. <<< ◆(Sym) 動的参照エンジン >>> */
15|/*-------------------------------------------------------------------------*/
16|
17|Sym sym;
18|void* Sym_chker;
19|
20|
21|/***********************************************************************
22|* 3. <<< [Sym_init] 初期化する >>>
23|*【補足】
24|*・m には、sym グローバル変数を使うようにしてください。
25|************************************************************************/
26|void Sym_init( Sym* m )
27|{
28| ERRORS_INITCHK( m, 0 );
29| ERRORS_SINGLETON_FOR_INIT( &Sym_chker, m );
30|
31| ListX_init( &m->vars );
32| ListX_init( &m->structs );
33| ListX_init( &m->funcs );
34| StrX_MemV2_init( &m->sym, 251, StrX_getHashI, false );
35|
36| ERRORS_FINISHCHK_FOR_INIT( Sym_finish );
37|}
38|
39|
40|
41|/***********************************************************************
42|* 4. <<< [Sym_finish] 後始末する >>>
43|************************************************************************/
44|void Sym_finish( Sym* m )
45|{
46| ERRORS_INITCHK( m, 1 );
47| ERRORS_SINGLETON_FOR_FINISH( &Sym_chker, m );
48| ERRORS_FINISHCHK_FOR_FINISH( Sym_finish );
49|
50| ListX_finish2( &m->vars, Sym_Var, NULL );
51| ListX_toEmptyFinish( &m->structs, Sym_Struct, Sym_Struct_finish );
52| ListX_toEmptyFinish( &m->funcs, Sym_Func, Sym_Func_finish );
53| StrX_MemV2_finish( &m->sym );
54|}
55|
56|
57|
58|/***********************************************************************
59|* 5. <<< [Sym_print] デバッグ表示する >>>
60|************************************************************************/
61|#ifndef ERRORS_CUT_DEBUG_TOOL
62|void Sym_print( Sym* m, const char* title )
63|{
64| Sym_Var* var;
65| Sym_Struct* st;
66| Sym_Func* func;
67|
68| ERRORS_INITCHK( m, 1 );
69|
70| for ( ListX_forEach( &m->vars, &var, Sym_Var ) ) {
71| Sym_Var_print( var, title );
72| }
73| for ( ListX_forEach( &m->structs, &st, Sym_Struct ) ) {
74| Sym_Struct_print( st, title );
75| }
76| for ( ListX_forEach( &m->funcs, &func, Sym_Func ) ) {
77| Sym_Func_print( func, title );
78| }
79|}
80|#endif
81|
82|
83|/***********************************************************************
84|* 6. <<< [Sym_registVar] 任意の型の変数を登録する >>>
85|*【引数】
86|* ・char* type; 変数の型名
87|* ・char* name; 変数名
88|* ・void* adr; 変数のアドレス
89|************************************************************************/
90|Sym_Var* Sym_registVar( Sym* m, const char* type, const char* name, void* adr )
91|{
92| Sym_Var* var;
93|
94| ERRORS_INITCHK( m, 1 );
95|
96| var = ListX_addLastMalloc( &m->vars, Sym_Var );
97|
98| Sym_Var_init( var, type, name, adr );
99|
100| return var;
101|}
102|
103|
104|/***********************************************************************
105|* 7. <<< [Sym_registBasicVar] 基本型の変数を登録する >>>
106|*【引数】
107|* ・Sym_Type type; 変数の型
108|* ・char* name; 変数名
109|* ・void* adr; 変数のアドレス
110|************************************************************************/
111|Sym_Var* Sym_registBasicVar( Sym* m, Sym_Type type, const char* name, void* adr )
112|{
113| Sym_Var* var;
114|
115| ERRORS_INITCHK( m, 1 );
116|
117| var = ListX_addLastMalloc( &m->vars, Sym_Var );
118|
119| Sym_Var_initBasic( var, type, name, adr );
120|
121| return var;
122|}
123|
124|
125|/***********************************************************************
126|* 8. <<< [Sym_registStructVar] 構造体変数を登録する >>>
127|*【引数】
128|* ・Sym_Struct* st; 変数の型
129|* ・char* name; 変数名
130|* ・void* adr; 変数のアドレス
131|************************************************************************/
132|Sym_Var* Sym_registStructVar( Sym* m, Sym_Struct* st, const char* name, void* adr )
133|{
134| Sym_Var* var;
135|
136| ERRORS_INITCHK( m, 1 );
137|
138| var = ListX_addLastMalloc( &m->vars, Sym_Var );
139|
140| Sym_Var_initStruct( var, st, name, adr );
141|
142| return var;
143|}
144|
145|
146|/***********************************************************************
147|* 9. <<< [Sym_unregistVar] 構造体変数の登録を解除する >>>
148|*【引数】
149|* ・char* name; 変数名
150|************************************************************************/
151|void Sym_unregistVar( Sym* m, const char* name )
152|{
153| Sym_Var* var;
154|
155| var = Sym_getVar( m, name );
156| ASSERT( var != NULL );
157| ListX_removeFree( &m->vars, var );
158|}
159|
160|
161|/***********************************************************************
162|* 10. <<< [Sym_getRef] 変数を参照するための情報を取得する >>>
163|*【引数】
164|* ・char* href; 参照名
165|* ・Sym_Ref* ref; 変数（出力）
166|*【補足】
167|*・href は、変数名や構造体変数名だけでなく、構造体のメンバ変数も
168|* ピリオド "." や"->"に続けて参照できます。"." と "->" は、
169|* どちらを指定してもかまいません。
170|* 例："var.member.sub" ... var 構造体の member, sub メンバ
171|*・ref から Sym_Ref クラスの関数を使用して、値や型などを取得できます。
172|************************************************************************/
173|void Sym_getRef( Sym* m, const char* href, Sym_Ref* ref )
174|{
175| Sym_Var* var;
176| char* p;
177| char* p2;
178| int n;
179|
180| ERRORS_INITCHK( m, 1 );
181|
182| {
183| char name[256];
184|
185| /* name を格納する */
186| p = strchr( href, '.' );
187| p2 = strstr( href, "->" );
188| if ( p == NULL || ( p2 != NULL && p2 < p ) ) p = p2;
189| if ( p == NULL ) strcpy( name, href );
190| else {
191| n = p - href;
192| strncpy( name, href, n );
193| name[n] = '\0';
194| }
195|
196| /* 変数または構造体のトップを取得する */
197| var = Sym_getVar( m, name );
198| if ( var == NULL ) {
199| error2_2( Sym_Err_NotFindSymbol,
200| "%s のシンボル %s が見つかりません。", href, name );
201| }
202| }
203|
204| Sym_Ref_init( ref, var->adr, var->type, var->st, Sym_NoID, NULL, NULL );
205|
206| if ( p != NULL )
207| Sym_Ref_getRef( ref, ( *p == '.' ? p + 1 : p + 2 ), ref );
208|}
209|
210|
211|/***********************************************************************
212|* 11. <<< [Sym_getFunc] 関数を呼び出すための情報を取得する >>>
213|*【補足】
214|*・返り値から Sym_Func クラスの関数を使用して、関数呼び出しや、引数の型
215|* の取得などができます。
216|************************************************************************/
217|Sym_Func* Sym_getFunc( Sym* m, const char* name )
218|{
219| Sym_Func* func;
220| char* name2;
221|
222| ERRORS_INITCHK( m, 1 );
223|
224| name2 = StrX_MemV2_alloc( &m->sym, name );
225|
226| for ( ListX_forEach( &m->funcs, &func, Sym_Func ) ) {
227| if ( func->name == name2 )
228| return func;
229| }
230| return NULL;
231|}
232|
233|
234|/***********************************************************************
235|* 12. <<< [Sym_getVar] 直下の変数を返す >>>
236|************************************************************************/
237|Sym_Var* Sym_getVar( Sym* m, const char* name )
238|{
239| Sym_Var* var;
240| char* name2;
241|
242| ERRORS_INITCHK( m, 1 );
243|
244| name2 = StrX_MemV2_alloc( &m->sym, name );
245|
246| for ( ListX_forEach( &m->vars, &var, Sym_Var ) ) {
247| if ( var->name == name2 )
248| return var;
249| }
250| return NULL;
251|}
252|
253|
254|/***********************************************************************
255|* 13. <<< [Sym_getStruct] 構造体型を返す >>>
256|************************************************************************/
257|Sym_Struct* Sym_getStruct( Sym* m, const char* name )
258|{
259| Sym_Struct* st;
260| char* name2;
261|
262| ERRORS_INITCHK( m, 1 );
263|
264| name2 = StrX_MemV2_alloc( &m->sym, name );
265|
266| for ( ListX_forEach( &m->structs, &st, Sym_Struct ) ) {
267| if ( st->name == name2 )
268| return st;
269| }
270| return NULL;
271|}
272|
273|
274|/*-------------------------------------------------------------------------*/
275|/* 14. <<< ◆(Sym_Var) 動的参照変数 >>> */
276|/*-------------------------------------------------------------------------*/
277|
278|
279|
280|/***********************************************************************
281|* 15. <<< [Sym_Var_init] 変数を初期化する >>>
282|************************************************************************/
283|void Sym_Var_init( Sym_Var* m, const char* type,
284| const char* name, void* adr )
285|{
286| Sym_Type typeID = Sym_Type_getID2( type );
287|
288| if ( typeID != Sym_NoID ) {
289| Sym_Var_initBasic( m, typeID, name, adr );
290| }
291| else {
292| Sym_Struct* st = Sym_getStruct( &sym, type );
293| if ( st != NULL )
294| Sym_Var_initStruct( m, st, name, adr );
295| else
296| error2_1( Sym_Err_NotFindType, "%s 型は登録されていません", type );
297| }
298|}
299|
300|
301|/***********************************************************************
302|* 16. <<< [Sym_Var_initBasic] 基本型の変数を初期化する >>>
303|************************************************************************/
304|void Sym_Var_initBasic( Sym_Var* m, Sym_Type type,
305| const char* name, void* adr )
306|{
307| m->name = StrX_MemV2_alloc( &sym.sym, name );
308| m->adr = adr;
309| m->type = type;
310| m->st = NULL;
311|}
312|
313|
314|/***********************************************************************
315|* 17. <<< [Sym_Var_initStruct] 構造体の変数を初期化する >>>
316|************************************************************************/
317|void Sym_Var_initStruct( Sym_Var* m, Sym_Struct* st,
318| const char* name, void* adr )
319|{
320| m->name = StrX_MemV2_alloc( &sym.sym, name );
321| m->adr = adr;
322| m->type = Sym_StructType;
323| m->st = st;
324|}
325|
326|
327|/***********************************************************************
328|* 18. <<< [Sym_Var_print] デバッグ出力する >>>
329|************************************************************************/
330|#ifndef ERRORS_CUT_DEBUG_TOOL
331|void Sym_Var_print( Sym_Var* m, const char* title )
332|{
333| Errors_printf( "%sSym_Var[%p] name=\"%s\", adr = %p, type = %s, st = %s[%p]",
334| title, m, m->name, m->adr, Sym_Type_getStr( m->type ),
335| ( m->st == NULL ? "NULL" : m->st->name ), m->st );
336|}
337|#endif
338|
339|/*-------------------------------------------------------------------------*/
340|/* 19. <<< ◆(Sym_Ref) 変数リファレンス >>> */
341|/*-------------------------------------------------------------------------*/
342|
343|
344|
345|/***********************************************************************
346|* 20. <<< [Sym_Ref_copy] コピーする >>>
347|************************************************************************/
348|void Sym_Ref_copy( Sym_Ref* dst, Sym_Ref* src )
349|{
350| *dst = *src;
351| if ( src->adr == (void*)&src->localVar )
352| dst->adr = (void*)&dst->localVar;
353|}
354|
355|
356|/***********************************************************************
357|* 21. <<< [Sym_Ref_getRef] 構造体変数からネストした変数を参照する >>>
358|*【引数】
359|* ・char* href; 参照名
360|* ・Sym_Ref* ref; 変数（出力）
361|*【補足】
362|*・Sym_getRef( &sym, "st.memb1", &ref ) で取得した参照 ref から
363|* Sym_Ref_getRef( &ref, "memb2", &ref2 ) で取得した ref2 は、
364|* Sym_getRef( &sym, "st.memb1.memb2", &ref3 ) で取得した ref3 と同じです。
365|************************************************************************/
366|void Sym_Ref_getRef( Sym_Ref* m, const char* href, Sym_Ref* ref )
367|{
368| Sym_Member* memb;
369| char* href2;
370| char* p;
371| char* p2;
372| Sym_Ref obj;
373| int n;
374| char name[256];
375|
376| if ( href[0] == '\0' )
377| { Sym_Ref_copy( ref, m ); return; }
378| ASSERT( m->adr != NULL );
379| ASSERT( m->type == Sym_StructType || m->type == Sym_StructTypeP );
380| Sym_Ref_copy( &obj, m );
381|
382| #if ERRORS_DEBUG_FALSE
383| Errors_printf( "Sym_Ref_getRef( href=%s )", href );
384| Errors_printf( " first adr = %p", obj.adr );
385| #endif
386|
387| for ( href2 = (char*)href;
388| /* for の終わりで判定 */;
389| href2 = ( *p == '.' ? p + 1 : p + 2 ) ) {
390|
391| /* name を格納する */
392| p = strchr( href2, '.' );
393| p2 = strstr( href2, "->" );
394| if ( p == NULL || ( p2 != NULL && p2 < p ) ) p = p2;
395| if ( p == NULL ) strcpy( name, href2 );
396| else {
397| n = p - href2;
398| strncpy( name, href2, n );
399| name[n] = '\0';
400| }
401|
402| /* 構造体のメンバを取得する */
403| if ( obj.type == Sym_StructType || obj.type == Sym_StructTypeP ) {
404|
405| ref->type = Sym_NoID;
406| if ( obj.st->readMembFunc ) {
407| obj.st->readMembFunc( &obj, name, ref );
408| }
409|
410| if ( ref->type == Sym_NoID ) {
411| memb = Sym_Struct_getMember( obj.st, name );
412| if ( memb == NULL ) {
413| error2_2( Sym_Err_NotFindSymbol,
414| "%s のシンボル %s が見つかりません。", href, name );
415| }
416| if ( obj.type == Sym_StructTypeP ) {
417| if ( obj.adr == NULL )
418| error2_1( Sym_Err_NullAsign, "NULL 参照(.%s)", name );
419| obj.adr = *(char**)obj.adr;
420| #if ERRORS_DEBUG_FALSE
421| Errors_printf( " * adr = %p", obj.adr );
422| #endif
423| }
424| if ( memb->readFunc == NULL ) {
425| if ( obj.adr == NULL )
426| error2_1( Sym_Err_NullAsign, "NULL 参照(.%s)", name );
427| obj.adr = (char*)obj.adr + memb->offset;
428| }
429| else {
430| if ( obj.adr == NULL )
431| error2_1( Sym_Err_NullAsign, "NULL 参照(.%s)", name );
432| memb->readFunc( obj.adr, &obj.localVar );
433| obj.adr = (char*)&obj.localVar;
434| ASSERT( obj.adr != NULL );
435| }
436| obj.type = memb->type; obj.st = memb->st;
437| obj.elem_type = memb->elem_type; obj.elem_st = memb->elem_st;
438| }
439| else {
440| Sym_Ref_copy( &obj, ref );
441| }
442| }
443| else {
444| error2_2( Sym_Err_ManyNest,
445| "シンボル %s の %s が、基本型に対する構造体参照をしています。",
446| href, name );
447| }
448| #if ERRORS_DEBUG_FALSE
449| Errors_printf( " %s adr = %p", name, obj.adr );
450| #endif
451|
452| if ( p == NULL ) break;
453| }
454|
455| Sym_Ref_copy( ref, &obj );
456|}
457|
458|
459|/***********************************************************************
460|* 22. <<< [Sym_Ref_getString] 変数の値を文字列で取得する >>>
461|*【引数】
462|* ・char* s; 変数の値（出力）
463|* ・int s_szie; s のメモリサイズ
464|************************************************************************/
465|void Sym_Ref_getString( Sym_Ref* m, char* s, int s_size )
466|{
467| switch ( m->type ) {
468| case Sym_StructTypeP:
469| case Sym_VoidP: sprintf( s, "%p", Sym_Ref_getPtr( m ) ); break;
470| case Sym_CharP: StrX_cpy( s, Sym_Ref_getCharP( m ), s_size ); break;
471| case Sym_CharArr: StrX_cpy( s, Sym_Ref_getCharArr( m ), s_size ); break;
472| case Sym_Int: sprintf( s, "%d", Sym_Ref_getInt( m ) ); break;
473| case Sym_Long: sprintf( s, "%ld", Sym_Ref_getLong( m ) ); break;
474| case Sym_Short: sprintf( s, "%d", Sym_Ref_getShort( m ) ); break;
475| case Sym_Char: sprintf( s, "%d", Sym_Ref_getChar( m ) ); break;
476| case Sym_Float: sprintf( s, "%f", Sym_Ref_getFloat( m ) ); break;
477| case Sym_Double: sprintf( s, "%lf", Sym_Ref_getDouble( m ) ); break;
478| case Sym_UInt: sprintf( s, "%u", Sym_Ref_getUInt( m ) ); break;
479| case Sym_ULong: sprintf( s, "%lu", Sym_Ref_getULong( m ) ); break;
480| case Sym_UShort: sprintf( s, "%u", Sym_Ref_getUShort( m ) ); break;
481| case Sym_UChar: sprintf( s, "%u", Sym_Ref_getUChar( m ) ); break;
482| case Sym_StructType:
483| sprintf( s, "(LinkError: cannot make string : struct %s [%p])", m->st->name, m->adr ); break;
484| default:
485| sprintf( s, "(LinkError: unknown type (%d))", m->type ); break;
486| }
487| ASSERT( strlen( s ) < (unsigned)s_size );
488|}
489|
490|
491|/***********************************************************************
492|* 23. <<< [Sym_Ref_getStringSize] 変数の値を文字列にしたときの文字列長+1を返す >>>
493|************************************************************************/
494|int Sym_Ref_getStringSize( Sym_Ref* m )
495|{
496| int ret;
497| char s[256];
498|
499| s[0] = '\0';
500|
501| switch ( m->type ) {
502| case Sym_StructTypeP:
503| case Sym_VoidP: sprintf( s, "%p", Sym_Ref_getPtr( m ) ); break;
504| case Sym_CharP: ret = strlen( Sym_Ref_getCharP( m ) ); break;
505| case Sym_CharArr: ret = strlen( Sym_Ref_getCharArr( m ) ); break;
506| case Sym_Int: sprintf( s, "%d", Sym_Ref_getInt( m ) ); break;
507| case Sym_Long: sprintf( s, "%ld", Sym_Ref_getLong( m ) ); break;
508| case Sym_Short: sprintf( s, "%d", Sym_Ref_getShort( m ) ); break;
509| case Sym_Char: sprintf( s, "%d", Sym_Ref_getChar( m ) ); break;
510| case Sym_Float: sprintf( s, "%f", Sym_Ref_getFloat( m ) ); break;
511| case Sym_Double: sprintf( s, "%lf", Sym_Ref_getDouble( m ) ); break;
512| case Sym_UInt: sprintf( s, "%u", Sym_Ref_getUInt( m ) ); break;
513| case Sym_ULong: sprintf( s, "%lu", Sym_Ref_getULong( m ) ); break;
514| case Sym_UShort: sprintf( s, "%u", Sym_Ref_getUShort( m ) ); break;
515| case Sym_UChar: sprintf( s, "%u", Sym_Ref_getUChar( m ) ); break;
516| case Sym_StructType:
517| sprintf( s, "(LinkError: cannot make string : struct %s [%p])", m->st->name, m->adr ); break;
518| default:
519| sprintf( s, "(LinkError: unknown type (%d))", m->type ); break;
520| }
521| if ( s[0] != '\0' ) ret = strlen( s );
522|
523| return ret;
524|}
525|
526|
527|/***********************************************************************
528|* 24. <<< [Sym_Ref_writeString] 変数の値を文字列でファイルに出力する >>>
529|*【引数】
530|* ・FILE* out; 出力ファイル
531|************************************************************************/
532|void Sym_Ref_writeString( Sym_Ref* m, FILE* out )
533|{
534| switch ( m->type ) {
535| case Sym_StructTypeP:
536| case Sym_VoidP: fprintf( out, "%p", Sym_Ref_getPtr( m ) ); break;
537| case Sym_CharP: fputs( Sym_Ref_getCharP( m ), out ); break;
538| case Sym_CharArr: fputs( Sym_Ref_getCharArr( m ), out ); break;
539| case Sym_Int: fprintf( out, "%d", Sym_Ref_getInt( m ) ); break;
540| case Sym_Long: fprintf( out, "%ld", Sym_Ref_getLong( m ) ); break;
541| case Sym_Short: fprintf( out, "%d", Sym_Ref_getShort( m ) ); break;
542| case Sym_Char: fprintf( out, "%d", Sym_Ref_getChar( m ) ); break;
543| case Sym_Float: fprintf( out, "%f", Sym_Ref_getFloat( m ) ); break;
544| case Sym_Double: fprintf( out, "%lf", Sym_Ref_getDouble( m ) ); break;
545| case Sym_UInt: fprintf( out, "%u", Sym_Ref_getUInt( m ) ); break;
546| case Sym_ULong: fprintf( out, "%lu", Sym_Ref_getULong( m ) ); break;
547| case Sym_UShort: fprintf( out, "%u", Sym_Ref_getUShort( m ) ); break;
548| case Sym_UChar: fprintf( out, "%u", Sym_Ref_getUChar( m ) ); break;
549| case Sym_StructType:
550| fprintf( out, "(LinkError: cannot make string : struct %s [%p])", m->st->name, m->adr ); break;
551| default:
552| fprintf( out, "(LinkError: unknown type (%d))", m->type ); break;
553| }
554|}
555|
556|/*-------------------------------------------------------------------------*/
557|/* 25. <<< ◆(Sym_Struct) 動的参照構造体型 >>> */
558|/*-------------------------------------------------------------------------*/
559|
560|
561|
562|/***********************************************************************
563|* 26. <<< [Sym_Struct_init] 初期化する >>>
564|************************************************************************/
565|void Sym_Struct_init( Sym_Struct* m, const char* name )
566|{
567| m->name = StrX_MemV2_alloc( &sym.sym, name );
568| ListX_init( &m->members );
569| m->loopFunc = NULL;
570| m->readMembFunc = NULL;
571|
572| ERRORS_FINISHCHK_FOR_INIT( Sym_Struct_finish );
573|}
574|
575|
576|/***********************************************************************
577|* 27. <<< [Sym_Struct_finish] 後始末する >>>
578|************************************************************************/
579|void Sym_Struct_finish( Sym_Struct* m )
580|{
581| ERRORS_FINISHCHK_FOR_FINISH( Sym_Struct_finish );
582|
583| ListX_finish2( &m->members, Sym_Member, Sym_Member_finish );
584|}
585|
586|
587|/***********************************************************************
588|* 28. <<< [Sym_Struct_print] デバッグ出力する >>>
589|************************************************************************/
590|#ifndef ERRORS_CUT_DEBUG_TOOL
591|void Sym_Struct_print( Sym_Struct* m, const char* title )
592|{
593| Sym_Member* memb;
594|
595| Errors_printf( "" );
596| Errors_printf( "%sSym_Struct[%p] name=\"%s\" ---------------------",
597| title, m, m->name );
598| for ( ListX_forEach( &m->members, &memb, Sym_Member ) ) {
599| Sym_Member_print( memb, title );
600| }
601|}
602|#endif
603|
604|/***********************************************************************
605|* 29. <<< [Sym_Struct_getMember] メンバ変数の情報を返す >>>
606|************************************************************************/
607|Sym_Member* Sym_Struct_getMember( Sym_Struct* m, const char* name )
608|{
609| Sym_Member* memb;
610| char* name2 = StrX_MemV2_alloc( &sym.sym, name );
611|
612| for ( ListX_forEach( &m->members, &memb, Sym_Member ) ) {
613| if ( memb->name == name2 )
614| return memb;
615| }
616| return NULL;
617|}
618|
619|/*-------------------------------------------------------------------------*/
620|/* 30. <<< ◆(Sym_Member) 動的参照構造体のメンバ変数 >>> */
621|/*-------------------------------------------------------------------------*/
622|
623|
624|
625|/***********************************************************************
626|* 31. <<< [Sym_Member_init] 初期化する >>>
627|************************************************************************/
628|void Sym_Member_init( Sym_Member* m, const char* name, Offset offset,
629| Sym_Type type, Sym_Struct* st, Sym_ReadPropF readFunc,
630| Sym_WritePropF writeFunc )
631|{
632| m->name = StrX_MemV2_alloc( &sym.sym, name );
633| m->offset = offset;
634| m->type = type;
635| m->st = st;
636| m->readFunc = readFunc;
637| m->writeFunc = writeFunc;
638| m->elem_type = Sym_NoID;
639| m->elem_st = NULL;
640| m->elem_param = NULL;
641| m->elem_param_delete = NULL;
642|
643| ERRORS_FINISHCHK_FOR_INIT( Sym_Member_finish );
644|}
645|
646|
647|/***********************************************************************
648|* 32. <<< [Sym_Member_finish] 初期化する >>>
649|************************************************************************/
650|void Sym_Member_finish( Sym_Member* m )
651|{
652| ERRORS_FINISHCHK_FOR_FINISH( Sym_Member_finish );
653|
654| if ( m->elem_param_delete != NULL )
655| m->elem_param_delete( m->elem_param );
656|}
657|
658|
659|/***********************************************************************
660|* 33. <<< [Sym_Member_print] デバッグ出力する >>>
661|************************************************************************/
662|#ifndef ERRORS_CUT_DEBUG_TOOL
663|void Sym_Member_print( Sym_Member* m, const char* title )
664|{
665| Errors_printf( "%sSym_Member[%p] name=\"%s\", offset=%d, type=%s, st = %s[%p],"
666| " readFunc=[%p], writeFunc=[%p]",
667| title, m, m->name, m->offset, Sym_Type_getStr( m->type ),
668| ( m->st == NULL ? "NULL" : m->st->name ), m->st,
669| m->readFunc, m->writeFunc );
670|}
671|#endif
672|
673|/*-------------------------------------------------------------------------*/
674|/* 34. <<< ◆(Sym_Type) 変数の型 >>> */
675|/*-------------------------------------------------------------------------*/
676|
677|
678|
679|/***********************************************************************
680|* 35. <<< [Sym_Type_getStr] 文字列に変換する >>>
681|************************************************************************/
682|char* Sym_Type_getStr( Sym_Type m )
683|{
684| static char* str[] = {
685| "Sym_NoID",
686| "Sym_Void",
687| "Sym_Int", "Sym_UInt", "Sym_Float", "Sym_Double",
688| "Sym_Long", "Sym_ULong", "Sym_Short", "Sym_UShort", "Sym_Char", "Sym_UChar",
689| "Sym_VoidP",
690| "Sym_IntP", "Sym_UIntP", "Sym_FloatP", "Sym_DoubleP",
691| "Sym_LongP", "Sym_ULongP", "Sym_ShortP", "Sym_UShortP", "Sym_CharP", "Sym_UCharP",
692| "Sym_CharArr",
693| "Sym_StructType", "Sym_StructTypeP",
694| };
695| ASSERT( m >= 0 && m < Sym_Type_over );
696|
697| return str[m];
698|}
699|
700|
701|/***********************************************************************
702|* 36. <<< [Sym_Type_getStr2] 型名に変換する >>>
703|************************************************************************/
704|char* Sym_Type_getStr2( Sym_Type m )
705|{
706| static char* str[] = {
707| "Sym_NoID",
708| "void",
709| "int", "unsigned int", "float", "double",
710| "long", "unsigned long", "short", "unsigned short", "char", "unsigned char",
711| "void*",
712| "int*", "unsigned int*", "float*", "double*",
713| "long*", "unsigned long*", "short*", "unsigned short*", "char*", "unsigned char*",
714| "char[]",
715| "struct", "struct*",
716| };
717| ASSERT( m >= 0 && m < Sym_Type_over );
718|
719| return str[m];
720|}
721|
722|
723|/***********************************************************************
724|* 37. <<< [Sym_Type_getID2] 型名から番号に変換する >>>
725|************************************************************************/
726|Sym_Type Sym_Type_getID2( const char* str )
727|{
728| int i;
729|
730| for ( i = 0; i < Sym_Type_over; i++ ) {
731| if ( strcmp( Sym_Type_getStr2( i ), str ) == 0 )
732| return i;
733| }
734|
735| return Sym_NoID;
736|}
737|
738|
739|/*-------------------------------------------------------------------------*/
740|/* 38. <<< ◆(Sym_Func) 動的参照関数 >>> */
741|/*-------------------------------------------------------------------------*/
742|
743|/***********************************************************************
744|* 39. <<< [Sym_Func_init] 初期化する >>>
745|************************************************************************/
746|void Sym_Func_init( Sym_Func* m, const char* name, Sym_FuncF func, int nArg )
747|{
748| int i;
749|
750| m->name = StrX_MemV2_alloc( &sym.sym, name );
751| m->func = func;
752| m->nArg = nArg;
753| m->types = (Sym_Type*)malloc( sizeof(Sym_Type) * (nArg + 1) );
754| m->sts = (Sym_Struct**)malloc( sizeof(Sym_Struct*) * (nArg + 1) );
755|
756| for ( i = 0; i <= nArg; i++ ) {
757| m->types[i] = Sym_NoID;
758| m->sts[i] = NULL;
759| }
760|
761| ERRORS_FINISHCHK_FOR_INIT( Sym_Func_finish );
762|}
763|
764|/***********************************************************************
765|* 40. <<< [Sym_Func_finish] 後始末する >>>
766|************************************************************************/
767|void Sym_Func_finish( Sym_Func* m )
768|{
769| ERRORS_FINISHCHK_FOR_FINISH( Sym_Func_finish );
770|
771| free( m->types );
772| free( m->sts );
773|}
774|
775|
776|/***********************************************************************
777|* 41. <<< [Sym_Func_print] デバッグ出力する >>>
778|************************************************************************/
779|#ifndef ERRORS_CUT_DEBUG_TOOL
780|void Sym_Func_print( Sym_Func* m, const char* title )
781|{
782| int i;
783| Errors_printf( "%sSym_Func[%p] name=\"%s\", func = %p, nArg = %d",
784| title, m, m->name, m->func, m->nArg );
785| Errors_printf( "%s ret type = %s, st = %s[%p]", title,
786| Sym_Type_getStr( m->types[0] ),
787| ( m->sts[0] == NULL ? "NULL" : m->sts[0]->name ),
788| m->sts[0] );
789| for ( i = 1; i <= m->nArg; i++ ) {
790| Errors_printf( "%s arg%d type = %s, st = %s[%p]", title, i,
791| Sym_Type_getStr( m->types[i] ),
792| ( m->sts[i] == NULL ? "NULL" : m->sts[i]->name ),
793| m->sts[i] );
794| }
795|}
796|#endif
797|
798|/***********************************************************************
799|* 42. <<< [Sym_Func_call] 関数を呼び出す >>>
800|************************************************************************/
801|void Sym_Func_call( Sym_Func* m, void** arg_adrs, void* ret_adr )
802|{
803| m->func( arg_adrs, ret_adr );
804|}
805|
806|
807|