Line data    Source code

       1             : // Copyright 2013 Google Inc. All Rights Reserved.
       2             : //
       3             : // Licensed under the Apache License, Version 2.0 (the "License");
       4             : // you may not use this file except in compliance with the License.
       5             : // You may obtain a copy of the License at
       6             : //
       7             : // http://www.apache.org/licenses/LICENSE-2.0
       8             : //
       9             : // Unless required by applicable law or agreed to in writing, software
      10             : // distributed under the License is distributed on an "AS IS" BASIS,
      11             : // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      12             : // See the License for the specific language governing permissions and
      13             : // limitations under the License.
      14             : //
      15             : // Helper functions for storing integer values into byte streams.
      16             : // No bounds checking is performed, that is the responsibility of the caller.
      17             : 
      18             : #ifndef WOFF2_STORE_BYTES_H_
      19             : #define WOFF2_STORE_BYTES_H_
      20             : 
      21             : #include <inttypes.h>
      22             : #include <stddef.h>
      23             : #include <string.h>
      24             : 
      25             : namespace woff2 {
      26             : 
      27           0 : inline size_t StoreU32(uint8_t* dst, size_t offset, uint32_t x) {
      28           0 :   dst[offset] = x >> 24;
      29           0 :   dst[offset + 1] = x >> 16;
      30           0 :   dst[offset + 2] = x >> 8;
      31           0 :   dst[offset + 3] = x;
      32           0 :   return offset + 4;
      33             : }
      34             : 
      35           0 : inline size_t Store16(uint8_t* dst, size_t offset, int x) {
      36             : #if (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
      37           0 :   uint16_t v = ((x & 0xFF) << 8) | ((x & 0xFF00) >> 8);
      38           0 :   memcpy(dst + offset, &v, 2);
      39             : #elif (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
      40             :   uint16_t v = static_cast<uint16_t>(x);
      41             :   memcpy(dst + offset, &v, 2);
      42             : #else
      43             :   dst[offset] = x >> 8;
      44             :   dst[offset + 1] = x;
      45             : #endif
      46           0 :   return offset + 2;
      47             : }
      48             : 
      49             : inline void StoreU32(uint32_t val, size_t* offset, uint8_t* dst) {
      50             :   dst[(*offset)++] = val >> 24;
      51             :   dst[(*offset)++] = val >> 16;
      52             :   dst[(*offset)++] = val >> 8;
      53             :   dst[(*offset)++] = val;
      54             : }
      55             : 
      56           0 : inline void Store16(int val, size_t* offset, uint8_t* dst) {
      57             : #if (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
      58           0 :   uint16_t v = ((val & 0xFF) << 8) | ((val & 0xFF00) >> 8);
      59           0 :   memcpy(dst + *offset, &v, 2);
      60             :       ((val & 0xFF) << 8) | ((val & 0xFF00) >> 8);
      61           0 :   *offset += 2;
      62             : #elif (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
      63             :   uint16_t v = static_cast<uint16_t>(val);
      64             :   memcpy(dst + *offset, &v, 2);
      65             :   *offset += 2;
      66             : #else
      67             :   dst[(*offset)++] = val >> 8;
      68             :   dst[(*offset)++] = val;
      69             : #endif
      70           0 : }
      71             : 
      72             : inline void StoreBytes(const uint8_t* data, size_t len,
      73             :                        size_t* offset, uint8_t* dst) {
      74             :   memcpy(&dst[*offset], data, len);
      75             :   *offset += len;
      76             : }
      77             : 
      78             : } // namespace woff2
      79             : 
      80             : #endif  // WOFF2_STORE_BYTES_H_