misc/lstr.c

   1 /*
   2 static char Copyright[] = "Copyright  Yngvi Sigurjonsson (yngvi@hafro.is), 1993";
   3 */
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include <ctype.h>
   8 #include <sys/types.h>
   9 #include <fcntl.h>
  10 #include <unistd.h>
  11
  12 #include "regfunc.h"
  13 #include "windows.h"
  14
  15 #define ToUpper(c)      toupper(c)
  16 #define ToLower(c)      tolower(c)
  17
  18 /* Funny to divide them between user and kernel. */
  19
  20 /* KERNEL.89 */
  21 LPSTR lstrcat(LPSTR target,LPCSTR source)
  22 {
  23 #ifdef DEBUG_STRING
  24   fprintf(stderr,"lstrcat(%s,%s)\n",target,source);
  25 #endif
  26   return strcat(target,source);
  27 }
  28
  29 /* USER.430 */
  30 INT lstrcmp(LPCSTR str1,LPCSTR str2)
  31 {
  32   return strcmp(str1,str2);
  33 }
  34
  35 /* USER.471 */
  36 INT lstrcmpi(LPCSTR str1,LPCSTR str2)
  37 {
  38   int i;
  39   i=0;
  40   while((toupper(str1[i])==toupper(str2[i]))&&(str1[i]!=0))
  41     i++;
  42   return toupper(str1[i])-toupper(str2[i]);
  43 }
  44
  45 /* KERNEL.88 */
  46 LPSTR lstrcpy(LPSTR target,LPCSTR source)
  47 {
  48   return strcpy(target,source);
  49 }
  50
  51 /* KERNEL.353 */
  52 LPSTR lstrcpyn(LPSTR target,LPCSTR source,int n)
  53 {
  54   return strncpy(target,source,n);
  55 }
  56
  57 /* KERNEL.90 */
  58 INT lstrlen(LPCSTR str)
  59 {
  60   return strlen(str);
  61 }
  62
  63 /* IsCharAlpha USER 433 */
  64 BOOL IsCharAlpha(char ch)
  65 {
  66   return isalpha(ch);   /* This is probably not right for NLS */
  67 }
  68
  69 /* IsCharAlphanumeric USER 434 */
  70 BOOL IsCharAlphanumeric(char ch)
  71 {
  72   return (ch<'0')?0:(ch<'9');
  73 }
  74
  75 /* IsCharUpper USER 435 */
  76 BOOL IsCharUpper(char ch)
  77 {
  78   return isupper(ch);
  79 }
  80
  81 /* IsCharLower USER 436 */
  82 BOOL IsCharLower(char ch)
  83 {
  84   return islower(ch);
  85 }
  86
  87 /* AnsiUpper USER.431 */
  88 LPSTR AnsiUpper(LPSTR strOrChar)
  89 {
  90         char *s = strOrChar;
  91   /* I am not sure if the locale stuff works with toupper, but then again
  92      I am not sure if the Linux libc locale stuffs works at all */
  93
  94         /* uppercase only one char if strOrChar < 0x10000 */
  95         if(HIWORD((DWORD)strOrChar)) {
  96                 while (*s) {
  97                         if (IsCharLower(*s))
  98                                 *s = ToUpper(*s);
  99                         s++;
 100                 }
 101                 return strOrChar;
 102         } else
 103                 if (IsCharLower((int)strOrChar))
 104                         return (LPSTR) ToUpper((int)strOrChar);
 105                 else
 106                         return (LPSTR) strOrChar;
 107 }
 108
 109 /* AnsiUpperBuff USER.437 */
 110 UINT AnsiUpperBuff(LPSTR str,UINT len)
 111 {
 112   int i;
 113   len=(len==0)?65536:len;
 114
 115   for(i=0;i<len;i++)
 116     str[i]=toupper(str[i]);
 117   return i;
 118 }
 119
 120 /* AnsiLower USER.432 */
 121 LPSTR AnsiLower(LPSTR strOrChar)
 122 {
 123         char *s = strOrChar;
 124   /* I am not sure if the locale stuff works with toupper, but then again
 125      I am not sure if the Linux libc locale stuffs works at all */
 126
 127         /* lowercase only one char if strOrChar < 0x10000 */
 128         if(HIWORD((DWORD)strOrChar)) {
 129                 while (*s) {
 130                         if (IsCharUpper(*s))
 131                                 *s = ToLower(*s);
 132                         s++;
 133                 }
 134                 return strOrChar;
 135         } else
 136                 if (IsCharUpper((int)strOrChar))
 137                         return (LPSTR) ToLower((int)strOrChar);
 138                 else
 139                         return (LPSTR) strOrChar;
 140 }
 141
 142 /* AnsiLowerBuff USER.438 */
 143 UINT AnsiLowerBuff(LPSTR str,UINT len)
 144 {
 145   int i;
 146   len=(len==0)?65536:len;
 147   i=0;
 148
 149   for(i=0;i<len;i++)
 150     str[i]=tolower(str[i]);
 151
 152   return i;
 153 }
 154
 155 /* AnsiNext USER.472 */
 156 LPSTR AnsiNext(LPSTR current)
 157 {
 158   return (*current)?current+1:current;
 159 }
 160
 161 /* AnsiPrev USER.473 */
 162 char FAR*  AnsiPrev(/*const*/ char FAR* start,char FAR* current)
 163 {
 164   return (current==start)?start:current-1;
 165 }
 166
 167 BYTE Oem2Ansi[256], Ansi2Oem[256];
 168
 169 void InitOemAnsiTranslations(void)
 170 {
 171   static int inited=0; /* should called called in some init function*/
 172   int transfile,i;
 173   if(inited) return;
 174   if((transfile=open("oem2ansi.trl",O_RDONLY))){
 175     read(transfile,Oem2Ansi,256);
 176     close(transfile);
 177   }
 178   else {  /* sets up passive translations if it does not find the file */
 179     for(i=0;i<256;i++)  /* Needs some fixing */
 180       Oem2Ansi[i]=i;
 181   }
 182   if((transfile=open("ansi2oem.trl",O_RDONLY))){
 183     read(transfile,Ansi2Oem,256);
 184     close(transfile);
 185   }
 186   else {  /* sets up passive translations if it does not find the file */
 187     for(i=0;i<256;i++)  /* Needs some fixing */
 188       Ansi2Oem[i]=i;
 189   }
 190   inited=1;
 191 }
 192
 193 /* AnsiToOem Keyboard.5 */
 194 INT AnsiToOem(LPSTR lpAnsiStr, LPSTR lpOemStr)   /* why is this int ??? */
 195 {
 196   InitOemAnsiTranslations(); /* should called called in some init function*/
 197   while(*lpAnsiStr){
 198     *lpOemStr++=Ansi2Oem[*lpAnsiStr++];
 199   }
 200   return -1;
 201 }
 202
 203 /* OemToAnsi Keyboard.6 */
 204 BOOL OemToAnsi(LPSTR lpOemStr, LPSTR lpAnsiStr)   /* why is this BOOL ???? */
 205 {
 206   InitOemAnsiTranslations(); /* should called called in some init function*/
 207   while(*lpOemStr){
 208     *lpAnsiStr++=Oem2Ansi[*lpOemStr++];
 209   }
 210   return -1;
 211 }
 212
 213 /* AnsiToOemBuff Keyboard.134 */
 214 void AnsiToOemBuff(LPSTR lpAnsiStr, LPSTR lpOemStr, INT nLength)
 215 {
 216   int i;
 217   InitOemAnsiTranslations(); /* should called called in some init function*/
 218   for(i=0;i<nLength;i++)
 219     lpOemStr[i]=Ansi2Oem[lpAnsiStr[i]];
 220 }
 221
 222 /* OemToAnsi Keyboard.135 */
 223 void OemToAnsiBuff(LPSTR lpOemStr, LPSTR lpAnsiStr, INT nLength)
 224 {
 225   int i;
 226   InitOemAnsiTranslations(); /* should called called in some init function*/
 227   for(i=0;i<nLength;i++)
 228     lpAnsiStr[i]=Oem2Ansi[lpOemStr[i]];
 229 }