The Tor Browser: intl/icu/source/tools/genrb/rle.c@6474c204b198 (annotated)

intl/icu/source/tools/genrb/rle.c@6474c204b198 (annotated)

intl/icu/source/tools/genrb/rle.c

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /*
 *******************************************************************************
 *
 *   Copyright (C) 2000-2003, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 *******************************************************************************
 *
 * File writejava.c
 *
 * Modification History:
 *
 *   Date        Name        Description
 *   01/11/02    Ram        Creation.
 *******************************************************************************
 */
 #include "rle.h"
 /**
  * The ESCAPE character is used during run-length encoding.  It signals
  * a run of identical chars.
  */
 static const uint16_t ESCAPE = 0xA5A5;
 /**
  * The ESCAPE_BYTE character is used during run-length encoding.  It signals
  * a run of identical bytes.
  */
 static const uint8_t ESCAPE_BYTE = (uint8_t)0xA5;
 /**
  * Append a byte to the given StringBuffer, packing two bytes into each
  * character.  The state parameter maintains intermediary data between
  * calls.
  * @param state A two-element array, with state[0] == 0 if this is the
  * first byte of a pair, or state[0] != 0 if this is the second byte
  * of a pair, in which case state[1] is the first byte.
  */
 static uint16_t*
 appendEncodedByte(uint16_t* buffer, uint16_t* buffLimit, uint8_t value, uint8_t state[],UErrorCode* status) {
     if(!status || U_FAILURE(*status)){
         return NULL;
     }
     if (state[0] != 0) {
         uint16_t c = (uint16_t) ((state[1] << 8) | (((int32_t) value) & 0xFF));
         if(buffer < buffLimit){
             *buffer++ = c;
         }else{
             *status = U_BUFFER_OVERFLOW_ERROR;
         }
         state[0] = 0;
         return buffer;
     }
     else {
         state[0] = 1;
         state[1] = value;
         return buffer;
     }
 }
 /**
  * Encode a run, possibly a degenerate run (of < 4 values).
  * @param length The length of the run; must be > 0 && <= 0xFF.
  */
 static uint16_t*
 encodeRunByte(uint16_t* buffer,uint16_t* bufLimit, uint8_t value, int32_t length, uint8_t state[], UErrorCode* status) {
     if(!status || U_FAILURE(*status)){
         return NULL;
     }
     if (length < 4) {
         int32_t j=0;
         for (; j<length; ++j) {
             if (value == ESCAPE_BYTE) {
                 buffer = appendEncodedByte(buffer,bufLimit, ESCAPE_BYTE, state,status);
             }
             buffer = appendEncodedByte(buffer,bufLimit, value, state, status);
         }
     }
     else {
         if (length == ESCAPE_BYTE) {
             if (value == ESCAPE_BYTE){
                buffer =  appendEncodedByte(buffer, bufLimit,ESCAPE_BYTE, state,status);
             }
             buffer = appendEncodedByte(buffer,bufLimit, value, state, status);
             --length;
         }
         buffer = appendEncodedByte(buffer,bufLimit, ESCAPE_BYTE, state,status);
         buffer = appendEncodedByte(buffer,bufLimit, (char)length, state, status);
         buffer = appendEncodedByte(buffer,bufLimit, value, state, status); /* Don't need to escape this value*/
     }
     return buffer;
 }
 #define APPEND( buffer, bufLimit, value, num, status){  \
     if(buffer<bufLimit){                    \
         *buffer++=(value);                  \
     }else{                                  \
         *status = U_BUFFER_OVERFLOW_ERROR;  \
     }                                       \
     num++;                                  \
 }
 /**
  * Encode a run, possibly a degenerate run (of < 4 values).
  * @param length The length of the run; must be > 0 && <= 0xFFFF.
  */
 static uint16_t*
 encodeRunShort(uint16_t* buffer,uint16_t* bufLimit, uint16_t value, int32_t length,UErrorCode* status) {
     int32_t num=0;
     if (length < 4) {
         int j=0;
         for (; j<length; ++j) {
             if (value == (int32_t) ESCAPE){
                 APPEND(buffer,bufLimit,ESCAPE, num, status);
             }
             APPEND(buffer,bufLimit,value,num, status);
         }
     }
     else {
         if (length == (int32_t) ESCAPE) {
             if (value == (int32_t) ESCAPE){
                 APPEND(buffer,bufLimit,ESCAPE,num,status);
             }
             APPEND(buffer,bufLimit,value,num,status);
             --length;
         }
         APPEND(buffer,bufLimit,ESCAPE,num,status);
         APPEND(buffer,bufLimit,(uint16_t) length, num,status);
         APPEND(buffer,bufLimit,(uint16_t)value, num, status); /* Don't need to escape this value */
     }
     return buffer;
 }
 /**
  * Construct a string representing a char array.  Use run-length encoding.
  * A character represents itself, unless it is the ESCAPE character.  Then
  * the following notations are possible:
  *   ESCAPE ESCAPE   ESCAPE literal
  *   ESCAPE n c      n instances of character c
  * Since an encoded run occupies 3 characters, we only encode runs of 4 or
  * more characters.  Thus we have n > 0 and n != ESCAPE and n <= 0xFFFF.
  * If we encounter a run where n == ESCAPE, we represent this as:
  *   c ESCAPE n-1 c
  * The ESCAPE value is chosen so as not to collide with commonly
  * seen values.
  */
 int32_t
 usArrayToRLEString(const uint16_t* src,int32_t srcLen,uint16_t* buffer, int32_t bufLen,UErrorCode* status) {
     uint16_t* bufLimit =  buffer+bufLen;
     uint16_t* saveBuffer = buffer;
     if(buffer < bufLimit){
         *buffer++ =  (uint16_t)(srcLen>>16);
         if(buffer<bufLimit){
             uint16_t runValue = src[0];
             int32_t runLength = 1;
             int i=1;
             *buffer++ = (uint16_t) srcLen;
             for (; i<srcLen; ++i) {
                 uint16_t s = src[i];
                 if (s == runValue && runLength < 0xFFFF){
                     ++runLength;
                 }else {
                     buffer = encodeRunShort(buffer,bufLimit, (uint16_t)runValue, runLength,status);
                     runValue = s;
                     runLength = 1;
                 }
             }
             buffer= encodeRunShort(buffer,bufLimit,(uint16_t)runValue, runLength,status);
         }else{
             *status = U_BUFFER_OVERFLOW_ERROR;
         }
     }else{
         *status = U_BUFFER_OVERFLOW_ERROR;
     }
     return (int32_t)(buffer - saveBuffer);
 }
 /**
  * Construct a string representing a byte array.  Use run-length encoding.
  * Two bytes are packed into a single char, with a single extra zero byte at
  * the end if needed.  A byte represents itself, unless it is the
  * ESCAPE_BYTE.  Then the following notations are possible:
  *   ESCAPE_BYTE ESCAPE_BYTE   ESCAPE_BYTE literal
  *   ESCAPE_BYTE n b           n instances of byte b
  * Since an encoded run occupies 3 bytes, we only encode runs of 4 or
  * more bytes.  Thus we have n > 0 and n != ESCAPE_BYTE and n <= 0xFF.
  * If we encounter a run where n == ESCAPE_BYTE, we represent this as:
  *   b ESCAPE_BYTE n-1 b
  * The ESCAPE_BYTE value is chosen so as not to collide with commonly
  * seen values.
  */
 int32_t
 byteArrayToRLEString(const uint8_t* src,int32_t srcLen, uint16_t* buffer,int32_t bufLen, UErrorCode* status) {
     const uint16_t* saveBuf = buffer;
     uint16_t* bufLimit =  buffer+bufLen;
     if(buffer < bufLimit){
         *buffer++ = ((uint16_t) (srcLen >> 16));
         if(buffer<bufLimit){
             uint8_t runValue = src[0];
             int runLength = 1;
             uint8_t state[2]= {0};
             int i=1;
             *buffer++=((uint16_t) srcLen);
             for (; i<srcLen; ++i) {
                 uint8_t b = src[i];
                 if (b == runValue && runLength < 0xFF){
                     ++runLength;
                 }
                 else {
                     buffer = encodeRunByte(buffer, bufLimit,runValue, runLength, state,status);
                     runValue = b;
                     runLength = 1;
                 }
             }
             buffer = encodeRunByte(buffer,bufLimit, runValue, runLength, state, status);
             /* We must save the final byte, if there is one, by padding
              * an extra zero.
              */
             if (state[0] != 0) {
                 buffer = appendEncodedByte(buffer,bufLimit, 0, state ,status);
             }
         }else{
             *status = U_BUFFER_OVERFLOW_ERROR;
         }
     }else{
         *status = U_BUFFER_OVERFLOW_ERROR;
     }
     return (int32_t) (buffer - saveBuf);
 }
 /**
  * Construct an array of shorts from a run-length encoded string.
  */
 int32_t
 rleStringToUCharArray(uint16_t* src, int32_t srcLen, uint16_t* target, int32_t tgtLen, UErrorCode* status) {
     int32_t length = 0;
     int32_t ai = 0;
     int i=2;
     if(!status || U_FAILURE(*status)){
         return 0;
     }
     /* the source is null terminated */
     if(srcLen == -1){
         srcLen = u_strlen(src);
     }
     if(srcLen <= 2){
         return 2;
     }
     length = (((int32_t) src[0]) << 16) | ((int32_t) src[1]);
     if(target == NULL){
         return length;
     }
     if(tgtLen < length){
         *status = U_BUFFER_OVERFLOW_ERROR;
         return length;
     }
     for (; i<srcLen; ++i) {
         uint16_t c = src[i];
         if (c == ESCAPE) {
             c = src[++i];
             if (c == ESCAPE) {
                 target[ai++] = c;
             } else {
                 int32_t runLength = (int32_t) c;
                 uint16_t runValue = src[++i];
                 int j=0;
                 for (; j<runLength; ++j) {
                     target[ai++] = runValue;
                 }
             }
         }
         else {
             target[ai++] = c;
         }
     }
     if (ai != length){
         *status = U_INTERNAL_PROGRAM_ERROR;
     }
     return length;
 }
 /**
  * Construct an array of bytes from a run-length encoded string.
  */
 int32_t
 rleStringToByteArray(uint16_t* src, int32_t srcLen, uint8_t* target, int32_t tgtLen, UErrorCode* status) {
     int32_t length = 0;
     UBool nextChar = TRUE;
     uint16_t c = 0;
     int32_t node = 0;
     int32_t runLength = 0;
     int32_t i = 2;
     int32_t ai=0;
     if(!status || U_FAILURE(*status)){
         return 0;
     }
     /* the source is null terminated */
     if(srcLen == -1){
         srcLen = u_strlen(src);
     }
     if(srcLen <= 2){
         return 2;
     }
     length = (((int32_t) src[0]) << 16) | ((int32_t) src[1]);
     if(target == NULL){
         return length;
     }
     if(tgtLen < length){
         *status = U_BUFFER_OVERFLOW_ERROR;
         return length;
     }
     for (; ai<tgtLen; ) {
        /* This part of the loop places the next byte into the local
         * variable 'b' each time through the loop.  It keeps the
         * current character in 'c' and uses the boolean 'nextChar'
         * to see if we've taken both bytes out of 'c' yet.
         */
         uint8_t b;
         if (nextChar) {
             c = src[i++];
             b = (uint8_t) (c >> 8);
             nextChar = FALSE;
         }
         else {
             b = (uint8_t) (c & 0xFF);
             nextChar = TRUE;
         }
        /* This part of the loop is a tiny state machine which handles
         * the parsing of the run-length encoding.  This would be simpler
         * if we could look ahead, but we can't, so we use 'node' to
         * move between three nodes in the state machine.
         */
         switch (node) {
         case 0:
             /* Normal idle node */
             if (b == ESCAPE_BYTE) {
                 node = 1;
             }
             else {
                 target[ai++] = b;
             }
             break;
         case 1:
            /* We have seen one ESCAPE_BYTE; we expect either a second
             * one, or a run length and value.
             */
             if (b == ESCAPE_BYTE) {
                 target[ai++] = ESCAPE_BYTE;
                 node = 0;
             }
             else {
                 runLength = b;
                 node = 2;
             }
             break;
         case 2:
             {
                 int j=0;
                /* We have seen an ESCAPE_BYTE and length byte.  We interpret
                 * the next byte as the value to be repeated.
                 */
                 for (; j<runLength; ++j){
                     if(ai<tgtLen){
                         target[ai++] = b;
                     }else{
                         *status = U_BUFFER_OVERFLOW_ERROR;
                         return ai;
                     }
                 }
                 node = 0;
                 break;
             }
         }
     }
     if (node != 0){
         *status = U_INTERNAL_PROGRAM_ERROR;
         /*("Bad run-length encoded byte array")*/
         return 0;
     }
     if (i != srcLen){
         /*("Excess data in RLE byte array string");*/
         *status = U_INTERNAL_PROGRAM_ERROR;
         return ai;
     }
     return ai;
 }

The Tor Browser / annotate

intl/icu/source/tools/genrb/rle.c@6474c204b198 (annotated)

intl/icu/source/tools/genrb/rle.c