git.oblomov.eu Git - wine/blob - tools/winebuild/utils.c

   1 /* small utility functions for winebuild */
   2
   3 #include "config.h"
   4
   5 #include <ctype.h>
   6 #include <stdarg.h>
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <unistd.h>
  11
  12 #include "build.h"
  13
  14 void *xmalloc (size_t size)
  15 {
  16     void *res;
  17
  18     res = malloc (size ? size : 1);
  19     if (res == NULL)
  20     {
  21         fprintf (stderr, "Virtual memory exhausted.\n");
  22         exit (1);
  23     }
  24     return res;
  25 }
  26
  27 void *xrealloc (void *ptr, size_t size)
  28 {
  29     void *res = realloc (ptr, size);
  30     if (res == NULL)
  31     {
  32         fprintf (stderr, "Virtual memory exhausted.\n");
  33         exit (1);
  34     }
  35     return res;
  36 }
  37
  38 char *xstrdup( const char *str )
  39 {
  40     char *res = strdup( str );
  41     if (!res)
  42     {
  43         fprintf (stderr, "Virtual memory exhausted.\n");
  44         exit (1);
  45     }
  46     return res;
  47 }
  48
  49 char *strupper(char *s)
  50 {
  51     char *p;
  52     for (p = s; *p; p++) *p = toupper(*p);
  53     return s;
  54 }
  55
  56 void fatal_error( const char *msg, ... )
  57 {
  58     va_list valist;
  59     va_start( valist, msg );
  60     if (input_file_name)
  61     {
  62         fprintf( stderr, "%s:", input_file_name );
  63         if (current_line)
  64             fprintf( stderr, "%d:", current_line );
  65         fputc( ' ', stderr );
  66     }
  67     vfprintf( stderr, msg, valist );
  68     va_end( valist );
  69     exit(1);
  70 }
  71
  72 void fatal_perror( const char *msg, ... )
  73 {
  74     va_list valist;
  75     va_start( valist, msg );
  76     if (input_file_name)
  77     {
  78         fprintf( stderr, "%s:", input_file_name );
  79         if (current_line)
  80             fprintf( stderr, "%d:", current_line );
  81         fputc( ' ', stderr );
  82     }
  83     vfprintf( stderr, msg, valist );
  84     perror( " " );
  85     va_end( valist );
  86     exit(1);
  87 }
  88
  89 void warning( const char *msg, ... )
  90 {
  91     va_list valist;
  92     va_start( valist, msg );
  93     if (input_file_name)
  94     {
  95         fprintf( stderr, "%s:", input_file_name );
  96         if (current_line)
  97             fprintf( stderr, "%d:", current_line );
  98         fputc( ' ', stderr );
  99     }
 100     fprintf( stderr, "warning: " );
 101     vfprintf( stderr, msg, valist );
 102     va_end( valist );
 103 }
 104
 105 /* dump a byte stream into the assembly code */
 106 void dump_bytes( FILE *outfile, const unsigned char *data, int len,
 107                  const char *label, int constant )
 108 {
 109     int i;
 110
 111     fprintf( outfile, "\nstatic %sunsigned char %s[%d] = {",
 112              constant ? "const " : "", label, len );
 113     for (i = 0; i < len; i++)
 114     {
 115         if (!(i & 7)) fprintf( outfile, "\n  " );
 116         fprintf( outfile, "0x%02x", *data++ );
 117         if (i < len - 1) fprintf( outfile, "," );
 118     }
 119     fprintf( outfile, "\n};\n" );
 120 }
 121
 122 /*****************************************************************
 123  *  Function:    get_alignment
 124  *
 125  *  Description:
 126  *    According to the info page for gas, the .align directive behaves
 127  * differently on different systems.  On some architectures, the
 128  * argument of a .align directive is the number of bytes to pad to, so
 129  * to align on an 8-byte boundary you'd say
 130  *     .align 8
 131  * On other systems, the argument is "the number of low-order zero bits
 132  * that the location counter must have after advancement."  So to
 133  * align on an 8-byte boundary you'd say
 134  *     .align 3
 135  *
 136  * The reason gas is written this way is that it's trying to mimick
 137  * native assemblers for the various architectures it runs on.  gas
 138  * provides other directives that work consistantly across
 139  * architectures, but of course we want to work on all arches with or
 140  * without gas.  Hence this function.
 141  *
 142  *
 143  *  Parameters:
 144  *                alignBoundary  --  the number of bytes to align to.
 145  *                                   If we're on an architecture where
 146  *                                   the assembler requires a 'number
 147  *                                   of low-order zero bits' as a
 148  *                                   .align argument, then this number
 149  *                                   must be a power of 2.
 150  *
 151  */
 152 int get_alignment(int alignBoundary)
 153 {
 154 #ifdef __PPC__
 155
 156     int n = 0;
 157
 158     switch(alignBoundary)
 159     {
 160     case 2:
 161         n = 1;
 162         break;
 163     case 4:
 164         n = 2;
 165         break;
 166     case 8:
 167         n = 3;
 168         break;
 169     case 16:
 170         n = 4;
 171         break;
 172     case 32:
 173         n = 5;
 174         break;
 175     case 64:
 176         n = 6;
 177         break;
 178     case 128:
 179         n = 7;
 180         break;
 181     case 256:
 182         n = 8;
 183         break;
 184     case 512:
 185         n = 9;
 186         break;
 187     case 1024:
 188         n = 10;
 189         break;
 190     case 2048:
 191         n = 11;
 192         break;
 193     case 4096:
 194         n = 12;
 195         break;
 196     case 8192:
 197         n = 13;
 198         break;
 199     case 16384:
 200         n = 14;
 201         break;
 202     case 32768:
 203         n = 15;
 204         break;
 205     case 65536:
 206         n = 16;
 207         break;
 208     default:
 209         fatal_error("Alignment to %d-byte boundary not supported on this architecture.\n",
 210                     alignBoundary);
 211     }
 212     return n;
 213
 214 #elif defined(__i386__) || defined(__sparc__)
 215
 216     return alignBoundary;
 217
 218 #else
 219 #error "How does the '.align' assembler directive work on your architecture?"
 220 #endif
 221 }