Return to OSNumber.cpp CVS log

Up to [Apple XNU] / XNU / libkern / c++

Annotation of XNU/libkern/c++/OSNumber.cpp, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
                      3:  *
                      4:  * @APPLE_LICENSE_HEADER_START@
                      5:  * 
                      6:  * The contents of this file constitute Original Code as defined in and
                      7:  * are subject to the Apple Public Source License Version 1.1 (the
                      8:  * "License").  You may not use this file except in compliance with the
                      9:  * License.  Please obtain a copy of the License at
                     10:  * http://www.apple.com/publicsource and read it before using this file.
                     11:  * 
                     12:  * This Original Code and all software distributed under the License are
                     13:  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
                     14:  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
                     15:  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
                     16:  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
                     17:  * License for the specific language governing rights and limitations
                     18:  * under the License.
                     19:  * 
                     20:  * @APPLE_LICENSE_HEADER_END@
                     21:  */
                     22: /* IOOffset.m created by rsulack on Wed 17-Sep-1997 */
                     23: 
                     24: #include <libkern/c++/OSNumber.h>
                     25: #include <libkern/c++/OSString.h>
                     26: #include <libkern/c++/OSSerialize.h>
                     27: #include <libkern/c++/OSLib.h>
                     28: 
                     29: #define sizeMask ((1ULL << (size)) - 1)
                     30: 
                     31: #define super OSObject
                     32: 
                     33: OSDefineMetaClassAndStructors(OSNumber, OSObject)
                     34: 
                     35: bool OSNumber::init(unsigned long long inValue, unsigned int numberOfBits)
                     36: {
                     37:     if (!super::init())
                     38:         return false;
                     39: 
                     40:     size = numberOfBits;
                     41:     value = (inValue & sizeMask);
                     42: 
                     43:     return true;
                     44: }
                     45: 
                     46: bool OSNumber::init(const char *value, unsigned int numberOfBits)
                     47: {
                     48:     unsigned long long thisOffset;
                     49: 
                     50: #ifdef q_works
                     51:     sscanf(value, "%qi", thisOffset);
                     52: #else
                     53:     unsigned int smallOffset;
                     54: 
                     55:     sscanf(value, "%i", &smallOffset);
                     56:     thisOffset = smallOffset;
                     57: #endif
                     58: 
                     59:     return init(thisOffset, numberOfBits);
                     60: }
                     61: 
                     62: void OSNumber::free() { super::free(); }
                     63: 
                     64: OSNumber *OSNumber::withNumber(unsigned long long value,
                     65:                            unsigned int numberOfBits)
                     66: {
                     67:     OSNumber *me = new OSNumber;
                     68: 
                     69:     if (me && !me->init(value, numberOfBits)) {
                     70:         me->free();
                     71:         return 0;
                     72:     }
                     73: 
                     74:     return me;
                     75: }
                     76: 
                     77: OSNumber *OSNumber::withNumber(const char *value, unsigned int numberOfBits)
                     78: {
                     79:     OSNumber *me = new OSNumber;
                     80: 
                     81:     if (me && !me->init(value, numberOfBits)) {
                     82:         me->free();
                     83:         return 0;
                     84:     }
                     85: 
                     86:     return me;
                     87: }
                     88: 
                     89: unsigned int OSNumber::numberOfBits() const { return size; }
                     90: 
                     91: unsigned int OSNumber::numberOfBytes() const { return (size + 7) / 8; }
                     92: 
                     93: 
                     94: unsigned char OSNumber::unsigned8BitValue() const
                     95: {
                     96:     return (unsigned char) value;
                     97: }
                     98: 
                     99: unsigned short OSNumber::unsigned16BitValue() const
                    100: {
                    101:     return (unsigned short) value;
                    102: }
                    103: 
                    104: unsigned int OSNumber::unsigned32BitValue() const
                    105: {
                    106:     return (unsigned int) value;
                    107: }
                    108: 
                    109: unsigned long long OSNumber::unsigned64BitValue() const
                    110: {
                    111:     return value;
                    112: }
                    113: 
                    114: void OSNumber::addValue(signed long long inValue)
                    115: {
                    116:     value = ((value + inValue) & sizeMask);
                    117: }
                    118: 
                    119: void OSNumber::setValue(unsigned long long inValue)
                    120: {
                    121:     value = (inValue & sizeMask);
                    122: }
                    123: 
                    124: bool OSNumber::isEqualTo(const OSNumber *integer) const
                    125: {
                    126:     return((value == integer->value));
                    127: }
                    128: 
                    129: bool OSNumber::isEqualTo(const OSObject *obj) const
                    130: {
                    131:     OSNumber * offset;
                    132:     if ((offset = OSDynamicCast(OSNumber, (OSObject *)obj )))
                    133:        return isEqualTo(offset);
                    134:     else
                    135:        return false;
                    136: }
                    137: 
                    138: bool OSNumber::serialize(OSSerialize *s) const
                    139: {
                    140:     char temp[32];
                    141:     
                    142:     if (s->previouslySerialized(this)) return true;
                    143: 
                    144:     sprintf(temp, "integer size=\"%d\"", size); 
                    145:     if (!s->addXMLStartTag(this, temp)) return false;
                    146:     
                    147:     //XXX    sprintf(temp, "0x%qx", value);
                    148:     if ((value >> 32)) {
                    149:         sprintf(temp, "0x%lx%08lx", (unsigned long)(value >> 32),
                    150:                     (unsigned long)(value & 0xFFFFFFFF));
                    151:     } else { 
                    152:         sprintf(temp, "0x%lx", (unsigned long)value);
                    153:     }
                    154:     if (!s->addString(temp)) return false;
                    155: 
                    156:     return s->addXMLEndTag("integer");
                    157: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.