miscutil.c

   1 const char miscutil_rcs[] = "$Id: miscutil.c,v 1.23 2001/10/29 03:48:10 david__schmidt Exp $";
   2 /*********************************************************************
   3  *
   4  * File        :  $Source: /cvsroot/ijbswa/current/miscutil.c,v $
   5  *
   6  * Purpose     :  zalloc, hash_string, safe_strerror, strcmpic,
   7  *                strncmpic, strsav, chomp, and MinGW32 strdup
   8  *                functions.
   9  *                These are each too small to deserve their own file
  10  *                but don't really fit in any other file.
  11  *
  12  * Copyright   :  Written by and Copyright (C) 2001 the SourceForge
  13  *                IJBSWA team.  http://ijbswa.sourceforge.net
  14  *
  15  *                Based on the Internet Junkbuster originally written
  16  *                by and Copyright (C) 1997 Anonymous Coders and
  17  *                Junkbusters Corporation.  http://www.junkbusters.com
  18  *
  19  *                This program is free software; you can redistribute it
  20  *                and/or modify it under the terms of the GNU General
  21  *                Public License as published by the Free Software
  22  *                Foundation; either version 2 of the License, or (at
  23  *                your option) any later version.
  24  *
  25  *                This program is distributed in the hope that it will
  26  *                be useful, but WITHOUT ANY WARRANTY; without even the
  27  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
  28  *                PARTICULAR PURPOSE.  See the GNU General Public
  29  *                License for more details.
  30  *
  31  *                The GNU General Public License should be included with
  32  *                this file.  If not, you can view it at
  33  *                http://www.gnu.org/copyleft/gpl.html
  34  *                or write to the Free Software Foundation, Inc., 59
  35  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  36  *
  37  * Revisions   :
  38  *    $Log: miscutil.c,v $
  39  *    Revision 1.23  2001/10/29 03:48:10  david__schmidt
  40  *    OS/2 native needed a snprintf() routine.  Added one to miscutil, brackedted
  41  *    by and __OS2__ ifdef.
  42  *
  43  *    Revision 1.22  2001/10/26 17:39:38  oes
  44  *    Moved ijb_isspace and ijb_tolower to project.h
  45  *
  46  *    Revision 1.21  2001/10/23 21:27:50  jongfoster
  47  *    Standardising error codes in string_append
  48  *    make_path() no longer adds '\\' if the dir already ends in '\\' (this
  49  *    is just copying a UNIX-specific fix to the Windows-specific part)
  50  *
  51  *    Revision 1.20  2001/10/22 15:33:56  david__schmidt
  52  *    Special-cased OS/2 out of the Netscape-abort-on-404-in-js problem in
  53  *    filters.c.  Added a FIXME in front of the offending code.  I'll gladly
  54  *    put in a better/more robust fix for all parties if one is presented...
  55  *    It seems that just returning 200 instead of 404 would pretty much fix
  56  *    it for everyone, but I don't know all the history of the problem.
  57  *
  58  *    Revision 1.19  2001/10/14 22:02:57  jongfoster
  59  *    New function string_append() which is like strsav(), but running
  60  *    out of memory isn't automatically FATAL.
  61  *
  62  *    Revision 1.18  2001/09/20 13:33:43  steudten
  63  *
  64  *    change long to int as return value in hash_string(). Remember the wraparound
  65  *    for int = long = sizeof(4) - thats maybe not what we want.
  66  *
  67  *    Revision 1.17  2001/09/13 20:51:29  jongfoster
  68  *    Fixing potential problems with characters >=128 in simplematch()
  69  *    This was also a compiler warning.
  70  *
  71  *    Revision 1.16  2001/09/10 10:56:59  oes
  72  *    Silenced compiler warnings
  73  *
  74  *    Revision 1.15  2001/07/13 14:02:24  oes
  75  *    Removed vim-settings
  76  *
  77  *    Revision 1.14  2001/06/29 21:45:41  oes
  78  *    Indentation, CRLF->LF, Tab-> Space
  79  *
  80  *    Revision 1.13  2001/06/29 13:32:14  oes
  81  *    Removed logentry from cancelled commit
  82  *
  83  *    Revision 1.12  2001/06/09 10:55:28  jongfoster
  84  *    Changing BUFSIZ ==> BUFFER_SIZE
  85  *
  86  *    Revision 1.11  2001/06/07 23:09:19  jongfoster
  87  *    Cosmetic indentation changes.
  88  *
  89  *    Revision 1.10  2001/06/07 14:51:38  joergs
  90  *    make_path() no longer adds '/' if the dir already ends in '/'.
  91  *
  92  *    Revision 1.9  2001/06/07 14:43:17  swa
  93  *    slight mistake in make_path, unix path style is /.
  94  *
  95  *    Revision 1.8  2001/06/05 22:32:01  jongfoster
  96  *    New function make_path() to splice directory and file names together.
  97  *
  98  *    Revision 1.7  2001/06/03 19:12:30  oes
  99  *    introduced bindup()
 100  *
 101  *    Revision 1.6  2001/06/01 18:14:49  jongfoster
 102  *    Changing the calls to strerr() to check HAVE_STRERR (which is defined
 103  *    in config.h if appropriate) rather than the NO_STRERR macro.
 104  *
 105  *    Revision 1.5  2001/06/01 10:31:51  oes
 106  *    Added character class matching to trivimatch; renamed to simplematch
 107  *
 108  *    Revision 1.4  2001/05/31 17:32:31  oes
 109  *
 110  *     - Enhanced domain part globbing with infix and prefix asterisk
 111  *       matching and optional unanchored operation
 112  *
 113  *    Revision 1.3  2001/05/29 23:10:09  oes
 114  *
 115  *
 116  *     - Introduced chomp()
 117  *     - Moved strsav() from showargs to miscutil
 118  *
 119  *    Revision 1.2  2001/05/29 09:50:24  jongfoster
 120  *    Unified blocklist/imagelist/permissionslist.
 121  *    File format is still under discussion, but the internal changes
 122  *    are (mostly) done.
 123  *
 124  *    Also modified interceptor behaviour:
 125  *    - We now intercept all URLs beginning with one of the following
 126  *      prefixes (and *only* these prefixes):
 127  *        * http://i.j.b/
 128  *        * http://ijbswa.sf.net/config/
 129  *        * http://ijbswa.sourceforge.net/config/
 130  *    - New interceptors "home page" - go to http://i.j.b/ to see it.
 131  *    - Internal changes so that intercepted and fast redirect pages
 132  *      are not replaced with an image.
 133  *    - Interceptors now have the option to send a binary page direct
 134  *      to the client. (i.e. ijb-send-banner uses this)
 135  *    - Implemented show-url-info interceptor.  (Which is why I needed
 136  *      the above interceptors changes - a typical URL is
 137  *      "http://i.j.b/show-url-info?url=www.somesite.com/banner.gif".
 138  *      The previous mechanism would not have intercepted that, and
 139  *      if it had been intercepted then it then it would have replaced
 140  *      it with an image.)
 141  *
 142  *    Revision 1.1.1.1  2001/05/15 13:59:00  oes
 143  *    Initial import of version 2.9.3 source tree
 144  *
 145  *
 146  *********************************************************************/
 147 \f
 148
 149 #include "config.h"
 150
 151 #include <stdio.h>
 152 #include <stdlib.h>
 153 #include <string.h>
 154 #include <malloc.h>
 155 #include <ctype.h>
 156 #include <assert.h>
 157
 158 #include "project.h"
 159 #include "miscutil.h"
 160 #include "errlog.h"
 161
 162 const char miscutil_h_rcs[] = MISCUTIL_H_VERSION;
 163
 164 /*********************************************************************
 165  *
 166  * Function    :  zalloc
 167  *
 168  * Description :  Malloc some memory and set it to '\0'.
 169  *                The way calloc() ought to be -acjc
 170  *
 171  * Parameters  :
 172  *          1  :  size = Size of memory chunk to return.
 173  *
 174  * Returns     :  Pointer to newly malloc'd memory chunk.
 175  *
 176  *********************************************************************/
 177 void *zalloc(int size)
 178 {
 179    void * ret;
 180
 181    if ((ret = (void *)malloc(size)) != NULL)
 182    {
 183       memset(ret, 0, size);
 184    }
 185
 186    return(ret);
 187 }
 188
 189
 190 /*********************************************************************
 191  *
 192  * Function    :  hash_string
 193  *
 194  * Description :  Take a string and compute a (hopefuly) unique numeric
 195  *                integer value.  This has several uses, but being able
 196  *                to "switch" a string the one of my favorites.
 197  *
 198  * Parameters  :
 199  *          1  :  s : string to be hashed.
 200  *
 201  * Returns     :  an unsigned long variable with the hashed value.
 202  *
 203  *********************************************************************/
 204 unsigned int hash_string( const char* s )
 205 {
 206    unsigned int h = 0;
 207
 208    for ( ; *s; ++s )
 209    {
 210       h = 5 * h + *s;
 211    }
 212
 213    return (h);
 214
 215 }
 216
 217
 218 #ifdef __MINGW32__
 219 /*********************************************************************
 220  *
 221  * Function    :  strdup
 222  *
 223  * Description :  For some reason (which is beyond me), gcc and WIN32
 224  *                don't like strdup.  When a "free" is executed on a
 225  *                strdup'd ptr, it can at times freez up!  So I just
 226  *                replaced it and problem was solved.
 227  *
 228  * Parameters  :
 229  *          1  :  s = string to duplicate
 230  *
 231  * Returns     :  Pointer to newly malloc'ed copy of the string.
 232  *
 233  *********************************************************************/
 234 char *strdup( const char *s )
 235 {
 236    char * result = (char *)malloc( strlen(s)+1 );
 237
 238    if (result != NULL)
 239    {
 240       strcpy( result, s );
 241    }
 242
 243    return( result );
 244 }
 245
 246 #endif /* def __MINGW32__ */
 247
 248
 249
 250 /*********************************************************************
 251  *
 252  * Function    :  safe_strerror
 253  *
 254  * Description :  Variant of the library routine strerror() which will
 255  *                work on systems without the library routine, and
 256  *                which should never return NULL.
 257  *
 258  * Parameters  :
 259  *          1  :  err = the `errno' of the last operation.
 260  *
 261  * Returns     :  An "English" string of the last `errno'.  Allocated
 262  *                with strdup(), so caller frees.  May be NULL if the
 263  *                system is out of memory.
 264  *
 265  *********************************************************************/
 266 char *safe_strerror(int err)
 267 {
 268    char *s = NULL;
 269    char buf[BUFFER_SIZE];
 270
 271
 272 #ifdef HAVE_STRERROR
 273    s = strerror(err);
 274 #endif /* HAVE_STRERROR */
 275
 276    if (s == NULL)
 277    {
 278       sprintf(buf, "(errno = %d)", err);
 279       s = buf;
 280    }
 281
 282    return(strdup(s));
 283
 284 }
 285
 286
 287 /*********************************************************************
 288  *
 289  * Function    :  strcmpic
 290  *
 291  * Description :  Case insensitive string comparison
 292  *
 293  * Parameters  :
 294  *          1  :  s1 = string 1 to compare
 295  *          2  :  s2 = string 2 to compare
 296  *
 297  * Returns     :  0 if s1==s2, Negative if s1<s2, Positive if s1>s2
 298  *
 299  *********************************************************************/
 300 int strcmpic(const char *s1, const char *s2)
 301 {
 302    while (*s1 && *s2)
 303    {
 304       if ( ( *s1 != *s2 ) && ( ijb_tolower(*s1) != ijb_tolower(*s2) ) )
 305       {
 306          break;
 307       }
 308       s1++, s2++;
 309    }
 310    return(ijb_tolower(*s1) - ijb_tolower(*s2));
 311
 312 }
 313
 314
 315 /*********************************************************************
 316  *
 317  * Function    :  strncmpic
 318  *
 319  * Description :  Case insensitive string comparison (upto n characters)
 320  *
 321  * Parameters  :
 322  *          1  :  s1 = string 1 to compare
 323  *          2  :  s2 = string 2 to compare
 324  *          3  :  n = maximum characters to compare
 325  *
 326  * Returns     :  0 if s1==s2, Negative if s1<s2, Positive if s1>s2
 327  *
 328  *********************************************************************/
 329 int strncmpic(const char *s1, const char *s2, size_t n)
 330 {
 331    if (n <= 0) return(0);
 332
 333    while (*s1 && *s2)
 334    {
 335       if ( ( *s1 != *s2 ) && ( ijb_tolower(*s1) != ijb_tolower(*s2) ) )
 336       {
 337          break;
 338       }
 339
 340       if (--n <= 0) break;
 341
 342       s1++, s2++;
 343    }
 344    return(ijb_tolower(*s1) - ijb_tolower(*s2));
 345
 346 }
 347
 348
 349 /*********************************************************************
 350  *
 351  * Function    :  chomp
 352  *
 353  * Description :  In-situ-eliminate all leading and trailing whitespace
 354  *                from a string.
 355  *
 356  * Parameters  :
 357  *          1  :  s : string to be chomped.
 358  *
 359  * Returns     :  chomped string
 360  *
 361  *********************************************************************/
 362 char *chomp(char *string)
 363 {
 364    char *p, *q, *r;
 365
 366    /*
 367     * strip trailing whitespace
 368     */
 369    p = string + strlen(string);
 370    while (p > string && ijb_isspace(*(p-1)))
 371    {
 372       p--;
 373    }
 374    *p = '\0';
 375
 376    /*
 377     * find end of leading whitespace
 378     */
 379    q = r = string;
 380    while (*q && ijb_isspace(*q))
 381    {
 382       q++;
 383    }
 384
 385    /*
 386     * if there was any, move the rest forwards
 387     */
 388    if (q != string)
 389    {
 390       while (q <= p)
 391       {
 392          *r++ = *q++;
 393       }
 394    }
 395
 396    return(string);
 397
 398 }
 399
 400
 401 /*********************************************************************
 402  *
 403  * Function    :  strsav
 404  *
 405  * Description :  Reallocate "old" and append text to it.  This makes
 406  *                it easier to append to malloc'd strings.
 407  *                Running out of memory is a FATAL error.
 408  *
 409  * Parameters  :
 410  *          1  :  old = Old text that is to be extended.  Will be
 411  *                free()d by this routine.  May be NULL.
 412  *          2  :  text_to_append = Text to be appended to old.
 413  *                May be NULL.
 414  *
 415  * Returns     :  Pointer to newly malloc'ed appended string.
 416  *                If there is no text to append, return old.  Caller
 417  *                must free().
 418  *
 419  *********************************************************************/
 420 char *strsav(char *old, const char *text_to_append)
 421 {
 422    int old_len, new_len = 0;
 423    char *p;
 424
 425    if (( text_to_append == NULL) || (*text_to_append == '\0'))
 426    {
 427       return(old);
 428    }
 429
 430    if (NULL == old)
 431    {
 432       if ((p = strdup(text_to_append)) == NULL)
 433       {
 434          log_error(LOG_LEVEL_FATAL, "strdup() failed!", new_len);
 435          /* Never get here - LOG_LEVEL_FATAL causes program exit */
 436       }
 437       return p;
 438    }
 439
 440    old_len = strlen(old);
 441    new_len = old_len + strlen(text_to_append) + 1;
 442
 443    if ((p = realloc(old, new_len)) == NULL)
 444    {
 445       log_error(LOG_LEVEL_FATAL, "realloc(%d) bytes failed!", new_len);
 446       /* Never get here - LOG_LEVEL_FATAL causes program exit */
 447    }
 448
 449    strcpy(p + old_len, text_to_append);
 450    return(p);
 451 }
 452
 453
 454 /*********************************************************************
 455  *
 456  * Function    :  string_append
 457  *
 458  * Description :  Reallocate target_string and append text to it.
 459  *                This makes it easier to append to malloc'd strings.
 460  *                This is similar to strsav(), but running out of
 461  *                memory isn't catastrophic.
 462  *
 463  *                Programming style:
 464  *
 465  *                The following style provides sufficient error
 466  *                checking for this routine, with minimal clutter
 467  *                in the source code.  It is recommended if you
 468  *                have many calls to this function:
 469  *
 470  *                char * s = strdup(...); // don't check for error
 471  *                string_append(&s, ...);  // don't check for error
 472  *                string_append(&s, ...);  // don't check for error
 473  *                string_append(&s, ...);  // don't check for error
 474  *                if (NULL == s) { ... handle error ... }
 475  *
 476  *                OR, equivalently:
 477  *
 478  *                char * s = strdup(...); // don't check for error
 479  *                string_append(&s, ...);  // don't check for error
 480  *                string_append(&s, ...);  // don't check for error
 481  *                if (string_append(&s, ...)) {... handle error ...}
 482  *
 483  * Parameters  :
 484  *          1  :  target_string = Pointer to old text that is to be
 485  *                extended.  *target_string will be free()d by this
 486  *                routine.  target_string must be non-NULL.
 487  *                If *target_string is NULL, this routine will
 488  *                do nothing and return with an error - this allows
 489  *                you to make many calls to this routine and only
 490  *                check for errors after the last one.
 491  *          2  :  text_to_append = Text to be appended to old.
 492  *                Must not be NULL.
 493  *
 494  * Returns     :  JB_ERR_OK on success, and sets *target_string
 495  *                   to newly malloc'ed appended string.  Caller
 496  *                   must free(*target_string).
 497  *                JB_ERR_MEMORY on out-of-memory.  (And free()s
 498  *                   *target_string and sets it to NULL).
 499  *                JB_ERR_MEMORY if *target_string is NULL.
 500  *
 501  *********************************************************************/
 502 jb_err string_append(char **target_string, const char *text_to_append)
 503 {
 504    size_t old_len;
 505    char *new_string;
 506
 507    assert(target_string);
 508    assert(text_to_append);
 509
 510    if (*target_string == NULL)
 511    {
 512       return JB_ERR_MEMORY;
 513    }
 514
 515    if (*text_to_append == '\0')
 516    {
 517       return JB_ERR_OK;
 518    }
 519
 520    old_len = strlen(*target_string);
 521
 522    if (NULL == (new_string = realloc(*target_string,
 523           strlen(text_to_append) + old_len + 1)))
 524    {
 525       free(*target_string);
 526
 527       *target_string = NULL;
 528       return JB_ERR_MEMORY;
 529    }
 530
 531    strcpy(new_string + old_len, text_to_append);
 532
 533    *target_string = new_string;
 534    return JB_ERR_OK;
 535 }
 536
 537
 538 /*********************************************************************
 539  *
 540  * Function    :  simplematch
 541  *
 542  * Description :  String matching, with a (greedy) '*' wildcard that
 543  *                stands for zero or more arbitrary characters and
 544  *                character classes in [], which take both enumerations
 545  *                and ranges.
 546  *
 547  * Parameters  :
 548  *          1  :  pattern = pattern for matching
 549  *          2  :  text    = text to be matched
 550  *
 551  * Returns     :  0 if match, else nonzero
 552  *
 553  *********************************************************************/
 554 int simplematch(char *pattern, char *text)
 555 {
 556    unsigned char *pat = (unsigned char *) pattern;
 557    unsigned char *txt = (unsigned char *) text;
 558    unsigned char *fallback = pat;
 559    int wildcard = 0;
 560
 561    unsigned char lastchar = 'a';
 562    unsigned i;
 563    unsigned char charmap[32];
 564
 565
 566    while (*txt)
 567    {
 568
 569       /* EOF pattern but !EOF text? */
 570       if (*pat == '\0')
 571       {
 572          return 1;
 573       }
 574
 575       /* '*' in the pattern?  */
 576       if (*pat == '*')
 577       {
 578
 579          /* The pattern ends afterwards? Speed up the return. */
 580          if (*++pat == '\0')
 581          {
 582             return 0;
 583          }
 584
 585          /* Else, set wildcard mode and remember position after '*' */
 586          wildcard = 1;
 587          fallback = pat;
 588       }
 589
 590       /* Character range specification? */
 591       if (*pat == '[')
 592       {
 593          memset(charmap, '\0', sizeof(charmap));
 594
 595          while (*++pat != ']')
 596          {
 597             if (!*pat)
 598             {
 599                return 1;
 600             }
 601             else if (*pat == '-')
 602             {
 603                if ((*++pat == ']') || *pat == '\0')
 604                {
 605                   return(1);
 606                }
 607                for(i = lastchar; i <= *pat; i++)
 608                {
 609                   charmap[i / 8] |= (1 << (i % 8));
 610                }
 611             }
 612             else
 613             {
 614                charmap[*pat / 8] |= (1 << (*pat % 8));
 615                lastchar = *pat;
 616             }
 617          }
 618       } /* -END- if Character range specification */
 619
 620
 621       /* Compare: Char match, or char range match*/
 622       if ((*pat == *txt)
 623       || ((*pat == ']') && (charmap[*txt / 8] & (1 << (*txt % 8)))) )
 624       {
 625          /* Sucess, go ahead */
 626          pat++;
 627       }
 628       else
 629       {
 630          /* In wildcard mode, just try again after failiure */
 631          if(wildcard)
 632          {
 633             pat = fallback;
 634          }
 635
 636          /* Else, bad luck */
 637          else
 638          {
 639             return 1;
 640          }
 641       }
 642       txt++;
 643    }
 644
 645    /* Cut off extra '*'s */
 646    if(*pat == '*')  pat++;
 647
 648    /* If this is the pattern's end, fine! */
 649    return(*pat);
 650
 651 }
 652
 653
 654 /*********************************************************************
 655  *
 656  * Function    :  bindup
 657  *
 658  * Description :  Duplicate the first n characters of a string that may
 659  *                contain '\0' characters.
 660  *
 661  * Parameters  :
 662  *          1  :  string = string to be duplicated
 663  *          2  :  n = number of bytes to duplicate
 664  *
 665  * Returns     :  pointer to copy, or NULL if failiure
 666  *
 667  *********************************************************************/
 668 char *bindup(const char *string, int n)
 669 {
 670    char *dup;
 671
 672    if (NULL == (dup = (char *)malloc(n)))
 673    {
 674       return NULL;
 675    }
 676    else
 677    {
 678      memcpy(dup, string, n);
 679    }
 680
 681    return dup;
 682
 683 }
 684
 685
 686 /*********************************************************************
 687  *
 688  * Function    :  make_path
 689  *
 690  * Description :  Takes a directory name and a file name, returns
 691  *                the complete path.  Handles windows/unix differences.
 692  *                If the file name is already an absolute path, or if
 693  *                the directory name is NULL or empty, it returns
 694  *                the filename.
 695  *
 696  * Parameters  :
 697  *          1  :  dir: Name of directory or NULL for none.
 698  *          2  :  file: Name of file.  Should not be NULL or empty.
 699  *
 700  * Returns     :  "dir/file" (Or on windows, "dir\file").
 701  *                It allocates the string on the heap.  Caller frees.
 702  *                Returns NULL in error (i.e. NULL file or out of
 703  *                memory)
 704  *
 705  *********************************************************************/
 706 char * make_path(const char * dir, const char * file)
 707 {
 708 #ifdef AMIGA
 709    char path[512];
 710
 711    if(dir)
 712    {
 713       strncpy(path,dir,512);
 714       path[511]=0;
 715    } else {
 716       path[0]=0;
 717    }
 718    if(AddPart(path,file,512))
 719    {
 720       return strdup(path);
 721    } else {
 722       return NULL;
 723    }
 724 #else /* ndef AMIGA */
 725
 726    if ((file == NULL) || (*file == '\0'))
 727    {
 728       return NULL; /* Error */
 729    }
 730
 731    if ((dir == NULL) || (*dir == '\0') /* No directory specified */
 732 #ifdef _WIN32
 733       || (*file == '\\') || (file[1] == ':') /* Absolute path (DOS) */
 734 #else /* ifndef _WIN32 */
 735       || (*file == '/') /* Absolute path (U*ix) */
 736 #endif /* ifndef _WIN32 */
 737       )
 738    {
 739       return strdup(file);
 740    }
 741    else
 742    {
 743       char * path;
 744
 745 #if defined(unix)
 746       if ( *dir != '/' && basedir && *basedir )
 747       {
 748               path = malloc( strlen( basedir ) + strlen(dir) + strlen(file) + 3);
 749               if (!path ) log_error(LOG_LEVEL_FATAL, "malloc failed!");
 750               strcpy(path, basedir);
 751               strcat(path, "/");
 752               strcat(path, dir);
 753               DBG(1, ("make_path: path: %s\n",path) );
 754       }
 755       else
 756       {
 757               path = malloc(strlen(dir) + strlen(file) + 2);
 758               if (!path ) log_error(LOG_LEVEL_FATAL, "malloc failed!");
 759               strcpy(path, dir);
 760       }
 761 #else
 762
 763       path = malloc(strlen(dir) + strlen(file) + 2);
 764       if (!path ) log_error(LOG_LEVEL_FATAL, "malloc failed!");
 765       strcpy(path, dir);
 766
 767 #endif /* defined unix */
 768
 769 #ifdef _WIN32
 770       if(path[strlen(path)-1] != '\\')
 771       {
 772          strcat(path, "\\");
 773       }
 774 #else /* ifndef _WIN32 */
 775       if(path[strlen(path)-1] != '/')
 776       {
 777          strcat(path, "/");
 778       }
 779 #endif /* ifndef _WIN32 */
 780       strcat(path, file);
 781
 782       return path;
 783    }
 784 #endif /* ndef AMIGA */
 785 }
 786
 787
 788 /*
 789  * What follows is a portable snprintf routine, written by Mark Martinec.
 790  * See: http://www.ijs.si/software/snprintf/
 791  * Anyone who needs it can add a define for themselves... so far, only
 792  * OS/2 (native) lacks snprintf.
 793
 794                                   snprintf.c
 795                    - a portable implementation of snprintf,
 796        including vsnprintf.c, asnprintf, vasnprintf, asprintf, vasprintf
 797
 798    snprintf is a routine to convert numeric and string arguments to
 799    formatted strings. It is similar to sprintf(3) provided in a system's
 800    C library, yet it requires an additional argument - the buffer size -
 801    and it guarantees never to store anything beyond the given buffer,
 802    regardless of the format or arguments to be formatted. Some newer
 803    operating systems do provide snprintf in their C library, but many do
 804    not or do provide an inadequate (slow or idiosyncratic) version, which
 805    calls for a portable implementation of this routine.
 806
 807 Author
 808
 809    Mark Martinec <mark.martinec@ijs.si>, April 1999, June 2000
 810    Copyright © 1999, Mark Martinec
 811
 812  */
 813
 814 #ifdef __OS2__
 815
 816 #define PORTABLE_SNPRINTF_VERSION_MAJOR 2
 817 #define PORTABLE_SNPRINTF_VERSION_MINOR 2
 818
 819 #if defined(NEED_ASPRINTF) || defined(NEED_ASNPRINTF) || defined(NEED_VASPRINTF) || defined(NEED_VASNPRINTF)
 820 # if defined(NEED_SNPRINTF_ONLY)
 821 # undef NEED_SNPRINTF_ONLY
 822 # endif
 823 # if !defined(PREFER_PORTABLE_SNPRINTF)
 824 # define PREFER_PORTABLE_SNPRINTF
 825 # endif
 826 #endif
 827
 828 #if defined(SOLARIS_BUG_COMPATIBLE) && !defined(SOLARIS_COMPATIBLE)
 829 #define SOLARIS_COMPATIBLE
 830 #endif
 831
 832 #if defined(HPUX_BUG_COMPATIBLE) && !defined(HPUX_COMPATIBLE)
 833 #define HPUX_COMPATIBLE
 834 #endif
 835
 836 #if defined(DIGITAL_UNIX_BUG_COMPATIBLE) && !defined(DIGITAL_UNIX_COMPATIBLE)
 837 #define DIGITAL_UNIX_COMPATIBLE
 838 #endif
 839
 840 #if defined(PERL_BUG_COMPATIBLE) && !defined(PERL_COMPATIBLE)
 841 #define PERL_COMPATIBLE
 842 #endif
 843
 844 #if defined(LINUX_BUG_COMPATIBLE) && !defined(LINUX_COMPATIBLE)
 845 #define LINUX_COMPATIBLE
 846 #endif
 847
 848 #include <sys/types.h>
 849 #include <string.h>
 850 #include <stdlib.h>
 851 #include <stdio.h>
 852 #include <stdarg.h>
 853 #include <assert.h>
 854 #include <errno.h>
 855
 856 #ifdef isdigit
 857 #undef isdigit
 858 #endif
 859 #define isdigit(c) ((c) >= '0' && (c) <= '9')
 860
 861 /* For copying strings longer or equal to 'breakeven_point'
 862  * it is more efficient to call memcpy() than to do it inline.
 863  * The value depends mostly on the processor architecture,
 864  * but also on the compiler and its optimization capabilities.
 865  * The value is not critical, some small value greater than zero
 866  * will be just fine if you don't care to squeeze every drop
 867  * of performance out of the code.
 868  *
 869  * Small values favor memcpy, large values favor inline code.
 870  */
 871 #if defined(__alpha__) || defined(__alpha)
 872 #  define breakeven_point   2   /* AXP (DEC Alpha)     - gcc or cc or egcs */
 873 #endif
 874 #if defined(__i386__)  || defined(__i386)
 875 #  define breakeven_point  12   /* Intel Pentium/Linux - gcc 2.96 */
 876 #endif
 877 #if defined(__hppa)
 878 #  define breakeven_point  10   /* HP-PA               - gcc */
 879 #endif
 880 #if defined(__sparc__) || defined(__sparc)
 881 #  define breakeven_point  33   /* Sun Sparc 5         - gcc 2.8.1 */
 882 #endif
 883
 884 /* some other values of possible interest: */
 885 /* #define breakeven_point  8 */  /* VAX 4000          - vaxc */
 886 /* #define breakeven_point 19 */  /* VAX 4000          - gcc 2.7.0 */
 887
 888 #ifndef breakeven_point
 889 #  define breakeven_point   6   /* some reasonable one-size-fits-all value */
 890 #endif
 891
 892 #define fast_memcpy(d,s,n) \
 893   { register size_t nn = (size_t)(n); \
 894     if (nn >= breakeven_point) memcpy((d), (s), nn); \
 895     else if (nn > 0) { /* proc call overhead is worth only for large strings*/\
 896       register char *dd; register const char *ss; \
 897       for (ss=(s), dd=(d); nn>0; nn--) *dd++ = *ss++; } }
 898
 899 #define fast_memset(d,c,n) \
 900   { register size_t nn = (size_t)(n); \
 901     if (nn >= breakeven_point) memset((d), (int)(c), nn); \
 902     else if (nn > 0) { /* proc call overhead is worth only for large strings*/\
 903       register char *dd; register const int cc=(int)(c); \
 904       for (dd=(d); nn>0; nn--) *dd++ = cc; } }
 905
 906 /* prototypes */
 907
 908 #if defined(NEED_ASPRINTF)
 909 int asprintf   (char **ptr, const char *fmt, /*args*/ ...);
 910 #endif
 911 #if defined(NEED_VASPRINTF)
 912 int vasprintf  (char **ptr, const char *fmt, va_list ap);
 913 #endif
 914 #if defined(NEED_ASNPRINTF)
 915 int asnprintf  (char **ptr, size_t str_m, const char *fmt, /*args*/ ...);
 916 #endif
 917 #if defined(NEED_VASNPRINTF)
 918 int vasnprintf (char **ptr, size_t str_m, const char *fmt, va_list ap);
 919 #endif
 920
 921 #if defined(HAVE_SNPRINTF)
 922 /* declare our portable snprintf  routine under name portable_snprintf  */
 923 /* declare our portable vsnprintf routine under name portable_vsnprintf */
 924 #else
 925 /* declare our portable routines under names snprintf and vsnprintf */
 926 #define portable_snprintf snprintf
 927 #if !defined(NEED_SNPRINTF_ONLY)
 928 #define portable_vsnprintf vsnprintf
 929 #endif
 930 #endif
 931
 932 #if !defined(HAVE_SNPRINTF) || defined(PREFER_PORTABLE_SNPRINTF)
 933 int portable_snprintf(char *str, size_t str_m, const char *fmt, /*args*/ ...);
 934 #if !defined(NEED_SNPRINTF_ONLY)
 935 int portable_vsnprintf(char *str, size_t str_m, const char *fmt, va_list ap);
 936 #endif
 937 #endif
 938
 939 /* declarations */
 940
 941 static char credits[] = "\n\
 942 @(#)snprintf.c, v2.2: Mark Martinec, <mark.martinec@ijs.si>\n\
 943 @(#)snprintf.c, v2.2: Copyright 1999, Mark Martinec. Frontier Artistic License applies.\n\
 944 @(#)snprintf.c, v2.2: http://www.ijs.si/software/snprintf/\n";
 945
 946 #if defined(NEED_ASPRINTF)
 947 int asprintf(char **ptr, const char *fmt, /*args*/ ...) {
 948   va_list ap;
 949   size_t str_m;
 950   int str_l;
 951
 952   *ptr = NULL;
 953   va_start(ap, fmt);                            /* measure the required size */
 954   str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap);
 955   va_end(ap);
 956   assert(str_l >= 0);        /* possible integer overflow if str_m > INT_MAX */
 957   *ptr = (char *) malloc(str_m = (size_t)str_l + 1);
 958   if (*ptr == NULL) { errno = ENOMEM; str_l = -1; }
 959   else {
 960     int str_l2;
 961     va_start(ap, fmt);
 962     str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap);
 963     va_end(ap);
 964     assert(str_l2 == str_l);
 965   }
 966   return str_l;
 967 }
 968 #endif
 969
 970 #if defined(NEED_VASPRINTF)
 971 int vasprintf(char **ptr, const char *fmt, va_list ap) {
 972   size_t str_m;
 973   int str_l;
 974
 975   *ptr = NULL;
 976   { va_list ap2;
 977     va_copy(ap2, ap);  /* don't consume the original ap, we'll need it again */
 978     str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap2);/*get required size*/
 979     va_end(ap2);
 980   }
 981   assert(str_l >= 0);        /* possible integer overflow if str_m > INT_MAX */
 982   *ptr = (char *) malloc(str_m = (size_t)str_l + 1);
 983   if (*ptr == NULL) { errno = ENOMEM; str_l = -1; }
 984   else {
 985     int str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap);
 986     assert(str_l2 == str_l);
 987   }
 988   return str_l;
 989 }
 990 #endif
 991
 992 #if defined(NEED_ASNPRINTF)
 993 int asnprintf (char **ptr, size_t str_m, const char *fmt, /*args*/ ...) {
 994   va_list ap;
 995   int str_l;
 996
 997   *ptr = NULL;
 998   va_start(ap, fmt);                            /* measure the required size */
 999   str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap);
