Return to subrs.c CVS log

Up to [Apple XNU] / XNU / osfmk / device

Annotation of XNU/osfmk/device/subrs.c, revision 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: /*
        !            23:  * @OSF_COPYRIGHT@
        !            24:  */
        !            25: /*
        !            26:  *(C)UNIX System Laboratories, Inc. all or some portions of this file are
        !            27:  *derived from material licensed to the University of California by
        !            28:  *American Telephone and Telegraph Co. or UNIX System Laboratories,
        !            29:  *Inc. and are reproduced herein with the permission of UNIX System
        !            30:  *Laboratories, Inc.
        !            31:  */
        !            32: 
        !            33: /* 
        !            34:  * Mach Operating System
        !            35:  * Copyright (c) 1993,1991,1990,1989,1988 Carnegie Mellon University
        !            36:  * All Rights Reserved.
        !            37:  * 
        !            38:  * Permission to use, copy, modify and distribute this software and its
        !            39:  * documentation is hereby granted, provided that both the copyright
        !            40:  * notice and this permission notice appear in all copies of the
        !            41:  * software, derivative works or modified versions, and any portions
        !            42:  * thereof, and that both notices appear in supporting documentation.
        !            43:  * 
        !            44:  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
        !            45:  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
        !            46:  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
        !            47:  * 
        !            48:  * Carnegie Mellon requests users of this software to return to
        !            49:  * 
        !            50:  *  Software Distribution Coordinator  or  [email protected]
        !            51:  *  School of Computer Science
        !            52:  *  Carnegie Mellon University
        !            53:  *  Pittsburgh PA 15213-3890
        !            54:  * 
        !            55:  * any improvements or extensions that they make and grant Carnegie Mellon
        !            56:  * the rights to redistribute these changes.
        !            57:  */
        !            58: /*
        !            59:  */
        !            60: /*
        !            61:  * Copyright (c) 1988 Regents of the University of California.
        !            62:  * All rights reserved.
        !            63:  *
        !            64:  * Redistribution and use in source and binary forms, with or without
        !            65:  * modification, are permitted provided that the following conditions
        !            66:  * are met:
        !            67:  * 1. Redistributions of source code must retain the above copyright
        !            68:  *    notice, this list of conditions and the following disclaimer.
        !            69:  * 2. Redistributions in binary form must reproduce the above copyright
        !            70:  *    notice, this list of conditions and the following disclaimer in the
        !            71:  *    documentation and/or other materials provided with the distribution.
        !            72:  * 3. All advertising materials mentioning features or use of this software
        !            73:  *    must display the following acknowledgement:
        !            74:  *     This product includes software developed by the University of
        !            75:  *     California, Berkeley and its contributors.
        !            76:  * 4. Neither the name of the University nor the names of its contributors
        !            77:  *    may be used to endorse or promote products derived from this software
        !            78:  *    without specific prior written permission.
        !            79:  *
        !            80:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
        !            81:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        !            82:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
        !            83:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
        !            84:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
        !            85:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
        !            86:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
        !            87:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
        !            88:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
        !            89:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
        !            90:  * SUCH DAMAGE.
        !            91:  */
        !            92: /*
        !            93:  * Random device subroutines and stubs.
        !            94:  */
        !            95: 
        !            96: #include <vm/vm_kern.h>
        !            97: #include <kern/misc_protos.h>
        !            98: 
        !            99: /* String routines, from CMU */
        !           100: #ifdef strcpy
        !           101: #undef strcmp
        !           102: #undef strncmp
        !           103: #undef strcpy
        !           104: #undef strncpy
        !           105: #undef strlen
        !           106: #endif
        !           107: 
        !           108: /*
        !           109:  * Abstract:
        !           110:  *      strcmp (s1, s2) compares the strings "s1" and "s2".
        !           111:  *      It returns 0 if the strings are identical. It returns
        !           112:  *      > 0 if the first character that differs in the two strings
        !           113:  *      is larger in s1 than in s2 or if s1 is longer than s2 and
        !           114:  *      the contents are identical up to the length of s2.
        !           115:  *      It returns < 0 if the first differing character is smaller
        !           116:  *      in s1 than in s2 or if s1 is shorter than s2 and the
        !           117:  *      contents are identical upto the length of s1.
        !           118:  */
        !           119: 
        !           120: int
        !           121: strcmp(
        !           122:         register const char *s1,
        !           123:         register const char *s2)
        !           124: {
        !           125:         register unsigned int a, b;
        !           126: 
        !           127:         do {
        !           128:                 a = *s1++;
        !           129:                 b = *s2++;
        !           130:                 if (a != b)
        !           131:                         return a-b;     /* includes case when
        !           132:                                            'a' is zero and 'b' is not zero
        !           133:                                            or vice versa */
        !           134:        } while (a != '\0');
        !           135: 
        !           136:         return 0;       /* both are zero */
        !           137: }
        !           138: 
        !           139: /*
        !           140:  * Abstract:
        !           141:  *      strncmp (s1, s2, n) compares the strings "s1" and "s2"
        !           142:  *      in exactly the same way as strcmp does.  Except the
        !           143:  *      comparison runs for at most "n" characters.
        !           144:  */
        !           145: 
        !           146: int
        !           147: strncmp(
        !           148:         register const char *s1,
        !           149:         register const char *s2,
        !           150:         size_t n)
        !           151: {
        !           152:         register unsigned int a, b;
        !           153: 
        !           154:         while (n != 0) {
        !           155:                 a = *s1++;
        !           156:                 b = *s2++;
        !           157:                 if (a != b)
        !           158:                         return a-b;     /* includes case when
        !           159:                                            'a' is zero and 'b' is not zero
        !           160:                                            or vice versa */
        !           161:                 if (a == '\0')
        !           162:                         return 0;       /* both are zero */
        !           163:                 n--;
        !           164:        }
        !           165: 
        !           166:         return 0;
        !           167: }
        !           168: 
        !           169: /*
        !           170:  * Abstract:
        !           171:  *      strcpy copies the contents of the string "from" including
        !           172:  *      the null terminator to the string "to". A pointer to "to"
        !           173:  *      is returned.
        !           174:  */
        !           175: 
        !           176: char *
        !           177: strcpy(
        !           178:         register char *to,
        !           179:         register const char *from)
        !           180: {
        !           181:         register char *ret = to;
        !           182: 
        !           183:         while ((*to++ = *from++) != '\0')
        !           184:                 continue;
        !           185: 
        !           186:         return ret;
        !           187: }
        !           188: 
        !           189: 
        !           190: /*
        !           191:  * Abstract:
        !           192:  *      strncpy copies "count" characters from the "from" string to
        !           193:  *      the "to" string. If "from" contains less than "count" characters
        !           194:  *      "to" will be padded with null characters until exactly "count"
        !           195:  *      characters have been written. The return value is a pointer
        !           196:  *      to the "to" string.
        !           197:  */
        !           198: 
        !           199: char *
        !           200: strncpy(
        !           201:        char *s1, 
        !           202:        const char *s2,
        !           203:        size_t n)
        !           204: {
        !           205:         char *os1 = s1;
        !           206:         unsigned long i;
        !           207: 
        !           208:         for (i = 0; i < n;)
        !           209:                 if ((*s1++ = *s2++) == '\0')
        !           210:                         for (i++; i < n; i++)
        !           211:                                 *s1++ = '\0';
        !           212:                 else
        !           213:                         i++;
        !           214:         return (os1);
        !           215: }
        !           216: 
        !           217: 
        !           218: #if !defined(__alpha)
        !           219: 
        !           220: /*
        !           221:  * Abstract:
        !           222:  *      strlen returns the number of characters in "string" preceeding
        !           223:  *      the terminating null character.
        !           224:  */
        !           225: 
        !           226: size_t
        !           227: strlen(
        !           228:         register const char *string)
        !           229: {
        !           230:         register const char *ret = string;
        !           231: 
        !           232:         while (*string++ != '\0')
        !           233:                 continue;
        !           234:         return string - 1 - ret;
        !           235: }
        !           236: #endif /* !defined(__alpha) */
        !           237: 
        !           238: /*
        !           239:  * atoi:
        !           240:  *
        !           241:  *      This function converts an ascii string into an integer.
        !           242:  *
        !           243:  * input        : string
        !           244:  * output       : a number
        !           245:  */
        !           246: 
        !           247: int
        !           248: atoi(
        !           249:        u_char  *cp)
        !           250: {
        !           251:         int     number;
        !           252: 
        !           253:         for (number = 0; ('0' <= *cp) && (*cp <= '9'); cp++)
        !           254:                 number = (number * 10) + (*cp - '0');
        !           255: 
        !           256:         return( number );
        !           257: }
        !           258: 
        !           259: /*
        !           260:  * convert an ASCII string (decimal radix) to an integer
        !           261:  * inputs:
        !           262:  *     p       string pointer.
        !           263:  *     t       char **, return a pointer to the cahr which terminates the
        !           264:  *             numeric string.
        !           265:  * returns:
        !           266:  *     integer value of the numeric string.
        !           267:  * side effect:
        !           268:  *     pointer to terminating char.
        !           269:  */
        !           270: 
        !           271: int
        !           272: atoi_term(
        !           273:        char    *p,     /* IN */
        !           274:        char    **t)    /* OUT */
        !           275: {
        !           276:         register int n;
        !           277:         register int f;
        !           278: 
        !           279:         n = 0;
        !           280:         f = 0;
        !           281:         for(;;p++) {
        !           282:                 switch(*p) {
        !           283:                 case ' ':
        !           284:                 case '\t':
        !           285:                         continue;
        !           286:                 case '-':
        !           287:                         f++;
        !           288:                 case '+':
        !           289:                         p++;
        !           290:                 }
        !           291:                 break;
        !           292:         }
        !           293:         while(*p >= '0' && *p <= '9')
        !           294:                 n = n*10 + *p++ - '0';
        !           295: 
        !           296:         /* return pointer to terminating character */
        !           297:         if ( t )
        !           298:                 *t = p;
        !           299: 
        !           300:         return(f? -n: n);
        !           301: }
        !           302: 
        !           303: /*
        !           304:  * convert an integer to an ASCII string.
        !           305:  * inputs:
        !           306:  *     num     integer to be converted
        !           307:  *     str     string pointer.
        !           308:  *
        !           309:  * outputs:
        !           310:  *     pointer to string start.
        !           311:  */
        !           312: 
        !           313: char *
        !           314: itoa(
        !           315:        int     num,
        !           316:        char    *str)
        !           317: {
        !           318:         char    digits[11];
        !           319:         register char *dp;
        !           320:         register char *cp = str;
        !           321: 
        !           322:         if (num == 0) {
        !           323:             *cp++ = '0';
        !           324:         }
        !           325:         else {
        !           326:             dp = digits;
        !           327:             while (num) {
        !           328:                 *dp++ = '0' + num % 10;
        !           329:                 num /= 10;
        !           330:             }
        !           331:             while (dp != digits) {
        !           332:                 *cp++ = *--dp;
        !           333:             }
        !           334:         }
        !           335:         *cp++ = '\0';
        !           336: 
        !           337:        return str;
        !           338: }
        !           339: 
        !           340: char *
        !           341: strcat(
        !           342:        register char *dest,
        !           343:        register const char *src)
        !           344: {
        !           345:        char *old = dest;
        !           346: 
        !           347:        while (*dest)
        !           348:                ++dest;
        !           349:        while (*dest++ = *src++)
        !           350:                ;
        !           351:        return (old);
        !           352: }
        !           353: 

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