applications/utilities/postProcessing/dataConversion/foamToTecplot360/tecio/tecsrc/TASSERT.h

   1 /*
   2  * NOTICE and LICENSE for Tecplot Input/Output Library (TecIO) - OpenFOAM
   3  *
   4  * Copyright (C) 1988-2009 Tecplot, Inc.  All rights reserved worldwide.
   5  *
   6  * Tecplot hereby grants OpenCFD limited authority to distribute without
   7  * alteration the source code to the Tecplot Input/Output library, known
   8  * as TecIO, as part of its distribution of OpenFOAM and the
   9  * OpenFOAM_to_Tecplot converter.  Users of this converter are also hereby
  10  * granted access to the TecIO source code, and may redistribute it for the
  11  * purpose of maintaining the converter.  However, no authority is granted
  12  * to alter the TecIO source code in any form or manner.
  13  *
  14  * This limited grant of distribution does not supersede Tecplot, Inc.'s
  15  * copyright in TecIO.  Contact Tecplot, Inc. for further information.
  16  *
  17  * Tecplot, Inc.
  18  * 3535 Factoria Blvd, Ste. 550
  19  * Bellevue, WA 98006, USA
  20  * Phone: +1 425 653 1200
  21  * http://www.tecplot.com/
  22  *
  23  */
  24 /*
  25 ******************************************************************
  26 ******************************************************************
  27 *******                                                   ********
  28 ******  (C) 1988-2008 Tecplot, Inc.                        *******
  29 *******                                                   ********
  30 ******************************************************************
  31 ******************************************************************
  32 */
  33 /*
  34  * Provide four levels of assertion control. Assertions provide a mechanism
  35  * to enforce a contract between a client and service provider. The assertions
  36  * are listed in order of highest to lowest priority. Assertions can be turned
  37  * off individually by defining the appropriate name (see preprossessor
  38  * definitions below), however, lower priority assertions should be turned
  39  * off prior to higher ones. As confidence in the code increases all assertions
  40  * can be turned off by defining NO_ASSERTS.
  41  *
  42  * The assertions defined below have the following meanings:
  43  *
  44  *     INVARIANT - Asserts that a property's state is invariant throughout the
  45  *                 life of the property's scope. Stating invariant properties
  46  *                 of an application provides a deeper understanding of the
  47  *                 application's state.  These statements are usually
  48  *                 positioned just ahead of the preconditions and just after
  49  *                 the postconditions.
  50  *
  51  *     REQUIRE   - Asserts that a method's preconditions are within their
  52  *                 valid domains. Preconditions are conditions placed upon
  53  *                 any state information relied upon for the call. These
  54  *                 statements should be as close to the top of the method
  55  *                 as possible (except for assertions on invariant properties).
  56  *
  57  *     ENSURE    - Asserts that a method's postconditions are within their
  58  *                 valid ranges. Postconditions are conditions placed upon
  59  *                 any state information modified by the call. These
  60  *                 statements should be as close to the bottom of the method
  61  *                 (presumably there is only one exit point) as possible
  62  *                 (except for assertions on invariant properties).
  63  *
  64  *     CHECK     - Any other assertion not covered by the above assertions.
  65  *                 These are often added within a method body to specify
  66  *                 something that may not be immediately obvious to the reader
  67  *                 or to validate your assumptions about a call to a 3rd party
  68  *                 method that does not use runtime assertions for its
  69  *                 preconditions or postconditions. Obviously if the 3rd party
  70  *                 method uses assertions then there is no need for the CHECK.
  71  *
  72  * Additionally a convenience macro is available to place in code that is
  73  * pending implementation.
  74  *
  75  *     NOT_IMPLEMENTED - Assertion that always fails during runtime for debug
  76  *                       builds and always fails at compile time for release
  77  *                       builds.
  78  */
  79 #if !defined TASSERT_H
  80 #define TASSERT_H
  81
  82 #if defined (MSWIN)
  83 # include <assert.h>
  84 #endif /* MSWIN */
  85
  86 #if !defined TECPLOTKERNEL && !defined STD_ASSERTS
  87 #define STD_ASSERTS
  88 #endif
  89
  90 #if !defined (MSWIN)
  91 #  include <assert.h>
  92 #  if !defined ASSERT
  93 #    define ASSERT assert
  94 #  endif
  95 #endif
  96
  97 #if defined MSWIN
  98 /* MFC .NET defines ENSURE, so we undefine it here */
  99 #if defined ENSURE
 100 #undef ENSURE
 101 #endif /* ENSURE */
 102 #endif /* MSWIN */
 103
 104 /* BEGINREMOVEFROMADDON */
 105 #define INVALID_REF       ((void *)0x0000FFFF)
 106 /*
 107  * Chances are low the address 0x11111111 will be used, so we'll risk asserting
 108  * against it (see unitialized assignment in newmalloc).
 109  */
 110 #define UNINITIALIZED_REF ((void *)0x11111111)
 111 #define INVALID_FN_REF    ((void *)NULL)
 112 /* ENDREMOVEFROMADDON */
 113
 114 #ifdef UNIXX
 115 /* BEGINREMOVEFROMADDON */
 116 #if defined TECPLOTKERNEL
 117 /* CORE SOURCE CODE REMOVED */
 118 #  if defined NO_ASSERTS
 119 #  else
 120 #  endif
 121 #endif /* TECPLOTKERNAL */
 122 /* ENDREMOVEFROMADDON */
 123
 124 /* BEGINREMOVEFROMADDON */
 125 #if !defined TECPLOTKERNEL
 126 /* For add-ons, there is a problem with VALID_REF, so just test for non-NULL */
 127 /* ENDREMOVEFROMADDON */
 128 #  define VALID_REF(p)      ( (p)  != NULL )
 129 #  define VALID_FN_REF(fp)  ( (fp) != NULL )
 130 /* BEGINREMOVEFROMADDON */
 131 #endif /* !defined TECPLOTKERNAL */
 132 /* ENDREMOVEFROMADDON */
 133
 134 /* BEGINREMOVEFROMADDON */
 135 /* Widgets are pointers under Motif */
 136 # define VALID_WIDGET(widget)       VALID_REF((widget))
 137 /* Menu widgets are pointers too */
 138 # define VALID_MENU_WIDGET(widget)   VALID_REF((widget))
 139 /* ENDREMOVEFROMADDON */
 140 #endif /* UNIXX */
 141
 142 #ifdef MSWIN
 143 /* BEGINREMOVEFROMADDON */
 144 /* Don't use AfxIsValidAddress()! See Bug <7245>.
 145    1/4/08, dto. */
 146 /* ENDREMOVEFROMADDON */
 147
 148 #if defined NO_ASSERTS
 149 /* release build in TecUtil layer uses these for TUASSERT */
 150 #  define VALID_REF(p)      ((p)  != NULL)
 151 #  define VALID_FN_REF(pf)  ((pf) != NULL)
 152 #else
 153 #  define VALID_REF(p)      ((p)  != NULL && !IsBadReadPtr((const void *)(p), 1))
 154 #  define VALID_FN_REF(pf)  ((pf) != NULL && !IsBadReadPtr((const void *)(pf),(UINT_PTR)sizeof(const void*)))
 155 #endif
 156
 157 /* BEGINREMOVEFROMADDON */
 158 /* Widgets are numbers under Windows, so we decode it with GetWindowFromWidget */
 159 # if defined ENGINE
 160 #   define VALID_WIDGET(widget)       ((widget) != NULL)
 161 # else
 162 #   define VALID_WIDGET(widget)       ((widget) != NULL && GetWindowFromWidget((widget))!=NULL)
 163 # endif // ENGINE
 164
 165 /* Menu widgets are numbers too, so we just check against zero */
 166 # define VALID_MENU_WIDGET(widget)  ((widget)!=NULL)
 167 /* ENDREMOVEFROMADDON */
 168 #endif /* MSWIN */
 169 /* BEGINREMOVEFROMADDON */
 170 /* handles are not pointers to memory, so the only test we can */
 171 /* perform is to check for 0 */
 172 #define VALID_HANDLE(handle)       ((handle)!=0)
 173
 174 #if defined FLEXLM
 175 #define VALID_FLEX_JOB_HANDLE(handle) ((handle) != NULL)
 176 #define VALID_FLEX_ERROR_CODE(ErrorCode)(ErrorCode <= 0)
 177 #endif /* FLEXLM */
 178
 179 /* ENDREMOVEFROMADDON */
 180 /* other useful validity checks */
 181 #define VALID_BOOLEAN(b)           ((b) == TRUE || (b) == FALSE)
 182 #define VALID_ENUM(value, type)    (0 <= (value) && \
 183                                          (value) < END_##type)
 184
 185 /* Test a parameter than can be NULL or a valid pointer */
 186 #define VALID_REF_OR_NULL(ptr) IMPLICATION((ptr) != NULL, VALID_REF(ptr))
 187 #define VALID_FN_REF_OR_NULL(ptr) IMPLICATION((ptr) != NULL, VALID_FN_REF(ptr))
 188
 189 /* BEGINREMOVEFROMADDON */
 190 #define VALID_TRANSLATED_STRING(ts) (!(ts).isNull())
 191
 192 /**
 193  * These macros are a little complicated but it allows one to
 194  * write a simple assertion regardless of the zone type or
 195  * selected plane:
 196  *
 197  *   REQUIRE(VALID_CELL_INDEX(CZData, CellIndex, Plane)));
 198  *
 199  * Prior to using the macros a call to SetupXxx,
 200  * or at a minimum SetupCZData, must be called to setup
 201  * the globals defining the dataset structure.
 202  */
 203 #define VALID_FE_CELL_INDEX(CZData, CellIndex) \
 204             (/* CellIndex range test */ \
 205              0 <= (CellIndex) && \
 206                   (CellIndex) < (CZData)->NumElements)
 207
 208 #define VALID_IPLANE_CELL_INDEX(CZData,CellIndex) \
 209             (/* CellIndex range test */ \
 210              (CellIndex) >= 0 && \
 211              IINDEX((CZData),CellIndex) <= MAX((CZData)->NumIPtsM1,1) && \
 212              JINDEX((CZData),CellIndex) <  MAX((CZData)->NumJPtsM1,1) && \
 213              KINDEX((CZData),CellIndex) <  MAX((CZData)->NumKPtsM1,1))
 214
 215 #define VALID_JPLANE_CELL_INDEX(CZData,CellIndex) \
 216             (/* CellIndex range test */ \
 217              (CellIndex) >= 0 && \
 218              IINDEX((CZData),CellIndex) <  MAX((CZData)->NumIPtsM1,1) && \
 219              JINDEX((CZData),CellIndex) <= MAX((CZData)->NumJPtsM1,1) && \
 220              KINDEX((CZData),CellIndex) <  MAX((CZData)->NumKPtsM1,1))
 221
 222 #define VALID_KPLANE_CELL_INDEX(CZData,CellIndex) \
 223             (/* CellIndex range test */ \
 224              (CellIndex) >= 0 && \
 225              IINDEX((CZData),CellIndex) <  MAX((CZData)->NumIPtsM1,1) && \
 226              JINDEX((CZData),CellIndex) <  MAX((CZData)->NumJPtsM1,1) && \
 227              KINDEX((CZData),CellIndex) <= MAX((CZData)->NumKPtsM1,1))
 228
 229 #define VALID_ORDERED_CELL_INDEX(CZData, CellIndex, Plane) \
 230             (/* macro preconditions */ \
 231              ((IJKPlanes_e)(Plane) == IJKPlanes_I || \
 232               (IJKPlanes_e)(Plane) == IJKPlanes_J || \
 233               (IJKPlanes_e)(Plane) == IJKPlanes_K || \
 234               (IJKPlanes_e)(Plane) == IJKPlanes_Volume) && \
 235 \
 236              /* CellIndex range test */ \
 237              (IMPLICATION(((IJKPlanes_e)(Plane) == IJKPlanes_I || \
 238                            (IJKPlanes_e)(Plane) == IJKPlanes_Volume), \
 239                           VALID_IPLANE_CELL_INDEX((CZData),CellIndex)) && \
 240               IMPLICATION(((IJKPlanes_e)(Plane) == IJKPlanes_J || \
 241                            (IJKPlanes_e)(Plane) == IJKPlanes_Volume), \
 242                           VALID_JPLANE_CELL_INDEX((CZData),CellIndex)) && \
 243               IMPLICATION(((IJKPlanes_e)(Plane) == IJKPlanes_K || \
 244                            (IJKPlanes_e)(Plane) == IJKPlanes_Volume), \
 245                           VALID_KPLANE_CELL_INDEX((CZData),CellIndex))))
 246
 247 #define VALID_CELL_INDEX(CZData, CellIndex, Plane) \
 248            (((CZData)->NM != NULL || (CZData)->FM != NULL) ? \
 249               VALID_FE_CELL_INDEX((CZData), (CellIndex)) : \
 250               VALID_ORDERED_CELL_INDEX((CZData), (CellIndex), (Plane)))
 251
 252 #define VALID_DATASET(dataSet,checkNumZones) (((dataSet) != NULL) && \
 253                                               IMPLICATION((checkNumZones),(dataSet)->NumZones >= 1))
 254
 255
 256
 257 #ifdef MSWIN
 258 /* Here is a more specific check in Windows for a valid
 259    pointer to an MFC Window object.
 260    Note that GetSafeHwnd() works even if pWnd is NULL, because
 261    it checks the 'this' pointer first */
 262 # define VALID_WND(pWnd) (::IsWindow((pWnd)->GetSafeHwnd()))
 263
 264 #else /* !MSWIN */
 265 # define VALID_WND(pWnd) /* Should not be used in Motif */
 266 #endif /* MSWIN */
 267 /* ENDREMOVEFROMADDON */
 268
 269 /* Check for a non-zero length string */
 270 #if defined MSWIN
 271 #  if defined NO_ASSERTS
 272 #    define VALID_NON_ZERO_LEN_STR(str) (VALID_REF(str) && !ISEMPTYSTRING(str))
 273 #  else
 274 #    define VALID_NON_ZERO_LEN_STR(str) \
 275          (VALID_REF(str)                                                            && \
 276          !IsBadReadPtr((const void*)(str),(UINT_PTR)(1+strlen((const char*)(str)))) && \
 277          !ISEMPTYSTRING(str))
 278 #  endif
 279 #else
 280 #  define VALID_NON_ZERO_LEN_STR(str) (VALID_REF(str) && !ISEMPTYSTRING(str))
 281 #endif
 282
 283 #define VALID_SET_INDEX(setIndex) (((SetIndex_t)setIndex)>=(SetIndex_t)1)
 284
 285 /* Check for valid stdio file handle */
 286 #define VALID_FILE_HANDLE(stream) ((stream) != NULL)
 287
 288 /* To check colors and pen numbers */
 289 /* BEGINREMOVEFROMADDON */
 290 #define VALID_BASIC_COLOR(BColor) \
 291           (FirstBasicColor<=(BColor) && (BColor)<=LastBasicColor)
 292 #define VALID_CONTOUR_COLOR(Color) \
 293           (ContourColorOffset<=(Color) && \
 294            (Color)<ContourColorOffset+GeneralBase.Limits.MaxNumContourLevels+1)
 295 #define VALID_PLOTTING_COLOR(Color) \
 296           (VALID_BASIC_COLOR(Color) || VALID_CONTOUR_COLOR(Color))
 297 #define VALID_INTERFACE_SPECIFIC_COLOR(BColor) \
 298           (FirstInterfaceColor<=(BColor) && (BColor)<=LastInterfaceColor)
 299 #define VALID_INTERFACE_COLOR(Color) \
 300           (VALID_PLOTTING_COLOR(Color) || VALID_INTERFACE_SPECIFIC_COLOR(Color))
 301 #define VALID_MULTICOLOR_COLOR(Color) \
 302           (((Color) == MultiColor_C) || ((Color) == MultiColor2_C) || \
 303            ((Color) == MultiColor3_C) || ((Color) == MultiColor4_C) || \
 304            ((Color) == MultiColor5_C) || ((Color) == MultiColor6_C) || \
 305            ((Color) == MultiColor7_C) || ((Color) == MultiColor8_C))
 306 #define VALID_RGB_COLOR(Color) \
 307           ((Color) == RGBColor_C)
 308 #define VALID_ASSIGNABLE_COLOR(C) \
 309         (VALID_BASIC_COLOR(C)      || \
 310          VALID_MULTICOLOR_COLOR(C) || \
 311          VALID_RGB_COLOR(C))
 312 #define VALID_PEN_OFFSET(PenOffset) \
 313           (Black_C<=(PenOffset) && (PenOffset)<=NumPlotterPens)
 314 #define VALID_PEN_OFFSET_FOR_OBJECT(PenOffset) \
 315           (FirstObjectPen<=(PenOffset) && (PenOffset)<=LastObjectPen)
 316
 317
 318 /* to check FE cells */
 319 #define VALID_ELEMENT_TYPE(element_type) \
 320           ((element_type) == ZoneType_FETriangle || \
 321            (element_type) == ZoneType_FEQuad     || \
 322            (element_type) == ZoneType_FETetra    || \
 323            (element_type) == ZoneType_FEBrick    || \
 324            (element_type) == ZoneType_FELineSeg)
 325
 326
 327
 328 /*
 329  * Test validity of zone and variable names. A valid name is one that has a
 330  * valid reference, is not padded with spaces and is within the maximum
 331  * specified length.
 332  */
 333 #define VALID_NAME(Name, MaxLength) \
 334           (VALID_REF(Name) && \
 335            (ISEMPTYSTRING(Name) || \
 336             (!isspace((Name)[0]) && !isspace((Name)[strlen(Name)-1]))) && \
 337            strlen(Name) <= (MaxLength))
 338 #define VALID_ZONE_NAME(Name) VALID_NAME((Name), MaxChrsZnTitle)
 339 #define VALID_VAR_NAME(Name)  VALID_NAME((Name), MaxChrsVarName)
 340
 341
 342 /* Special test for lighting effect (don't allow "none" in some cases) */
 343 #define VALID_LIGHTINGEFFECT(L) \
 344           (((L) == LightingEffect_Paneled) || ((L) == LightingEffect_Gouraud))
 345
 346
 347 /* type definition for assert failure notification function */
 348 typedef void (*TAssertFailureNotifyFunc)(
 349     const char *expression, /* text representation of the assertion */
 350     const char *file_name,  /* name of the file containing the assertion */
 351     int        line);       /* line number in the file of the assertion */
 352
 353 #if !defined STD_ASSERTS
 354 /* external function prototypes */
 355 extern void TAssert(
 356     const char *expression, /* text representation of the assertion */
 357     const char *file_name,  /* name of the file containing the assertion */
 358     int        line);       /* line number in the file of the assertion */
 359
 360 extern TAssertFailureNotifyFunc InstallTAssertFailureNotify(
 361     TAssertFailureNotifyFunc new_function); /* new notification function */
 362 #endif /* !STD_ASSERTS */
 363 /* ENDREMOVEFROMADDON */
 364
 365 #if defined NO_ASSERTS
 366 /* BEGINREMOVEFROMADDON */
 367 #   define TASSERT(EXPR)
 368 /* ENDREMOVEFROMADDON */
 369 #   define INVARIANT(EXPR)
 370 #   define REQUIRE(EXPR)
 371 #   define ENSURE(EXPR)
 372 #   define CHECK(EXPR)
 373 #   ifdef VERIFY
 374 #     undef VERIFY
 375 #   endif
 376 #   define VERIFY(EXPR)    ((void)(EXPR))
 377 /*
 378  * Only define IGNORENOTIMPLEMENTED if building a "test" release build
 379  * that you are fully aware may contain unimplemented features.
 380  */
 381 #   if defined IGNORENOTIMPLEMENTED
 382 #     define NOT_IMPLEMENTED() CHECK(FALSE)
 383 #   else
 384 #     if defined MSWIN
 385 /*
 386  * NOT_IMPLEMENTED is defined using a parameter, but should be called with none,
 387  * this will then throw a warning and not break the compile. Unix doesn't pick
 388  * up this warning, so break the compile under Unix
 389  */
 390 #       define NOT_IMPLEMENTED(x)  TAssert("Not Implemented", __FILE__, __LINE__)
 391 #     endif
 392 #     if defined UNIXX
 393 #       define NOT_IMPLEMENTED()  not implemented /* intentionally break the compile */
 394 #     endif
 395 #   endif
 396 #elif defined STD_ASSERTS
 397 /* BEGINREMOVEFROMADDON */
 398 #   define TASSERT(EXPR)         assert(EXPR)
 399 /* ENDREMOVEFROMADDON */
 400 #   define INVARIANT(EXPR)       assert(EXPR)
 401 #   define REQUIRE(EXPR)         assert(EXPR)
 402 #   define ENSURE(EXPR)          assert(EXPR)
 403 #   define CHECK(EXPR)           assert(EXPR)
 404 #   ifdef VERIFY
 405 #     undef VERIFY
 406 #   endif
 407 #   ifndef VERIFY
 408 #     if defined NDEBUG
 409 #       define VERIFY(EXPR) ((void)(EXPR))
 410 #     else
 411 #       define VERIFY(EXPR) assert(EXPR)
 412 #     endif
 413 #   endif /* VERIFY */
 414 #   define NOT_IMPLEMENTED()     assert(!("Not Implemented"))
 415 #else
 416 /* BEGINREMOVEFROMADDON */
 417 #if defined (MSWIN)
 418 #if defined CHECKED_BUILD
 419 #include <string>
 420 #include <vector>
 421 #include <algorithm>
 422
 423 class AssertionLog
 424 {
 425 public:
 426     static void initializeAssertLog(const std::string &fileName);
 427     static bool isLoggingAssertions();
 428     static void addAssertion(const std::string &message);
 429 private:
 430     static void writeOutAssertion(const std::string &message);
 431 private:
 432     static bool                     logAssertions;
 433     static std::string              logFileName;
 434     static std::vector<std::string> assertList;
 435 };
 436
 437 extern void TWinCheckedFailedLine(const char *Expr,
 438                                   const char *FileName,
 439                                   int LineNum);
 440
 441 #define TASSERT(EXPR)\
 442         do { if (!(EXPR)) { TWinCheckedFailedLine(#EXPR,__FILE__,__LINE__); } } while (0)
 443 #else
 444 #define TASSERT(EXPR) ASSERT(EXPR) /* MFC assert.
 445 Works in both release & debug builds */
 446 #endif /* CHECKED_BUILD */
 447 #else
 448 #define TASSERT(EXPR) (void)((EXPR) || (TAssert(#EXPR, __FILE__, __LINE__), 0))
 449 #endif
 450
 451 #   if defined NO_INVARIANTS
 452 #     define INVARIANT(EXPR)
 453 #   else
 454 #     define INVARIANT(EXPR) TASSERT(EXPR)
 455 #   endif
 456
 457 #   if defined NO_PRECONDITIONS
 458 #     define REQUIRE(EXPR)
 459 #   else
 460 #     define REQUIRE(EXPR) TASSERT(EXPR)
 461 #   endif
 462
 463 #   if defined NO_POSTCONDITIONS
 464 #     define ENSURE(EXPR)
 465 #   else
 466 #     define ENSURE(EXPR) TASSERT(EXPR)
 467 #   endif
 468
 469 #   if defined VERIFY
 470 #     undef VERIFY
 471 #   endif
 472
 473 #   if defined NO_CHECKS
 474 #     define CHECK(EXPR)
 475 #     define VERIFY(EXPR)  ((void)(EXPR))
 476 #   else
 477 #     define CHECK(EXPR)  TASSERT(EXPR)
 478 #     if defined NDEBUG
 479 #       define VERIFY(EXPR) ((void)(EXPR))
 480 #     else
 481 #       define VERIFY(EXPR) TASSERT(EXPR)
 482 #     endif
 483 #   endif
 484
 485 #   if defined NICE_NOT_IMPLEMENTED
 486 #     define NOT_IMPLEMENTED() NiceNotImplemented()
 487 #   else
 488 #     define NOT_IMPLEMENTED() TASSERT(!("Not Implemented"))
 489 #   endif
 490 /* ENDREMOVEFROMADDON */
 491 #endif
 492 /* BEGINREMOVEFROMADDON */
 493 #if !defined STD_ASSERTS
 494 extern void TecplotMopupOnAssert(void);
 495 #endif /* !STD_ASSERTS */
 496
 497 #if defined NICE_NOT_IMPLEMENTED
 498 extern void NiceNotImplemented(void);
 499 #endif
 500 /* ENDREMOVEFROMADDON */
 501
 502 /* convenience macros for implication, P -> Q, and equivalence, P <-> Q. */
 503 #define IMPLICATION(P,Q) (!(P) || (Q))
 504 #define EQUIVALENCE(P,Q) ((P) == (Q))
 505
 506 /* BEGINREMOVEFROMADDON */
 507 #if defined RLM
 508 #define VALID_RLM_HANDLE(h) ((h) != NULL)
 509 #endif /* RLM */
 510 /* ENDREMOVEFROMADDON */
 511
 512
 513 #endif /* TASSERT_H */