FreeCalypso > hg > leo2moko-debug

comparison gpf/INC/tdc_base.h @ 0:509db1a7b7b8

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
initial import: leo2moko-r1
author Space Falcon <falcon@ivan.Harhan.ORG>
date Mon, 01 Jun 2015 03:24:05 +0000
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:509db1a7b7b8
1 /*
2 +-----------------------------------------------------------------------------
3 | Project :
4 | Modul : TDC
5 +-----------------------------------------------------------------------------
6 | Copyright 2002 Texas Instruments Berlin, AG
7 | All rights reserved.
8 |
9 | This file is confidential and a trade secret of Texas
10 | Instruments Berlin, AG
11 | The receipt of or possession of this file does not convey
12 | any rights to reproduce or disclose its contents or to
13 | manufacture, use, or sell anything it may describe, in
14 | whole, or in part, without the specific written consent of
15 | Texas Instruments Berlin, AG.
16 +-----------------------------------------------------------------------------
17 | Purpose :
18 +-----------------------------------------------------------------------------
19 */
20
21 #if defined TDC_PRECOMPILE && !defined TDC_BASE_TDC_H
22 #pragma message("TDC_BASE.H ENTERING PRECOMPILE MODE")
23 /*
24 This code is added to make a prettier and easier to navigate .i-file
25 Purpose:
26 A) maintain info of which macro codes come from
27 B) maintain line breaks from inside macros
28
29 The process include the following steps:
30
31 1:
32 Command:
33 perl tdc_h.pl ..\..\..\..\INC\tdc_base.h >tdc_base.tdc_h
34 (add TDC_BEGIN_MACRO TDC_NL TDC_MACRO_END TDC_NL macros)
35
36 Example transformation:
37 Input: (tdc_base.h)
38 */
39 #define MULTI_LINE_MACRO(A) ... \
40 ... \
41 ...
42 #define SINGLE_LINE_MACRO(A) ...
43 /*
44 Output: (tdc_base.tdc_h)
45 #define MULTI_LINE_MACRO(A) TDC_BEGIN_MACRO(MULTI_LINE_MACRO(A)) ... TDC_NL\
46 ... TDC_NL\
47 ... TDC_MACRO_END()
48 #define SINGLE_LINE_MACRO(A) TDC_MACRO(SINGLE_LINE_MACRO(A)) ...
49 2:
50 Command:
51 EDI preprocess .cpp-file with TDC and TDC_PRECOMPILE defined
52 (as a consequence tdc_base.tdc_h is used instead of tdc_base.h)
53
54 Example transformation:
55 Input: (use_some_macro.cpp)
56 MULTI_LINE_MACRO(B)
57 Output: (use_some_macro.i)
58 TDC_BEGIN_MACRO("MULTI_LINE_MACRO(B)") ... TDC_NL ... TDC_NL ... TDC_MACRO_END()
59
60 3:
61 Command:
62 perl tdc_i.pl .\tdc.i >tdc.tdc_i
63 (replace TDC_NL with real newline, make pretty indention
64
65 Example transformation:
66 Input: (use_some_macro.i)
67 TDC_BEGIN_MACRO("MULTI_LINE_MACRO(B)") ... TDC_NL ... TDC_NL ... TDC_MACRO_END
68 Output: (use_some_macro.tdc_i)
69 TDC_BEGIN_MACRO("MULTI_LINE_MACRO(B)") ...
70 ...
71 ... TDC_MACRO_END()
72
73 */
74 #define TDC_BASE_TDC_H
75 #include "tdc_base.tdc_h"
76 #endif //defined TDC_PRECOMPILE && !defined TDC_BASE_TDC_H
77
78 #ifndef TDC_BASE_H // stadard h-file guard
79 #define TDC_BASE_H
80
81 //============================================================================
82 /// \defgroup Configuration
83 //\{
84
85 ///memory leak detection
86 #define noTDC_USE_ALLOC_DEBUG_COUNTER
87
88 #define TDC_DEBUG
89
90 #define TDC_NO_PROFILING
91
92 ///include T_PORT
93 #define TDC_PORT
94
95 #define noM_TDC_MESSAGE_DEMO
96
97 ///typeinfo not needed, everything we need is in cccdgen tables
98 #define noTDC_TYPEINFO
99
100 ///never defined
101 #define noDOT_COMPLETE
102
103 //\}
104
105 //============================================================================
106 // include files
107 //============================================================================
108
109 //tdc_test_header_begin
110 //extern int dummy_to_make_namespace_non_empty;
111 //} //temporare leave namespace tdc
112 #ifndef TDC_TEST_I_CPP
113 #include <setjmp.h>
114 #include <stddef.h>
115 #include <typeinfo.h>
116 #include <malloc.h>
117 #include <string.h>
118 #endif
119 //namespace tdc { // reenter namespace tdc
120
121 //============================================================================
122 // controling warning levels from compilers
123 //============================================================================
124
125 #pragma warning(disable:4786)
126 //tdc_test_header_end
127
128 /*
129 general info members are constructed etc by generic functions so these are normal ok when
130 arriving inside M_TDC_... :
131 Warning 1539: member 'T_raw::handle' (line 3242, file M:\gpf\inc\tdc_base.h, module M:\gpf\util\tap\tdc\src\tdc_lib_main.cpp) not assigned by assignment operator
132 Warning 1401: member 'T_raw::handle' (line 3242, file M:\gpf\inc\tdc_base.h, module M:\gpf\util\tap\tdc\src\tdc_lib_main.cpp) not initialized by constructor
133 */
134
135 /*lint -e1717*/ //Info 1717: empty prototype for function declaration, assumed '(void)'
136 /*lint -e1505*/ //TODO: add access specifier for all base classes
137 /*lint -DLINT*/
138 /*lint -esym(18,BUF_*)*/ //CCDGEN generates surplus typedefs for _dsc.h-files
139 /*#lint -libdir(M:\gpf\util\teststack\inc\tdcinc)*/
140 /*#lint -libh(M:\gpf\util\teststack\inc\tdcinc\p_xx_tdc_1.h)*/
141
142 /// this lint option is used inside a macro, VA can not handle comments in macros correctly
143 #define TDC_LINT_UNUSED_MEMBER /*lint -e{754}*/
144 #define TDC_LINT_UNASSIGNED_MEMBER /*lint -e{1539}*/
145 #define TDC_LINT_UNCOPIED_BASE /*lint -e{1538}*/
146 #define TDC_LINT_NO_SELFASSIGN_TEST /*lint -e{1529}*/
147 #define TDC_LINT_UNINITIALIZED_MEMBER /*lint -e{1401}*/
148 #define TDC_LINT_POSSIBLE_UNHANDLE_POINTER_MEMBER /*lint -e{1740}*/
149
150 //============================================================================
151 /// \defgroup Constants
152 //============================================================================
153 //\{
154
155 #define FALSE 0
156 #define TRUE 1
157
158 /// TDSConstant comming from macros.h -> used in cc.doc
159 #define NOT_PRESENT_8BIT 0xff
160
161 /// TDSConstant comming from macros.h -> used in cc.doc
162 #define NOT_PRESENT_16BIT 0xffff
163
164 /// TDSConstant comming from macros.h -> used in cc.doc
165 #define NOT_PRESENT_32BIT 0xffffffffL
166
167 //\}
168
169 //============================================================================
170
171 #if TDC_DEBUG_DOT_COMPLETE
172 struct T_TDC_DEBUG_DOT_COMPLETE__TDC_H_0
173 {
174 int i0;
175 };
176
177 struct T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1
178 {
179 int i;
180 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_0 operator->(){}
181 };
182
183 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1A()
184 {
185 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
186 s.
187 i;
188 s->
189 i0;
190 }
191 #else
192 #endif
193
194 //============================================================================
195 // partial compiling tdcinc\*.cpp
196 //============================================================================
197
198 /** VC6 can not handle more than 30000 types per compilation unit, but this
199 has not so much to do with this, here we are trying to minimize the overall
200 memory usage during compilation, this is a problem for the umts asn1 file
201 the big isue is that determin this number is not an excat sicense since
202 VC give NO hint on whic entry is coursing this problem if it ocour during
203 pass2 of the compilation
204
205 to overcome this problem CCDGEN generate additional gaurds in tdcinc\*.cpp files
206
207 enum form
208
209 #if TDC_ENUM_PART
210 #ifndef TDC_SKIP_FORWARD_MENUM_prefix_enumtypename
211 M_TDC_POST_MENUM (prefix_enumtypename)
212 #endif
213 #endif // TDC_ENUM_PART
214
215 other form (example is for MSG but PRIM, STRUCT, UNION etc. use the same layout)
216
217 #if N / TDC_SIZE == TDC_PART
218 #ifndef TDC_SKIP_FORWARD_msgname
219 M_TDC_POST_MSG (msgname)
220 #endif
221 #endif // N / TDC_SIZE == TDC_PART
222
223 where N is a sequence number running from 0 and onwards, incremented by 1 for
224 each struct in the file
225
226 by defining TDC_SIZE and TDC_PART the source files can be partial compiled
227 the default behaviour is to compile the hole file at once
228
229 */
230
231 #ifndef TDC_PART
232 #define TDC_SIZE 99999L // number of structs per compilation
233 #define TDC_PART 0L // which struct part to compile in this session
234 #define TDC_ENUM_PART 1 // if enum part is to be compiled in this session
235 #elif TDC_PART == -1
236 #define TDC_ENUM_PART 1 // if enum part is to be compiled in this session
237 #else
238 #define TDC_ENUM_PART 0 // if enum part is to be compiled in this session
239 #endif
240
241 //============================================================================
242 // configuration side effects
243 //============================================================================
244
245 #ifndef TDC_DESCRIPTOR
246
247 #define NO_TDC_DESCRIPTOR
248
249 #else //TDC_DESCRIPTOR
250
251 #define __T_TDC_INTERFACE_MESSAGE__
252 #define __T_TDC_INTERFACE_PRIMITIVE__
253
254 #endif //TDC_DESCRIPTOR
255
256 //============================================================================
257 /// \defgroup dot_complete helper macros
258 //============================================================================
259 //\{
260
261 #if DOT_COMPLETE
262 #define TDC_DOT_COMPLETE_HIDE(code) \
263 /* nothing */
264 struct T_TDC_EMPTY {};
265 #else//DOT_COMPLETE
266 #define TDC_DOT_COMPLETE_HIDE(code) \
267 code
268 #endif//DOT_COMPLETE
269
270 //\}
271
272 //============================================================================
273 //
274 //============================================================================
275
276 ///tdc_test_header_begin
277 #ifndef M_TDC_DOC
278 #if DOT_COMPLETE
279
280 void TDC_NOTHING() {} // generate code for breakpoint
281 size_t TDC_LENGTHOF(array) {}
282 void TDC_DYNAMIC_DEAD_CODE() {} // program execution is not suposed to reach this point
283
284 #else //DOT_COMPLETE
285
286 void tdc_nothing();
287 /** generate code for breakpoint */
288 #define TDC_NOTHING() \
289 tdc_nothing()
290
291 #define TDC_DYNAMIC_DEAD_CODE() tdc_dynamic_dead_code() // program execution is not suposed to reach this point
292
293
294 #define TDC_LENGTHOF(array) (size_t(sizeof array / sizeof *array))
295
296 #define M_TDC_STRING1(text) #text
297 /** expand macros before stringify */
298 #define M_TDC_STRING(text) M_TDC_STRING1(text)
299
300 #endif //DOT_COMPLETE
301 #endif //M_TDC_DOC
302
303 // macro to show pragma message with file name and line number when compiling (see M_TDC_MESSAGE_DEMO below)
304 //#define M_TDC_MESSAGE(text) message(__FILE__ "(" M_TDC_STRING(__LINE__) ") : message: \'" text "\'")
305 #define M_TDC_MESSAGE(text) message(__FILE__ "(" M_TDC_STRING(__LINE__) ") : message: \'" M_TDC_STRING(text) "\'")
306 #ifdef M_TDC_MESSAGE_DEMO
307 // e.g. show how a macro is expanded
308 #define MY(X) MY_##X
309 #pragma M_TDC_MESSAGE(M_TDC_STRING(MY(Y)))
310 // compiler output: \gpf\inc\tdc_base.h(130) : message: 'MY_Y'
311 #endif
312
313 /// \defgroup IN_CLASS values for IN_CLASS macro argument
314 //\{
315 #define M_TDC_IN_CLASS(code) code
316 #define M_TDC_NOT_IN_CLASS(code)
317 #define M_TDC_NOT_M_TDC_IN_CLASS(code)
318 #define M_TDC_NOT_M_TDC_NOT_IN_CLASS(code) code
319 //\}
320
321 /// \defgroup WITH_BODY values for WITH_BODY macro argument
322 //\{
323 #define M_TDC_WITH_BODY(code) code
324 #define M_TDC_WITHOUT_BODY(code) ;
325 //\}
326
327 /// temporary removed multiline comments in multiline macros
328 /// <pre>(some compilers have problems with constructions like:
329 /// #define MY_MACRO() /* \\
330 /// my comment */ my_code
331 /// )</pre>
332 #define M_TDC_COMMENT(code) ;
333
334
335 /// \defgroup MacroTesting
336 /** for testing macros
337 * these macros is only used when tdc.dsw has the active project set to "tdc_lib - Win32 Precompile"
338 */
339 //\{
340 #define TDC_MACRO_BEGIN_(name,line)
341 #define TDC_MACRO_(name,line)
342 #define TDC_MACRO_END_()
343 //\}
344
345 // /tdc_test_header_end
346
347 #ifndef USE_TDC_TEST_I_II// during testing we see this part in the preprocessed file tdc_test_i.ii
348
349 struct T_TDC_BASE_DOT_COMPLETE_TEST
350 {
351 int i; //HINT
352 };
353
354 #define TDC_TBD() tdc_tbd(__FILE__, __LINE__)
355
356 #define TDC_ASSERT(condition) tdc_assert(condition,#condition,__FILE__,__LINE__)
357
358 #ifndef TDC_DEBUG
359 #define IF_TDC_DEBUG(code)
360 #else
361 #define IF_TDC_DEBUG(code) code
362 #endif
363
364 #ifndef TDC_TEST_PROFILE
365
366 #define TDC_PURE_BODY(code)\
367 = 0;
368
369 #else
370
371 #define TDC_PURE_BODY(code)\
372 {\
373 tdc_pure_body();\
374 code\
375 }\
376
377 #endif
378
379 #if TDC_DEBUG_DOT_COMPLETE
380 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1C()
381 {
382 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
383 s.
384 i;
385 }
386 #else
387 #endif
388
389 void tdc_cursor_trace (char* file, int line, char* format, ...);
390 void tdc_trace (char* format, ...);
391 void __declspec(noreturn) tdc_trace_fail (char* format, ...); /*lint -sem(tdc_trace_fail,r_no)*/
392 extern "C" void tdc_usi_trace (char* format, ...);
393 void __declspec(noreturn) tdc_internal_error (char* format, ...); /*lint -sem(tdc_internal_error,r_no)*/
394 void __declspec(noreturn) tdc_user_error (char* format, ...); /*lint -sem(tdc_user_error,r_no)*/
395 void tdc_check_array_assignment(const void* that, const void* address);
396
397 // some error reporting functions, which have no argument becourse they have to be called from a lot of places
398 void __declspec(noreturn) tdc_tbd(char* file, int line); /*lint -sem(tdc_tbd,r_no)*/// this facility is yet to be defined i.e. implemented
399 void __declspec(noreturn) tdc_tbd(char* message); /*lint -sem(tdc_tbd,r_no)*/// this facility is yet to be defined i.e. implemented
400
401 void __declspec(noreturn) tdc_tbd_pointer_assignment_error();
402 void __declspec(noreturn) tdc_tbd_array_assignment_error();
403 void __declspec(noreturn) tdc_tbd_array_assignment_error_T_ARRAY();
404 void __declspec(noreturn) tdc_tbd_xxx_constructor_call(char* message);
405 void __declspec(noreturn) tdc_tbd_constructor_call(char* message);
406 void __declspec(noreturn) tdc_tbd_primitive_union_constructor_call();
407 void __declspec(noreturn) tdc_tbd_message_union_constructor_call();
408
409 void tdc_pure_body();
410 void tdc_dynamic_dead_code(); // program execution is not suposed to reach this point
411 void tdc_missing_h_file(); // use of AIM/SAP not included
412 void tdc_assert(int condition, char* message, char* file, int line);
413
414 //============================================================================
415
416 #if TDC_DEBUG_DOT_COMPLETE
417 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1D()
418 {
419 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
420 s.
421 i;
422 }
423 #else
424 #endif
425
426 //----------------------------------------------------------------------------
427
428 //tdc_test_header_begin
429
430 //----------------------------------------------------------------------------
431 //
432 //----------------------------------------------------------------------------
433 #ifdef M_TDC_DOC
434 /*
435 The definitions in this sections is only present to be able to generate call graphs to be used
436 in documentation (call graphs are generated with SourceInsight 3.5)
437 */
438 /// \defgroup NamingScheme Naming convention template tree
439 //\{
440 /// \callgraph
441 #define BASE() MAIN() PART()
442 #define MAIN() all_unions() PRIM_and_MSG() XXX()
443 #define all_unions() PRMITIVE_UNION() MESSAGE_UNION()
444 #define XXX() XXX_PRMITIVE_UNION() XXX_MESSAGE_UNION()
445 #define PRIM_and_MSG() PRIM() MSG()
446 #define PART() COMP() VAR()
447 #define COMP() STRUCT() UNION()
448 #define VAR() INT() ENUM()
449 #define ENUM() PENUM() MENM()
450 #define PRMITIVE_UNION()
451 #define MESSAGE_UNION()
452 #define XXX_PRMITIVE_UNION()
453 #define XXX_MESSAGE_UNION()
454 #define PRIM()
455 #define MSG()
456 #define STRUCT() PSTRUCT() MSTRUCT()
457 #define UNION() PUNION() PUNION()
458 #define PSTRUCT()
459 #define MSTRUCT()
460 #define PUNION()
461 #define PUNION()
462 #define PENUM()
463 #define MENM()
464 #define INT()
465 //\}
466 // base entries
467 /*
468 #define M_TDC_BASE\
469 M_TDC_FORWARD_BASE(SHORT_NAME, T_HANDLE)\
470 M_TDC_INSTANCE_ADDITIONAL_BASE(IN_CLASS, WITH_BODY, T_INTERFACE_, T_INSTANCE, T_HANDLE_)\
471 M_TDC_INTERFACE_ADDITIONAL_BASE(IN_CLASS, WITH_BODY, T_INTERFACE, T_INSTANCE_, T_HANDLE)\
472 M_TDC_DESCRIPTOR_ADDITIONAL_BASE(SHORT_NAME)\
473 M_TDC_FORWARD_BASE(SHORT_NAME, T_HANDLE)\
474 //*/
475 //TDC keywords
476 void TDC_keywords()
477 {
478 FAIL();
479 PASS();
480 SEND(primitive);
481 AWAIT(primitive);
482 START_TIMEOUT(timeout);
483 WAIT_TIMEOUT();
484 MUTE(timeout);
485 COMMAND(command);
486 TIMEOUT(timeout);
487 PARKING(enable);
488 ALT() //dummy "()"to force call graph
489 {
490 ON(await);
491 OTHERWISE();
492 }
493 TRAP() //dummy "()"to force call graph
494 {
495 }
496 ONFAIL() //dummy "()"to force call graph
497 {
498 }
499 }
500 #endif
501 //----------------------------------------------------------------------------
502
503 #if DOT_COMPLETE_DEFINES
504
505 #define CCC(COMMENT)
506
507 //----------------------------------------------------------------------------
508 // macros to generate dummy functions body
509 //----------------------------------------------------------------------------
510
511 #define M_TDC_TYPE_NAME\
512 //for(;;); /* no error for missing return */
513
514 #define T_TDC_TYPE_NAME
515
516 //----------------------------------------------------------------------------
517 // macros to repeat stuff that is similar in many descriptor classes
518 //----------------------------------------------------------------------------
519
520 #define M_TDC_FORWARD_PRIM(SAP,SHORT_NAME)
521 #define M_TDC_FORWARD_PSTRUCT(SHORT_NAME)
522 #define M_TDC_FORWARD_PUNION(SHORT_NAME)
523 #define M_TDC_FORWARD_SDU(SHORT_NAME)
524 #define M_TDC_FORWARD_PENUM(SHORT_NAME)
525 //-----
526 #define M_TDC_FORWARD_MSG(SHORT_NAME)
527 #define M_TDC_FORWARD_MSTRUCT(SHORT_NAME)
528 #define M_TDC_FORWARD_MUNION(SHORT_NAME)
529 #define M_TDC_FORWARD_MENUM(SHORT_NAME)
530 //-----
531 #define M_TDC_FORWARD_INT(SHORT_NAME)
532 #define M_TDC_FORWARD_XXX_PRIMITIVE_UNION(SAP)
533 #define M_TDC_FORWARD_XXX_MESSAGE_UNION(MSG)
534 #define M_TDC_FORWARD_PRIMITIVE()
535 #define M_TDC_FORWARD_MESSAGE()
536
537 //----------------------------------------------------------------------------
538 // macros to repeat stuff that is similar in many descriptor classes
539 //----------------------------------------------------------------------------
540
541 #define M_TDC_DESCRIPTOR_PRIM_ADDITIONAL(SHORT_NAME)
542 #define M_TDC_DESCRIPTOR_PSTRUCT_ADDITIONAL(SHORT_NAME)
543 #define M_TDC_DESCRIPTOR_PUNION_ADDITIONAL(SHORT_NAME)
544 #define M_TDC_DESCRIPTOR_SDU_ADDITIONAL(SHORT_NAME)
545 #define M_TDC_DESCRIPTOR_PENUM_ADDITIONAL(SHORT_NAME)
546 //-----
547 #define M_TDC_DESCRIPTOR_MSG_ADDITIONAL(SHORT_NAME)
548 #define M_TDC_DESCRIPTOR_MSTRUCT_ADDITIONAL(SHORT_NAME)
549 #define M_TDC_DESCRIPTOR_MUNION_ADDITIONAL(SHORT_NAME)
550 #define M_TDC_DESCRIPTOR_MENUM_ADDITIONAL(SHORT_NAME)
551 //-----
552 #define M_TDC_DESCRIPTOR_INT_ADDITIONAL(SHORT_NAME)
553 #define M_TDC_DESCRIPTOR_XXX_PRIMITIVE_UNION_ADDITIONAL(SAP)
554 #define M_TDC_DESCRIPTOR_XXX_MESSAGE_UNION_ADDITIONAL(MSG)
555 #define M_TDC_CREATE_DEFAULT_PRIMITIVE_DESCRIPTOR_CLASS(SAP)
556 #define M_TDC_DESCRIPTOR_PRIMITIVE_ADDITIONAL()
557 #define M_TDC_CREATE_DEFAULT_MESSAGE_DESCRIPTOR_CLASS(MSG)
558 #define M_TDC_DESCRIPTOR_MESSAGE_ADDITIONAL()
559
560 //----------------------------------------------------------------------------
561 // macros to repeat stuff that is similar in many interface classes
562 //----------------------------------------------------------------------------
563
564 #ifndef TDC_T_TDC_INTERFACE_DOT_COMPLETE_TEST
565 #define TDC_T_TDC_INTERFACE_DOT_COMPLETE_TEST
566 struct T_TDC_INTERFACE_DOT_COMPLETE_TEST
567 {
568 typedef char T_HANDLE;
569 };
570 #endif //TDC_T_TDC_INTERFACE_DOT_COMPLETE_TEST
571
572 //-----
573 #define M_TDC_INTERFACE_PRIM_ADDITIONAL(SHORT_NAME) /*nothing*/
574 #define M_TDC_INTERFACE_PSTRUCT_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME) /*nothing*/
575 #define M_TDC_INTERFACE_PUNION_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME) /*nothing*/
576 #define M_TDC_INTERFACE_SDU_ADDITIONAL(SHORT_NAME) /*nothing*/
577 #define M_TDC_INTERFACE_PENUM_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME) /*nothing*/
578 //-----
579 #define M_TDC_INTERFACE_MSG_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME) /*nothing*/
580 #define M_TDC_INTERFACE_MSTRUCT_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME) /*nothing*/
581 #define M_TDC_INTERFACE_MUNION_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME) /*nothing*/
582 #define M_TDC_INTERFACE_MENUM_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME) /*nothing*/
583 //-----
584 #define M_TDC_INTERFACE_INT_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME) /*nothing*/
585 #define M_TDC_INTERFACE_XXX_PRIMITIVE_UNION_ADDITIONAL(SAP,PREFIXED_SAP) /*nothing*/
586 #define M_TDC_INTERFACE_XXX_MESSAGE_UNION_ADDITIONAL(MSG,PREFIXED_MSG) /*nothing*/
587 #define M_TDC_CREATE_DEFAULT_PRIMITIVE_INTERFACE_CLASS(SAP) /*nothing*/
588 #define M_TDC_INTERFACE_PRIMITIVE_ADDITIONAL() /*nothing*/
589 #define M_TDC_CREATE_DEFAULT_MESSAGE_INTERFACE_CLASS(MSG) /*nothing*/
590 #define M_TDC_INTERFACE_MESSAGE_ADDITIONAL() /*nothing*/
591
592 //----------------------------------------------------------------------------
593 // macros to repeat stuff that is similar in many instance classes
594 //----------------------------------------------------------------------------
595
596 #define M_TDC_INSTANCE_PRIM_ADDITIONAL(SAP,SHORT_NAME) /*nothing*/
597 #define M_TDC_INSTANCE_PSTRUCT_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME) /*nothing*/
598 #define M_TDC_INSTANCE_PUNION_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME) /*nothing*/
599 #define M_TDC_INSTANCE_SDU_ADDITIONAL(SHORT_NAME) /*nothing*/
600 #define M_TDC_INSTANCE_PENUM_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME) /*nothing*/
601 //-----
602 #define M_TDC_INSTANCE_MSG_ADDITIONAL(MSG,SHORT_NAME) /*nothing*/
603 #define M_TDC_INSTANCE_MSTRUCT_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME) /*nothing*/
604 #define M_TDC_INSTANCE_MUNION_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME) /*nothing*/
605 #define M_TDC_INSTANCE_MENUM_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME) /*nothing*/
606 //-----
607 #define M_TDC_INSTANCE_INT_ADDITIONAL(SHORT_NAME) /*nothing*/
608 #define M_TDC_INSTANCE_XXX_PRIMITIVE_ADDITIONAL(SAP) /*nothing*/
609 #define M_TDC_INSTANCE_XXX_MESSAGE_ADDITIONAL(MSG) /*nothing*/
610 #define M_TDC_INSTANCE_PRIMITIVE_ADDITIONAL() /*nothing*/
611 #define M_TDC_INSTANCE_MESSAGE_ADDITIONAL() /*nothing*/
612
613 #else
614 #endif
615
616 //tdc_test_header_end
617
618 #if DOT_COMPLETE_DEFINES
619 #else //DOT_COMPLETE_DEFINES
620
621 #ifndef TDC_KEEP_CCC
622 #define CCC(COMMENT)
623 #endif //TDC_KEEP_CCC
624
625 //----------------------------------------------------------------------------
626 // macros to control namespace
627 //----------------------------------------------------------------------------
628
629 #define M_TDC_ENTER() //TODO namespace TDC {
630 #define M_TDC_LEAVE() //TODO }
631
632 //----------------------------------------------------------------------------
633 // macros to generate dummy functions body
634 //----------------------------------------------------------------------------
635
636 #define M_TDC_TYPE_NAME\
637 return T_TDC_TYPE_NAME();
638
639 //#define T_TDC_TYPE_NAME M_TDC_HIDE(T_TDC_TYPE_NAME)
640
641 //----------------------------------------------------------------------------
642 // macros to hide templates from dot-completion
643 //----------------------------------------------------------------------------
644
645 typedef char T_TDC_LEVEL;
646 extern T_TDC_LEVEL tdc_level;
647
648 //----------------------------------------------------------------------------
649 // macros to repeat stuff that is similar in many descriptor classes
650 //----------------------------------------------------------------------------
651
652 #ifndef TDC_DESCRIPTOR
653
654
655 #define M_TDC_FORWARD_BASE(SHORT_NAME,T_HANDLE)\
656 struct T_TDC_INTERFACE_##SHORT_NAME;\
657 T_TDC_INTERFACE_BASE* new_T_TDC_INTERFACE_##SHORT_NAME();\
658 struct T_HANDLE;\
659 T_TDC_HANDLE_BASE* new_##T_HANDLE();\
660
661 #define M_TDC_FORWARD_COMP(SHORT_NAME,TDC_IS)\
662 M_TDC_FORWARD_BASE(SHORT_NAME, T_TDC_HANDLE_##SHORT_NAME)\
663
664 #define M_TDC_FORWARD_VAR(SHORT_NAME)\
665 M_TDC_FORWARD_BASE(SHORT_NAME, T_TDC_DESCRIPTOR_##SHORT_NAME)\
666
667
668 #define M_TDC_POST_BASE(SHORT_NAME,T_HANDLE)\
669 M_TDC_INTERFACE_ADDITIONAL_BASE (M_TDC_NOT_IN_CLASS, M_TDC_WITH_BODY, T_TDC_INTERFACE_##SHORT_NAME, T_##SHORT_NAME, T_HANDLE)\
670 M_TDC_INSTANCE_ADDITIONAL_BASE (M_TDC_NOT_IN_CLASS, M_TDC_WITH_BODY, T_TDC_INTERFACE_##SHORT_NAME, T_##SHORT_NAME, T_HANDLE)\
671
672 #define M_TDC_POST_XXX(SHORT_NAME,TDC_IS)\
673 M_TDC_POST_BASE(SHORT_NAME, T_TDC_HANDLE_##SHORT_NAME)\
674
675 #define M_TDC_POST_COMP(SHORT_NAME,TDC_IS)\
676 M_TDC_POST_BASE(SHORT_NAME, T_TDC_HANDLE_##SHORT_NAME)\
677
678 #define M_TDC_POST_VAR(SHORT_NAME)\
679 M_TDC_POST_BASE(SHORT_NAME, T_TDC_DESCRIPTOR_##SHORT_NAME)\
680
681
682 #else //TDC_DESCRIPTOR
683
684
685 #define M_TDC_FORWARD_BASE(SHORT_NAME,T_HANDLE)\
686
687 #define M_TDC_FORWARD_COMP(SHORT_NAME,TDC_IS)\
688 M_TDC_FORWARD_DESCRIPTOR_COMP(SHORT_NAME,TDC_IS)\
689
690 // TODO:eliminate forwards: T_##SHORT_NAME and T_TDC_INTERFACE_##SHORT_NAME
691 #define M_TDC_FORWARD_VAR(SHORT_NAME)\
692 M_TDC_FORWARD_BASE(SHORT_NAME,T_TDC_HANDLE_##SHORT_NAME)\
693 struct T_TDC_DESCRIPTOR_##SHORT_NAME;\
694 struct T_##SHORT_NAME;\
695 struct T_TDC_INTERFACE_##SHORT_NAME;\
696 typedef T_TDC_DESCRIPTOR_##SHORT_NAME T_TDC_HANDLE_##SHORT_NAME;\
697 T_TDC_HANDLE_BASE* new_T_TDC_DESCRIPTOR_##SHORT_NAME();\
698
699 #define M_TDC_POST_DESCRIPTOR_BASE(SHORT_NAME,T_HANDLE)\
700 T_TDC_HANDLE_BASE* new_##T_HANDLE()\
701 {\
702 return new T_HANDLE;\
703 }\
704
705 #if TDC_DEBUG_DOT_COMPLETE
706 struct T_TDC_DEBUG_DOT_COMPLETE__TDC_H_6
707 {
708 int i6;
709 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 operator->(){return 0;}
710 };
711
712 inline void dot_complete_test(){
713 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_6 tdc_debug_dot_complete__tdc_h;
714 tdc_debug_dot_complete__tdc_h. i6;
715 tdc_debug_dot_complete__tdc_h-> i;
716 }
717 #else
718 #endif
719
720 #define M_TDC_POST_XXX(SHORT_NAME,TDC_IS)\
721 M_TDC_POST_DESCRIPTOR_BASE(SHORT_NAME,T_TDC_HANDLE_##SHORT_NAME)\
722 T_TDC_DESCRIPTOR_BASE* new_T_TDC_DESCRIPTOR_##SHORT_NAME ()\
723 {\
724 return new T_TDC_DESCRIPTOR_##SHORT_NAME;\
725 }\
726
727 #define M_TDC_POST_COMP(SHORT_NAME, TDC_IS)\
728 M_TDC_POST_DESCRIPTOR_COMP(SHORT_NAME, TDC_IS)\
729
730 #define M_TDC_POST_VAR(SHORT_NAME)\
731 M_TDC_POST_DESCRIPTOR_BASE(SHORT_NAME, T_TDC_DESCRIPTOR_##SHORT_NAME)\
732
733
734 #endif //TDC_DESCRIPTOR
735
736
737 #define M_TDC_FORWARD_DESCRIPTOR_COMP(SHORT_NAME,TDC_IS)\
738 M_TDC_HANDLE(M_TDC_IN_CLASS,M_TDC_WITHOUT_BODY,SHORT_NAME,TDC_IS)\
739
740 #define M_TDC_POST_DESCRIPTOR_COMP(SHORT_NAME, TDC_IS)\
741 M_TDC_POST_DESCRIPTOR_BASE(SHORT_NAME,T_TDC_HANDLE_##SHORT_NAME)\
742 T_TDC_DESCRIPTOR_BASE* T_TDC_HANDLE_##SHORT_NAME::implement_new_descriptor () const\
743 {\
744 return new T_TDC_DESCRIPTOR_##SHORT_NAME;\
745 }\
746 M_TDC_HANDLE_ADDITIONAL(M_TDC_NOT_IN_CLASS,M_TDC_WITH_BODY,T_TDC_HANDLE_##SHORT_NAME,SHORT_NAME,TDC_IS)\
747
748
749 /*lint -emacro(1706,M_TDC_HANDLE_ADDITIONAL)*/ //we don't want M_TDC_NOT(IN_CLASS(...)) for all the scope operators
750 #define M_TDC_HANDLE_ADDITIONAL(IN_CLASS,WITH_BODY,T_HANDLE_,SHORT_NAME,TDC_IS)\
751 IN_CLASS(virtual) char* T_HANDLE_::get_name () const\
752 WITH_BODY({\
753 return #SHORT_NAME;\
754 })\
755 IN_CLASS(virtual) long T_HANDLE_::get_sizeof ()\
756 WITH_BODY({\
757 return sizeof *this;\
758 })\
759 IN_CLASS(virtual) T_TDC_IS_ENUM T_HANDLE_::is ()\
760 WITH_BODY({\
761 return T_TDC_IS_ENUM (TDC_IS_COMP | TDC_IS);\
762 })\
763 IN_CLASS(static) T_TDC_HANDLE_BASE* T_HANDLE_::implement_new_handle ()\
764 WITH_BODY({\
765 return new T_HANDLE_();\
766 })\
767
768 #define M_TDC_HANDLE(IN_CLASS,WITH_BODY,SHORT_NAME,TDC_IS)\
769 struct T_TDC_DESCRIPTOR_##SHORT_NAME;\
770 struct T_TDC_HANDLE_##SHORT_NAME:T_TDC_HANDLE_BASE\
771 {\
772 typedef T_TDC_DESCRIPTOR_##SHORT_NAME T_DESCRIPTOR;\
773 M_TDC_HANDLE_ADDITIONAL(IN_CLASS,WITH_BODY,T_TDC_HANDLE_##SHORT_NAME,SHORT_NAME,TDC_IS)\
774 M_TDC_DESCRIPTOR_HANDLE_ADDITIONAL_PART (T_TDC_DESCRIPTOR_##SHORT_NAME)\
775 protected:\
776 virtual T_TDC_DESCRIPTOR_BASE* implement_new_descriptor () const;\
777 };\
778
779 #if TDC_DEBUG_DOT_COMPLETE
780 inline void dot_complete_test(){
781 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_6 tdc_debug_dot_complete__tdc_h;
782 tdc_debug_dot_complete__tdc_h. i6;
783 tdc_debug_dot_complete__tdc_h-> i;
784 }
785 #else
786 #endif
787
788 //------
789
790 #define M_TDC_FORWARD_PRIM(SHORT_NAME)\
791 M_TDC_FORWARD_COMP (SHORT_NAME,TDC_IS_PRIM)
792
793 #define M_TDC_FORWARD_PSTRUCT(SHORT_NAME)\
794 M_TDC_FORWARD_COMP (SHORT_NAME,TDC_IS_STRUCT)
795
796 #define M_TDC_FORWARD_PUNION(SHORT_NAME)\
797 M_TDC_FORWARD_COMP (SHORT_NAME,TDC_IS_UNION)
798
799 #define M_TDC_FORWARD_SDU(SHORT_NAME)\
800 M_TDC_FORWARD_COMP (SHORT_NAME,TDC_IS_SDU)
801
802 #define M_TDC_FORWARD_TYPEDEF_SDU(BUF)\
803 typedef T_TDC_HANDLE_SDU T_TDC_HANDLE_##BUF;\
804 typedef T_TDC_DESCRIPTOR_SDU T_TDC_DESCRIPTOR_##BUF;\
805
806 /**TODO: eliminate this macro*/
807 #define M_FORWARD_TYPEDEF_SDU(BUF)\
808 M_TDC_FORWARD_TYPEDEF_SDU(BUF)\
809
810 #define M_TDC_FORWARD_TYPEDEF(BASE,SHORT_NAME)\
811 typedef T_TDC_HANDLE_##BASE T_TDC_HANDLE_##SHORT_NAME;\
812 typedef T_TDC_DESCRIPTOR_##BASE T_TDC_DESCRIPTOR_##SHORT_NAME;\
813
814 #define M_TDC_FORWARD_PENUM(SHORT_NAME)\
815 M_TDC_FORWARD_VAR (SHORT_NAME)
816
817 #if TDC_DEBUG_DOT_COMPLETE
818 inline void dot_complete_test(){
819 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_6 tdc_debug_dot_complete__tdc_h;
820 tdc_debug_dot_complete__tdc_h. i6;
821 tdc_debug_dot_complete__tdc_h-> i;
822 }
823 #else
824 #endif
825
826 //------
827
828 #define M_TDC_FORWARD_MSG(SHORT_NAME)\
829 M_TDC_FORWARD_COMP (SHORT_NAME,TDC_IS_MSG)
830
831 #define M_TDC_FORWARD_MSTRUCT(SHORT_NAME)\
832 M_TDC_FORWARD_COMP (SHORT_NAME,TDC_IS_STRUCT)
833
834 #define M_TDC_FORWARD_MUNION(SHORT_NAME)\
835 M_TDC_FORWARD_COMP (SHORT_NAME,TDC_IS_UNION)
836
837 #define M_TDC_FORWARD_MENUM(SHORT_NAME)\
838 M_TDC_FORWARD_VAR (SHORT_NAME)
839
840 //------
841
842 #define M_TDC_FORWARD_INT(SHORT_NAME)\
843 M_TDC_FORWARD_BASE(SHORT_NAME, T_TDC_DESCRIPTOR_##SHORT_NAME)\
844 struct T_TDC_DESCRIPTOR_##SHORT_NAME;\
845 typedef T_TDC_DESCRIPTOR_##SHORT_NAME T_TDC_HANDLE_##SHORT_NAME;\
846 typedef T_TDC_INT_##SHORT_NAME SHORT_NAME;\
847 T_TDC_HANDLE_BASE* new_T_TDC_DESCRIPTOR_##SHORT_NAME();\
848
849 #if TDC_DEBUG_DOT_COMPLETE
850 inline void dot_complete_test(){
851 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_6 tdc_debug_dot_complete__tdc_h;
852 tdc_debug_dot_complete__tdc_h. i6;
853 tdc_debug_dot_complete__tdc_h-> i;
854 }
855 #else
856 #endif
857
858 #define M_TDC_FORWARD_XXX_PRIMITIVE_UNION(SAP)\
859 M_TDC_FORWARD_BASE (SAP, T_TDC_HANDLE_##SAP)\
860
861 #define M_TDC_FORWARD_XXX_MESSAGE_UNION(MSG)\
862 M_TDC_FORWARD_BASE (MSG,T_TDC_HANDLE_##MSG)\
863
864 #if TDC_DEBUG_DOT_COMPLETE
865 inline void dot_complete_test(){
866 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_6 tdc_debug_dot_complete__tdc_h;
867 tdc_debug_dot_complete__tdc_h. i6;
868 tdc_debug_dot_complete__tdc_h-> i;
869 }
870 #else
871 #endif
872
873 //----------------------------------------------------------------------------
874 // macros to repeat stuff that is similar in many descriptor classes
875 //----------------------------------------------------------------------------
876
877 #define M_TDC_POST_PRIM(SHORT_NAME)\
878 M_TDC_POST_COMP (SHORT_NAME, TDC_IS_PRIM)
879
880 #define M_TDC_POST_PSTRUCT(SHORT_NAME)\
881 M_TDC_POST_COMP (SHORT_NAME, TDC_IS_STRUCT)
882
883 #define M_TDC_POST_PUNION(SHORT_NAME)\
884 M_TDC_POST_COMP (SHORT_NAME, TDC_IS_UNION)
885
886 #define M_TDC_POST_SDU(SHORT_NAME)
887
888 #define M_TDC_POST_PENUM(SHORT_NAME)\
889 M_TDC_POST_VAR (SHORT_NAME)
890
891 #define M_TDC_POST_MSG(SHORT_NAME)\
892 M_TDC_POST_COMP (SHORT_NAME, TDC_IS_MSG)
893
894 #define M_TDC_POST_MSTRUCT(SHORT_NAME)\
895 M_TDC_POST_COMP (SHORT_NAME, TDC_IS_STRUCT)
896
897 #define M_TDC_POST_MUNION(SHORT_NAME)\
898 M_TDC_POST_COMP (SHORT_NAME, TDC_IS_UNION)
899
900 #define M_TDC_POST_MENUM(SHORT_NAME)\
901 M_TDC_POST_VAR (SHORT_NAME)
902
903 #define M_TDC_POST_INT(SHORT_NAME)
904
905 #define M_TDC_POST_XXX_PRIMITIVE_UNION(SAP)\
906 M_TDC_POST_XXX(SAP,TDC_IS_XXX_PRIMITIE_UNION)
907
908 #define M_TDC_POST_XXX_MESSAGE_UNION(MSG)\
909 M_TDC_POST_XXX(MSG,TDC_IS_XXX_MESSAGE_UNION)
910
911 #define M_TDC_POST_PRIMITIVE()
912
913 #define M_TDC_POST_MESSAGE()
914
915 #if TDC_DEBUG_DOT_COMPLETE
916 inline void dot_complete_test(){
917 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_6 tdc_debug_dot_complete__tdc_h;
918 tdc_debug_dot_complete__tdc_h. i6;
919 tdc_debug_dot_complete__tdc_h-> i;
920 }
921
922 struct T_TDC_DEBUG_DOT_COMPLETE__TDC_H_5
923 {
924 int i5;
925 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 operator->(){return 0;}
926 };
927
928 inline void dot_complete_test(){
929 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_5 tdc_debug_dot_complete__tdc_h;
930 tdc_debug_dot_complete__tdc_h. i4;
931 tdc_debug_dot_complete__tdc_h-> i;
932 }
933 #else
934 #endif
935
936 //============================================================================
937
938 #if TDC_DEBUG_DOT_COMPLETE
939 struct T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1F
940 {
941 int i1F;
942 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 operator->(){return 0;}
943 };
944 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1F()
945 {
946 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
947 s.
948 i;
949 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1F s1F;
950 s1F->
951 i0;
952 }
953 #else
954 #endif
955
956 //----------------------------------------------------------------------------
957 /// \defgroup M_TDC_DESCRIPTOR M_TDC_DESCRIPTOR
958 /// macros to repeat stuff that is similar in many descriptor classes
959 //----------------------------------------------------------------------------
960 //\{
961
962 /** declare action and description elements that are accessed through typecast to stencil */
963 #define M_TDC_DESCRIPTOR_HANDLE_ADDITIONAL_PART(T_DESCRIPTOR)\
964 T_TDC_ACTION_ENUM action TDC_LINT_UNUSED_MEMBER;\
965 T_DESCRIPTOR* descriptor TDC_LINT_UNUSED_MEMBER;\
966
967 #define M_TDC_DESCRIPTOR_ADDITIONAL_BASE(SHORT_NAME)\
968 private:\
969 virtual long get_sizeof ()\
970 {\
971 return sizeof *this;\
972 }\
973
974 #define M_TDC_DESCRIPTOR_ADDITIONAL_MAIN_BASE(SHORT_NAME)\
975 M_TDC_DESCRIPTOR_ADDITIONAL_BASE(SHORT_NAME)\
976 public:\
977 int ctrl;\
978 virtual int read_ctrl () const\
979 {\
980 return ctrl;\
981 }\
982 T_TDC_HANDLE_BASE* get_element (unsigned index)\
983 {\
984 return implement_get_union_element (index, ctrl);\
985 }\
986 virtual char* get_name () const\
987 {\
988 return #SHORT_NAME;\
989 }\
990 T_TDC_DESCRIPTOR_##SHORT_NAME ():\
991 ctrl (0)\
992 {\
993 }\
994
995
996 #define M_TDC_DESCRIPTOR_ADDITIONAL_STRUCT_BASE(SHORT_NAME)\
997 M_TDC_DESCRIPTOR_ADDITIONAL_BASE(SHORT_NAME)\
998 public:\
999 typedef T_TDC_HANDLE_##SHORT_NAME T_HANDLE;\
1000 virtual char* get_name () const\
1001 {\
1002 extern char* TDC_NAME_##SHORT_NAME;\
1003 return TDC_NAME_##SHORT_NAME;\
1004 }\
1005 friend T_TDC_DESCRIPTOR_BASE* new_T_TDC_DESCRIPTOR_##SHORT_NAME ()\
1006 {\
1007 return new T_TDC_DESCRIPTOR_##SHORT_NAME;\
1008 }\
1009 T_TDC_DESCRIPTOR_##SHORT_NAME ()\
1010 {\
1011 }\
1012
1013 #define M_TDC_DESCRIPTOR_ADDITIONAL_UNION_BASE(SHORT_NAME,TABLE_KIND)\
1014 M_TDC_DESCRIPTOR_ADDITIONAL_BASE(SHORT_NAME)\
1015 public:\
1016 typedef T_TDC_HANDLE_##SHORT_NAME T_HANDLE;\
1017 int ctrl;\
1018 virtual int read_ctrl () const\
1019 {\
1020 return ctrl;\
1021 }\
1022 T_TDC_HANDLE_BASE* get_element (unsigned index)\
1023 {\
1024 return implement_get_union_element (index, ctrl);\
1025 }\
1026 virtual char* get_name () const\
1027 {\
1028 extern char* TDC_NAME_##SHORT_NAME;\
1029 return TDC_NAME_##SHORT_NAME;\
1030 }\
1031 T_TDC_DESCRIPTOR_##SHORT_NAME ():\
1032 ctrl (0)\
1033 {\
1034 }\
1035
1036 /**
1037 * \todo move get_tap_handle() to var base class
1038 */
1039 #define M_TDC_DESCRIPTOR_ADDITIONAL_VAR(T_DESCRIPTOR, T_VAR, SHORT_NAME)\
1040 M_TDC_DESCRIPTOR_ADDITIONAL_BASE(SHORT_NAME)\
1041 public:\
1042 typedef T_DESCRIPTOR T_HANDLE;\
1043 T_TDC_ACTION_ENUM action;\
1044 union \
1045 {\
1046 T_VAR value;\
1047 T_TDC_BASIC_TYPES value_as_basic_types;\
1048 };\
1049 virtual char* get_name () const\
1050 {\
1051 extern char* TDC_NAME_##SHORT_NAME;\
1052 return TDC_NAME_##SHORT_NAME;\
1053 }\
1054 T_DESCRIPTOR ():\
1055 action (TDC_ACTION_DEFAULT)\
1056 {\
1057 }\
1058 virtual unsigned get_sizeof_target ()\
1059 {\
1060 return sizeof T_VAR;\
1061 }\
1062 static T_TDC_HANDLE_BASE* implement_new_handle ()\
1063 {\
1064 return new_##T_DESCRIPTOR();\
1065 }\
1066
1067 //-----
1068
1069 #define M_TDC_DESCRIPTOR_INT_ADDITIONAL(SHORT_NAME)\
1070 M_TDC_DESCRIPTOR_ADDITIONAL_VAR (T_TDC_DESCRIPTOR_##SHORT_NAME, T_TDC_INT_##SHORT_NAME,SHORT_NAME)\
1071 virtual T_TDC_IS_ENUM is ()\
1072 {\
1073 return TDC_IS_VAR;\
1074 }\
1075
1076 //-----
1077
1078 #define M_TDC_DESCRIPTOR_PRIM_ADDITIONAL(SHORT_NAME)\
1079 M_TDC_DESCRIPTOR_ADDITIONAL_STRUCT_BASE (SHORT_NAME)\
1080 virtual int get_id () const\
1081 {\
1082 return SHORT_NAME;\
1083 }\
1084
1085 #define M_TDC_DESCRIPTOR_PSTRUCT_ADDITIONAL(SHORT_NAME)\
1086 M_TDC_DESCRIPTOR_ADDITIONAL_STRUCT_BASE (SHORT_NAME)\
1087
1088 #define M_TDC_DESCRIPTOR_PUNION_ADDITIONAL(SHORT_NAME)\
1089 M_TDC_DESCRIPTOR_ADDITIONAL_UNION_BASE (SHORT_NAME,TDC_TABLE_KIND_PRIM)\
1090
1091 #define M_TDC_DESCRIPTOR_SDU_ADDITIONAL(SHORT_NAME)\
1092 M_TDC_DESCRIPTOR_ADDITIONAL_UNION_BASE (SHORT_NAME,TDC_TABLE_KIND_PRIM)\
1093
1094 #define M_TDC_DESCRIPTOR_PENUM_ADDITIONAL(SHORT_NAME)\
1095 M_TDC_DESCRIPTOR_ADDITIONAL_VAR (T_TDC_DESCRIPTOR_##SHORT_NAME, T_TDC_ENUM_##SHORT_NAME,SHORT_NAME)\
1096 friend T_TDC_HANDLE_BASE* new_T_TDC_DESCRIPTOR_##SHORT_NAME ();\
1097
1098 //-----
1099
1100 #define M_TDC_DESCRIPTOR_MSG_ADDITIONAL(SHORT_NAME)\
1101 M_TDC_DESCRIPTOR_ADDITIONAL_STRUCT_BASE (SHORT_NAME)\
1102 virtual int get_id () const\
1103 {\
1104 return SHORT_NAME;\
1105 }\
1106
1107 #define M_TDC_DESCRIPTOR_MSTRUCT_ADDITIONAL(SHORT_NAME)\
1108 M_TDC_DESCRIPTOR_ADDITIONAL_STRUCT_BASE (SHORT_NAME)\
1109
1110 #define M_TDC_DESCRIPTOR_MUNION_ADDITIONAL(SHORT_NAME)\
1111 M_TDC_DESCRIPTOR_ADDITIONAL_UNION_BASE (SHORT_NAME,TDC_TABLE_KIND_MSG)\
1112
1113 #define M_TDC_DESCRIPTOR_MENUM_ADDITIONAL(SHORT_NAME)\
1114 M_TDC_DESCRIPTOR_ADDITIONAL_VAR (T_TDC_DESCRIPTOR_##SHORT_NAME, T_TDC_ENUM_##SHORT_NAME,SHORT_NAME)\
1115 friend T_TDC_HANDLE_BASE* new_T_TDC_DESCRIPTOR_##SHORT_NAME ();\
1116
1117 //-----
1118
1119 #define M_TDC_DESCRIPTOR_XXX_PRIMITIVE_UNION_ADDITIONAL(SAP)\
1120 M_TDC_DESCRIPTOR_ADDITIONAL_MAIN_BASE (SAP)\
1121
1122 #define M_TDC_DESCRIPTOR_XXX_MESSAGE_UNION_ADDITIONAL(MSG)\
1123 M_TDC_DESCRIPTOR_ADDITIONAL_MAIN_BASE (MSG)\
1124 virtual int get_id () const\
1125 {\
1126 return CCDENT_##MSG;\
1127 }\
1128
1129 #ifdef TDC_LIB_MAIN_DSC
1130 #define IF_TDC_LIB_MAIN_DSC(code) code
1131 #else
1132 #define IF_TDC_LIB_MAIN_DSC(code)
1133 #endif
1134
1135 #define M_TDC_CREATE_DEFAULT_DESCRIPTOR_CLASS(SHORT_NAME, TDC_IS)\
1136 struct T_TDC_DESCRIPTOR_##SHORT_NAME;\
1137 struct T_TDC_HANDLE_##SHORT_NAME:T_TDC_HANDLE_BASE\
1138 {\
1139 typedef T_TDC_DESCRIPTOR_##SHORT_NAME T_DESCRIPTOR;\
1140 M_TDC_HANDLE_ADDITIONAL(M_TDC_IN_CLASS,M_TDC_WITH_BODY,T_TDC_HANDLE_##SHORT_NAME,SHORT_NAME,TDC_IS)\
1141 M_TDC_DESCRIPTOR_HANDLE_ADDITIONAL_PART (T_TDC_DESCRIPTOR_##SHORT_NAME)\
1142 protected:\
1143 static T_TDC_NEW_DESCRIPTOR new_descriptor;\
1144 virtual T_TDC_DESCRIPTOR_BASE* implement_new_descriptor () const\
1145 {\
1146 return call_implement_new_descriptor(new_descriptor);\
1147 }\
1148 friend char set_new_descriptor_T_TDC_HANDLE_##SHORT_NAME()\
1149 {\
1150 extern T_TDC_DESCRIPTOR_BASE* new_T_TDC_DESCRIPTOR_##SHORT_NAME ();\
1151 new_descriptor = new_T_TDC_DESCRIPTOR_##SHORT_NAME;\
1152 return 1;\
1153 }\
1154 };\
1155 T_TDC_HANDLE_BASE* new_T_TDC_HANDLE_##SHORT_NAME();\
1156 M_TDC_XXX_PRIMITIVE_UNION_ADDITIONAL_INLINE_1(SHORT_NAME,SHORT_NAME)\
1157 IF_TDC_LIB_MAIN_DSC(T_TDC_NEW_DESCRIPTOR T_TDC_HANDLE_##SHORT_NAME::new_descriptor;)\
1158
1159 #define M_TDC_CREATE_DEFAULT_PRIMITIVE_DESCRIPTOR_CLASS(SAP)\
1160 M_TDC_CREATE_DEFAULT_DESCRIPTOR_CLASS(SAP##_PRIMITIVE_UNION,TDC_IS_XXX_PRIMITIVE_UNION)\
1161
1162 #define M_TDC_CREATE_DEFAULT__T_TDC_HANDLE_XXX_PRIMITIVE_UNION(SAP,CCDSAP)\
1163 M_TDC_CREATE_DEFAULT_DESCRIPTOR_CLASS(SAP##_PRIMITIVE_UNION,TDC_IS_XXX_PRIMITIVE_UNION)\
1164
1165 #define M_TDC_DESCRIPTOR_PRIMITIVE_ADDITIONAL()\
1166 M_TDC_DESCRIPTOR_ADDITIONAL_MAIN_BASE (PRIMITIVE_UNION)\
1167
1168 #define M_TDC_CREATE_DEFAULT_MESSAGE_DESCRIPTOR_CLASS(MSG)\
1169 M_TDC_CREATE_DEFAULT_DESCRIPTOR_CLASS(MSG##_MESSAGE_UNION,TDC_IS_XXX_MESSAGE_UNION)\
1170 enum { CCDENT_##MSG##_MESSAGE_UNION = CCDENT_##MSG };\
1171
1172 #define M_TDC_CREATE_DEFAULT__T_TDC_HANDLE_XXX_MESSAGE_UNION(MSG,CCDENT)\
1173 M_TDC_CREATE_DEFAULT_MESSAGE_DESCRIPTOR_CLASS(MSG)
1174
1175 #define M_TDC_DESCRIPTOR_MESSAGE_ADDITIONAL()\
1176 M_TDC_DESCRIPTOR_ADDITIONAL_MAIN_BASE (MESSAGE_UNION)\
1177
1178 //\}
1179 //============================================================================
1180
1181 #if TDC_DEBUG_DOT_COMPLETE
1182 struct T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1H
1183 {
1184 int i1H;
1185 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 operator->(){return 0;}
1186 };
1187 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1H()
1188 {
1189 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
1190 s.
1191 i;
1192 s->
1193 i0;
1194 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1H s1H;
1195 s1H->
1196 i0;
1197 }
1198 #else
1199 #endif
1200
1201 //----------------------------------------------------------------------------
1202 /// \defgroup M_TDC_INTERFACE
1203 // macros to repeat stuff that is similar in many inteface classes
1204 //----------------------------------------------------------------------------
1205 //\{
1206
1207 /**
1208 * should these functions return T_RETURN / *this instead?
1209 */
1210 #define M_TDC_ADDITIONAL_CALL_FUNCTION_BASE(IN_CLASS, WITH_BODY, T_SCOPE,T_RETURN,T_ARG)\
1211 void T_SCOPE::operator = (T_ARG (*f) ())\
1212 WITH_BODY({\
1213 T_ARG value_ = f ();\
1214 set_value (value_);\
1215 TDC_LINT_UNASSIGNED_MEMBER\
1216 })\
1217 void T_SCOPE::operator = (void (*f) (T_ARG))\
1218 WITH_BODY({\
1219 T_ARG value_;\
1220 f (value_);\
1221 set_value (value_);\
1222 TDC_LINT_UNASSIGNED_MEMBER\
1223 })\
1224
1225 #define M_TDC_INTERFACE_ADDITIONAL_BASE(IN_CLASS, WITH_BODY, T_INTERFACE, T_INSTANCE_, T_HANDLE)\
1226 IN_CLASS(typedef T_INSTANCE_ T_INSTANCE;)\
1227 IN_CLASS(friend struct T_INSTANCE_;)\
1228 IN_CLASS(private:)\
1229 void T_INTERFACE::set_value (const T_INSTANCE_& value_)\
1230 WITH_BODY({\
1231 copy_instance ((const T_TDC_INSTANCE_BASE*)&value_);\
1232 })\
1233 IN_CLASS(explicit) T_INTERFACE::T_INTERFACE (const T_INTERFACE& value_)\
1234 WITH_BODY({\
1235 copy_interface (&value_);\
1236 TDC_LINT_UNCOPIED_BASE\
1237 })\
1238 IN_CLASS(public:)\
1239 void T_INTERFACE::operator = (const T_TDC_ACTION& action_)\
1240 WITH_BODY({\
1241 set_action (action_);\
1242 TDC_LINT_UNASSIGNED_MEMBER\
1243 })\
1244 void T_INTERFACE::operator = (const T_INTERFACE& value_)\
1245 WITH_BODY({\
1246 copy_interface (&value_);\
1247 TDC_LINT_NO_SELFASSIGN_TEST\
1248 TDC_LINT_UNASSIGNED_MEMBER\
1249 })\
1250 T_INSTANCE_ T_INTERFACE::operator = (const T_INSTANCE_& value_)\
1251 WITH_BODY({\
1252 copy_instance (&value_);\
1253 return value_;\
1254 TDC_LINT_UNASSIGNED_MEMBER\
1255 })\
1256 IN_CLASS(static) T_TDC_HANDLE_BASE* T_INTERFACE::implement_new_handle ()\
1257 WITH_BODY({\
1258 return new_##T_HANDLE();\
1259 })\
1260 IN_CLASS(friend) T_TDC_INTERFACE_BASE* new_##T_INTERFACE()\
1261 WITH_BODY({\
1262 return new T_INTERFACE;\
1263 })\
1264 M_TDC_ADDITIONAL_CALL_FUNCTION_BASE(IN_CLASS, WITH_BODY, T_INTERFACE,T_INSTANCE,T_INSTANCE)\
1265
1266 #define M_TDC_INTERFACE_ADDITIONAL_MAIN(IN_CLASS, WITH_BODY, SHORT_NAME,PREFIXED_SHORT_NAME, BASE)\
1267 public:\
1268 void operator = (const T_TDC_INTERFACE_##BASE##_BASE& value_)\
1269 {\
1270 set_main_value (&value_);\
1271 }\
1272 void operator = (const T_TDC_INSTANCE_##BASE##_BASE& value_)\
1273 {\
1274 set_main_value (&value_);\
1275 }\
1276 T_TDC_INTERFACE_##PREFIXED_SHORT_NAME ()\
1277 {\
1278 tdc_level--;\
1279 }\
1280 M_TDC_INTERFACE_ADDITIONAL_BASE (IN_CLASS, WITH_BODY, T_TDC_INTERFACE_##PREFIXED_SHORT_NAME, T_##SHORT_NAME, T_TDC_HANDLE_##PREFIXED_SHORT_NAME)
1281
1282 #define M_TDC_INTERFACE_ADDITIONAL_COMP(IN_CLASS, WITH_BODY, SHORT_NAME, PREFIXED_SHORT_NAME)\
1283 public:\
1284 T_TDC_INTERFACE_##PREFIXED_SHORT_NAME ()\
1285 {\
1286 tdc_level--;\
1287 }\
1288 M_TDC_INTERFACE_ADDITIONAL_BASE (IN_CLASS, WITH_BODY, T_TDC_INTERFACE_##PREFIXED_SHORT_NAME, T_##SHORT_NAME, T_TDC_HANDLE_##PREFIXED_SHORT_NAME)
1289
1290 #define M_TDC_INTERFACE_ADDITIONAL_VAR(IN_CLASS, WITH_BODY, SHORT_NAME, PREFIXED_SHORT_NAME)\
1291 public:\
1292 T_TDC_INTERFACE_##PREFIXED_SHORT_NAME ()\
1293 {\
1294 }\
1295 M_TDC_INTERFACE_ADDITIONAL_BASE (IN_CLASS, WITH_BODY, T_TDC_INTERFACE_##PREFIXED_SHORT_NAME, T_##SHORT_NAME, T_TDC_HANDLE_##PREFIXED_SHORT_NAME)
1296
1297 #define M_TDC_INTERFACE_INT_ADDITIONAL(SHORT_NAME)\
1298 public:\
1299 void operator = (int value_)\
1300 {\
1301 set_descriptor_value (value_);\
1302 }\
1303 M_TDC_INTERFACE_ADDITIONAL_VAR (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SHORT_NAME, SHORT_NAME)\
1304
1305 #define M_TDC_INTERFACE_ADDITIONAL_ENUM(IN_CLASS, WITH_BODY, SHORT_NAME, PREFIXED_SHORT_NAME)\
1306 public:\
1307 void set_value (int value_)\
1308 {\
1309 set_descriptor_value (value_);\
1310 }\
1311 void operator = (int value_)\
1312 {\
1313 set_descriptor_value (value_);\
1314 }\
1315 void set_value (const T_TDC_INSTANCE_INT_BASE &value_)\
1316 {\
1317 copy_instance (&value_);\
1318 }\
1319 void operator = (const T_TDC_INSTANCE_INT_BASE &value_)\
1320 {\
1321 copy_instance (&value_);\
1322 }\
1323 M_TDC_INTERFACE_ADDITIONAL_VAR (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SHORT_NAME, PREFIXED_SHORT_NAME)\
1324
1325 #define M_TDC_INTERFACE_ADDITIONAL_MAIN_CALL(IN_CLASS, WITH_BODY, SHORT_NAME,PREFIXED_SHORT_NAME,T_ARG)\
1326 T_##SHORT_NAME operator = (const T_ARG& value_)\
1327 {\
1328 set_value (value_);\
1329 return value_;\
1330 TDC_LINT_UNASSIGNED_MEMBER\
1331 }\
1332
1333 //-----
1334
1335 #define M_TDC_INTERFACE_PRIM_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME)\
1336 M_TDC_INTERFACE_ADDITIONAL_MAIN (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SHORT_NAME,PREFIXED_SHORT_NAME, PRIMITIVE)\
1337 M_TDC_INTERFACE_ADDITIONAL_MAIN_CALL (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SHORT_NAME,PREFIXED_SHORT_NAME, T_PRIMITIVE_UNION)\
1338
1339 #define M_TDC_INTERFACE_PSTRUCT_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME)\
1340 M_TDC_INTERFACE_ADDITIONAL_COMP (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1341
1342 #define M_TDC_INTERFACE_PUNION_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME)\
1343 M_TDC_INTERFACE_ADDITIONAL_COMP (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1344
1345 #define M_TDC_INTERFACE_PENUM_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME)\
1346 M_TDC_INTERFACE_ADDITIONAL_ENUM (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1347
1348 //-----
1349
1350 #define M_TDC_INTERFACE_MSG_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME)\
1351 M_TDC_INTERFACE_ADDITIONAL_MAIN (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SHORT_NAME,PREFIXED_SHORT_NAME, MESSAGE)\
1352 M_TDC_INTERFACE_ADDITIONAL_MAIN_CALL (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SHORT_NAME,PREFIXED_SHORT_NAME, T_MESSAGE_UNION)\
1353
1354 #define M_TDC_INTERFACE_MSTRUCT_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME)\
1355 M_TDC_INTERFACE_ADDITIONAL_COMP (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1356
1357 #define M_TDC_INTERFACE_MUNION_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME)\
1358 M_TDC_INTERFACE_ADDITIONAL_COMP (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1359
1360 #define M_TDC_INTERFACE_MENUM_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME)\
1361 M_TDC_INTERFACE_ADDITIONAL_ENUM (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1362
1363 //-----
1364
1365 #define M_TDC_INTERFACE_PRIM_ADDITIONAL_INLINE(SHORT_NAME,PREFIXED_SHORT_NAME)\
1366 M_TDC_INTERFACE_ADDITIONAL_MAIN (M_TDC_IN_CLASS, M_TDC_WITH_BODY, SHORT_NAME,PREFIXED_SHORT_NAME, PRIMITIVE)\
1367 M_TDC_INTERFACE_ADDITIONAL_MAIN_CALL (M_TDC_IN_CLASS, M_TDC_WITH_BODY, SHORT_NAME,PREFIXED_SHORT_NAME, T_PRIMITIVE_UNION)\
1368
1369 #define M_TDC_INTERFACE_PSTRUCT_ADDITIONAL_INLINE(SHORT_NAME,PREFIXED_SHORT_NAME)\
1370 M_TDC_INTERFACE_ADDITIONAL_COMP (M_TDC_IN_CLASS, M_TDC_WITH_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1371
1372 #define M_TDC_INTERFACE_PUNION_ADDITIONAL_INLINE(SHORT_NAME,PREFIXED_SHORT_NAME)\
1373 M_TDC_INTERFACE_ADDITIONAL_COMP (M_TDC_IN_CLASS, M_TDC_WITH_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1374
1375 #define M_TDC_INTERFACE_SDU_ADDITIONAL_INLINE(SHORT_NAME)\
1376 M_TDC_INTERFACE_ADDITIONAL_COMP (M_TDC_IN_CLASS, M_TDC_WITH_BODY, SHORT_NAME,SHORT_NAME)
1377
1378 #define M_TDC_INTERFACE_PENUM_ADDITIONAL_INLINE(SHORT_NAME,PREFIXED_SHORT_NAME)\
1379 M_TDC_INTERFACE_ADDITIONAL_ENUM (M_TDC_IN_CLASS, M_TDC_WITH_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1380
1381 //-----
1382
1383 #define M_TDC_INTERFACE_MSG_ADDITIONAL_INLINE(SHORT_NAME,PREFIXED_SHORT_NAME)\
1384 M_TDC_INTERFACE_ADDITIONAL_MAIN (M_TDC_IN_CLASS, M_TDC_WITH_BODY, SHORT_NAME,PREFIXED_SHORT_NAME, MESSAGE)\
1385 M_TDC_INTERFACE_ADDITIONAL_MAIN_CALL (M_TDC_IN_CLASS, M_TDC_WITH_BODY, SHORT_NAME,PREFIXED_SHORT_NAME, T_MESSAGE_UNION)\
1386
1387 #define M_TDC_INTERFACE_MSTRUCT_ADDITIONAL_INLINE(SHORT_NAME,PREFIXED_SHORT_NAME)\
1388 M_TDC_INTERFACE_ADDITIONAL_COMP (M_TDC_IN_CLASS, M_TDC_WITH_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1389
1390 #define M_TDC_INTERFACE_MUNION_ADDITIONAL_INLINE(SHORT_NAME,PREFIXED_SHORT_NAME)\
1391 M_TDC_INTERFACE_ADDITIONAL_COMP (M_TDC_IN_CLASS, M_TDC_WITH_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1392
1393 #define M_TDC_INTERFACE_MENUM_ADDITIONAL_INLINE(SHORT_NAME,PREFIXED_SHORT_NAME)\
1394 M_TDC_INTERFACE_ADDITIONAL_ENUM (M_TDC_IN_CLASS, M_TDC_WITH_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1395
1396 //-----
1397
1398 #define M_TDC_INTERFACE_ADDITIONAL_MAIN_XXX(M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY,XXX,PREFIXED_XXX)\
1399 private:\
1400 T_TDC_INTERFACE_##XXX (const T_TDC_INTERFACE_PRIMITIVE_BASE& primitive)\
1401 {\
1402 tdc_tbd_xxx_constructor_call(#XXX);\
1403 }\
1404
1405 #define M_TDC_INTERFACE_XXX_PRIMITIVE_UNION_ADDITIONAL(SAP,PREFIXED_SAP)\
1406 M_TDC_INTERFACE_ADDITIONAL_MAIN (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SAP,PREFIXED_SAP, PRIMITIVE)\
1407 M_TDC_INTERFACE_ADDITIONAL_MAIN_CALL (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SAP,PREFIXED_SAP, T_PRIMITIVE_UNION)\
1408 M_TDC_INTERFACE_ADDITIONAL_MAIN_XXX (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SAP,PREFIXED_SAP)\
1409 public:\
1410
1411 #define M_TDC_INTERFACE_XXX_PRIMITIVE_UNION_ADDITIONAL_INLINE(SAP,PREFIXED_SAP)\
1412 M_TDC_INTERFACE_ADDITIONAL_MAIN (M_TDC_IN_CLASS, M_TDC_WITH_BODY, SAP,PREFIXED_SAP, PRIMITIVE)\
1413 M_TDC_INTERFACE_ADDITIONAL_MAIN_CALL (M_TDC_IN_CLASS, M_TDC_WITH_BODY, SAP,PREFIXED_SAP, T_PRIMITIVE_UNION)\
1414 M_TDC_INTERFACE_ADDITIONAL_MAIN_XXX (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SAP,PREFIXED_SAP)\
1415 public:\
1416
1417 #define M_TDC_INTERFACE_XXX_MESSAGE_UNION_ADDITIONAL(MSG,PREFIXED_MSG)\
1418 M_TDC_INTERFACE_ADDITIONAL_MAIN (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, MSG, PREFIXED_MSG, MESSAGE)\
1419 M_TDC_INTERFACE_ADDITIONAL_MAIN_CALL (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, MSG, PREFIXED_MSG, T_MESSAGE_UNION)\
1420 M_TDC_INTERFACE_ADDITIONAL_MAIN_XXX (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, MSG,PREFIXED_MSG)\
1421 public:\
1422
1423 #define M_TDC_INTERFACE_XXX_MESSAGE_UNION_ADDITIONAL_INLINE(MSG,PREFIXED_MSG)\
1424 M_TDC_INTERFACE_ADDITIONAL_MAIN (M_TDC_IN_CLASS, M_TDC_WITH_BODY, MSG, PREFIXED_MSG, MESSAGE)\
1425 M_TDC_INTERFACE_ADDITIONAL_MAIN_CALL (M_TDC_IN_CLASS, M_TDC_WITH_BODY, MSG, PREFIXED_MSG, T_MESSAGE_UNION)\
1426 M_TDC_INTERFACE_ADDITIONAL_MAIN_XXX (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, MSG,PREFIXED_MSG)\
1427 public:\
1428
1429 #define M_TDC_CREATE_DEFAULT_INTERFACE_CLASS(SHORT_NAME)\
1430 struct T_TDC_INTERFACE_##SHORT_NAME;\
1431 struct T_TDC_HANDLE_##SHORT_NAME;\
1432
1433 #define M_TDC_CREATE_DEFAULT_PRIMITIVE_INTERFACE_CLASS(SAP)\
1434 M_TDC_CREATE_DEFAULT_INTERFACE_CLASS(SAP##_PRIMITIVE_UNION)\
1435
1436 #define M_TDC_CREATE_DEFAULT__T_TDC_INTERFACE_XXX_PRIMITIVE_UNION(SAP,CCDSAP)\
1437 enum { CCDSAP_##SAP = CCDSAP };\
1438 M_TDC_CREATE_DEFAULT_INTERFACE_CLASS(SAP##_PRIMITIVE_UNION)\
1439
1440 #define M_TDC_INTERFACE_PRIMITIVE_ADDITIONAL()\
1441 M_TDC_INTERFACE_ADDITIONAL_MAIN (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, PRIMITIVE_UNION, PRIMITIVE_UNION, PRIMITIVE)\
1442 private:\
1443 T_TDC_INTERFACE_PRIMITIVE_UNION (const T_TDC_INTERFACE_PRIMITIVE_BASE& primitive)\
1444 {\
1445 tdc_tbd_primitive_union_constructor_call();\
1446 }\
1447 public:\
1448
1449 #define M_TDC_INTERFACE_PRIMITIVE_ELEMENT_ADDITIONAL(SAP)\
1450 /*nothing*/
1451
1452 #define M_TDC_CREATE_DEFAULT_MESSAGE_INTERFACE_CLASS(MSG)\
1453 M_TDC_CREATE_DEFAULT_INTERFACE_CLASS(MSG##_MESSAGE_UNION)\
1454
1455 #define M_TDC_CREATE_DEFAULT__T_TDC_INTERFACE_XXX_MESSAGE_UNION(MSG,CCDENT)\
1456 enum { CCDENT_##MSG = CCDENT };\
1457 M_TDC_CREATE_DEFAULT_MESSAGE_INTERFACE_CLASS(MSG)
1458
1459 #define M_TDC_INTERFACE_MESSAGE_ADDITIONAL()\
1460 M_TDC_INTERFACE_ADDITIONAL_MAIN (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, MESSAGE_UNION,MESSAGE_UNION, MESSAGE)\
1461 private:\
1462 T_TDC_INTERFACE_MESSAGE_UNION (const T_TDC_INTERFACE_MESSAGE_BASE& primitive)\
1463 {\
1464 tdc_tbd_message_union_constructor_call();\
1465 }\
1466 public:\
1467
1468 #define M_TDC_INTERFACE_MESSAGE_ELEMENT_ADDITIONAL(MSG)\
1469 /*nothing*/
1470
1471 //\}
1472
1473 //============================================================================
1474
1475 #if TDC_DEBUG_DOT_COMPLETE
1476 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1I()
1477 {
1478 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
1479 s.
1480 i;
1481 s->
1482 i0;
1483 }
1484 #else
1485 #endif
1486
1487 //----------------------------------------------------------------------------
1488 /// \defgroup M_TDC_INSTANCE M_TDC_INSTANCE
1489 /// macros to repeat stuff that is similar in many instance classes
1490 //----------------------------------------------------------------------------
1491 //\{
1492
1493 /*lint -emacro(1706,M_TDC_INSTANCE_ADDITIONAL_BASE)*/ //we don't want M_TDC_NOT(IN_CLASS(...)) for all the scope operators
1494 #define M_TDC_INSTANCE_ADDITIONAL_BASE(IN_CLASS, WITH_BODY, T_INTERFACE_, T_INSTANCE, T_HANDLE_)\
1495 IN_CLASS(typedef T_INTERFACE_ T_INTERFACE;)\
1496 IN_CLASS(typedef T_HANDLE_ T_HANDLE;)\
1497 IN_CLASS(T_HANDLE* handle;)\
1498 IN_CLASS(static) T_TDC_HANDLE_BASE* T_INSTANCE::implement_new_handle ()\
1499 WITH_BODY({\
1500 return new_##T_HANDLE_();\
1501 })\
1502 IN_CLASS(virtual) T_TDC_INTERFACE_BASE* T_INSTANCE::new_interface() const\
1503 WITH_BODY({\
1504 return new_##T_INTERFACE_();\
1505 })\
1506 void T_INSTANCE::construct()\
1507 WITH_BODY({\
1508 construct_handle(new_##T_HANDLE_);\
1509 })\
1510 T_INSTANCE::T_INSTANCE ()\
1511 WITH_BODY({\
1512 construct();\
1513 TDC_LINT_UNINITIALIZED_MEMBER\
1514 })\
1515 T_INSTANCE::~T_INSTANCE ()\
1516 WITH_BODY({\
1517 destroy_handle ();\
1518 TDC_LINT_POSSIBLE_UNHANDLE_POINTER_MEMBER\
1519 })\
1520 T_INSTANCE::T_INSTANCE (const T_INTERFACE_& value_)\
1521 WITH_BODY({\
1522 construct_from_interface ((T_TDC_INTERFACE_BASE*)&value_, new_##T_HANDLE_); M_TDC_COMMENT(T_INTERFACE not defined yet; means need cast here to the base type pointer)\
1523 TDC_LINT_UNINITIALIZED_MEMBER\
1524 })\
1525 IN_CLASS(explicit) T_INSTANCE::T_INSTANCE (const T_TDC_HANDLE_BASE* value_)\
1526 WITH_BODY({\
1527 tdc_tbd_constructor_call(#T_INSTANCE);\
1528 TDC_LINT_UNINITIALIZED_MEMBER\
1529 })\
1530 void T_INSTANCE::operator = (const T_INSTANCE& value_)\
1531 WITH_BODY({\
1532 set_value (value_);\
1533 TDC_LINT_UNASSIGNED_MEMBER\
1534 TDC_LINT_NO_SELFASSIGN_TEST\
1535 })\
1536 M_TDC_NOT_##IN_CLASS(T_INTERFACE_* T_INSTANCE::operator -> ()\
1537 {\
1538 return (T_INTERFACE*)get_navigation();\
1539 })\
1540 T_INSTANCE::T_INSTANCE (const T_INSTANCE& value_)\
1541 WITH_BODY({\
1542 construct_from_instance (value_, new_##T_HANDLE_);\
1543 TDC_LINT_UNCOPIED_BASE\
1544 TDC_LINT_UNINITIALIZED_MEMBER\
1545 })\
1546 T_INSTANCE::T_INSTANCE (T_INSTANCE (*f) ())\
1547 WITH_BODY({\
1548 T_INSTANCE value_ = f ();\
1549 construct_from_instance (value_, new_##T_HANDLE_);\
1550 TDC_LINT_UNINITIALIZED_MEMBER\
1551 })\
1552 M_TDC_ADDITIONAL_CALL_FUNCTION_BASE(IN_CLASS, WITH_BODY, T_INSTANCE, T_INSTANCE, T_INSTANCE)
1553
1554 #define M_TDC_INSTANCE_ADDITIONAL_MAIN(IN_CLASS, WITH_BODY, SHORT_NAME, PREFIXED_SHORT_NAME, BASE)\
1555 public:\
1556 void operator = (const T_TDC_INTERFACE_##BASE##_BASE& value_)\
1557 {\
1558 set_main_value (&value_);\
1559 }\
1560 void operator = (const T_TDC_INSTANCE_##BASE##_BASE& value_)\
1561 {\
1562 set_main_value (&value_);\
1563 }\
1564 T_##SHORT_NAME (const T_TDC_INTERFACE_##BASE##_BASE& value_)\
1565 {\
1566 construct_main_value (&value_, new_T_TDC_HANDLE_##PREFIXED_SHORT_NAME);\
1567 }\
1568 T_##SHORT_NAME (const T_TDC_INSTANCE_##BASE##_BASE& value_)\
1569 {\
1570 construct_main_value (&value_, new_T_TDC_HANDLE_##PREFIXED_SHORT_NAME);\
1571 }\
1572 M_TDC_INSTANCE_ADDITIONAL_BASE (IN_CLASS, WITH_BODY, T_TDC_INTERFACE_##PREFIXED_SHORT_NAME, T_##SHORT_NAME, T_TDC_HANDLE_##PREFIXED_SHORT_NAME)
1573
1574 #define M_TDC_INSTANCE_PART_ADDITIONAL(IN_CLASS, WITH_BODY, T_INTERFACE, T_INSTANCE, T_DESCRIPTOR, T_HANDLE)\
1575 public:\
1576 T_INSTANCE (const T_TDC_ACTION& action_)\
1577 {\
1578 construct_from_action (action_, new_##T_HANDLE);\
1579 }\
1580 T_TDC_ACTION operator = (const T_TDC_ACTION& action_)\
1581 {\
1582 set_action (action_);\
1583 return action_;\
1584 }\
1585 M_TDC_INSTANCE_ADDITIONAL_BASE(IN_CLASS, WITH_BODY, T_INTERFACE, T_INSTANCE, T_HANDLE)
1586
1587 #define M_TDC_INSTANCE_COMP_ADDITIONAL(IN_CLASS, WITH_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)\
1588 M_TDC_INSTANCE_PART_ADDITIONAL (IN_CLASS, WITH_BODY, T_TDC_INTERFACE_##PREFIXED_SHORT_NAME, T_##SHORT_NAME, T_TDC_DESCRIPTOR_##PREFIXED_SHORT_NAME, T_TDC_HANDLE_##PREFIXED_SHORT_NAME)
1589
1590 #define M_TDC_INSTANCE_ENUM_ADDITIONAL(IN_CLASS, WITH_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)\
1591 T_##SHORT_NAME (int value_)\
1592 {\
1593 construct_from_number (value_, new_T_TDC_DESCRIPTOR_##PREFIXED_SHORT_NAME);\
1594 }\
1595 void operator = (int value_)\
1596 {\
1597 set_descriptor_value (value_);\
1598 }\
1599 bool operator == (T_TDC_ENUM_##PREFIXED_SHORT_NAME value_)\
1600 {\
1601 return cmp_descriptor_value (value_);\
1602 }\
1603 operator T_TDC_ENUM_##PREFIXED_SHORT_NAME ()\
1604 {\
1605 return (T_TDC_ENUM_##PREFIXED_SHORT_NAME) get_descriptor_value ();\
1606 }\
1607 M_TDC_INSTANCE_PART_ADDITIONAL (IN_CLASS, WITH_BODY, T_TDC_INTERFACE_##PREFIXED_SHORT_NAME, T_##SHORT_NAME, T_TDC_DESCRIPTOR_##PREFIXED_SHORT_NAME, T_TDC_DESCRIPTOR_##PREFIXED_SHORT_NAME)
1608
1609 #define M_TDC_INSTANCE_INT_ADDITIONAL(SHORT_NAME)\
1610 T_##SHORT_NAME (int value_)\
1611 {\
1612 construct_from_number (value_, new_T_TDC_DESCRIPTOR_##SHORT_NAME);\
1613 }\
1614 void operator = (int value_)\
1615 {\
1616 set_descriptor_value (value_);\
1617 }\
1618 M_TDC_INSTANCE_PART_ADDITIONAL (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, T_TDC_INTERFACE_##SHORT_NAME, T_##SHORT_NAME, T_TDC_DESCRIPTOR_##SHORT_NAME, T_TDC_DESCRIPTOR_##SHORT_NAME)
1619
1620 //-----
1621
1622 #define M_TDC_INSTANCE_PRIM_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME)\
1623 M_TDC_INSTANCE_ADDITIONAL_MAIN (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SHORT_NAME,PREFIXED_SHORT_NAME, PRIMITIVE)
1624
1625 #define M_TDC_INSTANCE_PSTRUCT_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME)\
1626 M_TDC_INSTANCE_COMP_ADDITIONAL (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1627
1628 #define M_TDC_INSTANCE_PUNION_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME)\
1629 M_TDC_INSTANCE_COMP_ADDITIONAL (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1630
1631 #define M_TDC_INSTANCE_SDU_ADDITIONAL(SHORT_NAME)\
1632 M_TDC_INSTANCE_COMP_ADDITIONAL (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SHORT_NAME,SHORT_NAME)
1633
1634 #define M_TDC_INSTANCE_PENUM_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME)\
1635 M_TDC_INSTANCE_ENUM_ADDITIONAL (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1636
1637 //-----
1638
1639 #define M_TDC_INSTANCE_MSG_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME)\
1640 M_TDC_INSTANCE_ADDITIONAL_MAIN (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SHORT_NAME,PREFIXED_SHORT_NAME, MESSAGE)
1641
1642 #define M_TDC_INSTANCE_MSTRUCT_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME)\
1643 M_TDC_INSTANCE_COMP_ADDITIONAL (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1644
1645 #define M_TDC_INSTANCE_MUNION_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME)\
1646 M_TDC_INSTANCE_COMP_ADDITIONAL (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1647
1648 #define M_TDC_INSTANCE_MENUM_ADDITIONAL(SHORT_NAME,PREFIXED_SHORT_NAME)\
1649 M_TDC_INSTANCE_ENUM_ADDITIONAL (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1650
1651 //-----
1652
1653 #define M_TDC_INSTANCE_XXX_PRIMITIVE_UNION_ADDITIONAL(SAP,PREFIXED_SAP)\
1654 M_TDC_INSTANCE_ADDITIONAL_MAIN (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, SAP,PREFIXED_SAP, PRIMITIVE)
1655
1656 #define M_TDC_INSTANCE_XXX_MESSAGE_UNION_ADDITIONAL(MSG,PREFIXED_MSG)\
1657 M_TDC_INSTANCE_ADDITIONAL_MAIN (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, MSG,PREFIXED_MSG, MESSAGE)
1658
1659 #define M_TDC_INSTANCE_PRIMITIVE_ADDITIONAL()\
1660 M_TDC_INSTANCE_ADDITIONAL_MAIN (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, PRIMITIVE_UNION,PRIMITIVE_UNION, PRIMITIVE)\
1661 static int call_tdc_initialize_primitive ();\
1662
1663 #define M_TDC_INSTANCE_MESSAGE_ADDITIONAL()\
1664 M_TDC_INSTANCE_ADDITIONAL_MAIN (M_TDC_IN_CLASS, M_TDC_WITHOUT_BODY, MESSAGE_UNION,MESSAGE_UNION, MESSAGE)\
1665 static int call_tdc_initialize_message ();\
1666
1667 //-----
1668
1669 #define M_TDC_INSTANCE_PRIM_ADDITIONAL_INLINE(SHORT_NAME,PREFIXED_SHORT_NAME)\
1670 M_TDC_INSTANCE_ADDITIONAL_MAIN (M_TDC_IN_CLASS, M_TDC_WITH_BODY, SHORT_NAME,PREFIXED_SHORT_NAME, PRIMITIVE)
1671
1672 #define M_TDC_INSTANCE_PSTRUCT_ADDITIONAL_INLINE(SHORT_NAME,PREFIXED_SHORT_NAME)\
1673 M_TDC_INSTANCE_COMP_ADDITIONAL (M_TDC_IN_CLASS, M_TDC_WITH_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1674
1675 #define M_TDC_INSTANCE_PUNION_ADDITIONAL_INLINE(SHORT_NAME,PREFIXED_SHORT_NAME)\
1676 M_TDC_INSTANCE_COMP_ADDITIONAL (M_TDC_IN_CLASS, M_TDC_WITH_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1677
1678 #define M_TDC_INSTANCE_PENUM_ADDITIONAL_INLINE(SHORT_NAME,PREFIXED_SHORT_NAME)\
1679 M_TDC_INSTANCE_ENUM_ADDITIONAL (M_TDC_IN_CLASS, M_TDC_WITH_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1680
1681 //-----
1682
1683 #define M_TDC_INSTANCE_MSG_ADDITIONAL_INLINE(SHORT_NAME,PREFIXED_SHORT_NAME)\
1684 M_TDC_INSTANCE_ADDITIONAL_MAIN (M_TDC_IN_CLASS, M_TDC_WITH_BODY, SHORT_NAME,PREFIXED_SHORT_NAME, MESSAGE)
1685
1686 #define M_TDC_INSTANCE_MSTRUCT_ADDITIONAL_INLINE(SHORT_NAME,PREFIXED_SHORT_NAME)\
1687 M_TDC_INSTANCE_COMP_ADDITIONAL (M_TDC_IN_CLASS, M_TDC_WITH_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1688
1689 #define M_TDC_INSTANCE_MUNION_ADDITIONAL_INLINE(SHORT_NAME,PREFIXED_SHORT_NAME)\
1690 M_TDC_INSTANCE_COMP_ADDITIONAL (M_TDC_IN_CLASS, M_TDC_WITH_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1691
1692 #define M_TDC_INSTANCE_MENUM_ADDITIONAL_INLINE(SHORT_NAME,PREFIXED_SHORT_NAME)\
1693 M_TDC_INSTANCE_ENUM_ADDITIONAL (M_TDC_IN_CLASS, M_TDC_WITH_BODY, SHORT_NAME,PREFIXED_SHORT_NAME)
1694
1695 //-----
1696
1697 template<class T_INSTANCE,class T_HANDLE>class T_TDC_FORCE_LINK_INSTANCE_WORKER
1698 {
1699 T_TDC_FORCE_LINK_INSTANCE_WORKER(){
1700 T_HANDLE::new_descriptor = T_INSTANCE::get_new_descriptor();
1701 }
1702 };
1703
1704 template<class T_INSTANCE,class T_HANDLE>class T_TDC_FORCE_LINK_INSTANCE
1705 {
1706 static T_TDC_FORCE_LINK_INSTANCE_WORKER<T_INSTANCE,T_HANDLE> worker;
1707 };
1708 template<class T_INSTANCE,class T_HANDLE>T_TDC_FORCE_LINK_INSTANCE_WORKER<T_INSTANCE,T_HANDLE> T_TDC_FORCE_LINK_INSTANCE<T_INSTANCE,T_HANDLE>::worker;
1709
1710 #define M_TDC_XXX_PRIMITIVE_UNION_ADDITIONAL_INLINE_1(SAP,PREFIXED_SAP)\
1711 extern char set_new_descriptor_T_TDC_HANDLE_##SAP();\
1712 static char init_new_descriptor_T_TDC_HANDLE_##SAP = set_new_descriptor_T_TDC_HANDLE_##SAP();\
1713
1714 #define M_TDC_XXX_PRIMITIVE_UNION_ADDITIONAL_INLINE(SAP,PREFIXED_SAP)\
1715
1716 #define M_TDC_XXX_MESSAGE_UNION_ADDITIONAL_INLINE(SAP,PREFIXED_SAP)\
1717
1718 /*
1719 #define M_TDC_XXX_PRIMITIVE_UNION_ADDITIONAL_INLINE(SAP,PREFIXED_SAP)\
1720 extern char set_new_descriptor_T_TDC_HANDLE_##SAP();\
1721 static char init_new_descriptor_T_TDC_HANDLE_##SAP = set_new_descriptor_T_TDC_HANDLE_##SAP();\
1722
1723 #define M_TDC_XXX_MESSAGE_UNION_ADDITIONAL_INLINE(SAP,PREFIXED_SAP)\
1724 extern char set_new_descriptor_T_TDC_HANDLE_##SAP();\
1725 static char init_new_descriptor_T_TDC_HANDLE_##SAP = set_new_descriptor_T_TDC_HANDLE_##SAP();\
1726 */
1727
1728 #define M_TDC_INSTANCE_XXX_PRIMITIVE_UNION_ADDITIONAL_INLINE(SAP,PREFIXED_SAP)\
1729 M_TDC_INSTANCE_ADDITIONAL_MAIN (M_TDC_IN_CLASS, M_TDC_WITH_BODY, SAP,PREFIXED_SAP, PRIMITIVE)\
1730 T_TDC_NEW_DESCRIPTOR get_new_descriptor()\
1731 {\
1732 extern T_TDC_DESCRIPTOR_BASE* new_T_TDC_DESCRIPTOR_##SAP();\
1733 return new_T_TDC_DESCRIPTOR_##SAP;\
1734 }\
1735
1736 #define M_TDC_INSTANCE_XXX_MESSAGE_UNION_ADDITIONAL_INLINE(MSG,PREFIXED_MSG)\
1737 M_TDC_INSTANCE_ADDITIONAL_MAIN (M_TDC_IN_CLASS, M_TDC_WITH_BODY, MSG,PREFIXED_MSG, MESSAGE)\
1738 T_TDC_NEW_DESCRIPTOR get_new_descriptor()\
1739 {\
1740 extern T_TDC_DESCRIPTOR_BASE* new_T_TDC_DESCRIPTOR_##MSG();\
1741 return new_T_TDC_DESCRIPTOR_##MSG;\
1742 }\
1743
1744 //\}
1745
1746 //-----
1747
1748 #ifdef TDC_TYPE_NAME_COMPLETE
1749 #define M_TDC_TYPE_NAME_COMPLETE TDC_DOT_COMPLETE_HIDE({ T_TDC_TYPE_NAME type_name = {0}; return type_name; })
1750 #else
1751 #define M_TDC_TYPE_NAME_COMPLETE ;
1752 #endif
1753
1754 #endif //DOT_COMPLETE_DEFINES
1755
1756 //============================================================================
1757
1758 #if TDC_DEBUG_DOT_COMPLETE
1759 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1J()
1760 {
1761 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
1762 s.
1763 i;
1764 s->
1765 i0;
1766 }
1767 #else
1768 #endif
1769
1770 //============================================================================
1771 // implementation classes
1772 //============================================================================
1773
1774 typedef bool T_TDC_TABLE_KIND;
1775
1776 enum T_TDC_ACTION_ENUM
1777 {
1778 TDC_ACTION_UNKNOWN,
1779 // MANDATORY-SEND OPTIONAL-SEND MANDATORY-WAIT OPTIONAL-WAIT
1780 TDC_ACTION_SKIP, // ERROR ABSENT SKIPED SKIPED
1781 TDC_ACTION_SHOW, // ERROR ABSENT SKIPED SKIPED
1782 TDC_ACTION_FORBID, // ERROR ABSENT ERROR CHECKED
1783 TDC_ACTION_REQUIRE, // ERROR ERROR ERROR CHECKED PRESENT
1784 TDC_ACTION_MESSAGE,
1785 TDC_ACTION_DESTROYED,
1786 TDC_ACTION_SKIP_TO_END,
1787 TDC_ACTION_SET = 0x10, // PRESENT PRESENT CHECKED CHECKED VALUE
1788 TDC_ACTION_HAS_VALUE = 0x20,
1789 TDC_ACTION_HAS_REF = 0x40,
1790 TDC_ACTION_IS_IMPLICIT = 0x80,
1791 TDC_ACTION_SET_VALUE = TDC_ACTION_SET + TDC_ACTION_HAS_VALUE,
1792 TDC_ACTION_SET_REF = TDC_ACTION_SET + TDC_ACTION_HAS_REF,
1793 TDC_ACTION_CHILD_TOUCHED = TDC_ACTION_SET + TDC_ACTION_HAS_REF + TDC_ACTION_IS_IMPLICIT,
1794 TDC_ACTION_DEFAULT = TDC_ACTION_UNKNOWN
1795 };
1796
1797 /** allow one optional extra set of () on action member functions, first set is suplyed by macro
1798 * second set might be suplyed by the user, this will have no effect on behaviour of code
1799 */
1800 struct T_TDC_ASSIGN_ACTION
1801 {
1802 void operator ()();
1803 };
1804
1805 extern T_TDC_ASSIGN_ACTION tdc_assign_action;
1806
1807 struct T_TDC_ACTION
1808 {
1809 //create a waper class for T_TDC_ACTION_ENUM so that the action constants can not be converted to integers
1810 T_TDC_ACTION_ENUM action;
1811 T_TDC_ACTION (T_TDC_ACTION_ENUM action_):
1812 action (action_)
1813 {
1814 //nothing
1815 }
1816 T_TDC_ACTION ();
1817 };
1818
1819 struct T_TDC_CREATE_ACTION:T_TDC_ACTION
1820 {
1821 /* This type is returned by constant action function, this allow the user to optional
1822 omit the "()" after the action name
1823 Src code After macro expantion Function returns After implicit type convting
1824 ======== ==================== ======================== =====================
1825 _skip tdc_skip() SKIP::T_TDC_CREATE_ACTION SKIP::T_TDC_ACTION
1826 _skip() tdc_skip()() SKIP::T_TDC_ACTION SKIP::T_TDC_ACTION
1827 _skip()() tdc_skip()()() <error T_TDC_ACTION have no operator ()>
1828 */
1829 T_TDC_CREATE_ACTION ();
1830 T_TDC_ACTION operator()();
1831 };
1832
1833 extern T_TDC_CREATE_ACTION SKIP;
1834 extern T_TDC_CREATE_ACTION SHOW;
1835 extern T_TDC_CREATE_ACTION FORBID;
1836 extern T_TDC_CREATE_ACTION REQUIRE;
1837 extern T_TDC_CREATE_ACTION SKIP_TO_END;
1838
1839 extern T_TDC_CREATE_ACTION tdc_skip();
1840 extern T_TDC_CREATE_ACTION tdc_show();
1841 extern T_TDC_CREATE_ACTION tdc_forbid();
1842 extern T_TDC_CREATE_ACTION tdc_require();
1843 extern T_TDC_CREATE_ACTION tdc_skip_to_end();
1844
1845 //----------------------------------------------------------------------------
1846
1847 enum T_TDC_EVENT_ENUM
1848 {
1849 TDC_EVENT_SEND,
1850 TDC_EVENT_AWAIT
1851 };
1852
1853 enum T_TDC_IS_ENUM
1854 {
1855 TDC_IS_UNKNOWN = 0,
1856 TDC_IS_VAR = 0x001,
1857 TDC_IS_STRUCT = 0x002,
1858 TDC_IS_SDU = 0x004,
1859 TDC_IS_P = 0x008,
1860 TDC_IS_M = 0x010,
1861 TDC_IS_COMP = 0x20,
1862 TDC_IS_ARRAY = 0x40,
1863 TDC_IS_UNION = 0x80,
1864 TDC_IS_MESSAGE_UNION = 0x100,
1865 TDC_IS_PRIMITIVE_UNION = 0x200,
1866 TDC_IS_MSG = 0x400,
1867 TDC_IS_PRIM = 0x800,
1868 TDC_IS_XXX_MESSAGE_UNION = 0x1000,
1869 TDC_IS_XXX_PRIMITIVE_UNION = 0x2000,
1870 TDC_IS_POINTER = 0x4000,
1871 TDC_IS_PVAR = TDC_IS_VAR | TDC_IS_P,
1872 TDC_IS_MVAR = TDC_IS_VAR | TDC_IS_M
1873 };
1874
1875 //----------------------------------------------------------------------------
1876
1877 struct T_TDC_HANDLE_BASE;
1878 struct T_TDC_DESCRIPTOR_BASE;
1879 struct T_TDC_INSTANCE_MAIN_BASE;
1880 struct T_TDC_INTERFACE_BASE;
1881 struct T_TDC_INSTANCE_BASE;
1882 struct T_TDC_PATH;
1883 struct T_TDC_PATH_TEXT;
1884
1885 typedef T_TDC_INTERFACE_BASE* (*T_TDC_NEW_INTERFACE)();
1886 typedef T_TDC_HANDLE_BASE* (*T_TDC_NEW_HANDLE)();
1887 typedef T_TDC_DESCRIPTOR_BASE* (*T_TDC_NEW_DESCRIPTOR)();
1888
1889 struct T_PRIMITIVE_UNION;
1890 struct T_TDC_INTERFACE_PRIMITIVE_UNION;
1891 struct T_TDC_DESCRIPTOR_PRIMITIVE_UNION;
1892
1893 struct T_MESSAGE_UNION;
1894 struct T_TDC_INTERFACE_MESSAGE_UNION;
1895 struct T_TDC_DESCRIPTOR_MESSAGE_UNION;
1896
1897 typedef signed long T_TDC_INT_S32;
1898 typedef signed short T_TDC_INT_S16;
1899 typedef signed char T_TDC_INT_S8;
1900 typedef unsigned long T_TDC_INT_U32;
1901 typedef unsigned short T_TDC_INT_U16;
1902 typedef unsigned char T_TDC_INT_U8;
1903 typedef char CHAR;
1904
1905 //----------------------------------------------------------------------------
1906 inline unsigned long num_elements(const unsigned char* array)
1907 {
1908 return strlen((const char*)array);
1909 }
1910
1911 inline unsigned long num_elements(const signed char* array)
1912 {
1913 return strlen((const char*)array);
1914 }
1915
1916
1917 //----------------------------------------------------------------------------
1918
1919 enum T_TDC_RW_MODE
1920 {
1921 TDC_RW_MODE_READ,
1922 TDC_RW_MODE_WRITE
1923 };
1924
1925 struct T_TDC_HANDLE_BASE
1926 {
1927 friend struct T_TDC_COPY;
1928 protected:
1929 T_TDC_ACTION_ENUM implement_get_action () const;
1930 void implement_set_action (T_TDC_ACTION_ENUM action_);
1931 T_TDC_DESCRIPTOR_BASE* implement_get_descriptor () const;
1932 void implement_set_descriptor (T_TDC_DESCRIPTOR_BASE* descriptor_);
1933 long implement_get_value () const;
1934 void implement_set_value (long value_);
1935 friend void add_name_info (T_TDC_HANDLE_BASE* descriptor_ref, int level, int parent, int index);
1936 T_TDC_PATH_TEXT path_text();
1937 virtual T_TDC_DESCRIPTOR_BASE* implement_new_descriptor () const;
1938 static T_TDC_DESCRIPTOR_BASE* call_implement_new_descriptor(T_TDC_NEW_DESCRIPTOR new_descriptor);
1939 public:
1940 T_TDC_DESCRIPTOR_BASE* make_descriptor ();
1941 T_TDC_DESCRIPTOR_BASE* make_array_descriptor (T_TDC_NEW_HANDLE new_element_handle);
1942 virtual char* get_name () const
1943 TDC_PURE_BODY({
1944 //TDC_ERROR();
1945 return 0;
1946 })
1947 virtual long get_sizeof () = 0
1948 {
1949 return sizeof *this;
1950 }
1951 T_TDC_HANDLE_BASE ();
1952 ~T_TDC_HANDLE_BASE ();
1953 T_TDC_HANDLE_BASE* get_element (int index)const;
1954 T_TDC_HANDLE_BASE* get_union_element ();
1955 void destroy ();
1956 T_TDC_DESCRIPTOR_BASE* get_descriptor()const;
1957 T_TDC_ACTION_ENUM get_action()const;
1958 long get_value()const;
1959 int get_ctrl()const;
1960 void clear();
1961 void set_descriptor_value(long value_);
1962 virtual unsigned get_sizeof_target ();
1963 virtual T_TDC_IS_ENUM is ();
1964 };
1965
1966 #ifdef TDC_USE_ALLOC_DEBUG_COUNTER
1967 struct T_TDC_ALLOC_DEBUG_COUNTER
1968 {
1969 int count;
1970 int max_count;
1971 int alloc_count;
1972 int free_count;
1973 bool alloc[1000];
1974 T_TDC_ALLOC_DEBUG_COUNTER ()
1975 {
1976 /* nothing here should allways be static allocated and there for cleared,
1977 futher more it is used before construction so intializing here will be fatal */
1978 }
1979 ~T_TDC_ALLOC_DEBUG_COUNTER ()
1980 {
1981 for (int first_not_freed = 0; !alloc[first_not_freed]; first_not_freed++)
1982 TDC_ASSERT (first_not_freed < sizeof alloc);
1983 TDC_ASSERT (count==0); // some where we have a leak
1984 }
1985 };
1986
1987 template<class T>
1988 struct T_TDC_ALLOC_DEBUG
1989 {
1990 static T_TDC_ALLOC_DEBUG_COUNTER counter;
1991 int alloc_count;
1992 T_TDC_ALLOC_DEBUG_COUNTER& counter_;
1993 T_TDC_ALLOC_DEBUG ():
1994 counter_ (counter)
1995 {
1996 counter.count++;
1997 alloc_count = counter.alloc_count++;
1998 if (alloc_count < sizeof counter.alloc)
1999 counter.alloc[alloc_count]=true;
2000 if (counter.max_count < counter.count)
2001 counter.max_count = counter.count;
2002 }
2003 ~T_TDC_ALLOC_DEBUG ()
2004 {
2005 if (alloc_count < sizeof counter.alloc)
2006 counter.alloc[alloc_count]=false;
2007 TDC_ASSERT (counter.count > 0); // deallocating more than ever allocated
2008 counter.free_count++;
2009 counter.count--;
2010 }
2011 };
2012
2013 template<class T>T_TDC_ALLOC_DEBUG_COUNTER T_TDC_ALLOC_DEBUG<T>::counter;
2014 #endif
2015
2016 enum {
2017 TDC_CTRL_DEFAULT = 0,
2018 TDC_CTRL_NO_DESCRIPTOR = -1,
2019 TDC_CTRL_NOT_AN_UNION = -2,
2020 TDC_REF_COUNT_ELEMENTS_DESTROYED = -2,
2021 TDC_DESCRIPTOR_DESTROYED_VALUE = -4,
2022 TDC_DUMMY_TAP_HANDLE = -16
2023 };
2024
2025 #define TDC_DESCRIPTOR_DESTROYED ((T_TDC_DESCRIPTOR_BASE*)TDC_DESCRIPTOR_DESTROYED_VALUE)
2026
2027 struct T_TDC_DESCRIPTOR_BASE
2028 #ifdef TDC_USE_ALLOC_DEBUG_COUNTER
2029 :T_TDC_ALLOC_DEBUG<T_TDC_DESCRIPTOR_BASE>
2030 #endif
2031 {
2032 private:
2033 friend struct T_TDC_COPY;
2034 friend void unsubscribe (T_TDC_DESCRIPTOR_BASE* descriptor);
2035 int ref_count;
2036 virtual long get_sizeof ()
2037 TDC_PURE_BODY(
2038 return 0;
2039 )
2040
2041 void destroy_elements ();
2042 protected:
2043 T_TDC_HANDLE_BASE* implement_get_element (unsigned index, char *first_element);
2044 T_TDC_HANDLE_BASE* implement_get_union_element (unsigned index, int& ctrl);
2045 public:
2046 void *operator new (size_t size);//TODO: operator new (size_t size); + eliminate T_TDC_HANDLE_BASE::T_TDC_HANDLE_BASE i.e. todo T_TDC_HANDLE_BASE::operator new (size_t size);
2047 T_TDC_PATH_TEXT path_text();
2048 virtual int read_ctrl () const
2049 {
2050 return TDC_CTRL_NOT_AN_UNION;
2051 }
2052 void set_skip_to_end_from_action (T_TDC_ACTION_ENUM action);
2053 virtual void set_skip_to_end (bool skip_to_end);
2054 virtual bool get_skip_to_end () const;
2055 virtual T_TDC_HANDLE_BASE* make_element (unsigned index);
2056 virtual T_TDC_HANDLE_BASE* get_element (unsigned index);
2057 virtual int get_tap_handle ();
2058 T_TDC_DESCRIPTOR_BASE ();
2059 virtual ~T_TDC_DESCRIPTOR_BASE ();
2060 virtual char* get_name () const
2061 TDC_PURE_BODY(
2062 return 0;
2063 )
2064 virtual T_TDC_IS_ENUM is ()
2065 {
2066 //TODO: TDC_ERROR() here and mov is function to distinct base classes;
2067 return TDC_IS_UNKNOWN;
2068 }
2069 };
2070
2071 union T_TDC_BASIC_TYPES
2072 {
2073 unsigned long u32;
2074 signed long s32;
2075 signed int s16;
2076 signed char s8;
2077 char c[4];
2078 };
2079
2080 //----------------------------------------------------------------------------
2081
2082 struct T_TDC_INTERFACE_BASE
2083 {
2084 private:
2085 void* operator &(); /* this member function is only here to prevent the user from taking the address of
2086 an interface, which make no sence to the user as it gives the address of
2087 some internal tdc navigation data */
2088 #ifdef LINT //TODO: introduce for VC too
2089 const void* operator &() const; /* but we don't want ripling errors from LINT
2090 the ripling errors comes from the fact that LINT seems to have a more correct
2091 interpretion of where to use the overloaded function and where to truely take
2092 the address*/
2093 #endif
2094 protected:
2095 T_TDC_LEVEL level[1];
2096 T_TDC_ASSIGN_ACTION set_action (const T_TDC_ACTION& action_);
2097 T_TDC_INTERFACE_BASE ()
2098 {
2099 //nothing
2100 }
2101 public:
2102 T_TDC_PATH* implement_make_descriptor_ref (T_TDC_RW_MODE rw_mode);
2103 T_TDC_PATH* make_descriptor_ref (T_TDC_RW_MODE rw_mode);
2104 const T_TDC_PATH* make_descriptor_ref (T_TDC_RW_MODE rw_mode) const;
2105 void set_descriptor_value (long value_);
2106 //bool cmp_descriptor_value (long value_);
2107 void copy_instance (const T_TDC_INSTANCE_BASE * value_);
2108 void copy_interface (const T_TDC_INTERFACE_BASE * value_);
2109 };
2110
2111 struct T_TDC_INTERFACE_MAIN_BASE
2112 #if DOT_COMPLETE_MEMBERS
2113 #else
2114 TDC_DOT_COMPLETE_HIDE(:T_TDC_INTERFACE_BASE)
2115 #endif
2116 {
2117 #if DOT_COMPLETE_MEMBERS
2118 #else
2119 protected:
2120 void set_main_value (const T_TDC_INTERFACE_MAIN_BASE* value_);
2121 void set_main_value (const T_TDC_INSTANCE_MAIN_BASE* value_);
2122 T_TDC_INTERFACE_BASE* get_element_navigation(T_TDC_NEW_INTERFACE new_element_interface);
2123 /*T_TDC_INTERFACE_MAIN_BASE ()
2124 {
2125 tdc_level++;
2126 }*/
2127 #endif
2128 };
2129
2130 struct T_TDC_INTERFACE_REF_BASE
2131 #if DOT_COMPLETE_MEMBERS
2132 #else
2133 TDC_DOT_COMPLETE_HIDE(:T_TDC_INTERFACE_BASE)
2134 #endif
2135 {
2136 #if DOT_COMPLETE_MEMBERS
2137 T_TDC_ASSIGN_ACTION _skip () {} /* you can use '= SKIP' as well */
2138 T_TDC_ASSIGN_ACTION _show () {} /* you can use '= SHOW' as well */
2139 T_TDC_ASSIGN_ACTION _forbid () {} /* you can use '= FORBID' as well */
2140 T_TDC_ASSIGN_ACTION _require () {} /* you can use '= REQUIRE' as well */
2141 #else//DOT_COMPLETE_MEMBERS
2142 T_TDC_INTERFACE_REF_BASE ()
2143 {
2144 level[0] = 'A'+tdc_level;
2145 }
2146 TDC_DOT_COMPLETE_HIDE(T_TDC_ASSIGN_ACTION tdc_skip ();) /* you can use '= SKIP' as well */
2147 TDC_DOT_COMPLETE_HIDE(T_TDC_ASSIGN_ACTION tdc_show ();) /* you can use '= SHOW' as well */
2148 TDC_DOT_COMPLETE_HIDE(T_TDC_ASSIGN_ACTION tdc_forbid ();) /* you can use '= FORBID' as well */
2149 TDC_DOT_COMPLETE_HIDE(T_TDC_ASSIGN_ACTION tdc_require ();) /* you can use '= REQUIRE' as well */
2150 #endif//DOT_COMPLETE_MEMBERS
2151 };
2152
2153 struct T_TDC_INTERFACE_VAR_BASE
2154 #if DOT_COMPLETE_MEMBERS
2155 #else
2156 TDC_DOT_COMPLETE_HIDE(:T_TDC_INTERFACE_BASE)
2157 #endif
2158 {
2159 #if DOT_COMPLETE_MEMBERS
2160 T_TDC_ASSIGN_ACTION _skip () {} /* you can use '= SKIP' as well */
2161 T_TDC_ASSIGN_ACTION _show () {} /* you can use '= SHOW' as well */
2162 T_TDC_ASSIGN_ACTION _forbid () {} /* you can use '= FORBID' as well */
2163 T_TDC_ASSIGN_ACTION _require () {} /* you can use '= REQUIRE' as well */
2164 #else//DOT_COMPLETE_MEMBERS
2165 T_TDC_INTERFACE_VAR_BASE ()
2166 {
2167 level[0] = 'A'+tdc_level;
2168 }
2169 TDC_DOT_COMPLETE_HIDE(T_TDC_ASSIGN_ACTION tdc_skip ();) /* you can use '= SKIP' as well */
2170 TDC_DOT_COMPLETE_HIDE(T_TDC_ASSIGN_ACTION tdc_show ();) /* you can use '= SHOW' as well */
2171 TDC_DOT_COMPLETE_HIDE(T_TDC_ASSIGN_ACTION tdc_forbid ();) /* you can use '= FORBID' as well */
2172 TDC_DOT_COMPLETE_HIDE(T_TDC_ASSIGN_ACTION tdc_require ();) /* you can use '= REQUIRE' as well */
2173 #endif//DOT_COMPLETE_MEMBERS
2174 };
2175
2176 //----------------------------------------------------------------------------
2177
2178 #if TDC_DEBUG_DOT_COMPLETE
2179 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1K()
2180 {
2181 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
2182 s.
2183 i;
2184 s->
2185 i0;
2186 }
2187 #else
2188 #endif
2189
2190 //----------------------------------------------------------------------------
2191 /** \defgroup PATH PATH
2192 * A set of classes and functions that is used for generating the path of
2193 * an element when generating warning or error messages.
2194 * TODO: need more work
2195 */
2196 //\{
2197
2198 struct T_TDC_PATH
2199 #ifdef TDC_USE_ALLOC_DEBUG_COUNTER
2200 :T_TDC_ALLOC_DEBUG<T_TDC_PATH>
2201 #endif
2202 {
2203 T_TDC_HANDLE_BASE* handle;
2204 T_TDC_DESCRIPTOR_BASE* cahed_descriptor;
2205 int indexes_count;
2206 union{
2207 int *indexes;
2208 struct T_WATCH_INDEXES{
2209 int i0,i1,i2,i3,i4,i5,i6,i7,i8,i9;
2210 }*watch_indexes;
2211 };
2212 T_TDC_INTERFACE_BASE* pattern;
2213 T_TDC_PATH* next;
2214 T_TDC_PATH (T_TDC_HANDLE_BASE* handle_);
2215 ~T_TDC_PATH ();
2216 void add_index(T_TDC_DESCRIPTOR_BASE* descriptor, int index);
2217 void add_to_cashed_path_list ();
2218 T_TDC_HANDLE_BASE* get_leaf();
2219 T_TDC_PATH_TEXT get_path_text ();
2220 T_TDC_PATH* duplicate()const;
2221 };
2222
2223 //----------------------------------------------------------------------------
2224
2225 #if TDC_DEBUG_DOT_COMPLETE
2226 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1L()
2227 {
2228 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
2229 s.
2230 i;
2231 s->
2232 i0;
2233
2234 }
2235 #else
2236 #endif
2237
2238 //----------------------------------------------------------------------------
2239
2240 struct const_T_TDC_COPY
2241 {
2242 T_TDC_HANDLE_BASE* descriptor_ref;
2243 const T_TDC_PATH* path;
2244 const_T_TDC_COPY (const T_TDC_PATH* path_):
2245 descriptor_ref (const_cast<T_TDC_PATH*>(path_)->get_leaf()),
2246 path (path_)
2247 {
2248 }
2249 const_T_TDC_COPY (const T_TDC_HANDLE_BASE* descriptor_ref_):
2250 descriptor_ref (const_cast<T_TDC_HANDLE_BASE*>(descriptor_ref_)),
2251 path (0)
2252 {
2253 }
2254 const_T_TDC_COPY (const const_T_TDC_COPY& src):
2255 descriptor_ref (src.descriptor_ref),
2256 path (0)
2257 {
2258 if (src.path)
2259 path = src.path->duplicate();
2260 }
2261 void operator = (const const_T_TDC_COPY& src)
2262 {
2263 descriptor_ref = src.descriptor_ref;
2264 if (path)
2265 delete path;
2266 if (src.path)
2267 path = src.path->duplicate();
2268 else
2269 path = 0;
2270 }
2271 const T_TDC_HANDLE_BASE* operator->()
2272 {
2273 return descriptor_ref;
2274 }
2275 operator const T_TDC_HANDLE_BASE*()const
2276 {
2277 return descriptor_ref;
2278 }
2279 ~const_T_TDC_COPY ()
2280 {
2281 if (path)
2282 delete path;
2283 }
2284 T_TDC_PATH_TEXT path_text ();
2285 T_TDC_ACTION_ENUM get_action () const
2286 {
2287 return descriptor_ref->get_action();
2288 }
2289 bool has_value () const
2290 {
2291 return (descriptor_ref->get_action() & TDC_ACTION_HAS_VALUE) != 0;
2292 }
2293 int get_value () const
2294 {
2295 return descriptor_ref->get_value();
2296 }
2297 };
2298
2299 struct T_TDC_COPY:const_T_TDC_COPY
2300 {
2301 friend struct T_TDC_COPY;
2302 T_TDC_COPY (T_TDC_PATH* path_):
2303 const_T_TDC_COPY (path_)
2304 {
2305 }
2306 T_TDC_COPY (T_TDC_HANDLE_BASE* descriptor_ref_):
2307 const_T_TDC_COPY (descriptor_ref_)
2308 {
2309 }
2310 T_TDC_HANDLE_BASE* operator->()
2311 {
2312 return descriptor_ref;
2313 }
2314 operator T_TDC_HANDLE_BASE*()const
2315 {
2316 return descriptor_ref;
2317 }
2318 void copy_descriptor_ref (const const_T_TDC_COPY& value_);
2319 void copy_number (long value_);
2320 T_TDC_ASSIGN_ACTION copy_action (T_TDC_ACTION_ENUM action_);
2321 private:
2322 void set_action_and_value (T_TDC_ACTION_ENUM action_, long value_=0xFCFCFCFC);
2323 };
2324
2325 //----------------------------------------------------------------------------
2326
2327 /** \struct T_TDC_PATH_TEXT
2328 T_TDC_PATH_TEXT is used to return a string on the heap that will auto dealloc
2329 <pre>
2330 e.g.
2331
2332 T_TDC_PATH_TEXT f()
2333 {
2334 return strdup ("...");
2335 }
2336
2337 void g()
2338 {
2339 printf ("%s", f()); // free of string allocated in f() will happen automatic
2340 // when ~T_TDC_PATH_TEXT is called at the end of sentence (at ';')
2341 }
2342 </pre>
2343 */
2344 struct T_TDC_PATH_TEXT
2345 {
2346 char* str;
2347 T_TDC_PATH_TEXT(char* str_);
2348 ~T_TDC_PATH_TEXT();
2349 };
2350
2351 //\}
2352
2353 //----------------------------------------------------------------------------
2354
2355 #if TDC_DEBUG_DOT_COMPLETE
2356 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1N()
2357 {
2358 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
2359 s.
2360 i;
2361 s->
2362 i0;
2363
2364 }
2365 #else
2366 #endif
2367
2368 //============================================================================
2369 /// \defgroup T_TDC_INTERFACE
2370 //\{
2371
2372 struct T_TDC_INTERFACE_REF:T_TDC_INTERFACE_REF_BASE
2373 {
2374 #if DOT_COMPLETE_MEMBERS
2375 #else
2376 T_TDC_INTERFACE_REF ()
2377 {
2378 tdc_level++;
2379 }
2380 #endif
2381 };
2382
2383 struct T_TDC_INTERFACE_VAR:T_TDC_INTERFACE_VAR_BASE
2384 {
2385 #if DOT_COMPLETE_MEMBERS
2386 #else
2387 T_TDC_INTERFACE_VAR ()
2388 {
2389 //nothing
2390 }
2391 #endif
2392 };
2393
2394 //============================================================================
2395
2396 #if TDC_DEBUG_DOT_COMPLETE
2397 struct T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1O
2398 {
2399 int i1O;
2400 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 operator->(){return 0;}
2401 };
2402 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1O()
2403 {
2404 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
2405 s.
2406 i;
2407 s->
2408 i0;
2409 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1O s10;
2410 s10->
2411 i0;
2412 }
2413 #else
2414 #endif
2415
2416 //----------------------------------------------------------------------------
2417
2418 #if DOT_COMPLETE
2419 #define TDC_HIDDEN_LEVEL_DEF
2420 #define TDC_HIDDEN_LEVEL(T_BASE)
2421 #define TDC_HIDDEN_LEVEL_MAIN_DEF
2422 #define TDC_HIDDEN_LEVEL_MAIN(T_BASE)
2423 struct T_TDC_INTERFACE_POINTER_MAIN_BASE:T_TDC_INTERFACE_REF_BASE
2424 {
2425 };
2426 #else
2427 #define TDC_HIDDEN_LEVEL_DEF
2428 #define TDC_HIDDEN_LEVEL
2429 #define TDC_HIDDEN_LEVEL_MAIN_DEF , class T_TDC_INTERFACE_POINTER_MAIN_BASE = T_TDC_INTERFACE_POINTER_MAIN_BASE_DEFAULT
2430 #define TDC_HIDDEN_LEVEL_MAIN(T_BASE) , T_BASE
2431 #endif
2432
2433 struct T_TDC_INTERFACE_PRIMITIVE_BASE:T_TDC_INTERFACE_MAIN_BASE
2434 {
2435 };
2436
2437 struct T_TDC_INTERFACE_MESSAGE_BASE:T_TDC_INTERFACE_MAIN_BASE
2438 {
2439 };
2440
2441 //template<class T TDC_HIDDEN_LEVEL_MAIN_DEF > struct T_TDC_INTERFACE_POINTER_MAIN:T_TDC_INTERFACE_POINTER_BASE
2442 template<class T TDC_HIDDEN_LEVEL_MAIN_DEF > struct T_TDC_INTERFACE_POINTER_MAIN:T_TDC_INTERFACE_POINTER_MAIN_BASE
2443 {
2444 T_TDC_INTERFACE_POINTER_MAIN ()
2445 {
2446 level[0] = 'A'+tdc_level;
2447 }
2448 #if DOT_COMPLETE_MEMBERS
2449 #else //DOT_COMPLETE_MEMBERS
2450 operator = (const T& t)
2451 {
2452 tdc_tbd_pointer_assignment_error();
2453 //get_navigation()->_set(t);
2454 return 0;
2455 }
2456 #endif //DOT_COMPLETE_MEMBERS
2457 /*operator = (const T_TDC_INSTANCE& t)
2458 {
2459 get_navigation()->_set(t);
2460 }*/
2461 T* operator-> (){
2462 return (T*)get_element_navigation(new_element_interface);
2463 }
2464 /*operator const T&()
2465 {
2466 return *get_navigation();
2467 }*/
2468 private:
2469 #if DOT_COMPLETE_MEMBERS
2470 #else //DOT_COMPLETE_MEMBERS
2471 static T_TDC_INTERFACE_BASE* new_element_interface()
2472 {
2473 return new T;
2474 }
2475 #endif //DOT_COMPLETE_MEMBERS
2476 };
2477
2478 template<class T> struct T_ARRAY;
2479
2480 struct T_TDC_INTERFACE_ARRAY_BASE
2481 :T_TDC_INTERFACE_REF_BASE
2482 {
2483 #if DOT_COMPLETE
2484 #else
2485 protected:
2486 T_TDC_INTERFACE_BASE* get_element_navigation(int index, T_TDC_NEW_INTERFACE new_element_interface, T_TDC_NEW_HANDLE new_handle);
2487 void copy_basic_array (const T_TDC_INT_U8* array, unsigned size, void *address);
2488 void copy_basic_array (const T_TDC_INT_S8* array, unsigned size, void *address);
2489 void copy_basic_array (const T_TDC_INT_U16* array, unsigned size, void *address);
2490 void copy_basic_array (const T_TDC_INT_S16* array, unsigned size, void *address);
2491 void copy_basic_array (const T_TDC_INT_U32* array, unsigned size, void *address);
2492 void copy_basic_array (const T_TDC_INT_S32* array, unsigned size, void *address);
2493 #endif
2494 };
2495
2496 /*
2497 ** TODO: Function header (this is a comment for an bug fix)
2498 **
2499 ** I would expect dropdown to work for this
2500 ** template<class T, int MAX_INDEX > struct T_TDC_INTERFACE_ARRAY:T_TDC_INTERFACE_POINTER_BASE_DEFAULT
2501 ** ^^
2502 ** and to fail for this
2503 ** template<class T, int MAX_INDEX, int DUMMY=0 > struct T_TDC_INTERFACE_ARRAY:T_TDC_INTERFACE_POINTER_BASE_DEFAULT
2504 ** ^^^^^^^^^^^^^
2505 **
2506 ** but it seams to be the otherway around (see more info in tcd_test.cpp::test_1000())
2507 */
2508
2509 #if DOT_COMPLETE
2510 template<class T /*T_INTERFACE*/, int MAX_INDEX = 1, int DUMMY=0> struct T_TDC_INTERFACE_ARRAY
2511 #else
2512 template<class T /*T_INTERFACE*/, int MAX_INDEX = 1> struct T_TDC_INTERFACE_ARRAY
2513 //template<class T /*T_INTERFACE*/> struct T_TDC_INTERFACE_ARRAY
2514 #endif
2515 :T_TDC_INTERFACE_ARRAY_BASE
2516 {
2517 public:
2518 T& operator [] (int index)//HINT: blah
2519 {
2520 return *(T*)get_element_navigation (index, new_element_interface, T::implement_new_handle);
2521 }
2522 T* operator-> ()//HINT: blah
2523 {
2524 return (T*)get_element_navigation (0, new_element_interface, T::implement_new_handle);
2525 }
2526 #if DOT_COMPLETE_MEMBERS
2527 #else//DOT_COMPLETE_MEMBERS
2528 T_TDC_INTERFACE_ARRAY ()
2529 {
2530 //nothing
2531 }
2532 void assign (const T_TDC_INT_U8* array, unsigned size, void *address)
2533 {
2534 copy_basic_array (array, size, address);
2535 }
2536 void assign (const T_TDC_INT_S8* array, unsigned size, void *address)
2537 {
2538 copy_basic_array (array, size, address);
2539 }
2540 void assign (const T_TDC_INT_U16* array, unsigned size, void *address)
2541 {
2542 copy_basic_array (array, size, address);
2543 }
2544 void assign (const T_TDC_INT_S16* array, unsigned size, void *address)
2545 {
2546 copy_basic_array (array, size, address);
2547 }
2548 void assign (const T_TDC_INT_U32* array, unsigned size, void *address)
2549 {
2550 copy_basic_array (array, size, address);
2551 }
2552 void assign (const T_TDC_INT_S32* array, unsigned size, void *address)
2553 {
2554 copy_basic_array (array, size, address);
2555 }
2556 void assign (const T_TDC_ACTION& action_, unsigned size, void *address)
2557 {
2558 set_action(action_);
2559 }
2560 /*template <class U>
2561 void assign (const U* u, unsigned size)
2562 {
2563 //TDC_TBD();
2564 }*/
2565 template <class U>
2566 void assign (const T_ARRAY<U>& src, unsigned size, void *address)
2567 {
2568 T_TDC_COPY handle = make_descriptor_ref (TDC_RW_MODE_WRITE);
2569 handle.copy_descriptor_ref (src.handle);
2570 }
2571 void assign (const T* t, unsigned size, void *address)
2572 {
2573 //tdc_check_array_assignment(array, address);
2574 tdc_tbd_array_assignment_error();
2575 }
2576 void assign (const T::T_INSTANCE* array, unsigned size, void *address)
2577 {
2578 tdc_check_array_assignment(array, address);
2579 //copy_instance_array (array, size);
2580 T_TDC_COPY handle = make_descriptor_ref (TDC_RW_MODE_WRITE);
2581 T_TDC_HANDLE_BASE* descriptor_ref = handle.descriptor_ref;
2582 T_TDC_DESCRIPTOR_BASE* descriptor = descriptor_ref->make_descriptor ();
2583 T_TDC_HANDLE_BASE** elements = ((T_TDC_DESCRIPTOR_ARRAY_BASE*)descriptor)->get_elements();
2584 if (!*elements)
2585 *elements = T::implement_new_handle ();
2586 int count = size / sizeof *array;
2587
2588 for (int i = 0; i < count; i++)
2589 {
2590 T_TDC_COPY dst_element = descriptor->make_element(i);
2591 const_T_TDC_COPY src_element = (T_TDC_HANDLE_BASE*) array[i].handle;
2592 dst_element.copy_descriptor_ref (src_element);
2593 }
2594 }
2595 template <class U>
2596 T_TDC_INTERFACE_ARRAY& operator = (const U& array)
2597 {
2598 int size = sizeof array; /* if you have error "illegal indirection" here the right hand operator can not be converted to an array
2599 see next error message for the bad assignment */
2600 assign (array, size, (void*)&array);
2601 return *this;
2602 }
2603 private:
2604 static T_TDC_INTERFACE_BASE* new_element_interface()
2605 {
2606 return new T;
2607 }
2608 #endif//DOT_COMPLETE_MEMBERS
2609 };
2610
2611 /*
2612 ** TODO: Function header (this is a comment for an bug fix)
2613 **
2614 ** When we change T_TDC_INTERFACE_ARRAY we have to change T_TDC_INTERFACE_POINTER too
2615 ** template<class T TDC_HIDDEN_LEVEL_DEF > struct T_TDC_INTERFACE_POINTER:T_TDC_INTERFACE_ARRAY<T, 1 TDC_HIDDEN_LEVEL>
2616 */
2617
2618 struct T_TDC_INTERFACE_POINTER_BASE:T_TDC_INTERFACE_REF_BASE
2619 {
2620 protected:
2621 T_TDC_INTERFACE_BASE* get_navigation(T_TDC_NEW_INTERFACE new_element_interface, T_TDC_NEW_HANDLE new_handle);
2622 T_TDC_INTERFACE_BASE* get_navigation(T_TDC_NEW_INTERFACE new_element_interface, T_TDC_NEW_HANDLE new_handle, int index);
2623 };
2624
2625 template<class T_INTERFACE> struct T_TDC_INTERFACE_POINTER
2626 #if DOT_COMPLETE
2627 #else
2628 :T_TDC_INTERFACE_POINTER_BASE
2629 #endif
2630 {
2631 T_INTERFACE* operator-> ()
2632 {
2633 return (T_INTERFACE*)get_navigation (new_element_interface, T_INTERFACE::implement_new_handle);
2634 }
2635 #if DOT_COMPLETE_MEMBERS
2636 #else//DOT_COMPLETE_MEMBERS
2637 T_INTERFACE& operator [] (int index)
2638 {
2639 return *(T_INTERFACE*)get_navigation (new_element_interface, T_INTERFACE::implement_new_handle, index);
2640 }
2641 static T_TDC_INTERFACE_BASE* new_element_interface()
2642 {
2643 return new T_INTERFACE;
2644 }
2645 /*T_TDC_INTERFACE_POINTER ()
2646 {
2647 //nothing
2648 }*/
2649 #endif//DOT_COMPLETE_MEMBERS
2650 };
2651
2652 //============================================================================
2653
2654 #if TDC_DEBUG_DOT_COMPLETE
2655 struct T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1P
2656 {
2657 int i1P;
2658 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 operator->(){return 0;}
2659 };
2660 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1P()
2661 {
2662 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
2663 s.
2664 i;
2665 s->
2666 i0;
2667 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1P s1P;
2668 s1P->
2669 i0;
2670 T_TDC_INTERFACE_ARRAY<int> i;
2671 i.assign(0,0);
2672 T_ARRAY<int> array;
2673 array.
2674
2675 }
2676 #else
2677 #endif
2678
2679 //----------------------------------------------------------------------------
2680 // T_TDC_INTERFACE
2681 //----------------------------------------------------------------------------
2682
2683 struct T_TDC_INTERFACE_PRIM_BASE:T_TDC_INTERFACE_PRIMITIVE_BASE
2684 {
2685 T_TDC_INTERFACE_PRIM_BASE ()
2686 {
2687 level[0] = 'A'+tdc_level;
2688 tdc_level++;
2689 }
2690 #if DOT_COMPLETE_MEMBERS//{{
2691 T_TDC_ASSIGN_ACTION _require () {} // you can use '= REQUIRE' as well
2692 #else//}DOT_COMPLETE_MEMBERS{
2693 T_TDC_ASSIGN_ACTION tdc_require() // you can use '= REQUIRE' as well
2694 {
2695 return set_action (REQUIRE);
2696 }
2697 #endif//}}DOT_COMPLETE_MEMBERS
2698 };
2699
2700 struct T_TDC_INTERFACE_PSTRUCT_BASE:T_TDC_INTERFACE_REF
2701 {
2702 };
2703
2704 struct T_TDC_INTERFACE_PUNION_BASE:T_TDC_INTERFACE_REF
2705 {
2706 };
2707
2708 struct T_TDC_INTERFACE_SDU_BASE:T_TDC_INTERFACE_REF
2709 {
2710 };
2711
2712 struct T_TDC_INTERFACE_PENUM_BASE:T_TDC_INTERFACE_VAR
2713 {
2714 };
2715
2716 struct T_TDC_INTERFACE_MSG_BASE:T_TDC_INTERFACE_MESSAGE_BASE
2717 {
2718 T_TDC_INTERFACE_MSG_BASE ()
2719 {
2720 level[0] = 'A'+tdc_level;
2721 tdc_level++;
2722 }
2723 #if DOT_COMPLETE_MEMBERS
2724 T_TDC_ASSIGN_ACTION _require () {} // you can use '= REQUIRE' as well
2725 #else//DOT_COMPLETE_MEMBERS
2726 T_TDC_ASSIGN_ACTION tdc_require() // you can use '= REQUIRE' as well
2727 {
2728 return set_action (REQUIRE);
2729 }
2730 #endif//DOT_COMPLETE_MEMBERS
2731 };
2732
2733 struct T_TDC_INTERFACE_MSTRUCT_BASE:T_TDC_INTERFACE_REF
2734 {
2735 };
2736
2737 struct T_TDC_INTERFACE_MUNION_BASE:T_TDC_INTERFACE_REF
2738 {
2739 };
2740
2741 struct T_TDC_INTERFACE_MENUM_BASE:T_TDC_INTERFACE_VAR
2742 {
2743 };
2744
2745 struct T_TDC_INTERFACE_INT_BASE:T_TDC_INTERFACE_VAR
2746 {
2747 };
2748
2749 struct T_TDC_INTERFACE_XXX_PRIMITIVE_UNION_BASE:T_TDC_INTERFACE_PRIMITIVE_BASE
2750 {
2751 T_TDC_INTERFACE_XXX_PRIMITIVE_UNION_BASE ()
2752 {
2753 level[0] = 'A'+tdc_level;
2754 tdc_level++;
2755 }
2756 };
2757
2758 struct T_TDC_INTERFACE_XXX_MESSAGE_UNION_BASE:T_TDC_INTERFACE_MESSAGE_BASE
2759 {
2760 T_TDC_INTERFACE_XXX_MESSAGE_UNION_BASE ()
2761 {
2762 level[0] = 'A'+tdc_level;
2763 tdc_level++;
2764 }
2765 };
2766
2767 struct T_TDC_INTERFACE_PRIMITIVE_UNION_BASE:T_TDC_INTERFACE_PRIMITIVE_BASE
2768 {
2769 T_TDC_INTERFACE_PRIMITIVE_UNION_BASE ()
2770 {
2771 level[0] = 'A'+tdc_level;
2772 tdc_level++;
2773 }
2774 };
2775
2776 struct T_TDC_INTERFACE_MESSAGE_UNION_BASE:T_TDC_INTERFACE_MESSAGE_BASE
2777 {
2778 T_TDC_INTERFACE_MESSAGE_UNION_BASE ()
2779 {
2780 level[0] = 'A'+tdc_level;
2781 tdc_level++;
2782 }
2783 };
2784
2785 #if TDC_DEBUG_DOT_COMPLETE
2786 struct T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1Q
2787 {
2788 int i1Q;
2789 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 operator->(){return 0;}
2790 };
2791 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1Q()
2792 {
2793 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
2794 s.
2795 i;
2796 s->
2797 i0;
2798 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1Q s1Q;
2799 s1Q->
2800 i;
2801 }
2802 #else
2803 #endif
2804
2805 template<class T> struct T_TDC_INTERFACE_XXX_PRIMITIVE:T_TDC_INTERFACE_POINTER_MAIN<T TDC_HIDDEN_LEVEL_MAIN(T_TDC_INTERFACE_PRIMITIVE_BASE) >
2806 {
2807 };
2808
2809 template<class T> struct T_TDC_INTERFACE_XXX_MESSAGE:T_TDC_INTERFACE_POINTER_MAIN<T TDC_HIDDEN_LEVEL_MAIN(T_TDC_INTERFACE_MESSAGE_BASE) >
2810 {
2811 };
2812
2813 template<class T> struct T_TDC_INTERFACE_PRIMITIVE:T_TDC_INTERFACE_POINTER_MAIN<T TDC_HIDDEN_LEVEL_MAIN(T_TDC_INTERFACE_PRIMITIVE_BASE) >
2814 {
2815 };
2816
2817 template<class T> struct T_TDC_INTERFACE_PRIMITIVE_UNION_POINTER:T_TDC_INTERFACE_POINTER_MAIN<T TDC_HIDDEN_LEVEL_MAIN(T_TDC_INTERFACE_PRIMITIVE_BASE) >
2818 {
2819 };
2820
2821 template<class T> struct T_TDC_INTERFACE_MESSAGE:T_TDC_INTERFACE_POINTER_MAIN<T TDC_HIDDEN_LEVEL_MAIN(T_TDC_INTERFACE_MESSAGE_BASE) >
2822 {
2823 };
2824
2825 template<class T> struct T_TDC_INTERFACE_MESSAGE_UNION_POINTER:T_TDC_INTERFACE_POINTER_MAIN<T TDC_HIDDEN_LEVEL_MAIN(T_TDC_INTERFACE_MESSAGE_BASE) >
2826 {
2827 };
2828
2829 //\}
2830
2831 #if TDC_DEBUG_DOT_COMPLETE
2832 struct T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1Q1
2833 {
2834 int i1Q1;
2835 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 operator->(){return 0;}
2836 };
2837 struct T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1Q1u
2838 {
2839 int i1Q1u;
2840 };
2841 template<class T>
2842 struct T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1Q1t1
2843 {
2844 int i1Q1t;
2845 //T* operator->(){return 0;}
2846 };
2847 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1Q1()
2848 {
2849 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1Q1 s1Q1;
2850 s1Q1->
2851 i;
2852 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1Q1t1<T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1Q1u> s1Q1t1u;
2853 s1Q1t1u.
2854 i1Q1t;
2855 s1Q1t1u->
2856 i1Q1u;
2857 /*T_TDC_INTERFACE_PRIMITIVE_UNION_POINTER z1Q1_;
2858 z1Q1_->
2859 i;*/
2860 T_TDC_INTERFACE_PRIMITIVE_UNION_POINTER<T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1Q1> z1Q1;
2861 z1Q1.
2862 x;
2863 z1Q1->
2864 i;
2865 }
2866 #else
2867 #endif
2868
2869 //============================================================================
2870
2871 #if TDC_DEBUG_DOT_COMPLETE
2872 struct T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1R
2873 {
2874 int i1R;
2875 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 operator->(){return 0;}
2876 };
2877 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1R()
2878 {
2879 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
2880 s.
2881 i;
2882 s->
2883 i0;
2884 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1R s1R;
2885 s1R->
2886 i0;
2887 }
2888 #else
2889 #endif
2890
2891 //----------------------------------------------------------------------------
2892 /// \defgroup T_TDC_DESCRIPTOR T_TDC_DESCRIPTOR
2893 /// base classes to repeat stuff that is similar in many descriptor classes
2894 //----------------------------------------------------------------------------
2895 //\{
2896
2897 struct T_TDC_DESCRIPTOR_ARRAY_BASE:T_TDC_DESCRIPTOR_BASE
2898 {
2899 int tap_handle;
2900 int implement_get_tap_array_handle (unsigned c_elements, T_TDC_DESCRIPTOR_BASE* sdu_handle);
2901 int get_tap_array_handle (unsigned c_elements);
2902 bool skip_to_end;
2903 virtual T_TDC_IS_ENUM is ();
2904 virtual void set_skip_to_end (bool skip_to_end_);
2905 virtual bool get_skip_to_end ();
2906 T_TDC_DESCRIPTOR_ARRAY_BASE ();
2907 virtual char* get_name () const;
2908 ~T_TDC_DESCRIPTOR_ARRAY_BASE ();
2909 T_TDC_HANDLE_BASE** get_elements();
2910 unsigned get_c_elements();
2911 void set_c_elements(unsigned c_elements);
2912 T_TDC_HANDLE_BASE* make_element (unsigned index);
2913 T_TDC_HANDLE_BASE* get_element (unsigned index);
2914 };
2915
2916 template<class T, int MAX_INDEX = 1>
2917 struct T_TDC_DESCRIPTOR_ARRAY:T_TDC_DESCRIPTOR_ARRAY_BASE
2918 {
2919 typedef T_TDC_DESCRIPTOR_ARRAY<T, MAX_INDEX> T_DESCRIPTOR_ARRAY;
2920 friend T_TDC_DESCRIPTOR_BASE * new_T_DESCRIPTOR_ARRAY(void)
2921 {
2922 return new T_TDC_DESCRIPTOR_ARRAY<T, MAX_INDEX>;
2923 }
2924 unsigned c_elements;
2925 typedef T T_ELEMENT;
2926 T_ELEMENT* elements;
2927 T_TDC_DESCRIPTOR_ARRAY()
2928 {
2929 c_elements = 0;
2930 elements = 0;
2931 }
2932 virtual int get_tap_handle ()
2933 {
2934 return get_tap_array_handle (c_elements);
2935 }
2936 #ifndef TDC_TEST_PROFILE
2937 virtual long get_sizeof ()
2938 {
2939 /* this function should never be called but the base version have no chance of returning a proper value so we keep it just in case */
2940 TDC_DYNAMIC_DEAD_CODE();
2941 return sizeof *this;
2942 }
2943 #endif
2944 };
2945
2946 struct T_TDC_HANDLE_ARRAY_BASE:T_TDC_HANDLE_BASE
2947 {
2948 virtual char* get_name () const;
2949 virtual T_TDC_IS_ENUM is ()
2950 {
2951 return TDC_IS_ARRAY;
2952 }
2953 };
2954
2955 template<class T, int MAX_INDEX = 1>
2956 struct T_TDC_HANDLE_ARRAY:T_TDC_HANDLE_ARRAY_BASE
2957 {
2958 typedef T_TDC_DESCRIPTOR_ARRAY<T, MAX_INDEX> T_DESCRIPTOR_ARRAY;
2959 virtual long get_sizeof ()
2960 {
2961 return sizeof *this;
2962 }
2963 M_TDC_DESCRIPTOR_HANDLE_ADDITIONAL_PART (T_DESCRIPTOR_ARRAY)
2964 protected:
2965 virtual T_TDC_DESCRIPTOR_BASE* implement_new_descriptor () const;
2966 };
2967
2968 #if DOT_COMPLETE
2969 #else
2970 // the dot complete compiler can not handle this code
2971 template<class T, int MAX_INDEX>
2972 T_TDC_DESCRIPTOR_BASE* T_TDC_HANDLE_ARRAY<T, MAX_INDEX>::implement_new_descriptor(void) const
2973 {
2974 //return new T_DESCRIPTOR_ARRAY;
2975 /*TODO: We don't allways need the element array and the code was once remove
2976 but it seems like there are still problems with code like:
2977 T_ARRAY<T_S8> parray_ps8c;
2978 parray_ps8c[0]. _require;
2979 */
2980 T_DESCRIPTOR_ARRAY *descriptor = new T_DESCRIPTOR_ARRAY;
2981 /*T_TDC_HANDLE_BASE** elements = ((T_TDC_DESCRIPTOR_ARRAY_BASE*)descriptor)->get_elements();
2982 if (!*elements)
2983 //*elements = new_handle ();
2984 *elements = T::implement_new_handle();*/
2985 return descriptor;
2986 }
2987 #endif
2988
2989 #ifdef TDC_SIMULATE_POINTER
2990 #define T_TDC_DESCRIPTOR_POINTER T_TDC_DESCRIPTOR_ARRAY
2991 #define T_TDC_HANDLE_POINTER T_TDC_HANDLE_ARRAY
2992 #else
2993
2994 struct T_TDC_DESCRIPTOR_POINTER_BASE:T_TDC_DESCRIPTOR_BASE
2995 {
2996 virtual T_TDC_IS_ENUM is ();
2997 virtual char* get_name () const;
2998 T_TDC_HANDLE_BASE** get_elements();
2999 virtual T_TDC_HANDLE_BASE* get_element (unsigned index);
3000 virtual int get_tap_handle ();
3001 //virtual int read_ctrl () const;
3002 };
3003
3004 template<class T /*T_HANDLE*/> struct T_TDC_DESCRIPTOR_POINTER:T_TDC_DESCRIPTOR_POINTER_BASE
3005 {
3006 typedef T_TDC_DESCRIPTOR_POINTER<T> T_DESCRIPTOR_POINTER;
3007 friend T_TDC_DESCRIPTOR_BASE * new_T_DESCRIPTOR_POINTER(void)
3008 {
3009 return new T_TDC_DESCRIPTOR_POINTER<T, MAX_INDEX>;
3010 }
3011 //T::T_DESCRIPTOR element;
3012 T* element;
3013 //T element;
3014 #ifndef TDC_TEST_PROFILE
3015 virtual long get_sizeof ()
3016 {
3017 /* this function should never be called but the base version have no chance of returning a proper value so we keep it just in case */
3018 TDC_DYNAMIC_DEAD_CODE();
3019 return sizeof *this;
3020 }
3021 #endif
3022 };
3023
3024 struct T_TDC_HANDLE_POINTER_BASE:T_TDC_HANDLE_BASE
3025 {
3026 virtual char* get_name () const;
3027 virtual T_TDC_IS_ENUM is ()
3028 {
3029 return TDC_IS_POINTER;
3030 }
3031 virtual T_TDC_DESCRIPTOR_BASE* implement_new_descriptor () const;
3032 };
3033
3034 template<class T> struct T_TDC_HANDLE_POINTER:T_TDC_HANDLE_POINTER_BASE
3035 {
3036 typedef T_TDC_DESCRIPTOR_POINTER<T> T_DESCRIPTOR_POINTER;
3037 virtual long get_sizeof ()
3038 {
3039 return sizeof *this;
3040 }
3041 M_TDC_DESCRIPTOR_HANDLE_ADDITIONAL_PART (T_DESCRIPTOR_POINTER)
3042 protected:
3043 virtual T_TDC_DESCRIPTOR_BASE* implement_new_descriptor () const;
3044 };
3045
3046 #if DOT_COMPLETE
3047 #else
3048 // the dot complete compiler can not handle this code
3049 template<class T>
3050 T_TDC_DESCRIPTOR_BASE* T_TDC_HANDLE_POINTER<T>::implement_new_descriptor(void) const
3051 {
3052 return new T_DESCRIPTOR_POINTER;
3053 }
3054 #endif
3055
3056 #endif
3057
3058 //----------------------------------------------------------------------------
3059
3060 struct T_TDC_DESCRIPTOR_MAIN_BASE:T_TDC_DESCRIPTOR_BASE
3061 {
3062 virtual int get_id () const
3063 TDC_PURE_BODY(
3064 return 0;
3065 )
3066 T_TDC_HANDLE_BASE* get_element (unsigned index)
3067 {
3068 char *first_element = (char*) this + sizeof *this;
3069 return implement_get_element (index, first_element);
3070 }
3071 };
3072
3073 struct T_TDC_DESCRIPTOR_XSTRUCT_BASE:T_TDC_DESCRIPTOR_BASE
3074 {
3075 int tap_handle;
3076 int get_tap_xstruct_handle (T_TDC_TABLE_KIND table_kind);
3077 T_TDC_DESCRIPTOR_XSTRUCT_BASE ();
3078 ~T_TDC_DESCRIPTOR_XSTRUCT_BASE ();
3079 T_TDC_HANDLE_BASE* get_element (unsigned index);
3080 };
3081
3082 struct T_TDC_DESCRIPTOR_INT_BASE:T_TDC_HANDLE_BASE
3083 {
3084 virtual int get_tap_handle ();
3085 };
3086
3087 //-----
3088
3089 struct T_TDC_DESCRIPTOR_PRIM_BASE:T_TDC_DESCRIPTOR_MAIN_BASE
3090 {
3091 virtual T_TDC_IS_ENUM is ()
3092 {
3093 return T_TDC_IS_ENUM (TDC_IS_COMP | TDC_IS_PRIM);
3094 }
3095 };
3096
3097 struct T_TDC_DESCRIPTOR_PSTRUCT_BASE:T_TDC_DESCRIPTOR_XSTRUCT_BASE
3098 {
3099 virtual T_TDC_IS_ENUM is ()
3100 {
3101 return TDC_IS_STRUCT;
3102 }
3103 virtual int get_tap_handle ();
3104 };
3105
3106 struct T_TDC_DESCRIPTOR_PUNION_BASE:T_TDC_DESCRIPTOR_BASE
3107 {
3108 virtual T_TDC_IS_ENUM is ()
3109 {
3110 return TDC_IS_UNION;
3111 }
3112 };
3113
3114 struct T_TDC_DESCRIPTOR_SDU_BASE:T_TDC_DESCRIPTOR_BASE
3115 {
3116 virtual T_TDC_IS_ENUM is ()
3117 {
3118 return TDC_IS_SDU;
3119 }
3120 virtual int get_tap_handle ()
3121 {
3122 return TDC_DUMMY_TAP_HANDLE;
3123 }
3124 void invoke_tap (T_TDC_EVENT_ENUM event) const;
3125 };
3126
3127 struct T_TDC_DESCRIPTOR_PENUM_BASE:T_TDC_HANDLE_BASE
3128 {
3129 virtual int get_tap_handle ();
3130 virtual T_TDC_IS_ENUM is ()
3131 {
3132 return TDC_IS_PVAR;
3133 }
3134 };
3135
3136 //-----
3137
3138 struct T_TDC_DESCRIPTOR_MSG_BASE:T_TDC_DESCRIPTOR_MAIN_BASE
3139 {
3140 virtual T_TDC_IS_ENUM is ()
3141 {
3142 return T_TDC_IS_ENUM (TDC_IS_COMP | TDC_IS_MSG);
3143 }
3144 };
3145
3146 struct T_TDC_DESCRIPTOR_MSTRUCT_BASE:T_TDC_DESCRIPTOR_XSTRUCT_BASE
3147 {
3148 virtual T_TDC_IS_ENUM is ()
3149 {
3150 return TDC_IS_STRUCT;
3151 }
3152 virtual int get_tap_handle ();
3153 };
3154
3155 struct T_TDC_DESCRIPTOR_MUNION_BASE:T_TDC_DESCRIPTOR_BASE
3156 {
3157 virtual T_TDC_IS_ENUM is ()
3158 {
3159 return TDC_IS_UNION;
3160 }
3161 };
3162
3163 struct T_TDC_DESCRIPTOR_MENUM_BASE:T_TDC_HANDLE_BASE
3164 {
3165 virtual int get_tap_handle ();
3166 virtual T_TDC_IS_ENUM is ()
3167 {
3168 return TDC_IS_MVAR;
3169 }
3170 };
3171
3172 //-----
3173
3174 struct T_TDC_DESCRIPTOR_XXX_PRIMITIVE_UNION_BASE:T_TDC_DESCRIPTOR_BASE
3175 {
3176 };
3177
3178 struct T_TDC_DESCRIPTOR_XXX_MESSAGE_UNION_BASE:T_TDC_DESCRIPTOR_BASE
3179 {
3180 };
3181
3182 struct T_TDC_DESCRIPTOR_PRIMITIVE_UNION_BASE:T_TDC_DESCRIPTOR_BASE
3183 {
3184 };
3185
3186 struct T_TDC_DESCRIPTOR_MESSAGE_UNION_BASE:T_TDC_DESCRIPTOR_BASE
3187 {
3188 //TODO: construct munions (when called from make_element_info, shold be hamless in get_element_info)
3189 };
3190
3191 //\}
3192
3193 //============================================================================
3194
3195 #if TDC_DEBUG_DOT_COMPLETE
3196 struct T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1S
3197 {
3198 int i1S;
3199 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 operator->(){return 0;}
3200 };
3201 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1S()
3202 {
3203 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
3204 s.
3205 i;
3206 s->
3207 i0;
3208 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1S s1S;
3209 s1S->
3210 i0;
3211 }
3212 #else
3213 #endif
3214
3215 //----------------------------------------------------------------------------
3216 /// \defgroup T_TDC_INSTANCE T_TDC_INSTANCE
3217 /// base classes to repeat stuff that is similar in many instance classes
3218 //----------------------------------------------------------------------------
3219 ///\{
3220
3221 struct T_TDC_INSTANCE_BASE
3222 {
3223 //private:
3224 T_TDC_HANDLE_BASE* implement_get_handle () const;
3225 void implement_set_handle(T_TDC_HANDLE_BASE* handle);
3226 //protected:
3227 virtual T_TDC_INTERFACE_BASE *new_interface () const;
3228 //public:
3229 T_TDC_INTERFACE_BASE *get_navigation () const;
3230 //protected:
3231 T_TDC_INTERFACE_BASE *get_element_navigation (int index) const;
3232 //public:
3233 T_TDC_INTERFACE_BASE *make_element_navigation (int index, T_TDC_NEW_HANDLE new_element_handle);
3234 T_TDC_HANDLE_BASE* get_descriptor_ref () const;
3235 T_TDC_ASSIGN_ACTION set_action(const T_TDC_ACTION& action_);
3236 void set_value (const T_TDC_INSTANCE_BASE& value_);
3237 void copy_instance (const T_TDC_INSTANCE_BASE * value_);
3238 void copy_interface (const T_TDC_INTERFACE_BASE * value_);
3239 T_TDC_ASSIGN_ACTION construct_from_action(const T_TDC_ACTION& action_, T_TDC_NEW_HANDLE new_handle);
3240 void construct_from_instance (const T_TDC_INSTANCE_BASE& value_, T_TDC_NEW_HANDLE new_handle);
3241 void construct_from_interface (const T_TDC_INTERFACE_BASE * value_, T_TDC_NEW_HANDLE new_handle);
3242 void set_descriptor_value (long value_);
3243 long get_descriptor_value ();
3244 bool cmp_descriptor_value (long value_);
3245 void construct_from_number (long value_, T_TDC_NEW_HANDLE new_handle);
3246 void destroy_handle ();
3247 T_TDC_HANDLE_BASE* construct_handle (T_TDC_NEW_HANDLE new_handle);
3248 T_TDC_HANDLE_BASE* construct_array_handle (T_TDC_NEW_HANDLE new_handle,T_TDC_NEW_HANDLE new_element_handle);
3249 T_TDC_DESCRIPTOR_BASE* construct_descriptor (T_TDC_NEW_HANDLE new_handle);
3250 T_TDC_DESCRIPTOR_BASE* construct_array_descriptor (T_TDC_NEW_HANDLE new_handle,T_TDC_NEW_HANDLE new_element_handle);
3251 T_TDC_INSTANCE_BASE();
3252 ~T_TDC_INSTANCE_BASE();
3253 private:
3254 ///Check for copy constructor missing in class derived from T_TDC_INSTANCE_BASE
3255 T_TDC_INSTANCE_BASE(const T_TDC_INSTANCE_BASE&);
3256 };
3257
3258 struct T_TDC_INSTANCE_MAIN_BASE:T_TDC_INSTANCE_BASE
3259 {
3260 void set_main_value (const T_TDC_INTERFACE_MAIN_BASE* value_);
3261 void set_main_value (const T_TDC_INSTANCE_MAIN_BASE* value_);
3262 void construct_main_value (const T_TDC_INTERFACE_MAIN_BASE* value_, T_TDC_NEW_HANDLE new_handle);
3263 void construct_main_value (const T_TDC_INSTANCE_MAIN_BASE* value_, T_TDC_NEW_HANDLE new_handle);
3264 };
3265
3266 struct T_TDC_INSTANCE_PART_BASE
3267 #if DOT_COMPLETE
3268 #else
3269 TDC_DOT_COMPLETE_HIDE(:T_TDC_INSTANCE_BASE)
3270 #endif
3271 {
3272 };
3273
3274 struct T_TDC_INSTANCE_PRIMITIVE_BASE
3275 #if DOT_COMPLETE
3276 #else
3277 TDC_DOT_COMPLETE_HIDE(:T_TDC_INSTANCE_MAIN_BASE)
3278 #endif
3279 {
3280 #if DOT_COMPLETE
3281 #else
3282 TDC_DOT_COMPLETE_HIDE(void invoke_tap (T_TDC_EVENT_ENUM) const;)
3283 #endif
3284 };
3285
3286 struct T_TDC_INSTANCE_MESSAGE_BASE
3287 #if DOT_COMPLETE
3288 #else
3289 TDC_DOT_COMPLETE_HIDE(:T_TDC_INSTANCE_MAIN_BASE)
3290 #endif
3291 {
3292 };
3293
3294 struct T_TDC_INSTANCE_PRIM_BASE:T_TDC_INSTANCE_PRIMITIVE_BASE
3295 {
3296 };
3297
3298 struct T_TDC_INSTANCE_PSTRUCT_BASE:T_TDC_INSTANCE_PART_BASE
3299 {
3300 };
3301
3302 struct T_TDC_INSTANCE_PUNION_BASE:T_TDC_INSTANCE_PART_BASE
3303 {
3304 };
3305
3306 struct T_TDC_INSTANCE_SDU_BASE:T_TDC_INSTANCE_PART_BASE
3307 {
3308 };
3309
3310 struct T_TDC_INSTANCE_PENUM_BASE:T_TDC_INSTANCE_PART_BASE
3311 {
3312 };
3313
3314 struct T_TDC_INSTANCE_MSG_BASE:T_TDC_INSTANCE_MESSAGE_BASE
3315 {
3316 };
3317
3318 struct T_TDC_INSTANCE_MSTRUCT_BASE:T_TDC_INSTANCE_PART_BASE
3319 {
3320 };
3321
3322 struct T_TDC_INSTANCE_MUNION_BASE:T_TDC_INSTANCE_PART_BASE
3323 {
3324 };
3325
3326 struct T_TDC_INSTANCE_MENUM_BASE:T_TDC_INSTANCE_PART_BASE
3327 {
3328 };
3329
3330 struct T_TDC_INSTANCE_INT_BASE:T_TDC_INSTANCE_PART_BASE
3331 {
3332 };
3333
3334 struct T_TDC_INSTANCE_XXX_PRIMITIVE_UNION_BASE:T_TDC_INSTANCE_PRIMITIVE_BASE
3335 {
3336 };
3337
3338 struct T_TDC_INSTANCE_XXX_MESSAGE_UNION_BASE:T_TDC_INSTANCE_MESSAGE_BASE
3339 {
3340 };
3341
3342 struct T_TDC_INSTANCE_PRIMITIVE_UNION_BASE:T_TDC_INSTANCE_PRIMITIVE_BASE
3343 {
3344 };
3345
3346 struct T_TDC_INSTANCE_MESSAGE_UNION_BASE:T_TDC_INSTANCE_MESSAGE_BASE
3347 {
3348 };
3349
3350 //----------------------------------------------------------------------------
3351
3352 struct T_TDC_INSTANCE_ARRAY_BASE
3353 #if DOT_COMPLETE
3354 #else
3355 TDC_DOT_COMPLETE_HIDE(:T_TDC_INSTANCE_BASE)
3356 #endif
3357 {
3358 #if DOT_COMPLETE_MEMBERS
3359 T_TDC_ASSIGN_ACTION _skip () {} /* you can use '= SKIP' as well */
3360 T_TDC_ASSIGN_ACTION _show () {} /* you can use '= SHOW' as well */
3361 T_TDC_ASSIGN_ACTION _forbid () {} /* you can use '= FORBID' as well */
3362 T_TDC_ASSIGN_ACTION _require () {} /* you can use '= REQUIRE' as well */
3363 #else//DOT_COMPLETE_MEMBERS
3364 T_TDC_ASSIGN_ACTION tdc_skip (); /* you can use '= SKIP' as well */
3365 T_TDC_ASSIGN_ACTION tdc_show (); /* you can use '= SHOW' as well */
3366 T_TDC_ASSIGN_ACTION tdc_forbid (); /* you can use '= FORBID' as well */
3367 T_TDC_ASSIGN_ACTION tdc_require (); /* you can use '= REQUIRE' as well */
3368 /*T_ARRAY operator = (const T_TDC_ACTION& action_)
3369 {
3370 set_action (action_);
3371 return *this;
3372 }*/
3373 #endif//DOT_COMPLETE_MEMBERS
3374 };
3375
3376 #if DOT_COMPLETE
3377 template<class T /*T_INSTANCE*/, int DUMMY> struct T_ARRAY
3378 #else
3379 template<class T /*T_INSTANCE*/> struct T_ARRAY
3380 #endif
3381 :T_TDC_INSTANCE_ARRAY_BASE
3382 {
3383 T::T_INTERFACE& operator [] (int index_)
3384 {
3385 return *(T::T_INTERFACE*)make_element_navigation(index_,T::implement_new_handle);
3386 }
3387 /*
3388 T::T_INTERFACE& operator -> ()
3389 {
3390 return *(T::T_INTERFACE*)get_element_navigation(0);
3391 }
3392 */
3393 #if DOT_COMPLETE
3394 #else
3395 typedef T_TDC_HANDLE_ARRAY<T::T_HANDLE> T_HANDLE;
3396 T_HANDLE* handle;
3397 friend T_TDC_HANDLE_BASE* new_T_HANDLE()\
3398 {
3399 return new T_HANDLE;//(T::implement_new_handle);
3400 }
3401 T_ARRAY operator = (const T_ARRAY& value_)
3402 {
3403 set_value (value_);
3404 return *this;
3405 }
3406 T_ARRAY ()
3407 {
3408 construct_array_handle(new_T_HANDLE,T::implement_new_handle);
3409 }
3410 ~T_ARRAY ()
3411 {
3412 destroy_handle();
3413 }
3414 // T_ARRAY (const T_ARRAY<T>& u1) => ambiguous call to overloaded function
3415 void assign (const T_ARRAY<T>& array, unsigned size, void* address)
3416 {
3417 construct_array_descriptor(new_T_HANDLE,T::implement_new_handle);
3418 T_TDC_COPY(handle).copy_descriptor_ref (array.handle);
3419 }
3420 template<class U1> void assign (const U1* array, unsigned size, void* address)
3421 {
3422 tdc_check_array_assignment(array, address);
3423 int count = size / sizeof *array;
3424 T_TDC_DESCRIPTOR_BASE* descriptor = construct_array_descriptor(new_T_HANDLE,T::implement_new_handle);
3425 for (int i = 0; i < count; i++)
3426 {
3427 T_TDC_COPY element = descriptor->make_element(i);
3428 element.copy_descriptor_ref ((T_TDC_HANDLE_BASE*) array[i].handle);
3429 }
3430 }
3431 void assign (const T_TDC_ACTION& action_, unsigned size, void *address)
3432 {
3433 construct_from_action (action_, new_T_HANDLE);
3434 }
3435 /*T_ARRAY (const T_ARRAY& array) //ambiguous call to overloaded function
3436 {
3437 assign (array, sizeof array, (void*)&array);
3438 }*/
3439 template<class U1> T_ARRAY (const U1& array)
3440 {
3441 assign (array, sizeof array, (void*)&array);
3442 }
3443 template<class U1> T_ARRAY (const U1& u1, T_TDC_ACTION action)
3444 {
3445 const T* array = u1;
3446 int count = sizeof u1 / sizeof *u1;
3447 T_TDC_DESCRIPTOR_BASE* descriptor = construct_array_descriptor(new_T_HANDLE,T::implement_new_handle);
3448 descriptor->set_skip_to_end_from_action (action.action);
3449 for (int i = 0; i < count; i++)
3450 {
3451 T_TDC_COPY element = descriptor->make_element(i);
3452 element.copy_descriptor_ref ((T_TDC_HANDLE_BASE*) array[i].handle);
3453 }
3454 }
3455 template<class U1> T_ARRAY (const U1& u1, T_TDC_CREATE_ACTION action)
3456 {
3457 const T* array = u1;
3458 int count = sizeof u1 / sizeof *u1;
3459 T_TDC_DESCRIPTOR_BASE* descriptor = construct_array_descriptor(new_T_HANDLE,T::implement_new_handle);
3460 descriptor->set_skip_to_end_from_action (action.action);
3461 for (int i = 0; i < count; i++)
3462 {
3463 T_TDC_COPY element = descriptor->make_element(i);
3464 element.copy_descriptor_ref ((T_TDC_HANDLE_BASE*) array[i].handle);
3465 }
3466 }
3467 template<class U1, class U2> T_ARRAY (const U1& u1, const U2& u2)
3468 {
3469 tdc_tbd_array_assignment_error_T_ARRAY();
3470 }
3471 /*
3472 template<class U1, class U2, class U3> T_ARRAY (U1 u1, U2 u2, U3 u3)
3473 {
3474 TDC_TBD();
3475 }
3476 template<class U1, class U2, class U3, class U4> T_ARRAY (U1 u1, U2 u2, U3 u3, U4 u4)
3477 {
3478 TDC_TBD();
3479 }
3480 template<class U1, class U2, class U3, class U4, class U5> T_ARRAY (U1 u1, U2 u2, U3 u3, U4 u4, U5 u5)
3481 {
3482 TDC_TBD();
3483 }
3484 */
3485 virtual T_TDC_INTERFACE_BASE *new_interface () const
3486 {
3487 return new T::T_INTERFACE;
3488 }
3489 #endif
3490 };
3491
3492
3493 #define M_TDC_BASIC_ARRAY(T_BASIC)\
3494 T_ARRAY ()\
3495 {\
3496 /*construct_handle(new_T_HANDLE);*/\
3497 }\
3498 template<class U1>\
3499 T_ARRAY (const U1& array, T_TDC_ACTION action)\
3500 {\
3501 assign (array, sizeof array, (void*)&array, action);\
3502 }\
3503 template<class U1>\
3504 T_ARRAY (const U1& array)\
3505 {\
3506 assign (array, sizeof array, (void*)&array, TDC_ACTION_UNKNOWN);\
3507 }\
3508 T_ARRAY operator = (const T_ARRAY& value_)\
3509 {\
3510 set_value (value_);\
3511 return *this;\
3512 }\
3513 T_ARRAY operator = (const T_TDC_ACTION& action_)\
3514 {\
3515 construct_from_action (action_,new_T_HANDLE);\
3516 return *this;\
3517 }\
3518
3519 template<class T, class T_BASIC> struct T_TDC_INSTANCE_BASIC_ARRAY:T_TDC_INSTANCE_ARRAY_BASE
3520 {
3521 typedef T_TDC_HANDLE_ARRAY<T::T_HANDLE> T_HANDLE;
3522 T_HANDLE* handle;
3523 static T_TDC_HANDLE_BASE* new_T_HANDLE()\
3524 {
3525 return new T_HANDLE;//(T::implement_new_handle);
3526 }
3527 T_TDC_INSTANCE_BASIC_ARRAY ()
3528 {
3529 construct_array_descriptor(new_T_HANDLE,T::implement_new_handle);
3530 }
3531 void assign (const T_BASIC* array, unsigned size, void* address, T_TDC_ACTION action)
3532 {
3533 tdc_check_array_assignment(array, address);
3534 unsigned count = size / sizeof T_BASIC;
3535 T_TDC_DESCRIPTOR_BASE* descriptor = construct_array_descriptor(new_T_HANDLE,T::implement_new_handle);
3536 descriptor->set_skip_to_end_from_action (action.action);
3537 for (int i = 0; i < count; i++)
3538 {
3539 T_TDC_COPY element= descriptor->make_element(i);
3540 element.copy_number (array[i]);
3541 }
3542 }
3543 void assign (const T_BASIC* array, unsigned size, void* address, T_TDC_CREATE_ACTION action)
3544 {
3545 tdc_check_array_assignment(array, address);
3546 unsigned count = size / sizeof T_BASIC;
3547 T_TDC_DESCRIPTOR_BASE* descriptor = construct_array_descriptor(new_T_HANDLE,T::implement_new_handle);
3548 descriptor->set_skip_to_end_from_action (action.action);
3549 for (int i = 0; i < count; i++)
3550 {
3551 T_TDC_COPY element= descriptor->make_element(i);
3552 element.copy_number (array[i]);
3553 }
3554 }
3555 void assign (const T_ARRAY<T>& array, unsigned size, void* address)
3556 {
3557 construct_array_descriptor(new_T_HANDLE,T::implement_new_handle);
3558 T_TDC_COPY(handle).copy_descriptor_ref (array.handle);
3559 }
3560 template<class U1> void assign (const U1* array, unsigned size, void* address)
3561 {
3562 tdc_check_array_assignment(array, address);
3563 int count = size / sizeof *array;
3564 T_TDC_DESCRIPTOR_BASE* descriptor = construct_array_descriptor(new_T_HANDLE,T::implement_new_handle);
3565 for (int i = 0; i < count; i++)
3566 {
3567 T_TDC_COPY element = descriptor->make_element(i);
3568 element.copy_descriptor_ref ((T_TDC_HANDLE_BASE*) array[i].handle);
3569 }
3570 }
3571 void assign (const T_TDC_ACTION& action_, unsigned size, void *address)
3572 {
3573 construct_from_action (action_, new_T_HANDLE);
3574 }
3575 void assign (const T_ARRAY<T_BASIC>& array, unsigned size, void* address, T_TDC_ACTION action)
3576 {
3577 construct_from_instance(array,new_T_HANDLE);
3578 }
3579 T::T_INTERFACE& operator [] (int index_)
3580 {
3581 return *(T::T_INTERFACE*)get_element_navigation(index_);
3582 }
3583 virtual T_TDC_INTERFACE_BASE *new_interface () const
3584 {
3585 return new T::T_INTERFACE;
3586 }
3587 };
3588
3589 //\}
3590
3591 //============================================================================
3592
3593 #if TDC_DEBUG_DOT_COMPLETE
3594 struct T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W
3595 {
3596 int i1W;
3597 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 operator->(){return 0;}
3598 };
3599 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W()
3600 {
3601 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
3602 s.
3603 i;
3604 s->
3605 i0;
3606 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W s1W;
3607 s1W->
3608 i0;
3609 }
3610 #else
3611 #endif
3612
3613 //============================================================================
3614 /// \defgroup BuildInTypes build in types
3615 //============================================================================
3616 //\{
3617
3618 //#pragma M_TDC_MESSAGE (M_TDC_STRING(M_TDC_FORWARD_INT (U8)))
3619 M_TDC_FORWARD_INT (U8)
3620 M_TDC_FORWARD_INT (S8)
3621 M_TDC_FORWARD_INT (U16)
3622 M_TDC_FORWARD_INT (S16)
3623 M_TDC_FORWARD_INT (U32)
3624 M_TDC_FORWARD_INT (S32)
3625
3626 M_TDC_FORWARD_PSTRUCT (raw)
3627 M_TDC_FORWARD_PSTRUCT (aim)
3628 M_TDC_FORWARD_COMP (MESSAGE_UNION,TDC_IS_MESSAGE_UNION)
3629
3630 //M_TDC_FORWARD_MSTRUCT(COMP_STENCIL)
3631 M_TDC_FORWARD_BASE(COMP_STENCIL, T_TDC_HANDLE_COMP_STENCIL)
3632 M_TDC_HANDLE(M_TDC_IN_CLASS,M_TDC_WITHOUT_BODY,COMP_STENCIL,TDC_IS_COMP)
3633
3634 #ifndef TDC_DOT_COMPLETE_HIDE_PROTOTYPES
3635 struct T_PRIMITIVE_UNION;
3636 struct T_TDC_INTERFACE_PRIMITIVE_UNION;
3637 struct T_TDC_DESCRIPTOR_PRIMITIVE_UNION;
3638 struct T_TDC_HANDLE_PRIMITIVE_UNION;
3639 T_TDC_HANDLE_BASE* new_T_TDC_HANDLE_PRIMITIVE_UNION();
3640
3641 struct T_MESSAGE_UNION;
3642 struct T_TDC_INTERFACE_MESSAGE_UNION;
3643 struct T_TDC_DESCRIPTOR_MESSAGE_UNION;
3644 struct T_TDC_HANDLE_MESSAGE_UNION;
3645 T_TDC_HANDLE_BASE* new_T_TDC_HANDLE_MESSAGE_UNION();
3646 #endif
3647
3648 struct T_TDC_DESCRIPTOR_S8:T_TDC_DESCRIPTOR_INT_BASE
3649 {
3650 M_TDC_DESCRIPTOR_INT_ADDITIONAL (S8)
3651 };
3652
3653 struct T_TDC_DESCRIPTOR_U8:T_TDC_DESCRIPTOR_INT_BASE
3654 {
3655 M_TDC_DESCRIPTOR_INT_ADDITIONAL (U8)
3656 };
3657
3658 struct T_TDC_DESCRIPTOR_S16:T_TDC_DESCRIPTOR_INT_BASE
3659 {
3660 M_TDC_DESCRIPTOR_INT_ADDITIONAL (S16)
3661 };
3662
3663 struct T_TDC_DESCRIPTOR_U16:T_TDC_DESCRIPTOR_INT_BASE
3664 {
3665 M_TDC_DESCRIPTOR_INT_ADDITIONAL (U16)
3666 };
3667
3668 struct T_TDC_DESCRIPTOR_S32:T_TDC_DESCRIPTOR_INT_BASE
3669 {
3670 M_TDC_DESCRIPTOR_INT_ADDITIONAL (S32)
3671 };
3672
3673 struct T_TDC_DESCRIPTOR_U32:T_TDC_DESCRIPTOR_INT_BASE
3674 {
3675 M_TDC_DESCRIPTOR_INT_ADDITIONAL (U32)
3676 };
3677
3678 struct T_TDC_DESCRIPTOR_raw:T_TDC_DESCRIPTOR_PSTRUCT_BASE
3679 {
3680 M_TDC_DESCRIPTOR_PSTRUCT_ADDITIONAL (raw)
3681 T_TDC_HANDLE_U16 l_buf;
3682 T_TDC_HANDLE_U16 o_buf;
3683 T_TDC_HANDLE_ARRAY<T_TDC_DESCRIPTOR_U8> buf;
3684 virtual int get_tap_handle ();
3685 };
3686
3687 struct T_TDC_DESCRIPTOR_COMP_STENCIL:T_TDC_DESCRIPTOR_MSTRUCT_BASE
3688 {
3689 M_TDC_DESCRIPTOR_MSTRUCT_ADDITIONAL (COMP_STENCIL)
3690 };
3691
3692 struct T_TDC_DESCRIPTOR_VAR_STENCIL:T_TDC_DESCRIPTOR_MENUM_BASE
3693 {
3694 typedef long T_TDC_ENUM_VAR_STENCIL;
3695 M_TDC_DESCRIPTOR_MENUM_ADDITIONAL (VAR_STENCIL)
3696 };
3697
3698 #if TDC_DEBUG_DOT_COMPLETE
3699 struct T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W1
3700 {
3701 int i1W1;
3702 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 operator->(){return 0;}
3703 };
3704 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W1()
3705 {
3706 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
3707 s.
3708 i;
3709 s->
3710 i0;
3711 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W1 s1W1;
3712 s1W1->
3713 i0;
3714 }
3715 #else
3716 #endif
3717
3718
3719 typedef T_TDC_DESCRIPTOR_ARRAY<T_TDC_HANDLE_COMP_STENCIL> T_TDC_DESCRIPTOR_ARRAY_STENCIL;
3720 typedef T_TDC_DESCRIPTOR_POINTER<T_TDC_HANDLE_COMP_STENCIL> T_TDC_DESCRIPTOR_POINTER_STENCIL;
3721 typedef T_TDC_HANDLE_POINTER<T_TDC_HANDLE_COMP_STENCIL> T_TDC_HANDLE_POINTER_STENCIL;
3722
3723
3724 #if TDC_DEBUG_DOT_COMPLETE
3725 struct T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W4
3726 {
3727 int i1W4;
3728 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 operator->(){return 0;}
3729 };
3730 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W4()
3731 {
3732 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
3733 s.
3734 i;
3735 s->
3736 i0;
3737 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W4 s1W4;
3738 s1W4->
3739 i0;
3740 }
3741 #else
3742 #endif
3743
3744 #if !defined TDC_DESCRIPTOR || defined TDC_PRECOMPILE
3745
3746 #if TDC_DEBUG_DOT_COMPLETE
3747 struct T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W5
3748 {
3749 int i1W5;
3750 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 operator->(){return 0;}
3751 };
3752 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W5()
3753 {
3754 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
3755 s.
3756 i;
3757 s->
3758 i0;
3759 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W5 s1W5;
3760 s1W5->
3761 i0;
3762 }
3763 #else
3764 #endif
3765
3766 struct T_U8:T_TDC_INSTANCE_INT_BASE
3767 {
3768 //enable pragma line to see expanded version of macro in list file
3769 //#pragma M_TDC_MESSAGE (M_TDC_STRING(M_TDC_INSTANCE_INT_ADDITIONAL (U8)))
3770 M_TDC_INSTANCE_INT_ADDITIONAL (U8)
3771 T_TDC_INTERFACE_U8* operator-> ();
3772 };
3773 struct T_TDC_INTERFACE_U8:T_TDC_INTERFACE_INT_BASE
3774 {
3775 //enable pragma line to see expanded version of macro in list file
3776 //#pragma M_TDC_MESSAGE (M_TDC_STRING(M_TDC_INTERFACE_INT_ADDITIONAL (U8)))
3777 M_TDC_INTERFACE_INT_ADDITIONAL (U8)
3778 #ifdef TDC_TYPE_NAME_COMPLETE
3779 struct T_TDC_TYPE_NAME { char T_U8, ___dummy__basic_type_have_no_members; } _type_name () M_TDC_TYPE_NAME_COMPLETE //HINT: ??? press CTRL + SHIFT + Q to create a reference to this variable
3780 #endif
3781 };
3782
3783 #if TDC_DEBUG_DOT_COMPLETE
3784 struct T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W6
3785 {
3786 int i1W6;
3787 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 operator->(){return 0;}
3788 };
3789 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W6()
3790 {
3791 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
3792 s.
3793 i;
3794 s->
3795 i0;
3796 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W6 s1W6;
3797 s1W6->
3798 i0;
3799 }
3800 #else
3801 #endif
3802
3803 struct T_S8:T_TDC_INSTANCE_INT_BASE
3804 {
3805 M_TDC_INSTANCE_INT_ADDITIONAL (S8)
3806 T_TDC_INTERFACE_S8* operator-> ();
3807 };
3808 struct T_TDC_INTERFACE_S8:T_TDC_INTERFACE_INT_BASE
3809 {
3810 M_TDC_INTERFACE_INT_ADDITIONAL (S8)
3811 #ifdef TDC_TYPE_NAME_COMPLETE
3812 struct T_TDC_TYPE_NAME { char T_S8, ___dummy__basic_type_have_no_members; } _type_name () M_TDC_TYPE_NAME_COMPLETE //HINT: ??? press CTRL + SHIFT + Q to create a reference to this variable
3813 #endif
3814 };
3815
3816 struct T_U16:T_TDC_INSTANCE_INT_BASE
3817 {
3818 M_TDC_INSTANCE_INT_ADDITIONAL (U16)
3819 T_TDC_INTERFACE_U16* operator-> ();
3820 };
3821 struct T_TDC_INTERFACE_U16:T_TDC_INTERFACE_INT_BASE
3822 {
3823 M_TDC_INTERFACE_INT_ADDITIONAL (U16)
3824 #ifdef TDC_TYPE_NAME_COMPLETE
3825 struct T_TDC_TYPE_NAME { char T_U16, ___dummy__basic_type_have_no_members; } _type_name () M_TDC_TYPE_NAME_COMPLETE //HINT: ??? press CTRL + SHIFT + Q to create a reference to this variable
3826 #endif
3827 };
3828
3829 struct T_S16:T_TDC_INSTANCE_INT_BASE
3830 {
3831 M_TDC_INSTANCE_INT_ADDITIONAL (S16)
3832 T_TDC_INTERFACE_S16* operator-> ();
3833 };
3834 struct T_TDC_INTERFACE_S16:T_TDC_INTERFACE_INT_BASE
3835 {
3836 M_TDC_INTERFACE_INT_ADDITIONAL (S16)
3837 #ifdef TDC_TYPE_NAME_COMPLETE
3838 struct T_TDC_TYPE_NAME { char T_S16, ___dummy__basic_type_have_no_members; } _type_name () M_TDC_TYPE_NAME_COMPLETE //HINT: ??? press CTRL + SHIFT + Q to create a reference to this variable
3839 #endif
3840 };
3841
3842 struct T_U32:T_TDC_INSTANCE_INT_BASE
3843 {
3844 M_TDC_INSTANCE_INT_ADDITIONAL (U32)
3845 T_TDC_INTERFACE_U32* operator-> ();
3846 };
3847 struct T_TDC_INTERFACE_U32:T_TDC_INTERFACE_INT_BASE
3848 {
3849 M_TDC_INTERFACE_INT_ADDITIONAL (U32)
3850 #ifdef TDC_TYPE_NAME_COMPLETE
3851 struct T_TDC_TYPE_NAME { char T_U32, ___dummy__basic_type_have_no_members; } _type_name () M_TDC_TYPE_NAME_COMPLETE //HINT: ??? press CTRL + SHIFT + Q to create a reference to this variable
3852 #endif
3853 };
3854
3855 struct T_S32:T_TDC_INSTANCE_INT_BASE
3856 {
3857 M_TDC_INSTANCE_INT_ADDITIONAL (S32)
3858 T_TDC_INTERFACE_S32* operator-> ();
3859 };
3860 struct T_TDC_INTERFACE_S32:T_TDC_INTERFACE_INT_BASE
3861 {
3862 M_TDC_INTERFACE_INT_ADDITIONAL (S32)
3863 #ifdef TDC_TYPE_NAME_COMPLETE
3864 struct T_TDC_TYPE_NAME { char T_S32, ___dummy__basic_type_have_no_members; } _type_name () M_TDC_TYPE_NAME_COMPLETE //HINT: ??? press CTRL + SHIFT + Q to create a reference to this variable
3865 #endif
3866 };
3867
3868 struct T_raw:T_TDC_INSTANCE_PSTRUCT_BASE
3869 {
3870 M_TDC_INSTANCE_PSTRUCT_ADDITIONAL (raw,raw)
3871 T_TDC_INTERFACE_raw* operator-> ();
3872 };
3873 struct T_TDC_INTERFACE_raw:T_TDC_INTERFACE_PSTRUCT_BASE
3874 {
3875 M_TDC_INTERFACE_PSTRUCT_ADDITIONAL (raw,raw)
3876 T_TDC_INTERFACE_U16 l_buf; //number of valid bits
3877 T_TDC_INTERFACE_U16 o_buf; //offset of first valid bit
3878 T_TDC_INTERFACE_ARRAY<T_TDC_INTERFACE_U8> buf; //array size = (o_buf + l_buf + 7) /8
3879 #ifdef TDC_TYPE_NAME_COMPLETE
3880 struct T_TDC_TYPE_NAME { char T_raw, ___l_buf___o_buf___buf; } _type_name () M_TDC_TYPE_NAME_COMPLETE //HINT: ??? press CTRL + SHIFT + Q to create a reference to this variable
3881 #endif
3882 };
3883
3884 #if TDC_DEBUG_DOT_COMPLETE
3885 struct T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W9
3886 {
3887 int i1W9;
3888 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 operator->(){return 0;}
3889 };
3890 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W9()
3891 {
3892 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
3893 s.
3894 i;
3895 s->
3896 i0;
3897 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W9 s1W9;
3898 s1W9->
3899 i0;
3900 }
3901 #else
3902 #endif
3903
3904 struct T_COMP_STENCIL:T_TDC_INSTANCE_MSTRUCT_BASE
3905 {
3906 /*void copy_instance (const T_TDC_INSTANCE_BASE * value_)
3907 {
3908 TDC_INTERNAL_ERROR();
3909 }*/
3910 M_TDC_INSTANCE_MSTRUCT_ADDITIONAL (COMP_STENCIL,COMP_STENCIL)
3911 };
3912 struct T_TDC_INTERFACE_COMP_STENCIL:T_TDC_INTERFACE_MSTRUCT_BASE
3913 {
3914 M_TDC_INTERFACE_MSTRUCT_ADDITIONAL (COMP_STENCIL,COMP_STENCIL)
3915 };
3916
3917 #if TDC_DEBUG_DOT_COMPLETE
3918 struct T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W9A9
3919 {
3920 int i1W9A9;
3921 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 operator->(){return 0;}
3922 };
3923 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W9A9()
3924 {
3925 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
3926 s.
3927 i;
3928 s->
3929 i0;
3930 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W9A9 s1W9A9;
3931 s1W9A9->
3932 i0;
3933 }
3934 #else
3935 #endif
3936
3937 #ifndef TDC_DOT_COMPLETE_SOURCE_INSIGHT
3938 /**
3939 allocation call tree:
3940 function defined in
3941 T_PRIMITIVE_UNION() tdc_base.h
3942 T_PRIMITIVE_UNION
3943 M_TDC_INSTANCE_ADDITIONAL_BASE
3944 construct_handle(new_T_TDC_HANDLE_PRIMITIVE_UNION) tdc.cpp
3945 T_TDC_INSTANCE_BASE
3946 new_T_TDC_HANDLE_PRIMITIVE_UNION ??? global
3947 ???
3948 implement_new_handle () tdc_lib_main_dsc.cpp virtual in T_TDC_HANDLE_PRIMITIVE_UNION
3949 M_TDC_POST_COMP
3950 M_TDC_POST_DESCRIPTOR_COMP
3951 M_TDC_HANDLE_ADDITIONAL
3952 new T_TDC_HANDLE_PRIMITIVE_UNION() not explicit declared
3953 T_TDC_HANDLE_BASE () tdc_dsc.cpp
3954 implement_set_action(TDC_ACTION_DEFAULT) tdc_dsc.cpp
3955
3956 T_PRIMITIVE_UNION
3957
3958 make_descriptor() tdc.cpp
3959 implement_new_descriptor () tdc.cpp
3960 new T_TDC_DESCRIPTOR_PRIMITIVE_UNION tdc_lib_main_dsc.cpp
3961 M_TDC_POST_COMP
3962 M_TDC_POST_DESCRIPTOR_COMP
3963
3964
3965 */
3966 #if TDC_DEBUG_DOT_COMPLETE
3967 struct T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W9B
3968 {
3969 int i1W9B;
3970 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 operator->(){return 0;}
3971 };
3972 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W9B()
3973 {
3974 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
3975 s.
3976 i;
3977 s->
3978 i0;
3979 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W9B s1W9B;
3980 s1W9B->
3981 i0;
3982 }
3983 #else
3984 #endif
3985
3986 struct T_PRIMITIVE_UNION
3987 TDC_DOT_COMPLETE_HIDE(:T_TDC_INSTANCE_PRIMITIVE_UNION_BASE)
3988 {
3989 TDC_DOT_COMPLETE_HIDE(M_TDC_INSTANCE_PRIMITIVE_ADDITIONAL ())
3990 T_TDC_INTERFACE_PRIMITIVE_UNION* operator-> ();
3991 };
3992
3993 struct T_MESSAGE_UNION:T_TDC_INSTANCE_MESSAGE_UNION_BASE
3994 {
3995 TDC_DOT_COMPLETE_HIDE(M_TDC_INSTANCE_MESSAGE_ADDITIONAL ())
3996 T_TDC_INTERFACE_MESSAGE_UNION* operator-> ();
3997 };
3998
3999 #if TDC_DEBUG_DOT_COMPLETE
4000 struct T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W9B
4001 {
4002 int i1W9B;
4003 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 operator->(){return 0;}
4004 };
4005 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1W9B()
4006 {
4007 T_PRIMITIVE_UNION primitive_union;
4008 primitive_union-> XX_TDC_1;
4009 }
4010 #else
4011 #endif
4012
4013 #else
4014 typedef T_TDC_INTERFACE_PRIMITIVE_UNION* T_PRIMITIVE_UNION;
4015 typedef T_TDC_INTERFACE_MESSAGE_UNION* T_MESSAGE_UNION;
4016 #endif
4017
4018 //----------------------------------------------------------------------------
4019
4020 //#if TDC_DOT_COMPLETE
4021 //#else
4022 template<> struct T_ARRAY<U8>:T_TDC_INSTANCE_BASIC_ARRAY<T_U8, U8>
4023 {
4024 M_TDC_BASIC_ARRAY(U8)
4025 };
4026
4027 template<> struct T_ARRAY<S8>:T_TDC_INSTANCE_BASIC_ARRAY<T_S8, S8>
4028 {
4029 M_TDC_BASIC_ARRAY(S8)
4030 };
4031
4032 template<> struct T_ARRAY<U16>:T_TDC_INSTANCE_BASIC_ARRAY<T_U16, U16>
4033 {
4034 M_TDC_BASIC_ARRAY(U16)
4035 };
4036
4037 template<> struct T_ARRAY<S16>:T_TDC_INSTANCE_BASIC_ARRAY<T_S16, S16>
4038 {
4039 M_TDC_BASIC_ARRAY(S16)
4040 };
4041
4042 template<> struct T_ARRAY<U32>:T_TDC_INSTANCE_BASIC_ARRAY<T_U32, U32>
4043 {
4044 M_TDC_BASIC_ARRAY(U32)
4045 };
4046
4047 template<> struct T_ARRAY<S32>:T_TDC_INSTANCE_BASIC_ARRAY<T_S32, S32>
4048 {
4049 M_TDC_BASIC_ARRAY(S32)
4050 };
4051 //#endif
4052
4053 #endif //!defined TDC_DESCRIPTOR || defined TDC_PRECOMPILE
4054
4055 //\}
4056
4057 //============================================================================
4058 // types used by dynamic part
4059 //============================================================================
4060
4061 struct T_TDC_AWAIT_CONTEXT;
4062 struct T_TDC_SEND_CONTEXT;
4063 struct T_TDC_AWAIT;
4064
4065 #ifdef DOT_COMPLETE
4066 struct T_ON{};
4067 #endif
4068
4069 //============================================================================
4070
4071 enum T_TDC_JMPRET
4072 {
4073 TDC_JMPRET_SETJMP = 0, //setjmp is hard coded to return 0
4074 TDC_JMPRET_INITIAL = 1,
4075 TDC_JMPRET_FAIL = 2,
4076 TDC_JMPRET_PASS = 3,
4077 TDC_JMPRET_BAD_BREAK = 4,
4078 TDC_JMPRET_CASE_PASS = 5,
4079 TDC_JMPRET_STEP_PASS = 6,
4080 TDC_JMPRET_ON_PASS = 7,
4081 TDC_JMPRET_ON_TEST = 8,
4082 TDC_JMPRET_ALT_ENTER = 9,
4083 TDC_JMPRET_OTHERWISE_PASS = 10,
4084 TDC_JMPRET_OTHERWISE_PARK = 11,
4085 TDC_JMPRET_TRAP_PASS = 12,
4086 TDC_JMPRET_POPED = 13,
4087 TDC_JMPRET_USER_ERROR = 14,
4088 TDC_JMPRET_INTERNAL_ERROR = 15,
4089 TDC_JMPRET_TAP_EXCLUDED = 16
4090 };
4091
4092 enum T_TDC_CONTEXT
4093 {
4094 TDC_CONTEXT_UNKNOWN,
4095 TDC_CONTEXT_FUNCTION,
4096 TDC_CONTEXT_CASE,
4097 TDC_CONTEXT_STEP,
4098 TDC_CONTEXT_ALT,
4099 TDC_CONTEXT_ON,
4100 TDC_CONTEXT_OTHERWISE,
4101 TDC_CONTEXT_TRAP
4102 };
4103
4104 struct T_TDC_DYNAMIC_CONTEXT_DATA
4105 {
4106 T_TDC_DYNAMIC_CONTEXT_DATA* parent;
4107 jmp_buf mark;
4108 T_TDC_DYNAMIC_CONTEXT_DATA* prev;
4109 T_TDC_JMPRET jmpret;
4110 char* file;
4111 int line;
4112 int event;
4113 bool testing;
4114 char *text;
4115 int destroy_on_fail_handles_count;
4116 T_TDC_CONTEXT context;
4117 T_TDC_HANDLE_BASE** destroy_on_fail_handles;
4118 void add_destroy_on_fail (T_TDC_HANDLE_BASE* handle);
4119 void remove_destroy_on_fail (T_TDC_HANDLE_BASE* handle);
4120 T_TDC_DYNAMIC_CONTEXT_DATA* pop ();
4121 T_TDC_DYNAMIC_CONTEXT_DATA (T_TDC_CONTEXT
4122 context_, T_TDC_DYNAMIC_CONTEXT_DATA* parent_, char* file_, int line_, char* text_);
4123 ~T_TDC_DYNAMIC_CONTEXT_DATA();
4124 void jmp(T_TDC_JMPRET jmpret_);
4125 };
4126
4127 struct T_TDC_CONTEXT_BASE
4128 {
4129 };
4130
4131 struct T_TDC_FUNCTION_CONTEXT:T_TDC_CONTEXT_BASE //the name of this type is contructed to give more info from error message
4132 {
4133 /*
4134 Got this error?
4135 error C2039: 'tdc_alt_context' : is not a member of 'T_TDC_FUNCTION_CONTEXT'
4136 you are violating the following rules:
4137
4138 "ON(...)...;" and "OTHERWISE()...;" must be inside an "ALT{...}"
4139
4140 TODO: test above statement
4141 */
4142 T_TDC_DYNAMIC_CONTEXT_DATA tdc_function_context; //this member name is contructed to give more info from error message
4143 T_TDC_FUNCTION_CONTEXT (char* file_, int line_);
4144 };
4145
4146 struct T_TDC_USER_ERROR_CASE_BASE
4147 {
4148 // for testing TDC only
4149 unsigned int failed;
4150 };
4151
4152 struct T_TDC_CASE
4153 {
4154 /** \struct T_TDC_CASE
4155 this type can not have constructor or member functions as it virolate 'extern "C"' in T_CASE macro
4156
4157 this type should only contain one member so that if returned from a function with '__declspec(dllexport)'
4158 it will be returned in the same way as if such a function returned int, returning an int is what tap2.exe
4159 expect
4160
4161 from an internal tdc point of view there is no difference between a function of type T_CASE and one of
4162 type T_TDC_CASE, this is used in some tdc_test test cases
4163
4164 founctions of type T_CASE (T_TDC_CASE) should not have explicit returns instead they should contain
4165 a BEGIN_CASE(...) which will make an implicit return (return is hidden inside macro);
4166 */
4167 unsigned int passed;
4168 };
4169
4170 struct T_TDC_CASE_CONTEXT:T_TDC_CONTEXT_BASE
4171 {
4172 T_TDC_DYNAMIC_CONTEXT_DATA tdc_not_alt_context;
4173 T_TDC_CASE_CONTEXT (T_TDC_DYNAMIC_CONTEXT_DATA* parent_, char* file_, int line_, char* text_);
4174 void tdc_end_for ();
4175 bool tdc_do_return ();
4176 void prepare_exit (int exit_code, char *message);
4177 T_TDC_CASE tdc_return_value ();
4178 T_TDC_USER_ERROR_CASE_BASE tdc_user_error_return_value ();
4179 };
4180
4181 struct T_TDC_only_one__BEGIN_CASE__allowed_per_function:T_TDC_CONTEXT_BASE
4182 {
4183 /* TODO: wrong text type name should say it all
4184 Got this error?
4185 error C2039: 'tdc_alt_context' : is not a member of 'T_TDC__OTHERWISE__MUST_BE_LAST_IN_ALT'
4186
4187 you are violating one of the following rules:
4188 A)
4189 "ON(...)...;" cannot follow "OTHERWISE()...;"
4190
4191 B)
4192 "AWAIT(...)" is not allow in side "ALT{...}" enclose it with an "ON(...)"
4193 e.g. ALT{... ON(AWAIT(...))...; ...}
4194 C)
4195 "FAIL()", "PASS()", "SEND(...)" are not allowed inside "ALT{...}" they must be
4196 inside the body of an "ON(AWAIT(something))...;" or "OTHERWISE()...;"
4197
4198 remember to use curly parantheses "{...}" when the body contain more than one command
4199 */
4200 T_TDC_DYNAMIC_CONTEXT_DATA* parent;
4201 T_TDC_only_one__BEGIN_CASE__allowed_per_function (T_TDC_DYNAMIC_CONTEXT_DATA& parent_);
4202 };
4203
4204 /// return of a step
4205 struct T_STEP
4206 {
4207 T_STEP ()
4208 {
4209 //nothing
4210 }
4211 };
4212
4213 struct T_TDC_STEP_CONTEXT:T_TDC_CONTEXT_BASE
4214 {
4215 T_TDC_DYNAMIC_CONTEXT_DATA tdc_not_alt_context;
4216 T_TDC_STEP_CONTEXT (T_TDC_DYNAMIC_CONTEXT_DATA* parent_, char* file_, int line_, char* text_);
4217 void tdc_end_for ();
4218 bool tdc_do_return ();
4219 T_STEP tdc_return_value ();
4220 };
4221
4222 struct T_TDC_only_one__BEGIN_STEP__allowed_per_function:T_TDC_CONTEXT_BASE
4223 {
4224 /* TODO: wrong text type name should say it all
4225 Got this error?
4226 error C2039: 'tdc_alt_context' : is not a member of 'T_TDC_only_one__BEGIN_STEP__allowed_per_function'
4227
4228 you are violating one of the following rules:
4229 A)
4230 "ON(...)...;" cannot follow "OTHERWISE()...;"
4231
4232 B)
4233 "AWAIT(...)" is not allow in side "ALT{...}" enclose it with an "ON(...)"
4234 e.g. ALT{... ON(AWAIT(...))...; ...}
4235 C)
4236 "FAIL()", "PASS()", "SEND(...)" are not allowed inside "ALT{...}" they must be
4237 inside the body of an "ON(AWAIT(something))...;" or "OTHERWISE()...;"
4238
4239 remember to use curly parantheses "{...}" when the body contain more than one command
4240 */
4241 T_TDC_DYNAMIC_CONTEXT_DATA* parent;
4242 T_TDC_only_one__BEGIN_STEP__allowed_per_function (T_TDC_DYNAMIC_CONTEXT_DATA& parent_);
4243 };
4244
4245 struct T_TDC_ALT_CONTEXT:T_TDC_CONTEXT_BASE
4246 {
4247 /*
4248 Got this error?
4249 error C2039: 'tdc_not_alt_context' : is not a member of 'T_TDC_ALT_CONTEXT'
4250
4251 you are violating one of the following rules:
4252 A)
4253 "AWAIT(...)" is not allow in side "ALT{...}" enclose it with an "ON(...)"
4254 e.g. ALT{... ON(AWAIT(...))...; ...}
4255 B)
4256 "FAIL()", "PASS()", "SEND(...)", "ALT{...}" are not allowed inside "ALT{...}" they must be
4257 inside the body of an "ON(AWAIT(something))...;" or "OTHERWISE()...;"
4258
4259 remember to use curly parantheses "{...}" when the body contain more than one command
4260 */
4261 T_TDC_DYNAMIC_CONTEXT_DATA tdc_alt_context;
4262 T_TDC_ALT_CONTEXT (T_TDC_DYNAMIC_CONTEXT_DATA& parent_, char* file_, int line_);
4263 void tdc_end_for();
4264 bool tdc_enter_for();
4265 };
4266
4267 struct T_TDC_ON_CONTEXT:T_TDC_CONTEXT_BASE
4268 {
4269 T_TDC_DYNAMIC_CONTEXT_DATA tdc_not_alt_context;
4270 T_TDC_ON_CONTEXT (T_TDC_DYNAMIC_CONTEXT_DATA& parent_, char* file_, int line_, char* text_);
4271 void tdc_end_for ();
4272 bool tdc_enter_for();
4273 bool tdc_on_expects_await(T_TDC_AWAIT& await_);
4274 };
4275
4276 struct T_TDC__OTHERWISE__MUST_BE_LAST_IN_ALT:T_TDC_CONTEXT_BASE
4277 {
4278 /*
4279 Got this error?
4280 error C2039: 'tdc_alt_context' : is not a member of 'T_TDC__OTHERWISE__MUST_BE_LAST_IN_ALT'
4281
4282 you are violating one of the following rules:
4283 A)
4284 "ON(...)...;" cannot follow "OTHERWISE()...;"
4285
4286 B)
4287 "AWAIT(...)" is not allow in side "ALT{...}" enclose it with an "ON(...)"
4288 e.g. ALT{... ON(AWAIT(...))...; ...}
4289 C)
4290 "FAIL()", "PASS()", "SEND(...)" are not allowed inside "ALT{...}" they must be
4291 inside the body of an "ON(AWAIT(something))...;" or "OTHERWISE()...;"
4292
4293 remember to use curly parantheses "{...}" when the body contain more than one command
4294 */
4295 T_TDC_DYNAMIC_CONTEXT_DATA* parent;
4296 T_TDC__OTHERWISE__MUST_BE_LAST_IN_ALT (T_TDC_DYNAMIC_CONTEXT_DATA& parent_);
4297 };
4298
4299 struct T_TDC_OTHERWISE_CONTEXT:T_TDC_CONTEXT_BASE
4300 {
4301 T_TDC_DYNAMIC_CONTEXT_DATA tdc_not_alt_context;
4302 T_TDC_OTHERWISE_CONTEXT (T_TDC_DYNAMIC_CONTEXT_DATA* parent_, char* file_, int line_);
4303 void tdc_end_for ();
4304 bool tdc_enter_for ();
4305 };
4306
4307 struct T_TDC_TRAP_CONTEXT:T_TDC_CONTEXT_BASE
4308 {
4309 T_TDC_DYNAMIC_CONTEXT_DATA tdc_not_alt_context;
4310 T_TDC_TRAP_CONTEXT (T_TDC_DYNAMIC_CONTEXT_DATA& parent_, char* file_, int line_);
4311 void tdc_end_for ();
4312 bool tdc_trap_testing ();
4313 bool tdc_initial ();
4314 bool tdc_enter_for ();
4315 };
4316
4317 struct T_TDC_EVENT_CONTEXT:T_TDC_CONTEXT_BASE
4318 {
4319 T_TDC_EVENT_CONTEXT (T_TDC_DYNAMIC_CONTEXT_DATA& parent, char* file_, int line_, char* text_, char* primitive_);
4320 T_TDC_EVENT_CONTEXT ();
4321 };
4322
4323 //============================================================================
4324
4325 #ifdef TDC_PORT
4326 struct T_PORT
4327 {
4328 T_PORT operator +(T_PORT& port); // be aware: ("x->y","z") + ("a->b","c") != ("x;a->y;b","z;c")
4329 #if DOT_COMPLETE
4330 T_ON AWAIT (T_PRIMITIVE_UNION primitive){}
4331 void SEND (T_PRIMITIVE_UNION primitive){}
4332 #else//DOT_COMPLETE
4333 char* src_list;
4334 char* dst_list;
4335 char* sap_list;
4336 bool is_send_port; // -> or <-> was specified
4337 bool is_await_port;// <- or <-> was specified
4338 T_PORT* next; // used when 2 or more ports have been linked together with operator +
4339 void construct(char* src_and_dst_list, char* sap_list_);
4340 T_PORT (char* src_and_dst_list, char* sap_list_);
4341 T_PORT (char* src_and_dst_list);
4342 T_PORT (T_PORT& port,T_PORT* port2=0);
4343 ~T_PORT ();
4344 T_TDC_AWAIT_CONTEXT tdc_await_context(T_TDC_DYNAMIC_CONTEXT_DATA& parent, char* file_, int line_, char* primitive_);
4345 T_TDC_SEND_CONTEXT tdc_send_context(T_TDC_DYNAMIC_CONTEXT_DATA& parent, char* file_, int line_, char* primitive_);
4346 #endif//DOT_COMPLETE
4347 };
4348
4349 extern T_PORT DEFAULT_PORT;
4350 #endif
4351
4352 //============================================================================
4353 /// \defgroup AWAIT
4354 //\{
4355
4356 /// Special values that can be awaited for the sake of testing TDC
4357 enum T_TDC_AWAIT_TESTING {
4358 TDC_AWAIT_FAIL, /// Hardcode AWAIT to fail
4359 TDC_AWAIT_PASS, /// Hardcode AWAIT to pass
4360 TDC_AWAIT_FORCE_PASS,
4361 };
4362
4363 #if DOT_COMPLETE
4364 int TDC_AWAIT_FAIL;
4365 int TDC_AWAIT_PASS;
4366 int TDC_AWAIT_FORCE_PASS;
4367 #endif
4368
4369 ///What an AWAIT returns
4370 struct T_TDC_AWAIT
4371 {
4372 T_TDC_AWAIT();
4373 private:
4374 template<class T> T_TDC_AWAIT operator, (T)
4375 {
4376 tdc_user_error ("AWAIT can not be part of a comma expression"); // should be courth compiletime as this function is private
4377 return T_TDC_AWAIT ();
4378 }
4379 };
4380
4381 struct T_TDC_AWAIT_CONTEXT:T_TDC_EVENT_CONTEXT
4382 {
4383 friend T_TDC_AWAIT_CONTEXT tdc_await_context (T_TDC_DYNAMIC_CONTEXT_DATA& parent, char* file_, int line_, char* primitive_);
4384 #ifdef TDC_PORT
4385 T_TDC_AWAIT_CONTEXT (T_PORT* port_, T_TDC_DYNAMIC_CONTEXT_DATA& parent, char* file_, int line_, char* primitive_);
4386 #else
4387 T_TDC_AWAIT_CONTEXT (T_TDC_DYNAMIC_CONTEXT_DATA& parent, char* file_, int line_, char* primitive_);
4388 #endif
4389 ~T_TDC_AWAIT_CONTEXT ();
4390 T_TDC_AWAIT tdc_implement_await (T_TDC_AWAIT_TESTING pass_or_fail);
4391 T_TDC_AWAIT tdc_implement_await (const T_TDC_INSTANCE_PRIMITIVE_BASE& primitive);
4392 template<class T> T_TDC_AWAIT tdc_implement_await (T (*f) ())
4393 {
4394 T primitive = f ();
4395 return tdc_implement_await (primitive);
4396 }
4397 template<class T> T_TDC_AWAIT tdc_implement_await (void (*f) (T))
4398 {
4399 T primitive;
4400 f (primitive);
4401 return tdc_implement_await (primitive);
4402 }
4403 };
4404
4405 //\}
4406
4407 //----------------------------------------------------------------------------
4408 /// \defgroup SEND
4409 //\{
4410
4411 struct T_TDC_SEND_CONTEXT
4412 :T_TDC_EVENT_CONTEXT
4413 {
4414 friend T_TDC_SEND_CONTEXT tdc_send_context (T_TDC_DYNAMIC_CONTEXT_DATA& parent, char* file_, int line_, char* primitive_);
4415 #ifdef TDC_PORT
4416 T_TDC_SEND_CONTEXT (T_PORT* port_, T_TDC_DYNAMIC_CONTEXT_DATA& parent, char* file_, int line_, char* primitive_);
4417 #else
4418 T_TDC_SEND_CONTEXT (T_TDC_DYNAMIC_CONTEXT_DATA& parent, char* file_, int line_, char* primitive_);
4419 #endif
4420 ~T_TDC_SEND_CONTEXT ();
4421 void tdc_implement_send (T_TDC_AWAIT_TESTING pass_or_fail);
4422 void tdc_implement_send (const T_TDC_INSTANCE_PRIMITIVE_BASE& primitive);
4423 template<class T>void tdc_implement_send (T (*f) ())
4424 {
4425 T primitive = f ();
4426 return tdc_implement_send (primitive);
4427 }
4428 template<class T>void tdc_implement_send (void (*f) (T))
4429 {
4430 T primitive;
4431 f (primitive);
4432 return tdc_implement_send (primitive);
4433 }
4434 };
4435
4436 //\}
4437
4438 //----------------------------------------------------------------------------
4439 /// \defgroup COMMAND COMMAND
4440 //\{
4441
4442 ///What a COMMAND returns
4443 struct T_TDC_COMMAND
4444 {
4445 T_TDC_COMMAND ();
4446 private:
4447 ///Hides ',' operator for COMMANDS
4448 template<class T>
4449 T_TDC_COMMAND operator, (T)
4450 {
4451 tdc_user_error ("COMMAND can not be part of comma expression"); // should be courth compiletime as this function is private
4452 return T_TDC_COMMAND();
4453 }
4454 };
4455
4456 struct T_TDC_COMMAND_CONTEXT:T_TDC_EVENT_CONTEXT
4457 {
4458 T_TDC_COMMAND_CONTEXT (T_TDC_DYNAMIC_CONTEXT_DATA& parent, char* file_,int line_, char* text_);
4459 T_TDC_COMMAND_CONTEXT (T_TDC_DYNAMIC_CONTEXT_DATA& parent, char* file_,int line_, char* text_, char* command_);
4460 T_TDC_COMMAND_CONTEXT (T_TDC_DYNAMIC_CONTEXT_DATA& parent, char* file_,int line_, char* text_, char* value_text_, long value_);
4461 T_TDC_COMMAND operator || (T_TDC_COMMAND& command_);
4462 };
4463
4464 //\}
4465
4466 /// \defgroup PARKING PARKING Command
4467 //\{
4468
4469 enum T_TDC_PARKING_ENUM /// Values should be indentical to those defined in tap_int.h
4470 {
4471 DISABLE = 0,
4472 SHORT_TERM = 1,
4473 LONG_TERM = 2,
4474 SHORT_TERM_FAIL = 3,
4475 LONG_TERM_FAIL = 4
4476 };
4477
4478 struct T_TDC_PARKING_CONTEXT:private T_TDC_COMMAND_CONTEXT
4479 {
4480 T_TDC_PARKING_CONTEXT (T_TDC_DYNAMIC_CONTEXT_DATA& parent, char* file_,int line_, char* value_text_, T_TDC_PARKING_ENUM value_);
4481 T_TDC_PARKING_CONTEXT (T_TDC_DYNAMIC_CONTEXT_DATA& parent, char* file_,int line_, char* value_text_, bool value_);
4482 T_TDC_PARKING_ENUM operator || (T_TDC_PARKING_ENUM value_);
4483 };
4484
4485 //\}
4486
4487 //============================================================================
4488
4489 extern T_TDC_FUNCTION_CONTEXT tdc_syntax_context;
4490
4491 extern T_TDC_DYNAMIC_CONTEXT_DATA* tdc_dynamic_context;
4492
4493 //----------------------------------------------------------------------------
4494
4495 extern void tdc_implement_fail(T_TDC_JMPRET jmpret);
4496
4497 extern void tdc_implement_user_fail(T_TDC_DYNAMIC_CONTEXT_DATA& parent, char* file_, int line_);
4498
4499 extern void tdc_implement_pass();
4500
4501 extern void tdc_implement_user_pass(T_TDC_DYNAMIC_CONTEXT_DATA& parent, char* file_, int line_);
4502
4503 //----------------------------------------------------------------------------
4504
4505 extern T_TDC_COMMAND tdc_implement_command (const char* text);
4506
4507 extern T_TDC_COMMAND tdc_implement_timeout (int time);
4508
4509 extern T_TDC_COMMAND tdc_implement_mute (int time);
4510
4511 extern T_TDC_COMMAND tdc_implement_start_timeout (int time);
4512
4513 extern T_TDC_COMMAND tdc_implement_wait_timeout ();
4514
4515 extern T_TDC_PARKING_ENUM tdc_implement_parking (T_TDC_PARKING_ENUM enabled);
4516 extern T_TDC_PARKING_ENUM tdc_implement_parking (bool enabled);
4517
4518 //============================================================================
4519
4520 #endif //TDC_TESTING
4521
4522 //============================================================================
4523 /// \defgroup TryCatchProtection
4524 //\{
4525
4526 /**
4527 map try, catch and throw to our version that prevent the user from using them
4528 by having both a plain and a "tdc_implement_..." version it is faily simple
4529 temporary to disable the mapping through #undef when need be
4530 this is some thing that the user should never do, but tdc have to, so the debugger
4531 see our longjmps as exceptions
4532
4533 //TODO: do this stuff debugger see longjumps as exceptions
4534 */
4535
4536 /// try, catch and throw conflicts with longjmp in vc6, use TRAP
4537 #define try tdc_implement_try
4538 /// try, catch and throw conflicts with longjmp in vc6, use ELSE
4539 #define catch(exception) tdc_implement_catch(exception)
4540 /// try, catch and throw conflicts with longjmp in vc6, use FAIL or PASS
4541 #define throw tdc_implement_throw
4542
4543 /// try, catch and throw conflicts with longjmp in vc6, use TRAP
4544 #define tdc_implement_try while(tdc_try_disabled)
4545 /// try, catch and throw conflicts with longjmp in vc6, use ELSE
4546 #define tdc_implement_catch(exception) while(tdc_catch_disabled)
4547 /// try, catch and throw conflicts with longjmp in vc6, use FAIL or PASS
4548 #define tdc_implement_throw while(tdc_throw_disabled)throw
4549
4550 //\}
4551 //----------------------------------------------------------------------------
4552
4553 #if DOT_COMPLETE //DOT_COMPLETE_PROTOTYPES
4554 #ifndef M_TDC_DOC //we don't want theses to occour twice in the call graph
4555
4556 // dummy functions to generate hint in dot-complete (e.g. when pressing <ctrl-shift-space> )
4557 // remember that functions must have a body to be considered for dot-completion by Visual Studio
4558
4559 void FAIL (void){}
4560
4561 void PASS (void){}
4562
4563 void SEND (T_PRIMITIVE_UNION primitive){}
4564
4565 T_ON AWAIT (T_PRIMITIVE_UNION primitive){}
4566
4567 void COMMAND (char* command_string){}
4568
4569 void TIMEOUT (int timeout){}
4570
4571 void START_TIMEOUT (int timeout){}
4572
4573 void WAIT_TIMEOUT (){}
4574
4575 void MUTE (int timeout){}
4576
4577 T_TDC_PARKING_ENUM PARKING (T_TDC_PARKING_ENUM enable){}
4578
4579 T_similar_syntax_as_while_statement BEGIN_CASE (char* trace_comment){}
4580
4581 T_similar_syntax_as_while_statement BEGIN_STEP (char* trace_comment){}
4582
4583 T_similar_syntax_as_while_statement ON (T_AWAIT){}
4584
4585 T_similar_syntax_as_while_statement OTHERWISE (){}
4586
4587 #endif//M_TDC_DOC
4588 #else//DOT_COMPLETE_PROTOTYPES
4589
4590 // real implementation
4591
4592 /*
4593 special constructions used in these macros:
4594
4595 ensure that only a ; is allowed after this macro
4596 do {...} while(0)
4597
4598 make variable declared in for(...) private to the statements ({...} or ...;) after this macro
4599 if(0);else
4600
4601 make implicit return at exit of loop (x might be replace by more code in the actual macros)
4602 for (int x=0;;x=1) if (x) return ...; else
4603 */
4604
4605 #define FAIL() do {tdc_implement_user_fail (tdc_syntax_context.tdc_not_alt_context, __FILE__, __LINE__); } while (0)
4606
4607 #define PASS() do {tdc_implement_user_pass (tdc_syntax_context.tdc_not_alt_context, __FILE__, __LINE__); } while (0)
4608
4609 #define SEND(primitive) tdc_send_context(tdc_syntax_context.tdc_not_alt_context, __FILE__, __LINE__, #primitive).tdc_implement_send(T_PRIMITIVE_UNION(primitive))
4610
4611 #define AWAIT(primitive) tdc_await_context(tdc_syntax_context.tdc_not_alt_context, __FILE__, __LINE__, #primitive).tdc_implement_await(T_PRIMITIVE_UNION(primitive))
4612
4613 #define START_TIMEOUT(timeout) (T_TDC_COMMAND_CONTEXT (tdc_syntax_context.tdc_not_alt_context, __FILE__, __LINE__, "START_TIMEOUT", #timeout, timeout) || tdc_implement_start_timeout(timeout))
4614
4615 #ifdef WAIT_TIMEOUT
4616 #undef WAIT_TIMEOUT /* To avoid class with defined macro in winbase.h */
4617 #endif
4618 #define WAIT_TIMEOUT() (T_TDC_COMMAND_CONTEXT (tdc_syntax_context.tdc_not_alt_context, __FILE__, __LINE__, "WAIT_TIMEOUT") || tdc_implement_wait_timeout())
4619
4620 #define MUTE(timeout) (T_TDC_COMMAND_CONTEXT (tdc_syntax_context.tdc_not_alt_context, __FILE__, __LINE__, "MUTE", #timeout, timeout) || tdc_implement_mute(timeout))
4621
4622 #define COMMAND(command) (T_TDC_COMMAND_CONTEXT (tdc_syntax_context.tdc_not_alt_context, __FILE__, __LINE__, #command) || tdc_implement_command(command))
4623
4624 #define TIMEOUT(timeout) (T_TDC_COMMAND_CONTEXT (tdc_syntax_context.tdc_not_alt_context, __FILE__, __LINE__, #timeout) || tdc_implement_timeout(timeout))
4625
4626 #define PARKING(enable) (T_TDC_PARKING_CONTEXT (tdc_syntax_context.tdc_not_alt_context, __FILE__, __LINE__, #enable, enable) || tdc_implement_parking(enable))
4627
4628 // some short cuts where user forgot '()' after '_skip' etc.
4629
4630 #define _skip tdc_skip()
4631 #define _show tdc_show()
4632 #define _forbid tdc_forbid()
4633 #define _require tdc_require()
4634 #define _skip_to_end tdc_skip_to_end()
4635
4636 #define _SKIP tdc_skip()
4637 #define _SHOW tdc_show()
4638 #define _FORBID tdc_forbid()
4639 #define _REQUIRE tdc_require()
4640 #define _SKIP_TO_END tdc_skip_to_end()
4641
4642 #endif//DOT_COMPLETE_PROTOTYPES
4643
4644 #define M_TDC_COMMAND_MUST_BE_LAST_IN_SCOPE true
4645
4646 /** \defgroup BEGIN_CASE BEGIN_CASE(){}
4647 Usage:
4648 <pre>
4649 T_CASE casename ()
4650 {
4651 BEGIN_CASE ("trace_comment")
4652 {
4653 ...
4654 }
4655 }
4656 </pre>
4657 */
4658 //\{
4659
4660 /// return type for a test CASE
4661 #define T_CASE \
4662 extern "C" __declspec(dllexport) T_TDC_CASE
4663
4664 /** \def T_TDC_USER_ERROR_CASE
4665 Test cases defined with T_TDC_USER_ERROR_CASE
4666 are cases that passes when they fail and fails when they passes,
4667 this is only intended for testing TDC it self.
4668 T_TDC_USER_ERROR_CASE will not reverse the result of a syntax error.
4669
4670 <pre>
4671 Usage:
4672 T_TDC_USER_ERROR_CASE casename ()
4673 {
4674 TDC_BEGIN_USER_ERROR_CASE ("trace_comment")
4675 {
4676 ...
4677 }
4678 }
4679 </pre>
4680 */
4681
4682 /// return type for a test USER ERROR CASE
4683 #define T_TDC_USER_ERROR_CASE\
4684 extern "C" __declspec(dllexport) T_TDC_USER_ERROR_CASE_BASE
4685
4686 /// stuff common to BEGIN_CASE and TDC_BEGIN_USER_ERROR_CASE
4687 #define M_TDC_BEGIN_CASE_BASE(trace_comment,return_value)\
4688 T_TDC_only_one__BEGIN_CASE__allowed_per_function tdc_begin_case (tdc_syntax_context.tdc_function_context);\
4689 if(0);else/*hide tdc_syntax_context after for body*/\
4690 for (T_TDC_CASE_CONTEXT tdc_context (tdc_begin_case.parent,__FILE__,__LINE__,trace_comment),\
4691 &tdc_syntax_context = ((tdc_context.tdc_not_alt_context.jmpret = T_TDC_JMPRET (setjmp (tdc_context.tdc_not_alt_context.mark))),tdc_context);\
4692 M_TDC_COMMAND_MUST_BE_LAST_IN_SCOPE;\
4693 tdc_context.tdc_end_for ())\
4694 if (tdc_context.tdc_do_return ())\
4695 return tdc_context.return_value ();\
4696 else
4697
4698 /// BEGIN_CASE should be the outermost scope in a CASE
4699 #define BEGIN_CASE(trace_comment)\
4700 M_TDC_BEGIN_CASE_BASE(trace_comment,tdc_return_value)
4701
4702 /// TDC_BEGIN_USER_ERROR_CASE a BEGIN_CASE for T_TDC_USER_ERROR_CASE
4703 #define TDC_BEGIN_USER_ERROR_CASE(trace_comment)\
4704 M_TDC_BEGIN_CASE_BASE(trace_comment,tdc_user_error_return_value)
4705
4706 //\}
4707
4708 /** \defgroup BEGIN_STEP BEGIN_STEP(){}
4709 <pre>
4710 Usage:
4711 T_STEP stepname (...)
4712 {
4713 BEGIN_STEP ("trace_comment")
4714 {
4715 ...
4716 }
4717 }
4718 </pre>
4719 */
4720 //\{
4721
4722 //TODO: move functionality from tdc_context to tdc_begin_step and delete tdc_context
4723 #define BEGIN_STEP(trace_comment)\
4724 T_TDC_only_one__BEGIN_STEP__allowed_per_function tdc_begin_step (tdc_syntax_context.tdc_function_context), &tdc_syntax_context = tdc_begin_step;\
4725 if (0); else\
4726 for (T_TDC_STEP_CONTEXT tdc_context (tdc_begin_step.parent,__FILE__,__LINE__,trace_comment),\
4727 &tdc_syntax_context = ((tdc_context.tdc_not_alt_context.jmpret = T_TDC_JMPRET (setjmp (tdc_context.tdc_not_alt_context.mark))),tdc_context);\
4728 M_TDC_COMMAND_MUST_BE_LAST_IN_SCOPE;\
4729 tdc_context.tdc_end_for ())\
4730 if (tdc_context.tdc_do_return ())\
4731 return tdc_context.tdc_return_value ();\
4732 else
4733
4734 //\}
4735
4736 /** \defgroup TRAP_ONFAIL TRAP{} & ONFAIL{}
4737 <pre>
4738 Usage:
4739 TRAP
4740 {
4741 ...
4742 FAIL();
4743 }
4744 ONFAIL
4745 {
4746 ...
4747 }
4748 </pre>
4749 */
4750 //\{
4751
4752 #define TRAP\
4753 if (0); else\
4754 for (T_TDC_TRAP_CONTEXT tdc_context (tdc_syntax_context.tdc_not_alt_context, __FILE__, __LINE__);\
4755 tdc_context.tdc_initial () && \
4756 (tdc_context.tdc_not_alt_context.jmpret = T_TDC_JMPRET (setjmp (tdc_context.tdc_not_alt_context.mark)),\
4757 tdc_context.tdc_enter_for ());\
4758 )\
4759 if (tdc_context.tdc_trap_testing ())\
4760 for (T_TDC_TRAP_CONTEXT &tdc_syntax_context = tdc_context; ; tdc_syntax_context.tdc_end_for())
4761
4762 #ifdef M_TDC_DOC
4763 #define ONFAIL() //Soure Insight will only draw call gaphs if "()" is present
4764 #else
4765 #define ONFAIL else // we don't want to do something special here, as we can't ensure warning on a plain else
4766 #endif
4767
4768 //\}
4769
4770 /** \defgroup ALT_ON_OTHERWISE ALT{}, ON() & OTHERWISE()
4771 <pre>
4772 Usage:
4773 ALT
4774 {
4775 ON (AWAIT (...)) ...;
4776 ON (AWAIT (...)) ...;
4777 ON (AWAIT (...)) ...;
4778 OTHERWISE () ...;
4779 }
4780 </pre>
4781 */
4782 //\{
4783
4784 #define ALT\
4785 if (0); else\
4786 for (T_TDC_ALT_CONTEXT tdc_context (tdc_syntax_context.tdc_not_alt_context, __FILE__, __LINE__), &tdc_syntax_context = tdc_context;\
4787 tdc_context.tdc_alt_context.jmpret = T_TDC_JMPRET (setjmp (tdc_context.tdc_alt_context.mark)),\
4788 tdc_context.tdc_enter_for ();\
4789 tdc_context.tdc_end_for ())
4790
4791 #define ON(await)\
4792 if (0); else\
4793 for (T_TDC_ON_CONTEXT tdc_context (tdc_syntax_context.tdc_alt_context,__FILE__,__LINE__,#await), &tdc_syntax_context = tdc_context;\
4794 tdc_context.tdc_not_alt_context.jmpret = T_TDC_JMPRET (setjmp (tdc_context.tdc_not_alt_context.mark)),\
4795 tdc_context.tdc_enter_for () && tdc_context.tdc_on_expects_await (await);\
4796 tdc_context.tdc_end_for ())
4797
4798 #define OTHERWISE()\
4799 T_TDC__OTHERWISE__MUST_BE_LAST_IN_ALT tdc_otherwise (tdc_syntax_context.tdc_alt_context), &tdc_syntax_context = tdc_otherwise;\
4800 if (0); else\
4801 for (T_TDC_OTHERWISE_CONTEXT tdc_syntax_context (tdc_otherwise.parent, __FILE__, __LINE__);\
4802 tdc_syntax_context.tdc_not_alt_context.jmpret = T_TDC_JMPRET (setjmp (tdc_syntax_context.tdc_not_alt_context.mark)),\
4803 tdc_syntax_context.tdc_enter_for (), M_TDC_COMMAND_MUST_BE_LAST_IN_SCOPE ;\
4804 tdc_syntax_context.tdc_end_for ())
4805
4806 //\}
4807
4808 //============================================================================
4809
4810 #if TDC_DEBUG_DOT_COMPLETE
4811 void F_TDC_DEBUG_DOT_COMPLETE__TDC_H_1Z()
4812 {
4813 T_TDC_DEBUG_DOT_COMPLETE__TDC_H_1 s;
4814 s.
4815 i;
4816 s->i0;
4817 T_TDC_INTERFACE_ARRAY<int> i;
4818 i.
4819 }
4820 #else
4821 #endif
4822
4823 //============================================================================
4824
4825 #endif //TDC_BASE_H
4826
4827