string.h

/* -*- mode: C; c-basic-offset: 4; intent-tabs-mode: nil -*-
 *
 * Sifteo SDK
 *
 * Copyright <c> 2012 Sifteo, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#pragma once
#ifdef NOT_USERSPACE
#   error This is a userspace-only header, not allowed by the current build.
#endif

#include <sifteo/abi.h>

namespace Sifteo {

struct Fixed {
    Fixed(int value, unsigned width, bool leadingZeroes=false)
        : value(value), width(width), leadingZeroes(leadingZeroes) {}
    int value;
    unsigned width;
    bool leadingZeroes;
};

struct FixedFP {
    FixedFP(float value, unsigned left, unsigned right, bool leadingZeroes=false)
        : widthL(left), widthR(right), leadingZeroes(leadingZeroes)
    {
        // Left side: truncate to integer
        valueL = int(value);

        /*
         * Right side: We want to convert the right side to an integer by
         * multiplying it by 10^right, then we can rely on String's
         * field width truncation to do the rest. There aren't very many
         * values of 'right' that won't overflow, so we can do this
         * with a lookup table. Typically the field width is constant
         * at compile-time, so this lookup table will optimize out.
         */
        switch (right) {
            default:   ASSERT(0);
            case 0:    valueR = value * 0; break;
            case 1:    valueR = value * 10; break;
            case 2:    valueR = value * 100; break;
            case 3:    valueR = value * 1000; break;
            case 4:    valueR = value * 10000; break;
            case 5:    valueR = value * 100000; break;
            case 6:    valueR = value * 1000000; break;
            case 7:    valueR = value * 10000000; break;
            case 8:    valueR = value * 100000000; break;
            case 9:    valueR = value * 1000000000; break;
        }
    }

    int valueL;
    int valueR;
    unsigned widthL, widthR;
    bool leadingZeroes;
};

struct Hex {
    Hex(uint32_t value, unsigned width=8, bool leadingZeroes=true)
        : value(value), width(width), leadingZeroes(leadingZeroes) {}
    uint32_t value;
    unsigned width;
    bool leadingZeroes;
};

struct Hex64 {
    Hex64(uint64_t value, unsigned width=16, bool leadingZeroes=true)
        : value(value), width(width), leadingZeroes(leadingZeroes) {}
    uint64_t value;
    unsigned width;
    bool leadingZeroes;
};


inline int strncmp(const char *a, const char *b, unsigned count)
{
    return _SYS_strncmp(a, b, count);
}

inline unsigned strnlen(const char *str, uint32_t maxLen) {
    return _SYS_strnlen(str, maxLen);
}

template <unsigned tCapacity>
class String {
public:

    typedef char* iterator;
    typedef const char* const_iterator;

    String() {
        clear();
    }

    char * c_str() {
        return buffer;
    }
    
    const char * c_str() const {
        return buffer;
    }
    
    operator char *() {
        return buffer;
    }

    operator const char *() const {
        return buffer;
    }

    static unsigned capacity() {
        return tCapacity;
    }

    unsigned size() const {
        return _SYS_strnlen(buffer, tCapacity-1);
    }

    iterator begin() {
        return &buffer[0];
    }

    iterator end() {
        return &buffer[size()];
    }

    const_iterator begin() const {
        return &buffer[0];
    }

    const_iterator end() const {
        return &buffer[size()];
    }

    void clear() {
        buffer[0] = '\0';
    }

    bool empty() const {
        return buffer[0] == '\0';
    }

    template <class T> int compare(const T &other) const {
        return strncmp(*this, other, MIN(capacity(), other.capacity()));
    }

    int compare(const char *other) const {
        return strncmp(*this, other, capacity());
    }

    String& operator=(const char *src) {
        _SYS_strlcpy(buffer, src, tCapacity);
        return *this;
    }

    String& operator+=(const char *src) {
        _SYS_strlcat(buffer, src, tCapacity);
        return *this;
    }

    char &operator[](unsigned index) {
        return buffer[index];
    }

    char &operator[](int index) {
        return buffer[index];
    }

    char operator[](unsigned index) const {
        return buffer[index];
    }

    char operator[](int index) const {
        return buffer[index];
    }

    String& operator<<(const char *src) {
        _SYS_strlcat(buffer, src, tCapacity);
        return *this;
    }

    String& operator<<(int src) {
        _SYS_strlcat_int(buffer, src, tCapacity);
        return *this;
    }

    String& operator<<(const Fixed &src) {
        _SYS_strlcat_int_fixed(buffer, src.value, src.width, src.leadingZeroes, tCapacity);
        return *this;
    }

    String& operator<<(const FixedFP &src) {
        _SYS_strlcat_int_fixed(buffer, src.valueL, src.widthL, src.leadingZeroes, tCapacity);
        _SYS_strlcat(buffer, ".", tCapacity);
        _SYS_strlcat_int_fixed(buffer, src.valueR, src.widthR, true, tCapacity);
        return *this;
    }

    String& operator<<(const Hex &src) {
        _SYS_strlcat_int_hex(buffer, src.value, src.width, src.leadingZeroes, tCapacity);
        return *this;
    }

    String& operator<<(const Hex64 &src) {
        uint32_t high = src.value >> 32;
        uint32_t low = src.value;
        if (src.width > 8 || high != 0) {
            _SYS_strlcat_int_hex(buffer, high, src.width - 8, src.leadingZeroes, tCapacity);
            _SYS_strlcat_int_hex(buffer, low, 8, true, tCapacity);
        } else {
            _SYS_strlcat_int_hex(buffer, low, src.width, src.leadingZeroes, tCapacity);
        }
        return *this;
    }

    template <typename T> bool operator==(const T &other) {
        return compare(other) == 0;
    }

    template <typename T> bool operator!=(const T &other) {
        return compare(other) != 0;
    }

    template <typename T> bool operator<(const T &other) {
        return compare(other) < 0;
    }

    template <typename T> bool operator<=(const T &other) {
        return compare(other) <= 0;
    }

    template <typename T> bool operator>(const T &other) {
        return compare(other) > 0;
    }

    template <typename T> bool operator>=(const T &other) {
        return compare(other) >= 0;
    }

private:
    char buffer[tCapacity];
};

};  // namespace Sifteo