home *** CD-ROM | disk | FTP | other *** search
/ ARM Club 3 / TheARMClub_PDCD3.iso / hensa / texted / b084_1 / c / char < prev    next >
Text File  |  1991-04-07  |  7KB  |  277 lines
  1. /*      CHAR.C: Character handling functions for
  2.                 MicroEMACS 3.10
  3.                 (C)opyright 1988 by Daniel Lawrence
  4.  
  5.                 ALL THE CODE HERE IS FOR VARIOUS FORMS OF ASCII AND
  6.                 WILL HAVE TO BE MODIFIED FOR EBCDIC
  7. */
  8.  
  9. #include        <stdio.h>
  10. #include        "estruct.h"
  11. #include        "etype.h"
  12. #include        "edef.h"
  13. #include        "elang.h"
  14.  
  15. #if     DIACRIT
  16. /*      isletter()
  17.                 Is the character a letter?  We presume a letter must
  18.         be either in the upper or lower case tables (even if it gets
  19.         translated to itself).
  20. */
  21.  
  22. int PASCAL NEAR isletter(ch)
  23.  
  24. register unsigned int ch;
  25.  
  26. {
  27.         return(isupper(ch) || islower(ch));
  28. }
  29.  
  30. #if !RISCOS
  31. /*      islower()
  32.                 Is the character a lower case letter?  This looks
  33.         in the lower to uppercase translation table.
  34. */
  35.  
  36. int PASCAL NEAR islower(ch)
  37. register unsigned int   ch;
  38. {
  39.         return(lowcase[ch] != 0);
  40. }
  41.  
  42. /*      isupper()
  43.                 Is the character a upper case letter?  This looks
  44.         in the upper to lowercase translation table.
  45. */
  46.  
  47. int PASCAL NEAR isupper(ch)
  48. register unsigned int   ch;
  49. {
  50.         return(upcase[ch] != 0);
  51. }
  52. #endif
  53.  
  54. /*      chcase()
  55.  
  56.                 Change the case of the current character.
  57.         First check lower and then upper.  If it is not a letter,
  58.         it gets returned unchanged.
  59. */
  60.  
  61. unsigned int PASCAL NEAR chcase(ch)
  62. register unsigned int   ch;
  63. {
  64.         /* translate lowercase */
  65.         if (islower(ch))
  66.                 return(lowcase[ch]);
  67.  
  68.         /* translate uppercase */
  69.         if (isupper(ch))
  70.                 return(upcase[ch]);
  71.  
  72.         /* let the rest pass */
  73.         return(ch);
  74. }
  75.  
  76. /* change *cp to an upper case character */
  77.  
  78. uppercase(cp)
  79.  
  80. char *cp;       /* ptr to character to uppercase */
  81.  
  82. {
  83.         /* translate lowercase */
  84.         if (islower(*cp))
  85.                 *cp = lowcase[*cp];
  86. }
  87.  
  88. /* change *cp to an lower case character */
  89.  
  90. lowercase(cp)
  91.  
  92. char *cp;       /* ptr to character to lowercase */
  93.  
  94. {
  95.         /* translate lowercase */
  96.         if (isupper(*cp))
  97.                 *cp = upcase[*cp];
  98. }
  99.  
  100. char PASCAL NEAR upperc(ch)     /* return the upper case equivalant of a character */
  101.  
  102. char ch;        /* character to get uppercase euivalant of */
  103.  
  104. {
  105.         if (islower(ch))
  106.                 return(lowcase[ch]);
  107.         else
  108.                 return(ch);
  109. }
  110.  
  111. char PASCAL NEAR lowerc(ch)     /* return the lower case equivalant of a character */
  112.  
  113. char ch;        /* character to get lowercase equivalant of */
  114.  
  115. {
  116.         if (isupper(ch))
  117.                 return(upcase[ch]);
  118.         else
  119.                 return(ch);
  120. }
  121.  
  122. PASCAL NEAR initchars() /* initialize the character upper/lower case tables */
  123.  
  124. {
  125.         register int index;     /* index into tables */
  126.  
  127.         /* all of both tables to zero */
  128.         for (index = 0; index < HICHAR; index++) {
  129.                 lowcase[index] = 0;
  130.                 upcase[index] = 0;
  131.         }
  132.  
  133.         /* lower to upper */
  134.         for (index = 'a'; index <= 'z'; index++)
  135.                 lowcase[index] = index - DIFCASE;
  136.  
  137.         /* upper to lower */
  138.         for (index = 'A'; index <= 'Z'; index++)
  139.                 upcase[index] = index + DIFCASE;
  140.  
  141. #if     MSDOS
  142.         /* setup various extended IBM-PC characters */
  143.         upcase[0x80]  = 0x87;   /* C with a cedilla */
  144.         lowcase[0x81] = 0x9a;   /* U with an umlat */
  145.         lowcase[0x82] = 0x90;   /* E with an acute accent */
  146.         lowcase[0x83] = 0x83;   /* A with two dots */
  147.         lowcase[0x84] = 0x8e;   /* A with an umlat */
  148.         lowcase[0x85] = 0x85;   /* A with a grave accent */
  149.         lowcase[0x86] = 0x8f;   /* A with a circle */
  150.         lowcase[0x87] = 0x80;   /* C with a cedilla */
  151.         lowcase[0x88] = 0x88;   /* E with a ^ */
  152.         lowcase[0x89] = 0x89;   /* E with two dots */
  153.         lowcase[0x8a] = 0x8a;   /* E with a grave accent */
  154.         lowcase[0x8b] = 0x8b;   /* I with two dots */
  155.         lowcase[0x8c] = 0x8c;   /* I with a ^ */
  156.         lowcase[0x8d] = 0x8d;   /* I with a grave accent */
  157.         upcase[0x8e]  = 0x84;   /* A with an umlat */
  158.         upcase[0x8f]  = 0x86;   /* A with a circle */
  159.         upcase[0x90]  = 0x82;   /* E with an acute accent */
  160.         lowcase[0x91] = 0x92;   /* AE combination */
  161.         upcase[0x92]  = 0x91;   /* AE combination */
  162.         lowcase[0x93] = 0x93;   /* O with a ^ */
  163.         lowcase[0x94] = 0x99;   /* O with an umlat */
  164.         lowcase[0x95] = 0x95;   /* O with an acute accent */
  165.         lowcase[0x96] = 0x96;   /* U with a ^ */
  166.         lowcase[0x97] = 0x97;   /* U with an grave accent */
  167.         lowcase[0x98] = 0x98;   /* Y with two dots */
  168.         upcase[0x99]  = 0x94;   /* O with an umlat */
  169.         upcase[0x9a]  = 0x81;   /* U with an umlat */
  170.         lowcase[0xa0] = 0xa0;   /* A with an acute accent */
  171.         lowcase[0xa1] = 0xa1;   /* I with an acute accent */
  172.         lowcase[0xa2] = 0xa2;   /* O with an acute accent */
  173.         lowcase[0xa3] = 0xa3;   /* U with an acute accent */
  174.         lowcase[0xa4] = 0xa5;   /* N with a ...... */
  175.         upcase[0xa5]  = 0xa4;   /* N with a ...... */
  176.         lowcase[0xa6] = 0xa6;   /* A underlined */
  177.         lowcase[0xa7] = 0xa7;   /* O underlined */
  178. #endif
  179. }
  180.  
  181. /*      Set a character in the lowercase map */
  182.  
  183. int PASCAL NEAR setlower(ch, val)
  184.  
  185. char *ch;       /* ptr to character to set */
  186. char *val;      /* value to set it to */
  187.  
  188. {
  189.         return(lowcase[*ch & 255] = *val & 255);
  190. }
  191.  
  192. /*      Set a character in the uppercase map */
  193.  
  194. int PASCAL NEAR setupper(ch, val)
  195.  
  196. char *ch;       /* ptr to character to set */
  197. char *val;      /* value to set it to */
  198.  
  199. {
  200.         return(upcase[*ch & 255] = *val & 255);
  201. }
  202. #else
  203. /* change *cp to an upper case character */
  204.  
  205. uppercase(cp)
  206.  
  207. char *cp;       /* ptr to character to uppercase */
  208.  
  209. {
  210.         /* translate lowercase */
  211.         if (islower(*cp))
  212.                 *cp -= DIFCASE;
  213. }
  214.  
  215. /* change *cp to an lower case character */
  216.  
  217. lowercase(cp)
  218.  
  219. char *cp;       /* ptr to character to lowercase */
  220.  
  221. {
  222.         /* translate lowercase */
  223.         if (isupper(*cp))
  224.                 *cp += DIFCASE;
  225. }
  226.  
  227. char PASCAL NEAR upperc(ch)     /* return the upper case equivalant of a character */
  228.  
  229. char ch;        /* character to get uppercase euivalant of */
  230.  
  231. {
  232.         if (islower(ch))
  233.                 return(ch - DIFCASE);
  234.         else
  235.                 return(ch);
  236. }
  237.  
  238. char PASCAL NEAR lowerc(ch)     /* return the lower case equivalant of a character */
  239.  
  240. char ch;        /* character to get lowercase equivalant of */
  241.  
  242. {
  243.         if (isupper(ch))
  244.                 return(ch + DIFCASE);
  245.         else
  246.                 return(ch);
  247. }
  248.  
  249. PASCAL NEAR initchars() /* initialize the character upper/lower case tables */
  250.  
  251. {
  252.         /* there is nothing we need to do here! */
  253. }
  254.  
  255. /*      Set a character in the lowercase map */
  256.  
  257. int PASCAL NEAR setlower(ch, val)
  258.  
  259. char *ch;       /* ptr to character to set */
  260. char *val;      /* value to set it to */
  261.  
  262. {
  263.         return(*val & 255);
  264. }
  265.  
  266. /*      Set a character in the uppercase map */
  267.  
  268. int PASCAL NEAR setupper(ch, val)
  269.  
  270. char *ch;       /* ptr to character to set */
  271. char *val;      /* value to set it to */
  272.  
  273. {
  274.         return(*val & 255);
  275. }
  276. #endif
  277.