home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 6 / AACD06.ISO / AACD / Programming / ICU / src / icu / source / tools / genrb / read.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-10-19  |  10.0 KB  |  367 lines
  1. /*
  2. *******************************************************************************
  3. *                                                                             *
  4. * COPYRIGHT:                                                                  *
  5. *   (C) Copyright International Business Machines Corporation, 1998, 1999     *
  6. *   Licensed Material - Program-Property of IBM - All Rights Reserved.        *
  7. *   US Government Users Restricted Rights - Use, duplication, or disclosure   *
  8. *   restricted by GSA ADP Schedule Contract with IBM Corp.                    *
  9. *                                                                             *
  10. *******************************************************************************
  11. *
  12. * File read.c
  13. *
  14. * Modification History:
  15. *
  16. *   Date        Name        Description
  17. *   05/26/99    stephen     Creation.
  18. *******************************************************************************
  19. */
  20.  
  21. #include "read.h"
  22. #include "error.h"
  23. #include "ufile.h"
  24. #include "ustdio.h"
  25.  
  26. #define OPENBRACE    0x007B
  27. #define CLOSEBRACE   0x007D
  28. #define COMMA        0x002C
  29. #define QUOTE        0x0022
  30. #define ESCAPE       0x005C
  31. #define SLASH        0x002F
  32. #define ASTERISK     0x002A
  33. #define SPACE        0x0020
  34.  
  35.  
  36. /* Protos */
  37. static enum ETokenType getStringToken(UFILE *f, UChar initialChar, 
  38.                       struct UString *token,
  39.                       UErrorCode *status);
  40. static UChar unescape(UFILE *f, UErrorCode *status);
  41. static UChar getNextChar(UFILE *f, bool_t skipwhite, UErrorCode *status);
  42. static void seekUntilNewline(UFILE *f, UErrorCode *status);
  43. static void seekUntilEndOfComment(UFILE *f, UErrorCode *status);
  44. static bool_t isWhitespace(UChar c);
  45. static bool_t isNewline(UChar c);
  46.      
  47.  
  48. /* Read and return the next token from the stream.  If the token is of
  49.    type eString, fill in the token parameter with the token.  If the
  50.    token is eError, then the status parameter will contain the
  51.    specific error.  This will be eItemNotFound at the end of file,
  52.    indicating that all tokens have been returned.  This method will
  53.    never return eString twice in a row; instead, multiple adjacent
  54.    string tokens will be merged into one, with no intervening
  55.    space. */
  56. enum ETokenType getNextToken(UFILE *f,
  57.                  struct UString *token,
  58.                  UErrorCode *status)
  59. {
  60.   UChar c;
  61.   
  62.   if(U_FAILURE(*status)) return tok_error;
  63.  
  64.   /* Skip whitespace */
  65.   c = getNextChar(f, TRUE, status);
  66.   if(U_FAILURE(*status)) return tok_error;
  67.   
  68.   switch(c) {
  69.   case OPENBRACE:    return tok_open_brace;
  70.   case CLOSEBRACE:   return tok_close_brace;
  71.   case COMMA:        return tok_comma;
  72.   case U_EOF:        return tok_EOF;
  73.   default:           return getStringToken(f, c, token, status);
  74.   }
  75. }
  76.  
  77. /* Copy a string token into the given UnicodeString.  Upon entry, we
  78.    have already read the first character of the string token, which is
  79.    not a whitespace character (but may be a QUOTE or ESCAPE). This
  80.    function reads all subsequent characters that belong with this
  81.    string, and copy them into the token parameter. The other
  82.    important, and slightly convoluted purpose of this function is to
  83.    merge adjacent strings.  It looks forward a bit, and if the next
  84.    non comment, non whitespace item is a string, it reads it in as
  85.    well.  If two adjacent strings are quoted, they are merged without
  86.    intervening space.  Otherwise a single SPACE character is
  87.    inserted. */
  88. static enum ETokenType getStringToken(UFILE *f,
  89.                       UChar initialChar,
  90.                       struct UString *token,
  91.                       UErrorCode *status)
  92. {
  93.   bool_t lastStringWasQuoted;
  94.   UChar c;
  95.  
  96.   /* We are guaranteed on entry that initialChar is not a whitespace
  97.      character. If we are at the EOF, or have some other problem, it
  98.      doesn't matter; we still want to validly return the initialChar
  99.      (if nothing else) as a string token. */
  100.  
  101.   if(U_FAILURE(*status)) return tok_error;
  102.   
  103.   /* setup */
  104.   lastStringWasQuoted = FALSE;
  105.   c = initialChar;
  106.   ustr_setlen(token, 0, status);
  107.  
  108.   if(U_FAILURE(*status)) return tok_error;
  109.   
  110.   for(;;) {
  111.     if(c == QUOTE) {
  112.       if( ! lastStringWasQuoted && token->fLength > 0) {
  113.     ustr_ucat(token, SPACE, status);
  114.     if(U_FAILURE(*status)) return tok_error;
  115.       }
  116.       lastStringWasQuoted = TRUE;
  117.       
  118.       for(;;) {
  119.     c = u_fgetc(f, status);
  120.     /* EOF reached */
  121.     if(c == (UChar)U_EOF)        return tok_EOF;
  122.     /* Unterminated quoted strings */
  123.     if(U_FAILURE(*status))  return tok_error;
  124.     if(c == QUOTE) 
  125.       break;
  126.     if(c == ESCAPE) 
  127.       c = unescape(f, status);
  128.     ustr_ucat(token, c, status);
  129.     if(U_FAILURE(*status)) return tok_error;
  130.       }
  131.     }
  132.     else {
  133.       if(token->fLength > 0) {
  134.     ustr_ucat(token, SPACE, status);
  135.     if(U_FAILURE(*status)) return tok_error;
  136.       }
  137.       lastStringWasQuoted = FALSE;
  138.       
  139.       if(c == ESCAPE) 
  140.     c = unescape(f, status);
  141.       ustr_ucat(token, c, status);
  142.       if(U_FAILURE(*status)) return tok_error;
  143.  
  144.       for(;;) {
  145.     /* DON'T skip whitespace */
  146.     c = getNextChar(f, FALSE, status);
  147.     if(U_FAILURE(*status)) 
  148.       return tok_string;
  149.  
  150.     if(c == QUOTE
  151.        || c == OPENBRACE
  152.        || c == CLOSEBRACE
  153.        || c == COMMA)
  154.       {
  155.         u_fungetc(c, f, status);
  156.         break;
  157.       }
  158.  
  159.     if(isWhitespace(c)) 
  160.       break;
  161.     
  162.     if(c == ESCAPE) 
  163.       c = unescape(f, status);
  164.     ustr_ucat(token, c, status);
  165.     if(U_FAILURE(*status)) return tok_error;
  166.       }
  167.     }
  168.     
  169.     /* DO skip whitespace */
  170.     c = getNextChar(f, TRUE, status);
  171.     if(U_FAILURE(*status)) 
  172.       return tok_string;
  173.     
  174.     if(c == OPENBRACE || c == CLOSEBRACE || c == COMMA) {
  175.       u_fungetc(c, f, status);
  176.       return tok_string;
  177.     }
  178.   }
  179. }
  180.  
  181. /* Retrieve the next character, ignoring comments.  If skipwhite is
  182.    true, whitespace is skipped as well. */
  183. static UChar getNextChar(UFILE *f,
  184.              bool_t skipwhite, 
  185.              UErrorCode *status)
  186. {
  187.   UChar c;
  188.  
  189.   if(U_FAILURE(*status)) return U_EOF;
  190.   
  191.   for(;;) {
  192.     c = u_fgetc(f, status);
  193.     if(c == (UChar)U_EOF) return U_EOF;
  194.     
  195.     if(skipwhite && isWhitespace(c)) 
  196.       continue;
  197.     
  198.     /* This also handles the get() failing case */
  199.     if(c != SLASH)
  200.       return c;
  201.     
  202.     c = u_fgetc(f, status);
  203.     if(c == (UChar)U_EOF) return U_EOF;
  204.     
  205.     switch(c) {
  206.     case SLASH:
  207.       seekUntilNewline(f, status);
  208.       break;
  209.       
  210.     case ASTERISK:
  211.       /* Note that we silently ignore an unterminated comment */
  212.       seekUntilEndOfComment(f, status);
  213.       break;
  214.       
  215.     default:
  216.       u_fungetc(c, f, status);
  217.       /* If get() failed this is a NOP */
  218.       return SLASH;
  219.     }
  220.   }
  221. }
  222.  
  223. void seekUntilNewline(UFILE *f,
  224.               UErrorCode *status)
  225. {
  226.   UChar c;
  227.  
  228.   if(U_FAILURE(*status)) return;
  229.   
  230.   do {
  231.     c = u_fgetc(f, status);
  232.   } while(! isNewline(c) && c != (UChar)U_EOF && *status == U_ZERO_ERROR);
  233.   
  234.   /*if(U_FAILURE(*status))
  235.     err = kItemNotFound;*/
  236. }
  237.  
  238. void seekUntilEndOfComment(UFILE *f,
  239.                UErrorCode *status)
  240. {
  241.   UChar c, d;
  242.  
  243.   if(U_FAILURE(*status)) return;
  244.  
  245.   do {
  246.     c = u_fgetc(f, status);
  247.     if(c == ASTERISK) {
  248.       d = u_fgetc(f, status);
  249.       if(d != SLASH)
  250.     u_fungetc(d, f, status);
  251.       else
  252.     break;
  253.     }
  254.   } while(c != (UChar)U_EOF && *status == U_ZERO_ERROR);
  255.  
  256.   if(c == (UChar)U_EOF) {
  257.     *status = U_INVALID_FORMAT_ERROR;
  258.     setErrorText("Unterminated comment detected");
  259.   }
  260. }
  261.  
  262. static UChar unescape(UFILE *f,
  263.               UErrorCode *status)
  264. {
  265.   UChar c;
  266.   UChar out;
  267.   int16_t maxChars;
  268.   
  269.   if(U_FAILURE(*status)) return U_EOF;
  270.   
  271.   c = u_fgetc(f, status);
  272.   if(c == (UChar)U_EOF || U_FAILURE(*status)) return U_EOF;
  273.  
  274.   switch (c) {
  275.     
  276.     /* '\t' or '\T' causes a tab character to be written to the output */
  277.   case 0x0074: case 0x0054:
  278.     return 0x0009;
  279.     
  280.     /* '\n' or '\N' causes a line feed to be written to the output */
  281.   case 0x006E: case 0x004E:
  282.     return 0x000A;
  283.     
  284.     /* \x## and \u#### allow characters to be specified by character
  285.      code.  The characters following \x or \u (up to two after \x or
  286.      four after \u) are treated as hexadecimal digits, and the
  287.      hexadecimal number they represent is the numeric character code
  288.      (Latin1 for \x and Unicode for \u) of the character that is
  289.      written to the output.  A character that isn't a valid
  290.      hexadecimal digit terminates the escape sequence (but still gets
  291.      treated independently).  If the sequence evaluates to zero (i.e.,
  292.      either '\x' or '\u' by itself, or '\x00' or '\u0000'), nothing is
  293.      written to the output, which effectively means you can't have
  294.      null characters in the file. */
  295.   case 0x0078: case 0x0058: case 0x0075: case 0x0055:
  296.     if(c == 0x0078 || c == 0x0058)
  297.       maxChars = 2;
  298.     else
  299.       maxChars = 4;
  300.     out = 0;
  301.     while(maxChars != 0 && *status == U_ZERO_ERROR) {
  302.       c = u_fgetc(f, status);
  303.       if(c == (UChar)U_EOF || U_FAILURE(*status)) return U_EOF;
  304.       
  305.       switch(c) {
  306.     /* '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' */
  307.       case 0x0030: case 0x0031: case 0x0032: case 0x0033: case 0x0034:
  308.       case 0x0035: case 0x0036: case 0x0037: case 0x0038: case 0x0039:
  309.     out = (out << 4) + (c - 0x0030);
  310.     break;
  311.     
  312.     /* 'A', 'B', 'C', 'D', 'E', 'F' */
  313.       case 0x0041: case 0x0042: case 0x0043: case 0x0044: case 0x0045: 
  314.       case 0x0046:
  315.     out = (out << 4) + (c - 0x0041 + 10);
  316.     break;
  317.  
  318.     /* 'a', 'b', 'c', 'd', 'e', 'f' */
  319.       case 0x0061: case 0x0062: case 0x0063: case 0x0064: case 0x0065: 
  320.       case 0x0066:
  321.     out = (out << 4) + (c - 0x0061 + 10);
  322.     break;
  323.     
  324.       default:
  325.     u_fungetc(c, f, status);
  326.     maxChars = 1;   /* so we fall out of the loop */
  327.     break;
  328.       }
  329.       --maxChars;
  330.     }
  331.     return out;
  332.     
  333.     /* if a backslash preceds any character other than x, u, t, or n,
  334.      that character is just copied to the output as-is (meaning it's
  335.      deprived of any special meaning it otherwise would have had:
  336.      ESCAPE puts a literal backslash in the output stream, for
  337.      example, and QUOTE puts a literal double quote in the output
  338.      stream. */
  339.   default:
  340.     return c;
  341.   }
  342. }
  343.  
  344. static bool_t isWhitespace(UChar c)
  345. {
  346.   switch (c) {
  347.     /* ' ', '\t', '\n', '\r', 0x2029 */
  348.   case 0x0020: case 0x0009: case 0x000A: case 0x000D:  case 0x2029:
  349.     return TRUE;
  350.     
  351.   default:
  352.     return FALSE;
  353.   }
  354. }
  355.  
  356. static bool_t isNewline(UChar c)
  357. {
  358.   switch (c) {
  359.     /* '\n', '\r', 0x2029 */
  360.   case 0x000A: case 0x000D: case 0x2029:
  361.     return TRUE;
  362.     
  363.   default:
  364.     return FALSE;
  365.   }
  366. }
  367.