Changeset e1813cf in mainline for kernel/generic/src/lib/string.c

Timestamp:

2009-03-31T22:51:41Z (15 years ago)

Author:

Jiri Svoboda <jirik.svoboda@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

ce87a8aa

Parents:

b54d2f1

Message:

Start converting string functions according to the terminology agreed upon.

File:

• kernel/generic/src/lib/string.c (modified) (9 diffs)

kernel/generic/src/lib/string.c

@@ -57 +57 @@
 #define CONT_BITS 6
 
-/** Decode a single UTF-8 character from a NULL-terminated string.
- *
- * Decode a single UTF-8 character from a plain char NULL-terminated
- * string. Decoding starts at @index and this index is moved to the
- * beginning of the next character. In case of decoding error,
- * index advances. However, index is never moved beyond (str+limit).
- *
- * @param str   Plain character NULL-terminated string.
+/** Decode a single character from a substring.
+ *
+ * Decode a single character from a substring of size @a sz. Decoding starts
+ * at @a offset and this offset is moved to the beginning of the next
+ * character. In case of decoding error, offset generally advances at least
+ * by one. However, offset is never moved beyond (str + sz).
+ *
+ * @param str   String (not necessarily NULL-terminated).
  * @param index Index (counted in plain characters) where to start
  *              the decoding.
- * @param limit Maximal allowed value of index.
- *
- * @return Decoded character in UTF-32 or '?' if the encoding is wrong.
- *
- */
-wchar_t utf8_decode(const char *str, index_t *index, index_t limit)
+ * @param limit Size of the substring.
+ *
+ * @return      Value of decoded character or '?' on decoding error.
+ *
+ */
+wchar_t chr_decode(const char *str, size_t *offset, size_t sz)
 {
         uint8_t b0, b;          /* Bytes read from str. */
@@ -80 +80 @@
         int cbytes;             /* Number of continuation bytes. */
 
-        if (*index + 1 > limit)
+        if (*offset + 1 > sz)
                 return invalch;
 
-        b0 = (uint8_t) str[(*index)++];
+        b0 = (uint8_t) str[(*offset)++];
 
         /* Determine code length. */
@@ -108 +108 @@
         }
 
-        if (*index + cbytes > limit) {
+        if (*offset + cbytes > sz) {
                 return invalch;
         }
@@ -116 +116 @@
         /* Decode continuation bytes. */
         while (cbytes > 0) {
-                b = (uint8_t) str[(*index)++];
+                b = (uint8_t) str[(*offset)++];
 
                 /* Must be 10xxxxxx. */
@@ -131 +131 @@
 }
 
-/** Encode a single UTF-32 character as UTF-8
- *
- * Encode a single UTF-32 character as UTF-8 and store it into
- * the given buffer at @index. Encoding starts at @index and
- * this index is moved at the position where the next character
- * can be written to.
- *
- * @param ch    Input UTF-32 character.
- * @param str   Output buffer.
- * @param index Index (counted in plain characters) where to start
- *              the encoding
- * @param limit Maximal allowed value of index.
- *
- * @return True if the character was encoded or false if there is not
- *         enought space in the output buffer or the character is invalid
- *         Unicode code point.
- *
- */
-bool utf8_encode(const wchar_t ch, char *str, index_t *index, index_t limit)
+/** Encode a single character to string representation.
+ *
+ * Encode a single character to string representation (i.e. UTF-8) and store
+ * it into a buffer at @a offset. Encoding starts at @a offset and this offset
+ * is moved to the position where the next character can be written to.
+ *
+ * @param ch            Input character.
+ * @param str           Output buffer.
+ * @param offset        Offset (in bytes) where to start writing.
+ * @param sz            Size of the output buffer.
+ *
+ * @return True if the character was encoded successfully or false if there
+ *         was not enough space in the output buffer or the character code
+ *         was invalid.
+ */
+bool chr_encode(const wchar_t ch, char *str, size_t *offset, size_t sz)
 {
         uint32_t cc;            /* Unsigned version of ch. */
@@ -157 +154 @@
         int i;
 
-        if (*index >= limit)
+        if (*offset >= sz)
                 return false;
 
@@ -185 +182 @@
 
         /* Check for available space in buffer. */
-        if (*index + cbytes >= limit)
+        if (*offset + cbytes >= sz)
                 return false;
 
         /* Encode continuation bytes. */
         for (i = cbytes; i > 0; --i) {
-                str[*index + i] = 0x80 | (cc & LO_MASK_32(CONT_BITS));
+                str[*offset + i] = 0x80 | (cc & LO_MASK_32(CONT_BITS));
                 cc = cc >> CONT_BITS;
         }
 
         /* Encode first byte. */
-        str[*index] = (cc & LO_MASK_32(b0_bits)) | HI_MASK_8(8 - b0_bits - 1);
-
-        /* Advance index. */
-        *index += (1 + cbytes);
+        str[*offset] = (cc & LO_MASK_32(b0_bits)) | HI_MASK_8(8 - b0_bits - 1);
+
+        /* Advance offset. */
+        *offset += (1 + cbytes);
         
         return true;
@@ -227 +224 @@
                 if (size >= count)
                         break;
-                ch = utf8_decode(str, &index, UTF8_NO_LIMIT);
+                ch = chr_decode(str, &index, UTF8_NO_LIMIT);
                 if (ch == '\0') break;
 
@@ -289 +286 @@
         index_t index = 0;
         
-        while (utf8_decode(str, &index, UTF8_NO_LIMIT) != 0) {
+        while (chr_decode(str, &index, UTF8_NO_LIMIT) != 0) {
                 size++;
         }