programs/winetest/util.c

   1 /*
   2  * Utility functions.
   3  *
   4  * Copyright 2003 Dimitrie O. Paun
   5  * Copyright 2003 Ferenc Wagner
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23 #include <windef.h>
  24 #include <winbase.h>
  25
  26 #include "winetest.h"
  27
  28 HANDLE logfile = 0;
  29
  30 void *heap_alloc (size_t len)
  31 {
  32     void *p = HeapAlloc(GetProcessHeap(), 0, len);
  33
  34     if (!p) report (R_FATAL, "Out of memory.");
  35     return p;
  36 }
  37
  38 void *heap_realloc (void *op, size_t len)
  39 {
  40     void *p = HeapReAlloc(GetProcessHeap(), 0, op, len);
  41
  42     if (len && !p) report (R_FATAL, "Out of memory.");
  43     return p;
  44 }
  45
  46 char *heap_strdup( const char *str )
  47 {
  48     int len = strlen(str) + 1;
  49     char* res = HeapAlloc(GetProcessHeap(), 0, len);
  50     if (!res) report (R_FATAL, "Out of memory.");
  51     memcpy(res, str, len);
  52     return res;
  53 }
  54
  55 void heap_free (void *op)
  56 {
  57     HeapFree(GetProcessHeap(), 0, op);
  58 }
  59
  60 static char *vstrfmtmake (size_t *lenp, const char *fmt, __ms_va_list ap)
  61 {
  62     size_t size = 1000;
  63     char *p, *q;
  64     int n;
  65
  66     p = HeapAlloc(GetProcessHeap(), 0, size);
  67     if (!p) return NULL;
  68     while (1) {
  69         n = vsnprintf (p, size, fmt, ap);
  70         if (n < 0) size *= 2;   /* Windows */
  71         else if ((unsigned)n >= size) size = n+1; /* glibc */
  72         else break;
  73         q = HeapReAlloc(GetProcessHeap(), 0, p, size);
  74         if (!q) {
  75           heap_free (p);
  76           return NULL;
  77        }
  78        p = q;
  79     }
  80     if (lenp) *lenp = n;
  81     return p;
  82 }
  83
  84 char *vstrmake (size_t *lenp, __ms_va_list ap)
  85 {
  86     const char *fmt;
  87
  88     fmt = va_arg (ap, const char*);
  89     return vstrfmtmake (lenp, fmt, ap);
  90 }
  91
  92 char * WINAPIV strmake (size_t *lenp, ...)
  93 {
  94     __ms_va_list ap;
  95     char *p;
  96
  97     __ms_va_start (ap, lenp);
  98     p = vstrmake (lenp, ap);
  99     if (!p) report (R_FATAL, "Out of memory.");
 100     __ms_va_end (ap);
 101     return p;
 102 }
 103
 104 void WINAPIV xprintf (const char *fmt, ...)
 105 {
 106     __ms_va_list ap;
 107     size_t size;
 108     DWORD written;
 109     char *buffer, *head;
 110
 111     __ms_va_start (ap, fmt);
 112     buffer = vstrfmtmake (&size, fmt, ap);
 113     head = buffer;
 114     __ms_va_end (ap);
 115     while (size) {
 116         if (!WriteFile( logfile, head, size, &written, NULL ))
 117             report (R_FATAL, "Can't write logs: %u", GetLastError());
 118         head += written;
 119         size -= written;
 120     }
 121     heap_free (buffer);
 122 }
 123
 124 int
 125 goodtagchar (char c)
 126 {
 127     return (('a'<=c && c<='z') ||
 128             ('A'<=c && c<='Z') ||
 129             ('0'<=c && c<='9') ||
 130             c=='-' || c=='.');
 131 }
 132
 133 const char *
 134 findbadtagchar (const char *tag)
 135 {
 136     while (*tag)
 137         if (goodtagchar (*tag)) tag++;
 138         else return tag;
 139     return NULL;
 140 }