misc/lstr.c

   1 /*
   2  * String functions
   3  *
   4  * Copyright 1993 Yngvi Sigurjonsson (yngvi@hafro.is)
   5  */
   6
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <ctype.h>
  11
  12 #include "ldt.h"
  13 #include "windows.h"
  14 #include "stddebug.h"
  15 #include "debug.h"
  16
  17 #define ToUpper(c)      toupper(c)
  18 #define ToLower(c)      tolower(c)
  19
  20
  21 static const BYTE Oem2Ansi[256] =
  22 "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\244"
  23 "\020\021\022\023\266\247\026\027\030\031\032\033\034\035\036\037"
  24 "\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057"
  25 "\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077"
  26 "\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117"
  27 "\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137"
  28 "\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157"
  29 "\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177"
  30 "\307\374\351\342\344\340\345\347\352\353\350\357\356\354\304\305"
  31 "\311\346\306\364\366\362\373\371\377\326\334\242\243\245\120\203"
  32 "\341\355\363\372\361\321\252\272\277\137\254\275\274\241\253\273"
  33 "\137\137\137\246\246\246\246\053\053\246\246\053\053\053\053\053"
  34 "\053\055\055\053\055\053\246\246\053\053\055\055\246\055\053\055"
  35 "\055\055\055\053\053\053\053\053\053\053\053\137\137\246\137\137"
  36 "\137\337\137\266\137\137\265\137\137\137\137\137\137\137\137\137"
  37 "\137\261\137\137\137\137\367\137\260\225\267\137\156\262\137\137";
  38
  39 static const BYTE Ansi2Oem[256] =
  40 "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017"
  41 "\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
  42 "\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057"
  43 "\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077"
  44 "\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117"
  45 "\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137"
  46 "\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157"
  47 "\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177"
  48 "\200\201\054\237\054\137\375\374\210\045\123\074\117\215\216\217"
  49 "\220\140\047\042\042\371\055\137\230\231\163\076\157\235\236\131"
  50 "\040\255\233\234\017\235\335\025\042\143\246\256\252\055\162\137"
  51 "\370\361\375\063\047\346\024\372\054\061\247\257\254\253\137\250"
  52 "\101\101\101\101\216\217\222\200\105\220\105\105\111\111\111\111"
  53 "\104\245\117\117\117\117\231\170\117\125\125\125\232\131\137\341"
  54 "\205\240\203\141\204\206\221\207\212\202\210\211\215\241\214\213"
  55 "\144\244\225\242\223\157\224\366\157\227\243\226\201\171\137\230";
  56
  57 /* Funny to divide them between user and kernel. */
  58
  59 /* KERNEL.89 */
  60 SEGPTR lstrcat( SEGPTR target, SEGPTR source )
  61 {
  62     strcat( (char *)PTR_SEG_TO_LIN(target), (char *)PTR_SEG_TO_LIN(source) );
  63     return target;
  64 }
  65
  66 /* USER.430 */
  67 INT lstrcmp(LPCSTR str1,LPCSTR str2)
  68 {
  69   return strcmp(str1,str2);
  70 }
  71
  72 /* USER.471 */
  73 INT lstrcmpi(LPCSTR str1,LPCSTR str2)
  74 {
  75   int i;
  76   i=0;
  77   while((toupper(str1[i])==toupper(str2[i]))&&(str1[i]!=0))
  78     i++;
  79   return toupper(str1[i])-toupper(str2[i]);
  80 }
  81
  82 /* KERNEL.88 */
  83 SEGPTR lstrcpy( SEGPTR target, SEGPTR source )
  84 {
  85     strcpy( (char *)PTR_SEG_TO_LIN(target), (char *)PTR_SEG_TO_LIN(source) );
  86     return target;
  87 }
  88
  89 /* KERNEL.353 32-bit version*/
  90 char *lstrcpyn(char *dst, char *src, int n)
  91 {
  92     char *tmp = dst;
  93     while(n-- > 1 && *src)
  94         *dst++ = *src++;
  95     *dst = 0;
  96     return tmp;
  97 }
  98
  99 /* KERNEL.353 16-bit version*/
 100 SEGPTR WIN16_lstrcpyn( SEGPTR target, SEGPTR source, WORD n )
 101 {
 102     lstrcpyn((char *)PTR_SEG_TO_LIN(target), (char *)PTR_SEG_TO_LIN(source),n);
 103     return target;
 104 }
 105
 106 /* KERNEL.90 */
 107 INT lstrlen(LPCSTR str)
 108 {
 109   return strlen(str);
 110 }
 111
 112 /* IsCharAlpha USER 433 */
 113 BOOL IsCharAlpha(char ch)
 114 {
 115   return isalpha(ch);   /* This is probably not right for NLS */
 116 }
 117
 118 /* IsCharAlphanumeric USER 434 */
 119 BOOL IsCharAlphanumeric(char ch)
 120 {
 121   return (ch < '0') ? 0 : (ch <= '9');
 122 }
 123
 124 /* IsCharUpper USER 435 */
 125 BOOL IsCharUpper(char ch)
 126 {
 127   return isupper(ch);
 128 }
 129
 130 /* IsCharLower USER 436 */
 131 BOOL IsCharLower(char ch)
 132 {
 133   return islower(ch);
 134 }
 135
 136 /***********************************************************************
 137  *           AnsiUpper   (USER.431)
 138  */
 139
 140 /* 16-bit version */
 141 SEGPTR WIN16_AnsiUpper( SEGPTR strOrChar )
 142 {
 143   /* I am not sure if the locale stuff works with toupper, but then again
 144      I am not sure if the Linux libc locale stuffs works at all */
 145
 146     /* uppercase only one char if strOrChar < 0x10000 */
 147     if (HIWORD(strOrChar))
 148     {
 149         char *s = PTR_SEG_TO_LIN(strOrChar);
 150         while (*s) {
 151             *s = ToUpper( *s );
 152             s++;
 153         }
 154         return strOrChar;
 155     }
 156     else return (SEGPTR)ToUpper( (int)strOrChar );
 157 }
 158
 159 /* 32-bit version */
 160 LPSTR AnsiUpper(LPSTR strOrChar)
 161 {
 162     char *s = strOrChar;
 163   /* I am not sure if the locale stuff works with toupper, but then again
 164      I am not sure if the Linux libc locale stuffs works at all */
 165
 166     while (*s) {
 167         *s = ToUpper( *s );
 168         s++;
 169     }
 170     return strOrChar;
 171 }
 172
 173
 174 /***********************************************************************
 175  *           AnsiUpperBuff   (USER.437)
 176  */
 177 UINT AnsiUpperBuff(LPSTR str,UINT len)
 178 {
 179   int i;
 180   len=(len==0)?65536:len;
 181
 182   for(i=0;i<len;i++)
 183     str[i]=toupper(str[i]);
 184   return i;
 185 }
 186
 187 /***********************************************************************
 188  *           AnsiLower   (USER.432)
 189  */
 190
 191 /* 16-bit version */
 192 SEGPTR WIN16_AnsiLower(SEGPTR strOrChar)
 193 {
 194   /* I am not sure if the locale stuff works with toupper, but then again
 195      I am not sure if the Linux libc locale stuffs works at all */
 196
 197     /* lowercase only one char if strOrChar < 0x10000 */
 198     if (HIWORD(strOrChar))
 199     {
 200         char *s = PTR_SEG_TO_LIN( strOrChar );
 201         while (*s) {
 202             *s = ToLower( *s );
 203             s++;
 204         }
 205         return strOrChar;
 206     }
 207     else return (SEGPTR)ToLower( (int)strOrChar );
 208 }
 209
 210 /* 32-bit version */
 211 LPSTR AnsiLower(LPSTR strOrChar)
 212 {
 213     char *s = strOrChar;
 214   /* I am not sure if the locale stuff works with toupper, but then again
 215      I am not sure if the Linux libc locale stuffs works at all */
 216
 217     while (*s) {
 218         *s = ToLower( *s );
 219         s++;
 220     }
 221     return strOrChar;
 222 }
 223
 224
 225 /***********************************************************************
 226  *           AnsiLowerBuff   (USER.438)
 227  */
 228 UINT AnsiLowerBuff(LPSTR str,UINT len)
 229 {
 230   int i;
 231   len=(len==0)?65536:len;
 232   i=0;
 233
 234   for(i=0;i<len;i++)
 235     str[i]=tolower(str[i]);
 236
 237   return i;
 238 }
 239
 240
 241 /* AnsiNext USER.472 */
 242 SEGPTR AnsiNext(SEGPTR current)
 243 {
 244     return (*(char *)PTR_SEG_TO_LIN(current)) ? current + 1 : current;
 245 }
 246
 247 /* AnsiPrev USER.473 */
 248 SEGPTR AnsiPrev( SEGPTR start, SEGPTR current)
 249 {
 250     return (current==start)?start:current-1;
 251 }
 252
 253
 254 /* AnsiToOem Keyboard.5 */
 255 INT AnsiToOem(LPSTR lpAnsiStr, LPSTR lpOemStr)
 256 {
 257     dprintf_keyboard(stddeb, "AnsiToOem: %s\n", lpAnsiStr);
 258     while(*lpAnsiStr){
 259         *lpOemStr++=Ansi2Oem[(unsigned char)(*lpAnsiStr++)];
 260     }
 261     *lpOemStr = 0;
 262     return -1;
 263 }
 264
 265 /* OemToAnsi Keyboard.6 */
 266 BOOL OemToAnsi(LPSTR lpOemStr, LPSTR lpAnsiStr)
 267 {
 268     dprintf_keyboard(stddeb, "OemToAnsi: %s\n", lpOemStr);
 269     while(*lpOemStr){
 270         *lpAnsiStr++=Oem2Ansi[(unsigned char)(*lpOemStr++)];
 271     }
 272     *lpAnsiStr = 0;
 273     return -1;
 274 }
 275
 276 /* AnsiToOemBuff Keyboard.134 */
 277 void AnsiToOemBuff(LPSTR lpAnsiStr, LPSTR lpOemStr, INT nLength)
 278 {
 279   int i;
 280   for(i=0;i<nLength;i++)
 281     lpOemStr[i]=Ansi2Oem[(unsigned char)(lpAnsiStr[i])];
 282 }
 283
 284 /* OemToAnsi Keyboard.135 */
 285 void OemToAnsiBuff(LPSTR lpOemStr, LPSTR lpAnsiStr, INT nLength)
 286 {
 287   int i;
 288   for(i=0;i<nLength;i++)
 289     lpAnsiStr[i]=Oem2Ansi[(unsigned char)(lpOemStr[i])];
 290 }