xkbevd/utils.c

   1
   2   /*\
   3    *
   4    *                          COPYRIGHT 1990
   5    *                    DIGITAL EQUIPMENT CORPORATION
   6    *                       MAYNARD, MASSACHUSETTS
   7    *                        ALL RIGHTS RESERVED.
   8    *
   9    * THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE AND
  10    * SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT CORPORATION.
  11    * DIGITAL MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THIS SOFTWARE
  12    * FOR ANY PURPOSE.  IT IS SUPPLIED "AS IS" WITHOUT EXPRESS OR IMPLIED
  13    * WARRANTY.
  14    *
  15    * IF THE SOFTWARE IS MODIFIED IN A MANNER CREATING DERIVATIVE COPYRIGHT
  16    * RIGHTS, APPROPRIATE LEGENDS MAY BE PLACED ON THE DERIVATIVE WORK IN
  17    * ADDITION TO THAT SET FORTH ABOVE.
  18    *
  19    * Permission to use, copy, modify, and distribute this software and its
  20    * documentation for any purpose and without fee is hereby granted, provided
  21    * that the above copyright notice appear in all copies and that both that
  22    * copyright notice and this permission notice appear in supporting
  23    * documentation, and that the name of Digital Equipment Corporation not be
  24    * used in advertising or publicity pertaining to distribution of the
  25    * software without specific, written prior permission.
  26   \*/
  27
  28 #define DEBUG_VAR_LOCAL
  29 #include        "utils.h"
  30 #include        <ctype.h>
  31 #include        <stdlib.h>
  32
  33 unsigned int DEBUG_VAR;
  34
  35 /***====================================================================***/
  36
  37 Opaque
  38 uAlloc(unsigned size)
  39 {
  40     return((Opaque)malloc(size));
  41 }
  42
  43 /***====================================================================***/
  44
  45 Opaque
  46 uCalloc(unsigned n, unsigned size)
  47 {
  48     return((Opaque)calloc(n,size));
  49 }
  50
  51 /***====================================================================***/
  52
  53 Opaque
  54 uRealloc(Opaque old, unsigned newSize)
  55 {
  56     if (old==NULL)
  57          return((Opaque)malloc(newSize));
  58     else return((Opaque)realloc((char *)old,newSize));
  59 }
  60
  61 /***====================================================================***/
  62
  63 Opaque
  64 uRecalloc(Opaque old, unsigned nOld, unsigned nNew, unsigned itemSize)
  65 {
  66 char *rtrn;
  67
  68     if (old==NULL)
  69          rtrn= (char *)calloc(nNew,itemSize);
  70     else {
  71         rtrn= (char *)realloc((char *)old,nNew*itemSize);
  72         if ((rtrn)&&(nNew>nOld)) {
  73             bzero(&rtrn[nOld*itemSize],(nNew-nOld)*itemSize);
  74         }
  75     }
  76     return (Opaque)rtrn;
  77 }
  78
  79 /***====================================================================***/
  80
  81 void
  82 uFree(Opaque ptr)
  83 {
  84     if (ptr!=(Opaque)NULL)
  85         free((char *)ptr);
  86     return;
  87 }
  88
  89 /***====================================================================***/
  90 /***                  FUNCTION ENTRY TRACKING                           ***/
  91 /***====================================================================***/
  92
  93 static  FILE    *entryFile=     NULL;
  94 static  int      uEntryLevel;
  95
  96 Boolean
  97 uSetEntryFile(const char *name)
  98 {
  99     if ((entryFile!=NULL)&&(entryFile!=stderr)) {
 100         fprintf(entryFile,"switching to %s\n",name?name:"stderr");
 101         fclose(entryFile);
 102     }
 103     if (name!=NullString)       entryFile=      fopen(name,"w");
 104     else                        entryFile=      stderr;
 105     if (entryFile==NULL) {
 106         entryFile=      stderr;
 107         return(False);
 108     }
 109     return(True);
 110 }
 111
 112 void
 113 uEntry(int l, const char *s,...)
 114 {
 115 int     i;
 116 va_list ap;
 117
 118     va_start(ap, s);
 119     for (i=0;i<uEntryLevel;i++) {
 120         putc(' ',entryFile);
 121     }
 122     vfprintf(entryFile,s,ap);
 123     uEntryLevel+= l;
 124     va_end(ap);
 125     return;
 126 }
 127
 128 void
 129 uExit(int l, const char *rtVal)
 130 {
 131 int     i;
 132
 133     uEntryLevel-= l;
 134     if (uEntryLevel<0)  uEntryLevel=    0;
 135     for (i=0;i<uEntryLevel;i++) {
 136         putc(' ',entryFile);
 137     }
 138     fprintf(entryFile,"---> 0x%p\n",rtVal);
 139     return;
 140 }
 141
 142 /***====================================================================***/
 143 /***                    PRINT FUNCTIONS                                 ***/
 144 /***====================================================================***/
 145
 146         FILE    *uDebugFile=            NULL;
 147         int      uDebugIndentLevel=     0;
 148         int      uDebugIndentSize=      4;
 149
 150 Boolean
 151 uSetDebugFile(const char *name)
 152 {
 153     if ((uDebugFile!=NULL)&&(uDebugFile!=stderr)) {
 154         fprintf(uDebugFile,"switching to %s\n",name?name:"stderr");
 155         fclose(uDebugFile);
 156     }
 157     if (name!=NullString)       uDebugFile=     fopen(name,"w");
 158     else                        uDebugFile=     stderr;
 159     if (uDebugFile==NULL) {
 160         uDebugFile=     stderr;
 161         return(False);
 162     }
 163     return(True);
 164 }
 165
 166 void
 167 uDebug(const char *s,...)
 168 {
 169 int     i;
 170 va_list ap;
 171
 172     va_start(ap, s);
 173     for (i=(uDebugIndentLevel*uDebugIndentSize);i>0;i--) {
 174         putc(' ',uDebugFile);
 175     }
 176     vfprintf(uDebugFile,s,ap);
 177     fflush(uDebugFile);
 178     va_end(ap);
 179     return;
 180 }
 181
 182 void
 183 uDebugNOI(const char *s,...)
 184 {
 185 va_list ap;
 186
 187     va_start(ap, s);
 188     vfprintf(uDebugFile,s,ap);
 189     fflush(uDebugFile);
 190     va_end(ap);
 191     return;
 192 }
 193
 194 /***====================================================================***/
 195
 196 static  FILE    *errorFile=     NULL;
 197
 198 Boolean
 199 uSetErrorFile(const char *name)
 200 {
 201     if ((errorFile!=NULL)&&(errorFile!=stderr)) {
 202         fprintf(errorFile,"switching to %s\n",name?name:"stderr");
 203         fclose(errorFile);
 204     }
 205     if (name!=NullString)       errorFile=      fopen(name,"w");
 206     else                        errorFile=      stderr;
 207     if (errorFile==NULL) {
 208         errorFile=      stderr;
 209         return(False);
 210     }
 211     return(True);
 212 }
 213
 214 void
 215 uInformation(const char *s,...)
 216 {
 217     va_list ap;
 218
 219     va_start(ap, s);
 220     vfprintf(errorFile,s,ap);
 221     fflush(errorFile);
 222     va_end(ap);
 223     return;
 224 }
 225
 226 /***====================================================================***/
 227
 228 void
 229 uAction(const char *s,...)
 230 {
 231     va_list ap;
 232
 233     va_start(ap, s);
 234     fprintf(errorFile,"                  ");
 235     vfprintf(errorFile,s,ap);
 236     fflush(errorFile);
 237     va_end(ap);
 238     return;
 239 }
 240
 241 /***====================================================================***/
 242
 243 void
 244 uWarning(const char *s,...)
 245 {
 246     va_list ap;
 247
 248     va_start(ap, s);
 249     fprintf(errorFile,"Warning:          ");
 250     vfprintf(errorFile,s,ap);
 251     fflush(errorFile);
 252     va_end(ap);
 253     return;
 254 }
 255
 256 /***====================================================================***/
 257
 258 void
 259 uError(const char *s,...)
 260 {
 261     va_list ap;
 262
 263     va_start(ap, s);
 264     fprintf(errorFile,"Error:            ");
 265     vfprintf(errorFile,s,ap);
 266     fflush(errorFile);
 267     va_end(ap);
 268     return;
 269 }
 270
 271 /***====================================================================***/
 272
 273 void
 274 uFatalError(const char *s,...)
 275 {
 276     va_list ap;
 277
 278     va_start(ap, s);
 279     fprintf(errorFile,"Fatal Error:      ");
 280     vfprintf(errorFile,s,ap);
 281     fprintf(errorFile,"                  Exiting\n");
 282     fflush(errorFile);
 283     va_end(ap);
 284     exit(1);
 285     /* NOTREACHED */
 286 }
 287
 288 /***====================================================================***/
 289
 290 void
 291 uInternalError(const char *s,...)
 292 {
 293     va_list ap;
 294
 295     va_start(ap, s);
 296     fprintf(errorFile,"Internal error:   ");
 297     vfprintf(errorFile,s,ap);
 298     fflush(errorFile);
 299     va_end(ap);
 300     return;
 301 }
 302
 303 /***====================================================================***/
 304
 305 #ifndef HAVE_STRDUP
 306 char *
 307 uStringDup(const char *str)
 308 {
 309 char *rtrn;
 310
 311     if (str==NULL)
 312         return NULL;
 313     rtrn= (char *)uAlloc(strlen(str)+1);
 314     strcpy(rtrn,str);
 315     return rtrn;
 316 }
 317 #endif
 318
 319 #ifndef HAVE_STRCASECMP
 320 int
 321 uStrCaseCmp(const char *str1, const char *str2)
 322 {
 323     char buf1[512],buf2[512];
 324     char c, *s;
 325     register int n;
 326
 327     for (n=0, s = buf1; (c = *str1++); n++) {
 328         if (isupper(c))
 329             c = tolower(c);
 330         if (n>510)
 331             break;
 332         *s++ = c;
 333     }
 334     *s = '\0';
 335     for (n=0, s = buf2; (c = *str2++); n++) {
 336         if (isupper(c))
 337             c = tolower(c);
 338         if (n>510)
 339             break;
 340         *s++ = c;
 341     }
 342     *s = '\0';
 343     return (strcmp(buf1, buf2));
 344 }
 345
 346 int
 347 uStrCasePrefix(const char *prefix, const char *str)
 348 {
 349     char c1;
 350     char c2;
 351     while (((c1=*prefix)!='\0')&&((c2=*str)!='\0')) {
 352         if (isupper(c1))        c1= tolower(c1);
 353         if (isupper(c2))        c2= tolower(c2);
 354         if (c1!=c2)
 355             return 0;
 356         prefix++; str++;
 357     }
 358     if (c1!='\0')
 359         return 0;
 360     return 1;
 361 }
 362
 363 #endif