home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / cons-010.zip / Console / src / common / strop.c < prev    next >
C/C++ Source or Header  |  1997-07-30  |  6KB  |  238 lines
  1. /******************************************************************************\
  2. |*                                                                            *|
  3. |* String manipulation routines                                               *|
  4. |* Copyright (C) 1997 by FRIENDS software                                     *|
  5. |* All Rights Reserved                                                        *|
  6. |* Portability: Any OS with a C compiler                                      *|
  7. |*                                                                            *|
  8. |* This program is free software; you can redistribute it and/or modify       *|
  9. |* it under the terms of the GNU General Public License as published by       *|
  10. |* the Free Software Foundation; either version 2 of the License, or          *|
  11. |* (at your option) any later version.                                        *|
  12. |*                                                                            *|
  13. |* This program is distributed in the hope that it will be useful,            *|
  14. |* but WITHOUT ANY WARRANTY; without even the implied warranty of             *|
  15. |* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *|
  16. |* GNU General Public License for more details.                               *|
  17. |*                                                                            *|
  18. |* You should have received a copy of the GNU General Public License          *|
  19. |* along with this program; if not, write to the Free Software                *|
  20. |* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA  *|
  21. |*                                                                            *|
  22. \******************************************************************************/
  23.  
  24. #include <stdio.h>
  25. #include <stdlib.h>
  26. #include <string.h>
  27. #include "strop.h"
  28.  
  29. char upCase(char Ch)
  30. {
  31.  if ((Ch >= 'a') && (Ch <= 'z'))
  32.        return Ch & 0xDF;
  33.   else return Ch;
  34. }
  35.  
  36. char loCase(char Ch)
  37. {
  38.  if ((Ch >= 'A') && (Ch <= 'Z'))
  39.        return Ch | 0x20;
  40.   else return Ch;
  41. }
  42.  
  43. char *extractDir(char *pathName)
  44. {
  45.  char *dir;
  46.  int len = strlen(pathName);
  47.  while ((len-- > 0) &&
  48.         (pathName[len] != '/') &&
  49.         (pathName[len] != '\\') &&
  50.         (pathName[len] != ':')) ;
  51.  dir = malloc(++len + 1);
  52.  if (dir)
  53.  {
  54.   strncpy(dir, pathName, len);
  55.   dir[len] = 0;
  56.  }
  57.  return dir;
  58. }
  59.  
  60. char *extractName(char *pathName)
  61. {
  62.  char *name;
  63.  int len = strlen(pathName);
  64.  int slen = len;
  65.  while ((len > 0) &&
  66.         (pathName[len-1] != '/') &&
  67.         (pathName[len-1] != '\\') &&
  68.         (pathName[len-1] != ':')) len--;
  69.  name = malloc(slen - len + 2);
  70.  if (name)
  71.   strncpy(name, &pathName[len], slen - len + 1);
  72.  return name;
  73. }
  74.  
  75. char *removeStartSpaces(char *sz)
  76. {
  77.  int i = 0;
  78.  char ch;
  79.  while (((ch = sz[i]) != 0) &&
  80.         ((ch == SPACE) || (ch == TAB) || (ch == LF) || (ch == CR))) i++;
  81.  if (i != 0) strcpy(sz, &sz[i]);
  82.  return sz;
  83. }
  84.  
  85. char *removeLastSpaces(char *sz)
  86. {
  87.  int i = strlen(sz) - 1;
  88.  char ch;
  89.  while ((i >= 0) &&
  90.         (((ch = sz[i]) == SPACE) || (ch == TAB) ||
  91.           (ch == LF) || (ch == CR))) sz[i--] = 0;
  92.  return sz;
  93. }
  94.  
  95. int Token(char *sz, char *wordlist)
  96. {
  97.  int sp = 0;
  98.  int tp = 0;
  99.  int tl = 0;
  100.  int wn = 1;
  101.  
  102.  while ((wordlist[tl] | wordlist[tl + 1]) != 0) tl++;
  103.  
  104.  while (tp <= tl)
  105.   {
  106.    if (wordlist[tp] == 0)
  107.     {
  108.      strcpy(sz, &sz[sp]);
  109.      return wn;
  110.     }
  111.    if ((sz[sp] != 0) && (loCase(sz[sp]) == loCase(wordlist[tp])))
  112.          { sp++; tp++; }
  113.     else {
  114.           sp = 0; wn++;
  115.           while ((wordlist[tp++] != 0) && (tp < tl)) ;
  116.          }
  117.   }
  118.  return 0;
  119. }
  120.  
  121. char *GetToken(char *wordlist, int no)
  122. {
  123.  int i;
  124.  int sp = 0;
  125.  
  126.  for (i = 1; i < no; i++)
  127.   while (wordlist[sp++] != 0) ;
  128.  
  129.  return &wordlist[sp];
  130. }
  131.  
  132. long decVal(char *s)
  133. {
  134.  long  Value = 0;
  135.  char  ch;
  136.  int   sl = strlen(s);
  137.  int   sign = 0;
  138.  
  139.  switch (s[0])
  140.  {
  141.   case '-': sign = 1;
  142.   case '+': strncpy(s, &s[1], sl--); break;
  143.  }
  144.  while (((ch = s[0]) >= '0') && (ch <= '9'))
  145.   {
  146.    Value = Value * 10 + (ch - '0');
  147.    strncpy(s, &s[1], sl--);
  148.   }
  149.  return (sign ? -Value : Value);
  150. }
  151.  
  152. char *decStr(ulong val, int nch, char *buff)
  153. {
  154.  char   fch = 1;
  155.  ldiv_t dr;
  156.  while (nch && (val | fch))
  157.   {
  158.    dr = ldiv(val, 10);
  159.    buff[--nch] = (char)(dr.rem + '0');
  160.    val = dr.quot;
  161.    fch = 0;
  162.   }
  163.  return &buff[nch];
  164. }
  165.  
  166. char hexChar(char Val)
  167. {
  168.  return (Val > 9? Val - 10 + 'A' : Val + '0');
  169. }
  170.  
  171. ulong hexVal(char *s)
  172. {
  173.  ulong Value = 0;
  174.  char  ch;
  175.  int   sl = strlen(s);
  176.  
  177.  while ((((ch = upCase(s[0])) >= '0') && (ch <= '9')) ||
  178.         ((ch >= 'A') && (ch <= 'F')))
  179.   {
  180.    Value = (Value << 4) + (ch > '9'? ch - 'A' + 10 : ch - '0');
  181.    strncpy(s, &s[1], sl--);
  182.   }
  183.  return Value;
  184. }
  185.  
  186. char *hexStr(ulong val, int nch, char *buff)
  187. {
  188.  char   fch = 1;
  189.  
  190.  while (nch && (val | fch))
  191.   {
  192.    buff[--nch] = hexChar(val & 0x0F);
  193.    val >>= 4;
  194.    fch = 0;
  195.   }
  196.  return &buff[nch];
  197. }
  198.  
  199. char *Strg(char Ch, int Num, char *S)
  200. {
  201.  memset(S, Ch, Num);
  202.  S[Num] = 0;
  203.  return S;
  204. }
  205.  
  206. int strfirst(char Ch, char *S)
  207. {
  208.  int pos = 0;
  209.  while ((S[pos]) && (S[pos] != Ch)) pos++;
  210.  if (!S[pos]) return -1; else return pos;
  211. }
  212.  
  213. int strlast(char Ch, char *S)
  214. {
  215.  int pos = strlen(S) - 1;
  216.  while ((pos >= 0) && (S[pos] != Ch)) pos--;
  217.  return pos;
  218. }
  219.  
  220. int firstwordlen(char *S)
  221. {
  222.  int pos = 0;
  223.  while ((S[pos]) && (S[pos] != SPACE) && (S[pos] != TAB)) pos++;
  224.  return pos;
  225. }
  226.  
  227. void strdel(char *S, int start, int count)
  228. {
  229.  int len = strlen(S);
  230.  if (start < len)
  231.  {
  232.   if (start + count < len)
  233.    strcpy((char *)&S[start], (char *)&S[start + count]);
  234.   else
  235.    S[start] = 0;
  236.  }
  237. }
  238.