Open Menu / mach_o / Version32.cpp
Loading...
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
/*
 * Copyright (c) 2017 Apple Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_LICENSE_HEADER_END@
 */

#include <stdint.h>
#include <string.h>
#include <assert.h>
#include <charconv>

#include "Version32.h"

namespace mach_o {


Error Version32::fromString(std::string_view versString, Version32& vers,
                            void (^ _Nullable truncationHandler)(void))
{
    // Initialize default value
    vers = Version32();

    uint32_t x = 0;
    uint32_t y = 0;
    uint32_t z = 0;
    const char* endPtr = versString.data() + versString.size();
    auto res = std::from_chars(versString.data(), endPtr, x);
    if ( res.ec == std::errc{} && *res.ptr == '.' ) {
        res = std::from_chars(res.ptr + 1, endPtr, y);
        if ( res.ec == std::errc{} && *res.ptr == '.' )
            res = std::from_chars(res.ptr + 1, endPtr, z);
    }
    bool valueOverflow = (x > 0xffff) || (y > 0xff) || (z > 0xff);
    if ( valueOverflow && truncationHandler ) {
        truncationHandler();
        x = std::min(x, 0xFFFFU);
        y = std::min(y, 0xFFU);
        z = std::min(z, 0xFFU);
        valueOverflow = false;
    }
    if ( res.ptr == nullptr || res.ptr != endPtr || valueOverflow ) {
        if ( valueOverflow || (truncationHandler == nullptr) || (res.ptr == versString.data()) ) {
            char errVersString[versString.size() + 1];
            memcpy(errVersString, versString.data(), versString.size());
            errVersString[versString.size()] = 0;
            return Error("malformed version number '%s' cannot fit in 32-bit xxxx.yy.zz", (const char*)errVersString);
        }
    }

    vers = Version32(x, y, z);
    return Error::none();
}


static void appendDigit(char*& s, unsigned& num, unsigned place, bool& startedPrinting)
{
    if ( num >= place ) {
        unsigned dig = (num/place);
        *s++ = '0' + dig;
        num -= (dig*place);
        startedPrinting = true;
    }
    else if ( startedPrinting ) {
        *s++ = '0';
    }
}

static void appendNumber(char*& s, unsigned num)
{
    assert(num < 99999);
    bool startedPrinting = false;
    appendDigit(s, num, 10000, startedPrinting);
    appendDigit(s, num,  1000, startedPrinting);
    appendDigit(s, num,   100, startedPrinting);
    appendDigit(s, num,    10, startedPrinting);
    appendDigit(s, num,     1, startedPrinting);
    if ( !startedPrinting )
        *s++ = '0';
}


const char* Version32::toString(char buffer[32]) const
{
    // sprintf(versionString, "%d.%d.%d", (_raw >> 16), ((_raw >> 8) & 0xFF), (_raw & 0xFF));
    char* s = buffer;
    appendNumber(s, (_raw >> 16));
    *s++ = '.';
    appendNumber(s, (_raw >> 8) & 0xFF);
    unsigned micro = (_raw & 0xFF);
    if ( micro != 0 ) {
        *s++ = '.';
        appendNumber(s, micro);
    }
    *s++ = '\0';
    return buffer;
}



} // namespace mach_o