X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=flower%2Flibc-extension.cc;h=fbb4b61652fe5094f32fee613f4d52f682cce5bf;hb=0b544cfb7332615ef809b71b57ab656741311ae1;hp=c786a51efe456b41bf4e4406293cdbc11ce8f0bc;hpb=1a66290a98e7de8d6d41485b5b71a9f7e1fe35c7;p=lilypond.git diff --git a/flower/libc-extension.cc b/flower/libc-extension.cc index c786a51efe..fbb4b61652 100644 --- a/flower/libc-extension.cc +++ b/flower/libc-extension.cc @@ -1,112 +1,176 @@ /* - libc-extension.cc -- compensate for lacking libc functions. + This file is part of LilyPond, the GNU music typesetter. + Copyright (C) 1997--2014 Han-Wen Nienhuys + Jan Nieuwenhuizen - source file of the flowerlib + LilyPond is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. - (c) 1997 Han-Wen Nienhuys + LilyPond is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with LilyPond. If not, see . */ -#include -#include -#include -#include "libc-extension.hh" +#include +#include +#include +#include +#include + +using namespace std; + +#include "libc-extension.hh" -char* -strnlwr (char* start_l ,int n) +char * +strnlwr (char *start, int n) { - char * p = start_l + n; - while ( --p >= start_l) { - *p = tolower (*p); /* a macro on some compilers */ + char *p = start + n; + while (--p >= start) + { + *p = (char)tolower (*p); /* a macro on some compilers */ } - return start_l; + return start; } -char* -strnupr (char* start_l, int n) +char * +strnupr (char *start, int n) { - char * p = start_l + n; - while ( --p >= start_l) { - *p = toupper (*p); /* a macro on some compilers */ + char *p = start + n; + while (--p >= start) + { + *p = (char)toupper (*p); /* a macro on some compilers */ } - return start_l; + return start; } #if !HAVE_MEMMEM /** locate a substring. #memmem# finds the first occurrence of - #needle# in #haystack# - */ + #needle# in #haystack#. This is not ANSI-C. -char * -memmem (Byte const * haystack, int haystack_len, - Byte const *needle,int needle_len) + The prototype is not in accordance with the Linux Programmer's + Manual v1.15, but it is with /usr/include/string.h */ + +unsigned char * +_memmem (unsigned char const *haystack, int haystack_len, + unsigned char const *needle, int needle_len) { - Byte const * end_haystack = haystack + haystack_len - needle_len; - Byte const * end_needle = needle + needle_len ; - - /* Ahhh ... Some minimal lowlevel stuff. This *is* nice; Varation - is the spice of life */ - while (haystack < end_haystack) { - Byte const *subneedle_l = needle; - Byte const *subhaystack_l = haystack; - while (subneedle_l < end_needle) { - if (*subneedle_l++ != *subhaystack_l++) - goto next; // yeah. I should be prosecuted. - } - - // completed the needle. Gotcha. - return (char*) haystack; - next: - haystack++; + unsigned char const *end_haystack = haystack + haystack_len - needle_len + 1; + unsigned char const *end_needle = needle + needle_len; + + /* Ahhh ... Some minimal lowlevel stuff. This *is* nice; Varation + is the spice of life */ + while (haystack < end_haystack) + { + unsigned char const *subneedle = needle; + unsigned char const *subhaystack = haystack; + while (subneedle < end_needle) + if (*subneedle++ != *subhaystack++) + goto next; + + /* Completed the needle. Gotcha. */ + return (unsigned char *) haystack; +next: + haystack++; } - return 0; + return 0; +} + +void * +memmem (void const *haystack, int haystack_len, + void const *needle, int needle_len) +{ + unsigned char const *haystack_byte_c = (unsigned char const *)haystack; + unsigned char const *needle_byte_c = (unsigned char const *)needle; + return _memmem (haystack_byte_c, haystack_len, needle_byte_c, needle_len); } + #endif -Byte * -memrchr (Byte const * p, int n, char c) +unsigned char * +memrchr (unsigned char const *p, int n, char c) { - const Byte * q = p+n; - while (q > p) { - if (*--q == c) - return (Byte*)q; + const unsigned char *q = p + n; + while (q > p) + { + if (*--q == c) + return (unsigned char *)q; } - return 0; + return 0; } - template inline void my_swap (T &t1, T &t2, T &tmp) { - tmp = t1; - t1 = t2; - t2 = tmp; + tmp = t1; + t1 = t2; + t2 = tmp; } -Byte* -strrev (Byte* byte_l, int length_i) +unsigned char * +memrev (unsigned char *byte, int length) { - Byte tmp_byte; - - Byte* left_l = byte_l; - Byte* right_l = byte_l + length_i; - - while ( right_l > left_l) { - my_swap (*right_l-- , *left_l++ , tmp_byte); - } - return byte_l; + unsigned char tmp_byte; + unsigned char *left = byte; + unsigned char *right = byte + length; + + while (right > left) + my_swap (*right--, *left++, tmp_byte); + return byte; } +/* + There are some strange problems with round() on early glibcs. +*/ +double +my_round (double x) +{ + return floor (x - 0.5) + 1.0; +} + +/* namespace std { */ + +#ifndef isinf +#if !HAVE_ISINF +int +isinf (double x) +{ + return x && (x == x / 2); +} +#endif +#endif + #if ! HAVE_SNPRINTF -int snprintf ( char *str, size_t, - char const *format, ...) +int +snprintf (char *str, size_t n, char const *format, ...) { - va_list ap; - va_start (ap, format); - int i = vsprintf (str, format, ap); - va_end (ap); - return i; + va_list ap; + va_start (ap, format); + int i = vsprintf (str, format, ap); + if (i > 0 && (unsigned) i > n) + assert (false); + va_end (ap); + return i; } #endif + +#if ! HAVE_VSNPRINTF +int +vsnprintf (char *str, size_t n, char const *format, va_list args) +{ + int i = vsprintf (str, format, args); + if (i > 0 && (unsigned) i > n) + assert (false); + return i; +} +#endif + +/* } namespace std */