applications/utilities/postProcessing/dataConversion/foamToTecplot360/tecio/tecsrc/q_msg.cpp

   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 #include "stdafx.h"
  25 #include "MASTER.h"
  26
  27 #define TECPLOTENGINEMODULE
  28
  29 /*
  30 ******************************************************************
  31 ******************************************************************
  32 *******                                                   ********
  33 ******  (C) 1988-2008 Tecplot, Inc.                        *******
  34 *******                                                   ********
  35 ******************************************************************
  36 ******************************************************************
  37 */
  38
  39 #define Q_MSGMODULE
  40 #include "GLOBAL.h"
  41 #include "TASSERT.h"
  42 #include "Q_UNICODE.h"
  43 #include "ALLOC.h"
  44 #include "ARRLIST.h"
  45
  46 #if defined TECPLOTKERNEL
  47 /* CORE SOURCE CODE REMOVED */
  48 #if !defined ENGINE
  49 #if defined MOTIF
  50 #endif
  51 #if defined MSWIN
  52 #endif
  53 #endif
  54 #endif
  55
  56 #include "STRUTIL.h"
  57 #if defined TECPLOTKERNEL
  58 /* CORE SOURCE CODE REMOVED */
  59 #endif
  60
  61 using std::string;
  62 using namespace tecplot::strutil;
  63 #if defined TECPLOTKERNEL
  64 /* CORE SOURCE CODE REMOVED */
  65 #endif
  66
  67 #define MAXCHARACTERSPERLINE 60
  68 /*
  69  * Wrap a string so it contains at most CharactersPerLine
  70  * characters. Embedded newlines are left alone. Spaces
  71  * following newlines are also left alone.
  72  */
  73 Boolean_t WrapString(const char  *OldString,
  74                      char       **NewString)
  75 {
  76     size_t L;
  77     if (OldString == NULL)
  78         return (FALSE);
  79
  80     /*
  81      *  Assume Old string has ample spaces.  Will only be
  82      *  replacing some spaces with newlines and removing
  83      *  other spaces.  New string can be allocated to be
  84      *  same length as old string.
  85      */
  86
  87     L = strlen(OldString);
  88     *NewString = ALLOC_ARRAY(L + 1, char, "new error message string");
  89     if (*NewString == NULL)
  90         return (FALSE);
  91
  92     strcpy(*NewString, OldString);
  93
  94     if (L > MAXCHARACTERSPERLINE)
  95     {
  96         char *LineStart = *NewString;
  97         char *LastWord  = *NewString;
  98         char *WPtr      = *NewString;
  99         while (WPtr && (*WPtr != '\0'))
 100         {
 101             size_t CurLen;
 102             /*
 103              * Find next hard newline.  If there is one befor the
 104              * line should be chopped then reset the Last Word to
 105              * be at the first word after the newline.
 106              */
 107             WPtr = strchr(LineStart, '\n');
 108             if (WPtr && ((WPtr - LineStart) < MAXCHARACTERSPERLINE))
 109             {
 110                 WPtr++;
 111                 while (*WPtr == '\n')
 112                     WPtr++;
 113                 LineStart = WPtr;
 114                 /*
 115                  * Skip over trailing spaces.  Special handling to
 116                  * allow indent after hard newline.
 117                  */
 118                 while (*WPtr == ' ')
 119                     WPtr++;
 120                 LastWord  = WPtr;
 121                 continue;
 122             }
 123             /*
 124              *  Find next "word"
 125              */
 126             WPtr = strchr(LastWord, ' ');
 127             if (WPtr != NULL)
 128             {
 129                 while (*WPtr == ' ')
 130                     WPtr++;
 131             }
 132
 133             if (WPtr == NULL)
 134             {
 135                 CurLen = strlen(LineStart);
 136             }
 137             else
 138             {
 139                 CurLen = WPtr - LineStart;
 140             }
 141
 142             if (CurLen > MAXCHARACTERSPERLINE)
 143             {
 144                 /*
 145                  * Line is too long.  Back up to previous
 146                  * word and replace preceeding space with
 147                  * a newline.
 148                  */
 149                 if (LastWord == LineStart)
 150                 {
 151                     /*
 152                      * Bad news, line has very long word.
 153                      */
 154                     if (WPtr && (*WPtr != '\0'))
 155                     {
 156                         *(WPtr - 1) = '\n';
 157                         LastWord = WPtr;
 158                     }
 159                 }
 160                 else
 161                 {
 162                     *(LastWord - 1) = '\n';
 163                 }
 164                 LineStart = LastWord;
 165             }
 166             else
 167                 LastWord = WPtr;
 168         }
 169     }
 170     return (TRUE);
 171 }
 172
 173
 174 static void SendWarningToFile(FILE *F,
 175                               const char *S)
 176 {
 177     char *S2;
 178     REQUIRE(VALID_REF(F));
 179     REQUIRE(VALID_REF(S));
 180     if (WrapString(S, &S2))
 181     {
 182         fprintf(F, "Warning: %s\n", S2);
 183         FREE_ARRAY(S2, "temp warning string");
 184     }
 185 }
 186
 187 #if defined TECPLOTKERNEL
 188 /* CORE SOURCE CODE REMOVED */
 189 #endif
 190
 191
 192 /**
 193  * Show the warning message. Note that the Format string can be the only
 194  * argument, in which case it is essentially the warning message itself.
 195  *
 196  * param Format
 197  *     C Format string or a simple message.
 198  * param ...
 199  *     Zero or more variable arguments. The number of arguments must correspond
 200  *     to the placeholders in the format string.
 201  */
 202 void Warning(TranslatedString Format,
 203              ...) /* zero or more arguments */
 204 {
 205     REQUIRE(!Format.isNull());
 206
 207     static Boolean_t InWarning = FALSE; /* ...used to prevent recursive deadlock */
 208     if (!InWarning)
 209     {
 210 #if defined TECPLOTKERNEL
 211 /* CORE SOURCE CODE REMOVED */
 212 #endif
 213
 214         InWarning = TRUE;
 215         {
 216             /*
 217              * Attempt to format the string. Failing that simply use the original format
 218              * string argument which, if we ran out of memory while formatting, is
 219              * probably just an warning message saying that we ran out of memory in some
 220              * previous operation anyway.
 221              */
 222             Boolean_t cleanUp = TRUE;
 223
 224             va_list  Arguments;
 225             va_start(Arguments, Format);
 226             char* message = vFormatString(Format.c_str(), Arguments);
 227             va_end(Arguments);
 228
 229             if (message == NULL)
 230             {
 231                 cleanUp = FALSE; // ...this boolean allows us to "carefully" cast away the const'ness
 232                 message = (char*)Format.c_str();
 233             }
 234
 235 #if defined TECPLOTKERNEL
 236 /* CORE SOURCE CODE REMOVED */
 237 #ifdef MSWIN
 238 #endif
 239 #if defined UNIXX
 240 #endif
 241 #if defined MSWIN
 242 #endif
 243 #else /* !TECPLOTKERNEL */
 244             {
 245                 SendWarningToFile(stderr, message);
 246             }
 247 #endif
 248
 249             if (cleanUp)
 250                 FREE_ARRAY(message, "message");
 251         }
 252         InWarning = FALSE;
 253
 254 #if defined TECPLOTKERNEL
 255 /* CORE SOURCE CODE REMOVED */
 256 #endif
 257     }
 258 }
 259
 260
 261 static void SendErrToFile(FILE       *File,
 262                           const char *Msg)
 263 {
 264     char *FormattedMsg;
 265     REQUIRE(VALID_REF(File));
 266     REQUIRE(VALID_REF(Msg));
 267     if (WrapString(Msg, &FormattedMsg))
 268     {
 269         fprintf(File, "Err: %s\n", FormattedMsg);
 270         FREE_ARRAY(FormattedMsg, "temp error string");
 271     }
 272     else
 273         fprintf(File, "Err: %s\n", Msg);
 274 }
 275
 276
 277 /* Fall-back ErrMsg procedure when nothing else works */
 278 static void DefaultErrMsg(const char *Msg)
 279 {
 280     REQUIRE(VALID_REF(Msg));
 281
 282 #ifdef MSWIN
 283 #ifdef TECPLOTKERNEL
 284 /* CORE SOURCE CODE REMOVED */
 285 #else
 286     MessageBox(NULL, Msg, "Error", MB_OK | MB_ICONERROR);
 287 #endif
 288 #else
 289     SendErrToFile(stderr, Msg);
 290 #endif
 291 }
 292
 293 static void PostErrorMessage(TranslatedString Format,
 294                              va_list          Arguments)
 295 {
 296     REQUIRE(!Format.isNull());
 297
 298     /*
 299      * Attempt to format the string. Failing that simply use the original format
 300      * string argument which, if we ran out of memory while formatting, is
 301      * probably just an error message saying that we ran out of memory in some
 302      * previous operation anyway.
 303      */
 304     Boolean_t cleanUp = TRUE;
 305     char* messageString = vFormatString(Format.c_str(), Arguments);
 306     if (messageString == NULL)
 307     {
 308         cleanUp = FALSE; // ...this boolean allows us to "carefully" cast away the const'ness
 309         messageString = (char*)Format.c_str();
 310     }
 311
 312 #if defined TECPLOTKERNEL
 313 /* CORE SOURCE CODE REMOVED */
 314 #ifdef MSWIN
 315 #endif
 316 #if defined UNIXX
 317 #if !defined ENGINE
 318 #endif
 319 #endif
 320 #else /* !TECPLOTKERNEL */
 321     {
 322         DefaultErrMsg(messageString);
 323     }
 324 #endif
 325
 326     /* cleanup if we allocated the string */
 327     if (cleanUp)
 328         FREE_ARRAY(messageString, "messageString");
 329 }
 330
 331 /*
 332  * NOTES:
 333  *   This function is thread safe in that it may be safely called by multiple
 334  *   threads however when running interactively only the first error message is
 335  *   queued for display on idle. In batch mode all messages are sent to the
 336  *   batch log file.
 337  */
 338 void vErrMsg(TranslatedString Format,
 339              va_list          Arguments)
 340 {
 341     REQUIRE(!Format.isNull());
 342
 343     static Boolean_t InErrMsg = FALSE; /* ...used to prevent recursive deadlock */
 344     if (!InErrMsg)
 345     {
 346 #if defined TECPLOTKERNEL
 347 /* CORE SOURCE CODE REMOVED */
 348 #endif
 349
 350         InErrMsg = TRUE;
 351         {
 352             PostErrorMessage(Format, Arguments);
 353         }
 354         InErrMsg = FALSE;
 355
 356 #if defined TECPLOTKERNEL
 357 /* CORE SOURCE CODE REMOVED */
 358 #endif
 359     }
 360 }
 361
 362 /**
 363  * Show the error message. Note that the Format string can be the only
 364  * argument, in which case it is essentially the error message itself.
 365  *
 366  * @param Format
 367  *   C Format string or a simple message.
 368  * @param ...
 369  *   Zero or more variable arguments. The number of arguments must correspond
 370  *   to the placeholders in the format string.
 371  */
 372 void ErrMsg(TranslatedString Format,
 373             ...) /* zero or more arguments */
 374 {
 375     REQUIRE(!Format.isNull());
 376
 377     va_list Arguments;
 378     va_start(Arguments, Format);
 379 #if defined TECPLOTKERNEL
 380 /* CORE SOURCE CODE REMOVED */
 381 #else
 382     PostErrorMessage(Format, Arguments);
 383 #endif
 384     va_end(Arguments);
 385 }
 386
 387
 388 #if defined TECPLOTKERNEL
 389 /* CORE SOURCE CODE REMOVED */
 390 #if !defined ENGINE
 391 #endif
 392 #if !defined ENGINE
 393 #if defined MOTIF
 394 #endif
 395 #if defined MSWIN
 396 #endif
 397 #endif
 398 #if !defined ENGINE
 399 #if defined MOTIF
 400 #endif
 401 #if defined MSWIN
 402 #endif
 403 #endif
 404 #if !defined ENGINE
 405 #if defined MOTIF
 406 #endif /* MOTIF */
 407 #if defined MSWIN
 408 #endif
 409 #if defined MOTIF
 410 #endif /* MOTIF */
 411 #endif
 412 #if !defined ENGINE
 413 #endif
 414 #endif /* TECPLOTKERNEL */
 415