diff --git a/arch/x86/include/asm/limits.h b/arch/x86/include/asm/limits.h new file mode 100644 index 00000000..cd3f9442 --- /dev/null +++ b/arch/x86/include/asm/limits.h @@ -0,0 +1,55 @@ +/* + * Copyright 2011 Stefan Lankes, Chair for Operating Systems, + * RWTH Aachen University + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * This file is part of MetalSVM. + */ + +#ifndef __ARCH_LIMITS_H__ +#define __ARCH_LIMITS_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#define CHAR_BIT 8 /* number of bits in a char */ + +#define SCHAR_MAX 0x7f /* max value for a signed char */ +#define SCHAR_MIN (-0x7f - 1) /* min value for a signed char */ + +#define UCHAR_MAX 0xff /* max value for an unsigned char */ + +#define USHRT_MAX 0xffff /* max value for an unsigned short */ +#define SHRT_MAX 0x7fff /* max value for a short */ +#define SHRT_MIN (-0x7fff - 1) /* min value for a short */ + +#define UINT_MAX 0xffffffffU /* max value for an unsigned int */ +#define INT_MAX 0x7fffffff /* max value for an int */ +#define INT_MIN (-0x7fffffff - 1) /* min value for an int */ + +#define ULONG_MAX 0xffffffffUL /* max value for an unsigned long */ +#define LONG_MAX 0x7fffffffL /* max value for a long */ +#define LONG_MIN (-0x7fffffffL - 1) /* min value for a long */ + + /* max value for an unsigned long long */ +#define ULLONG_MAX 0xffffffffffffffffULL +#define LLONG_MAX 0x7fffffffffffffffLL /* max value for a long long */ +#define LLONG_MIN (-0x7fffffffffffffffLL - 1) /* min for a long long */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/metalsvm/config.h.example b/include/metalsvm/config.h.example index 908fcb39..5c8edf11 100644 --- a/include/metalsvm/config.h.example +++ b/include/metalsvm/config.h.example @@ -60,9 +60,6 @@ extern "C" { #define NORETURN __attribute__((noreturn)) #define STDCALL __attribute__((stdcall)) -#define ULONG_MAX 0xffffffff -#define USHRT_MAX 0xffff - #define HAVE_ARCH_MEMSET #define HAVE_ARCH_MEMCPY #define HAVE_ARCH_STRLEN diff --git a/include/metalsvm/ctype.h b/include/metalsvm/ctype.h new file mode 100644 index 00000000..463b8414 --- /dev/null +++ b/include/metalsvm/ctype.h @@ -0,0 +1,107 @@ +/**************************************************************************************** + * + * Author: Stefan Lankes + * Chair for Operating Systems, RWTH Aachen University + * Date: 24/03/2011 + * + **************************************************************************************** + * + * Written by the Chair for Operating Systems, RWTH Aachen University + * + * NO Copyright (C) 2010, Stefan Lankes, + * consider these trivial functions to be public domain. + * + * These functions are distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + */ + +#ifndef __CTYPE_H_ +#define __CYTPE_H_ + +static inline int isascii(int c) +{ + return (((unsigned char)(c))<=0x7f); +} + +static inline int toascii(c) +{ + return (((unsigned char)(c))&0x7f); +} + +static inline int isspace(int c) +{ + if (!isascii(c)) + return 0; + + if (' ' == (unsigned char) c) + return 1; + if ('\n' == (unsigned char) c) + return 1; + if ('\r' == (unsigned char) c) + return 1; + if ('\t' == (unsigned char) c) + return 1; + if ('\v' == (unsigned char) c) + return 1; + if ('\f' == (unsigned char) c) + return 1; + + return 0; +} + +static inline int isdigit(int c) +{ + if (!isascii(c)) + return 0; + + if (((unsigned char) c >= '0') && ((unsigned char) c <= '9')) + return 1; + + return 0; +} + +static inline int islower(int c) +{ + if (!isascii(c)) + return 0; + + if (((unsigned char) c >= 'a') && ((unsigned char) c <= 'z')) + return 1; + + return 0; +} + +static inline int isupper(int c) +{ + if (!isascii(c)) + return 0; + + if (((unsigned char) c >= 'A') && ((unsigned char) c <= 'Z')) + return 1; + + return 0; +} + +static inline int isalpha(int c) +{ + if (isupper(c) || islower(c)) + return 1; + + return 0; +} + +static inline unsigned char tolower(unsigned char c) +{ + if (isupper(c)) + c -= 'A'-'a'; + return c; +} + +static inline unsigned char toupper(unsigned char c) +{ + if (islower(c)) + c -= 'a'-'A'; + return c; +} + +#endif diff --git a/include/metalsvm/stdlib.h b/include/metalsvm/stdlib.h index d04bc9aa..883818b6 100644 --- a/include/metalsvm/stdlib.h +++ b/include/metalsvm/stdlib.h @@ -42,6 +42,13 @@ void* kmalloc(size_t); void* mem_allocation(size_t sz, uint32_t flags); void kfree(void*, size_t); +long strtol(const char* str, char** endptr, int base); + +static inline int atoi(const char *str) +{ + return (int)strtol(str, (char **)NULL, 10); +} + #ifdef __cplusplus } #endif diff --git a/libkern/Makefile b/libkern/Makefile index b302f3e7..ee3a0588 100644 --- a/libkern/Makefile +++ b/libkern/Makefile @@ -1,4 +1,4 @@ -C_source := string.c stdio.c printf.c sprintf.c qdivrem.c udivdi3.c umoddi3.c +C_source := string.c stdio.c printf.c sprintf.c qdivrem.c udivdi3.c umoddi3.c strtol.c MODULE := libkern include $(TOPDIR)/Makefile.inc diff --git a/libkern/qdivrem.c b/libkern/qdivrem.c index 470252dd..8a1b6877 100644 --- a/libkern/qdivrem.c +++ b/libkern/qdivrem.c @@ -44,6 +44,7 @@ /* MetalSVM prelude */ #include +#include typedef uint64_t u_quad_t; typedef int64_t quad_t; diff --git a/libkern/strtol.c b/libkern/strtol.c new file mode 100644 index 00000000..af2115eb --- /dev/null +++ b/libkern/strtol.c @@ -0,0 +1,139 @@ +/*- + * Copyright (c) 1990, 1993 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * From: @(#)strtol.c 8.1 (Berkeley) 6/4/93 + */ + +/* + * The code has been taken from FreeBSD (sys/libkern/qdivrem.c) and is therefore + * BSD-licensed. Unnecessary functions have been removed and all typedefs required + * have been added. + */ + +/* + * The code has been taken from FreeBSD (sys/libkern/qdivrem.c) and is therefore + * BSD-licensed. Unnecessary functions have been removed and all typedefs required + * have been added. + */ + +/* MetalSVM prelude */ +#include +#include +#include + +/* + * Convert a string to a long integer. + * + * Ignores `locale' stuff. Assumes that the upper and lower case + * alphabets and digits are each contiguous. + */ +long +strtol(nptr, endptr, base) + const char *nptr; + char **endptr; + int base; +{ + const char *s = nptr; + unsigned long acc; + unsigned char c; + unsigned long cutoff; + int neg = 0, any, cutlim; + + /* + * Skip white space and pick up leading +/- sign if any. + * If base is 0, allow 0x for hex and 0 for octal, else + * assume decimal; if base is already 16, allow 0x. + */ + do { + c = *s++; + } while (isspace(c)); + if (c == '-') { + neg = 1; + c = *s++; + } else if (c == '+') + c = *s++; + if ((base == 0 || base == 16) && + c == '0' && (*s == 'x' || *s == 'X')) { + c = s[1]; + s += 2; + base = 16; + } + if (base == 0) + base = c == '0' ? 8 : 10; + + /* + * Compute the cutoff value between legal numbers and illegal + * numbers. That is the largest legal value, divided by the + * base. An input number that is greater than this value, if + * followed by a legal input character, is too big. One that + * is equal to this value may be valid or not; the limit + * between valid and invalid numbers is then based on the last + * digit. For instance, if the range for longs is + * [-2147483648..2147483647] and the input base is 10, + * cutoff will be set to 214748364 and cutlim to either + * 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated + * a value > 214748364, or equal but the next digit is > 7 (or 8), + * the number is too big, and we will return a range error. + * + * Set any if any `digits' consumed; make it negative to indicate + * overflow. + */ + cutoff = neg ? -(unsigned long)LONG_MIN : LONG_MAX; + cutlim = cutoff % (unsigned long)base; + cutoff /= (unsigned long)base; + for (acc = 0, any = 0;; c = *s++) { + if (!isascii(c)) + break; + if (isdigit(c)) + c -= '0'; + else if (isalpha(c)) + c -= isupper(c) ? 'A' - 10 : 'a' - 10; + else + break; + if (c >= base) + break; + if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim)) + any = -1; + else { + any = 1; + acc *= base; + acc += c; + } + } + if (any < 0) { + acc = neg ? LONG_MIN : LONG_MAX; + } else if (neg) + acc = -acc; + if (endptr != 0) + *((const char **)endptr) = any ? s - 1 : nptr; + return (acc); +} +