1000   va_end(ap);
1001   assert(str_l >= 0);        /* possible integer overflow if str_m > INT_MAX */
1002   if ((size_t)str_l + 1 < str_m) str_m = (size_t)str_l + 1;      /* truncate */
1003   /* if str_m is 0, no buffer is allocated, just set *ptr to NULL */
1004   if (str_m == 0) {  /* not interested in resulting string, just return size */
1005   } else {
1006     *ptr = (char *) malloc(str_m);
1007     if (*ptr == NULL) { errno = ENOMEM; str_l = -1; }
1008     else {
1009       int str_l2;
1010       va_start(ap, fmt);
1011       str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap);
1012       va_end(ap);
1013       assert(str_l2 == str_l);
1014     }
1015   }
1016   return str_l;
1017 }
1018 #endif
1019
1020 #if defined(NEED_VASNPRINTF)
1021 int vasnprintf (char **ptr, size_t str_m, const char *fmt, va_list ap) {
1022   int str_l;
1023
1024   *ptr = NULL;
1025   { va_list ap2;
1026     va_copy(ap2, ap);  /* don't consume the original ap, we'll need it again */
1027     str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap2);/*get required size*/
1028     va_end(ap2);
1029   }
1030   assert(str_l >= 0);        /* possible integer overflow if str_m > INT_MAX */
1031   if ((size_t)str_l + 1 < str_m) str_m = (size_t)str_l + 1;      /* truncate */
1032   /* if str_m is 0, no buffer is allocated, just set *ptr to NULL */
1033   if (str_m == 0) {  /* not interested in resulting string, just return size */
1034   } else {
1035     *ptr = (char *) malloc(str_m);
1036     if (*ptr == NULL) { errno = ENOMEM; str_l = -1; }
1037     else {
1038       int str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap);
1039       assert(str_l2 == str_l);
1040     }
1041   }
1042   return str_l;
1043 }
1044 #endif
1045
1046 /*
1047  * If the system does have snprintf and the portable routine is not
1048  * specifically required, this module produces no code for snprintf/vsnprintf.
1049  */
1050 #if !defined(HAVE_SNPRINTF) || defined(PREFER_PORTABLE_SNPRINTF)
1051
1052 #if !defined(NEED_SNPRINTF_ONLY)
1053 int portable_snprintf(char *str, size_t str_m, const char *fmt, /*args*/ ...) {
1054   va_list ap;
1055   int str_l;
1056
1057   va_start(ap, fmt);
1058   str_l = portable_vsnprintf(str, str_m, fmt, ap);
1059   va_end(ap);
1060   return str_l;
1061 }
1062 #endif
1063
1064 #if defined(NEED_SNPRINTF_ONLY)
1065 int portable_snprintf(char *str, size_t str_m, const char *fmt, /*args*/ ...) {
1066 #else
1067 int portable_vsnprintf(char *str, size_t str_m, const char *fmt, va_list ap) {
1068 #endif
1069
1070 #if defined(NEED_SNPRINTF_ONLY)
1071   va_list ap;
1072 #endif
1073   size_t str_l = 0;
1074   const char *p = fmt;
1075
1076 /* In contrast with POSIX, the ISO C99 now says
1077  * that str can be NULL and str_m can be 0.
1078  * This is more useful than the old:  if (str_m < 1) return -1; */
1079
1080 #if defined(NEED_SNPRINTF_ONLY)
1081   va_start(ap, fmt);
1082 #endif
1083   if (!p) p = "";
1084   while (*p) {
1085     if (*p != '%') {
1086    /* if (str_l < str_m) str[str_l++] = *p++;    -- this would be sufficient */
1087    /* but the following code achieves better performance for cases
1088     * where format string is long and contains few conversions */
1089       const char *q = strchr(p+1,'%');
1090       size_t n = !q ? strlen(p) : (q-p);
1091       if (str_l < str_m) {
1092         size_t avail = str_m-str_l;
1093         fast_memcpy(str+str_l, p, (n>avail?avail:n));
1094       }
1095       p += n; str_l += n;
1096     } else {
1097       const char *starting_p;
1098       size_t min_field_width = 0, precision = 0;
1099       int zero_padding = 0, precision_specified = 0, justify_left = 0;
1100       int alternate_form = 0, force_sign = 0;
1101       int space_for_positive = 1; /* If both the ' ' and '+' flags appear,
1102                                      the ' ' flag should be ignored. */
1103       char length_modifier = '\0';            /* allowed values: \0, h, l, L */
1104       char tmp[32];/* temporary buffer for simple numeric->string conversion */
1105
1106       const char *str_arg;      /* string address in case of string argument */
1107       size_t str_arg_l;         /* natural field width of arg without padding
1108                                    and sign */
1109       unsigned char uchar_arg;
1110         /* unsigned char argument value - only defined for c conversion.
1111            N.B. standard explicitly states the char argument for
1112            the c conversion is unsigned */
1113
1114       size_t number_of_zeros_to_pad = 0;
1115         /* number of zeros to be inserted for numeric conversions
1116            as required by the precision or minimal field width */
1117
1118       size_t zero_padding_insertion_ind = 0;
1119         /* index into tmp where zero padding is to be inserted */
1120
1121       char fmt_spec = '\0';
1122         /* current conversion specifier character */
1123
1124       str_arg = credits;/* just to make compiler happy (defined but not used)*/
1125       str_arg = NULL;
1126       starting_p = p; p++;  /* skip '%' */
1127    /* parse flags */
1128       while (*p == '0' || *p == '-' || *p == '+' ||
1129              *p == ' ' || *p == '#' || *p == '\'') {
1130         switch (*p) {
1131         case '0': zero_padding = 1; break;
1132         case '-': justify_left = 1; break;
1133         case '+': force_sign = 1; space_for_positive = 0; break;
1134         case ' ': force_sign = 1;
1135      /* If both the ' ' and '+' flags appear, the ' ' flag should be ignored */
1136 #ifdef PERL_COMPATIBLE
1137      /* ... but in Perl the last of ' ' and '+' applies */
1138                   space_for_positive = 1;
1139 #endif
1140                   break;
1141         case '#': alternate_form = 1; break;
1142         case '\'': break;
1143         }
1144         p++;
1145       }
1146    /* If the '0' and '-' flags both appear, the '0' flag should be ignored. */
1147
1148    /* parse field width */
1149       if (*p == '*') {
1150         int j;
1151         p++; j = va_arg(ap, int);
1152         if (j >= 0) min_field_width = j;
1153         else { min_field_width = -j; justify_left = 1; }
1154       } else if (isdigit((int)(*p))) {
1155         /* size_t could be wider than unsigned int;
1156            make sure we treat argument like common implementations do */
1157         unsigned int uj = *p++ - '0';
1158         while (isdigit((int)(*p))) uj = 10*uj + (unsigned int)(*p++ - '0');
1159         min_field_width = uj;
1160       }
1161    /* parse precision */
1162       if (*p == '.') {
1163         p++; precision_specified = 1;
1164         if (*p == '*') {
1165           int j = va_arg(ap, int);
1166           p++;
1167           if (j >= 0) precision = j;
1168           else {
1169             precision_specified = 0; precision = 0;
1170          /* NOTE:
1171           *   Solaris 2.6 man page claims that in this case the precision
1172           *   should be set to 0.  Digital Unix 4.0, HPUX 10 and BSD man page
1173           *   claim that this case should be treated as unspecified precision,
1174           *   which is what we do here.
1175           */
1176           }
1177         } else if (isdigit((int)(*p))) {
1178           /* size_t could be wider than unsigned int;
1179              make sure we treat argument like common implementations do */
1180           unsigned int uj = *p++ - '0';
1181           while (isdigit((int)(*p))) uj = 10*uj + (unsigned int)(*p++ - '0');
1182           precision = uj;
1183         }
1184       }
1185    /* parse 'h', 'l' and 'll' length modifiers */
1186       if (*p == 'h' || *p == 'l') {
1187         length_modifier = *p; p++;
1188         if (length_modifier == 'l' && *p == 'l') {   /* double l = long long */
1189 #ifdef SNPRINTF_LONGLONG_SUPPORT
1190           length_modifier = '2';                  /* double l encoded as '2' */
1191 #else
1192           length_modifier = 'l';                 /* treat it as a single 'l' */
1193 #endif
1194           p++;
1195         }
1196       }
1197       fmt_spec = *p;
1198    /* common synonyms: */
1199       switch (fmt_spec) {
1200       case 'i': fmt_spec = 'd'; break;
1201       case 'D': fmt_spec = 'd'; length_modifier = 'l'; break;
1202       case 'U': fmt_spec = 'u'; length_modifier = 'l'; break;
1203       case 'O': fmt_spec = 'o'; length_modifier = 'l'; break;
1204       default: break;
1205       }
1206    /* get parameter value, do initial processing */
1207       switch (fmt_spec) {
1208       case '%': /* % behaves similar to 's' regarding flags and field widths */
1209       case 'c': /* c behaves similar to 's' regarding flags and field widths */
1210       case 's':
1211         length_modifier = '\0';          /* wint_t and wchar_t not supported */
1212      /* the result of zero padding flag with non-numeric conversion specifier*/
1213      /* is undefined. Solaris and HPUX 10 does zero padding in this case,    */
1214      /* Digital Unix and Linux does not. */
1215 #if !defined(SOLARIS_COMPATIBLE) && !defined(HPUX_COMPATIBLE)
1216         zero_padding = 0;    /* turn zero padding off for string conversions */
1217 #endif
1218         str_arg_l = 1;
1219         switch (fmt_spec) {
1220         case '%':
1221           str_arg = p; break;
1222         case 'c': {
1223           int j = va_arg(ap, int);
1224           uchar_arg = (unsigned char) j;   /* standard demands unsigned char */
1225           str_arg = (const char *) &uchar_arg;
1226           break;
1227         }
1228         case 's':
1229           str_arg = va_arg(ap, const char *);
1230           if (!str_arg) str_arg_l = 0;
1231        /* make sure not to address string beyond the specified precision !!! */
1232           else if (!precision_specified) str_arg_l = strlen(str_arg);
1233        /* truncate string if necessary as requested by precision */
1234           else if (precision == 0) str_arg_l = 0;
1235           else {
1236        /* memchr on HP does not like n > 2^31  !!! */
1237             const char *q = memchr(str_arg, '\0',
1238                              precision <= 0x7fffffff ? precision : 0x7fffffff);
1239             str_arg_l = !q ? precision : (q-str_arg);
1240           }
1241           break;
1242         default: break;
1243         }
1244         break;
1245       case 'd': case 'u': case 'o': case 'x': case 'X': case 'p': {
1246         /* NOTE: the u, o, x, X and p conversion specifiers imply
1247                  the value is unsigned;  d implies a signed value */
1248
1249         int arg_sign = 0;
1250           /* 0 if numeric argument is zero (or if pointer is NULL for 'p'),
1251             +1 if greater than zero (or nonzero for unsigned arguments),
1252             -1 if negative (unsigned argument is never negative) */
1253
1254         int int_arg = 0;  unsigned int uint_arg = 0;
1255           /* only defined for length modifier h, or for no length modifiers */
1256
1257         long int long_arg = 0;  unsigned long int ulong_arg = 0;
1258           /* only defined for length modifier l */
1259
1260         void *ptr_arg = NULL;
1261           /* pointer argument value -only defined for p conversion */
1262
1263 #ifdef SNPRINTF_LONGLONG_SUPPORT
1264         long long int long_long_arg = 0;
1265         unsigned long long int ulong_long_arg = 0;
1266           /* only defined for length modifier ll */
1267 #endif
1268         if (fmt_spec == 'p') {
1269         /* HPUX 10: An l, h, ll or L before any other conversion character
1270          *   (other than d, i, u, o, x, or X) is ignored.
1271          * Digital Unix:
1272          *   not specified, but seems to behave as HPUX does.
1273          * Solaris: If an h, l, or L appears before any other conversion
1274          *   specifier (other than d, i, u, o, x, or X), the behavior
1275          *   is undefined. (Actually %hp converts only 16-bits of address
1276          *   and %llp treats address as 64-bit data which is incompatible
1277          *   with (void *) argument on a 32-bit system).
1278          */
1279 #ifdef SOLARIS_COMPATIBLE
1280 #  ifdef SOLARIS_BUG_COMPATIBLE
1281           /* keep length modifiers even if it represents 'll' */
1282 #  else
1283           if (length_modifier == '2') length_modifier = '\0';
1284 #  endif
1285 #else
1286           length_modifier = '\0';
1287 #endif
1288           ptr_arg = va_arg(ap, void *);
1289           if (ptr_arg != NULL) arg_sign = 1;
1290         } else if (fmt_spec == 'd') {  /* signed */
1291           switch (length_modifier) {
1292           case '\0':
1293           case 'h':
1294          /* It is non-portable to specify a second argument of char or short
1295           * to va_arg, because arguments seen by the called function
1296           * are not char or short.  C converts char and short arguments
1297           * to int before passing them to a function.
1298           */
1299             int_arg = va_arg(ap, int);
1300             if      (int_arg > 0) arg_sign =  1;
1301             else if (int_arg < 0) arg_sign = -1;
1302             break;
1303           case 'l':
1304             long_arg = va_arg(ap, long int);
1305             if      (long_arg > 0) arg_sign =  1;
1306             else if (long_arg < 0) arg_sign = -1;
1307             break;
1308 #ifdef SNPRINTF_LONGLONG_SUPPORT
1309           case '2':
1310             long_long_arg = va_arg(ap, long long int);
1311             if      (long_long_arg > 0) arg_sign =  1;
1312             else if (long_long_arg < 0) arg_sign = -1;
1313             break;
1314 #endif
1315           }
1316         } else {  /* unsigned */
1317           switch (length_modifier) {
1318           case '\0':
1319           case 'h':
1320             uint_arg = va_arg(ap, unsigned int);
1321             if (uint_arg) arg_sign = 1;
1322             break;
1323           case 'l':
1324             ulong_arg = va_arg(ap, unsigned long int);
1325             if (ulong_arg) arg_sign = 1;
1326             break;
1327 #ifdef SNPRINTF_LONGLONG_SUPPORT
1328           case '2':
1329             ulong_long_arg = va_arg(ap, unsigned long long int);
1330             if (ulong_long_arg) arg_sign = 1;
1331             break;
1332 #endif
1333           }
1334         }
1335         str_arg = tmp; str_arg_l = 0;
1336      /* NOTE:
1337       *   For d, i, u, o, x, and X conversions, if precision is specified,
1338       *   the '0' flag should be ignored. This is so with Solaris 2.6,
1339       *   Digital UNIX 4.0, HPUX 10, Linux, FreeBSD, NetBSD; but not with Perl.
1340       */
1341 #ifndef PERL_COMPATIBLE
1342         if (precision_specified) zero_padding = 0;
1343 #endif
1344         if (fmt_spec == 'd') {
1345           if (force_sign && arg_sign >= 0)
1346             tmp[str_arg_l++] = space_for_positive ? ' ' : '+';
1347          /* leave negative numbers for sprintf to handle,
1348             to avoid handling tricky cases like (short int)(-32768) */
1349 #ifdef LINUX_COMPATIBLE
1350         } else if (fmt_spec == 'p' && force_sign && arg_sign > 0) {
1351           tmp[str_arg_l++] = space_for_positive ? ' ' : '+';
1352 #endif
1353         } else if (alternate_form) {
1354           if (arg_sign != 0 && (fmt_spec == 'x' || fmt_spec == 'X') )
1355             { tmp[str_arg_l++] = '0'; tmp[str_arg_l++] = fmt_spec; }
1356          /* alternate form should have no effect for p conversion, but ... */
1357 #ifdef HPUX_COMPATIBLE
1358           else if (fmt_spec == 'p'
1359          /* HPUX 10: for an alternate form of p conversion,
1360           *          a nonzero result is prefixed by 0x. */
1361 #ifndef HPUX_BUG_COMPATIBLE
1362          /* Actually it uses 0x prefix even for a zero value. */
1363                    && arg_sign != 0
1364 #endif
1365                   ) { tmp[str_arg_l++] = '0'; tmp[str_arg_l++] = 'x'; }
1366 #endif
1367         }
1368         zero_padding_insertion_ind = str_arg_l;
1369         if (!precision_specified) precision = 1;   /* default precision is 1 */
1370         if (precision == 0 && arg_sign == 0
1371 #if defined(HPUX_BUG_COMPATIBLE) || defined(LINUX_COMPATIBLE)
1372             && fmt_spec != 'p'
1373          /* HPUX 10 man page claims: With conversion character p the result of
1374           * converting a zero value with a precision of zero is a null string.
1375           * Actually HP returns all zeroes, and Linux returns "(nil)". */
1376 #endif
1377         ) {
1378          /* converted to null string */
1379          /* When zero value is formatted with an explicit precision 0,
1380             the resulting formatted string is empty (d, i, u, o, x, X, p).   */
1381         } else {
1382           char f[5]; int f_l = 0;
1383           f[f_l++] = '%';    /* construct a simple format string for sprintf */
1384           if (!length_modifier) { }
1385           else if (length_modifier=='2') { f[f_l++] = 'l'; f[f_l++] = 'l'; }
1386           else f[f_l++] = length_modifier;
1387           f[f_l++] = fmt_spec; f[f_l++] = '\0';
1388           if (fmt_spec == 'p') str_arg_l += sprintf(tmp+str_arg_l, f, ptr_arg);
1389           else if (fmt_spec == 'd') {  /* signed */
1390             switch (length_modifier) {
1391             case '\0':
1392             case 'h': str_arg_l+=sprintf(tmp+str_arg_l, f, int_arg);  break;
1393             case 'l': str_arg_l+=sprintf(tmp+str_arg_l, f, long_arg); break;
1394 #ifdef SNPRINTF_LONGLONG_SUPPORT
1395             case '2': str_arg_l+=sprintf(tmp+str_arg_l,f,long_long_arg); break;
1396 #endif
1397             }
1398           } else {  /* unsigned */
1399             switch (length_modifier) {
1400             case '\0':
1401             case 'h': str_arg_l+=sprintf(tmp+str_arg_l, f, uint_arg);  break;
1402             case 'l': str_arg_l+=sprintf(tmp+str_arg_l, f, ulong_arg); break;
1403 #ifdef SNPRINTF_LONGLONG_SUPPORT
1404             case '2': str_arg_l+=sprintf(tmp+str_arg_l,f,ulong_long_arg);break;
1405 #endif
1406             }
1407           }
1408          /* include the optional minus sign and possible "0x"
1409             in the region before the zero padding insertion point */
1410           if (zero_padding_insertion_ind < str_arg_l &&
1411               tmp[zero_padding_insertion_ind] == '-') {
1412             zero_padding_insertion_ind++;
1413           }
1414           if (zero_padding_insertion_ind+1 < str_arg_l &&
1415               tmp[zero_padding_insertion_ind]   == '0' &&
1416              (tmp[zero_padding_insertion_ind+1] == 'x' ||
1417               tmp[zero_padding_insertion_ind+1] == 'X') ) {
1418             zero_padding_insertion_ind += 2;
1419           }
1420         }
1421         { size_t num_of_digits = str_arg_l - zero_padding_insertion_ind;
1422           if (alternate_form && fmt_spec == 'o'
1423 #ifdef HPUX_COMPATIBLE                                  /* ("%#.o",0) -> ""  */
1424               && (str_arg_l > 0)
1425 #endif
1426 #ifdef DIGITAL_UNIX_BUG_COMPATIBLE                      /* ("%#o",0) -> "00" */
1427 #else
1428               /* unless zero is already the first character */
1429               && !(zero_padding_insertion_ind < str_arg_l
1430                    && tmp[zero_padding_insertion_ind] == '0')
1431 #endif
1432           ) {        /* assure leading zero for alternate-form octal numbers */
1433             if (!precision_specified || precision < num_of_digits+1) {
1434              /* precision is increased to force the first character to be zero,
1435                 except if a zero value is formatted with an explicit precision
1436                 of zero */
1437               precision = num_of_digits+1; precision_specified = 1;
1438             }
1439           }
1440        /* zero padding to specified precision? */
1441           if (num_of_digits < precision)
1442             number_of_zeros_to_pad = precision - num_of_digits;
1443         }
1444      /* zero padding to specified minimal field width? */
1445         if (!justify_left && zero_padding) {
1446           int n = min_field_width - (str_arg_l+number_of_zeros_to_pad);
1447           if (n > 0) number_of_zeros_to_pad += n;
1448         }
1449         break;
1450       }
1451       default: /* unrecognized conversion specifier, keep format string as-is*/
1452         zero_padding = 0;  /* turn zero padding off for non-numeric convers. */
1453 #ifndef DIGITAL_UNIX_COMPATIBLE
1454         justify_left = 1; min_field_width = 0;                /* reset flags */
1455 #endif
1456 #if defined(PERL_COMPATIBLE) || defined(LINUX_COMPATIBLE)
1457      /* keep the entire format string unchanged */
1458         str_arg = starting_p; str_arg_l = p - starting_p;
1459      /* well, not exactly so for Linux, which does something inbetween,
1460       * and I don't feel an urge to imitate it: "%+++++hy" -> "%+y"  */
1461 #else
1462      /* discard the unrecognized conversion, just keep *
1463       * the unrecognized conversion character          */
1464         str_arg = p; str_arg_l = 0;
1465 #endif
1466         if (*p) str_arg_l++;  /* include invalid conversion specifier unchanged
1467                                  if not at end-of-string */
1468         break;
1469       }
1470       if (*p) p++;      /* step over the just processed conversion specifier */
1471    /* insert padding to the left as requested by min_field_width;
1472       this does not include the zero padding in case of numerical conversions*/
1473       if (!justify_left) {                /* left padding with blank or zero */
1474         int n = min_field_width - (str_arg_l+number_of_zeros_to_pad);
1475         if (n > 0) {
1476           if (str_l < str_m) {
1477             size_t avail = str_m-str_l;
1478             fast_memset(str+str_l, (zero_padding?'0':' '), (n>avail?avail:n));
1479           }
1480           str_l += n;
1481         }
1482       }
1483    /* zero padding as requested by the precision or by the minimal field width
1484     * for numeric conversions required? */
1485       if (number_of_zeros_to_pad <= 0) {
1486      /* will not copy first part of numeric right now, *
1487       * force it to be copied later in its entirety    */
1488         zero_padding_insertion_ind = 0;
1489       } else {
1490      /* insert first part of numerics (sign or '0x') before zero padding */
1491         int n = zero_padding_insertion_ind;
1492         if (n > 0) {
1493           if (str_l < str_m) {
1494             size_t avail = str_m-str_l;
1495             fast_memcpy(str+str_l, str_arg, (n>avail?avail:n));
1496           }
1497           str_l += n;
1498         }
1499      /* insert zero padding as requested by the precision or min field width */
1500         n = number_of_zeros_to_pad;
1501         if (n > 0) {
1502           if (str_l < str_m) {
1503             size_t avail = str_m-str_l;
1504             fast_memset(str+str_l, '0', (n>avail?avail:n));
1505           }
1506           str_l += n;
1507         }
1508       }
1509    /* insert formatted string
1510     * (or as-is conversion specifier for unknown conversions) */
1511       { int n = str_arg_l - zero_padding_insertion_ind;
1512         if (n > 0) {
1513           if (str_l < str_m) {
1514             size_t avail = str_m-str_l;
1515             fast_memcpy(str+str_l, str_arg+zero_padding_insertion_ind,
1516                         (n>avail?avail:n));
1517           }
1518           str_l += n;
1519         }
1520       }
1521    /* insert right padding */
1522       if (justify_left) {          /* right blank padding to the field width */
1523         int n = min_field_width - (str_arg_l+number_of_zeros_to_pad);
1524         if (n > 0) {
1525           if (str_l < str_m) {
1526             size_t avail = str_m-str_l;
1527             fast_memset(str+str_l, ' ', (n>avail?avail:n));
1528           }
1529           str_l += n;
1530         }
1531       }
1532     }
1533   }
1534 #if defined(NEED_SNPRINTF_ONLY)
1535   va_end(ap);
1536 #endif
1537   if (str_m > 0) { /* make sure the string is null-terminated
1538                       even at the expense of overwriting the last character
1539                       (shouldn't happen, but just in case) */
1540     str[str_l <= str_m-1 ? str_l : str_m-1] = '\0';
1541   }
1542   /* Return the number of characters formatted (excluding trailing null
1543    * character), that is, the number of characters that would have been
1544    * written to the buffer if it were large enough.
1545    *
1546    * The value of str_l should be returned, but str_l is of unsigned type
1547    * size_t, and snprintf is int, possibly leading to an undetected
1548    * integer overflow, resulting in a negative return value, which is illegal.
1549    * Both XSH5 and ISO C99 (at least the draft) are silent on this issue.
1550    * Should errno be set to EOVERFLOW and EOF returned in this case???
1551    */
1552   return (int) str_l;
1553 }
1554 #endif
1555 #endif /* __OS2__ */
1556 /*
1557   Local Variables:
1558   tab-width: 3
1559   end:
1560 */