Changeset bc56f30 in mainline for uspace/lib/cpp/include


Ignore:
Timestamp:
2019-05-27T12:38:26Z (6 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
0d14c25
Parents:
4d51c60
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2019-02-13 16:06:49)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2019-05-27 12:38:26)
Message:

Make some libc and libposix headers usable in C++

These headers either get included from standard C++ headers,
or are standard themselves, which means any unnamespaced nonstandard
identifiers are a problem. This commit attempts to fix those
issues, and removes hacks previously used in libcpp to work around it.

Location:
uspace/lib/cpp/include
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/cpp/include/__bits/chrono.hpp

    r4d51c60 rbc56f30  
    611611            static time_point now()
    612612            {
    613                 hel::timespec ts{};
    614                 hel::getrealtime(&ts);
     613                ::std::timespec ts{};
     614                ::helenos::getrealtime(&ts);
    615615
    616616                rep time = NSEC2USEC(ts.tv_nsec);
    … …  
    654654            static time_point now()
    655655            {
    656                 hel::timespec ts{};
    657                 hel::getuptime(&ts);
     656                ::std::timespec ts{};
     657                ::helenos::getuptime(&ts);
    658658
    659659                rep time = NSEC2USEC(ts.tv_nsec);

  • uspace/lib/cpp/include/__bits/io/ios.hpp

    r4d51c60 rbc56f30  
    4141{
    4242    using streamoff = long long;
    43     using streamsize = hel::ssize_t;
     43    using streamsize = ::ssize_t;
    4444
    4545    /**

  • uspace/lib/cpp/include/__bits/limits.hpp

    r4d51c60 rbc56f30  
    528528            static constexpr unsigned short min()
    529529            {
    530                 return USHRT_MIN;
     530                return 0;
    531531            }
    532532
    … …  
    552552            static constexpr unsigned int min()
    553553            {
    554                 return UINT_MIN;
     554                return 0;
    555555            }
    556556
    … …  
    576576            static constexpr unsigned long min()
    577577            {
    578                 return ULONG_MIN;
     578                return 0;
    579579            }
    580580
    … …  
    600600            static constexpr unsigned long long min()
    601601            {
    602                 return ULLONG_MIN;
     602                return 0;
    603603            }
    604604

  • uspace/lib/cpp/include/__bits/locale/num_get.hpp

    r4d51c60 rbc56f30  
    301301                if (size > 0)
    302302                {
    303                     int ret{};
     303                    int olderrno{errno};
     304                    errno = EOK;
     305
    304306                    if constexpr (is_signed<BaseType>::value)
    305                         ret = std::hel::str_int64_t(base.buffer_, nullptr, num_base, false, &res);
    306                     else
    307                         ret = std::hel::str_uint64_t(base.buffer_, nullptr, num_base, false, &res);
    308 
    309                     if (ret != EOK)
    310                     {
     307                        res = ::strtoll(base.buffer_, nullptr, num_base);
     308                    else
     309                        res = ::strtoull(base.buffer_, nullptr, num_base);
     310
     311                    if (errno != EOK)
    311312                        err |= ios_base::failbit;
    312                         v = 0;
    313                     }
    314                     else if (res > static_cast<BaseType>(numeric_limits<T>::max()))
     313
     314                    errno = olderrno;
     315
     316                    if (res > static_cast<BaseType>(numeric_limits<T>::max()))
    315317                    {
    316318                        err |= ios_base::failbit;

  • uspace/lib/cpp/include/__bits/random.hpp

    r4d51c60 rbc56f30  
    10301030             *       something better.
    10311031             */
    1032             hel::srand(hel::time(nullptr));
     1032            ::srand(::time(nullptr));
    10331033        }
    10341034
    10351035        result_type operator()()
    10361036        {
    1037             return hel::rand();
     1037            return ::rand();
    10381038        }
    10391039

  • uspace/lib/cpp/include/__bits/string/string.hpp

    r4d51c60 rbc56f30  
    8282        static int compare(const char_type* s1, const char_type* s2, size_t n)
    8383        {
    84             return hel::str_lcmp(s1, s2, n);
     84            return ::strncmp(s1, s2, n);
    8585        }
    8686
    8787        static size_t length(const char_type* s)
    8888        {
    89             return hel::str_size(s);
     89            return ::strlen(s);
    9090        }
    9191
    … …  
    367367            // TODO: This function does not exits...
    368368            __unimplemented();
    369             //return hel::wstr_lcmp(s1, s2, n);
    370369            return 0;
    371370        }
    … …  
    373372        static size_t length(const char_type* s)
    374373        {
    375             return hel::wstr_size(s);
     374            size_t i = 0;
     375            while (s[i] != 0)
     376                i++;
     377            return i;
    376378        }
    377379

  • uspace/lib/cpp/include/__bits/thread/condition_variable.hpp

    r4d51c60 rbc56f30  
    3535namespace std
    3636{
    37     extern "C" {
    38         #include <fibril.h>
    39         #include <fibril_synch.h>
    40     }
    41 
    4237    enum class cv_status
    4338    {

  • uspace/lib/cpp/include/__bits/thread/threading.hpp

    r4d51c60 rbc56f30  
    3030#define LIBCPP_BITS_THREAD_THREADING
    3131
    32 namespace std::hel
    33 {
    34     extern "C" {
    35         #include <fibril.h>
    36         #include <fibril_synch.h>
    37     }
    38 }
    39 
    4032#include <chrono>
     33
     34#include <fibril.h>
     35#include <fibril_synch.h>
    4136
    4237namespace std::aux
    … …  
    5449    struct threading_policy<fibril_tag>
    5550    {
    56         using mutex_type        = hel::fibril_mutex_t;
    57         using thread_type       = hel::fid_t;
    58         using condvar_type      = hel::fibril_condvar_t;
    59         using time_unit         = hel::usec_t;
    60         using shared_mutex_type = hel::fibril_rwlock_t;
     51        using mutex_type        = ::helenos::fibril_mutex_t;
     52        using thread_type       = ::helenos::fid_t;
     53        using condvar_type      = ::helenos::fibril_condvar_t;
     54        using time_unit         = ::helenos::usec_t;
     55        using shared_mutex_type = ::helenos::fibril_rwlock_t;
    6156
    6257        struct thread
    … …  
    6560            static thread_type create(Callable clbl, Payload& pld)
    6661            {
    67                 return hel::fibril_create(clbl, (void*)&pld);
     62                return ::helenos::fibril_create(clbl, (void*)&pld);
    6863            }
    6964
    7065            static void start(thread_type thr)
    7166            {
    72                 hel::fibril_add_ready(thr);
     67                ::helenos::fibril_add_ready(thr);
    7368            }
    7469
    7570            static thread_type this_thread()
    7671            {
    77                 return hel::fibril_get_id();
     72                return ::helenos::fibril_get_id();
    7873            }
    7974
    8075            static void yield()
    8176            {
    82                 hel::fibril_yield();
     77                ::helenos::fibril_yield();
    8378            }
    8479
    … …  
    9489            static void init(mutex_type& mtx)
    9590            {
    96                 hel::fibril_mutex_initialize(&mtx);
     91                ::helenos::fibril_mutex_initialize(&mtx);
    9792            }
    9893
    9994            static void lock(mutex_type& mtx)
    10095            {
    101                 hel::fibril_mutex_lock(&mtx);
     96                ::helenos::fibril_mutex_lock(&mtx);
    10297            }
    10398
    10499            static void unlock(mutex_type& mtx)
    105100            {
    106                 hel::fibril_mutex_unlock(&mtx);
     101                ::helenos::fibril_mutex_unlock(&mtx);
    107102            }
    108103
    109104            static bool try_lock(mutex_type& mtx)
    110105            {
    111                 return hel::fibril_mutex_trylock(&mtx);
     106                return ::helenos::fibril_mutex_trylock(&mtx);
    112107            }
    113108
    … …  
    123118            static void init(condvar_type& cv)
    124119            {
    125                 hel::fibril_condvar_initialize(&cv);
     120                ::helenos::fibril_condvar_initialize(&cv);
    126121            }
    127122
    128123            static void wait(condvar_type& cv, mutex_type& mtx)
    129124            {
    130                 hel::fibril_condvar_wait(&cv, &mtx);
     125                ::helenos::fibril_condvar_wait(&cv, &mtx);
    131126            }
    132127
    133128            static int wait_for(condvar_type& cv, mutex_type& mtx, time_unit timeout)
    134129            {
    135                 return hel::fibril_condvar_wait_timeout(&cv, &mtx, timeout);
     130                return ::helenos::fibril_condvar_wait_timeout(&cv, &mtx, timeout);
    136131            }
    137132
    138133            static void signal(condvar_type& cv)
    139134            {
    140                 hel::fibril_condvar_signal(&cv);
     135                ::helenos::fibril_condvar_signal(&cv);
    141136            }
    142137
    143138            static void broadcast(condvar_type& cv)
    144139            {
    145                 hel::fibril_condvar_broadcast(&cv);
     140                ::helenos::fibril_condvar_broadcast(&cv);
    146141            }
    147142        };
    … …  
    157152            static void sleep(time_unit time)
    158153            {
    159                 hel::fibril_usleep(time);
     154                ::helenos::fibril_usleep(time);
    160155            }
    161156        };
    … …  
    165160            static void init(shared_mutex_type& mtx)
    166161            {
    167                 hel::fibril_rwlock_initialize(&mtx);
     162                ::helenos::fibril_rwlock_initialize(&mtx);
    168163            }
    169164
    170165            static void lock(shared_mutex_type& mtx)
    171166            {
    172                 hel::fibril_rwlock_write_lock(&mtx);
     167                ::helenos::fibril_rwlock_write_lock(&mtx);
    173168            }
    174169
    175170            static void unlock(shared_mutex_type& mtx)
    176171            {
    177                 hel::fibril_rwlock_write_unlock(&mtx);
     172                ::helenos::fibril_rwlock_write_unlock(&mtx);
    178173            }
    179174
    180175            static void lock_shared(shared_mutex_type& mtx)
    181176            {
    182                 hel::fibril_rwlock_read_lock(&mtx);
     177                ::helenos::fibril_rwlock_read_lock(&mtx);
    183178            }
    184179
    185180            static void unlock_shared(shared_mutex_type& mtx)
    186181            {
    187                 hel::fibril_rwlock_read_unlock(&mtx);
     182                ::helenos::fibril_rwlock_read_unlock(&mtx);
    188183            }
    189184

  • uspace/lib/cpp/include/cassert

    r4d51c60 rbc56f30  
    3030#define LIBCPP_CASSERT
    3131
    32 
    33 extern "C" {
    34     #include <assert.h>
    35 }
    36 
    37 // TODO: For some reason, this function isn't visible (maybe the
    38 //       noreturn attribute?), adding a redeclaration here for the
    39 //       time being.
    40 
    41 extern void __helenos_assert_abort(const char *, const char *, unsigned int);
     32#include <assert.h>
    4233
    4334#define __unimplemented() assert(!"Not implemented!")

  • uspace/lib/cpp/include/cctype

    r4d51c60 rbc56f30  
    3030#define LIBCPP_CCTYPE
    3131
    32 
    33 namespace std::hel
    34 {
    35     extern "C" {
    36         #include <ctype.h>
    37     }
    38 }
     32#include <ctype.h>
    3933
    4034namespace std
    4135{
    42     using std::hel::isalnum;
    43     using std::hel::isalpha;
    44     using std::hel::islower;
    45     using std::hel::isupper;
    46     using std::hel::isdigit;
    47     /* using std::hel::isxdigit; */
    48     /* using std::hel::iscntrl; */
    49     /* using std::hel::isgraph; */
    50     using std::hel::isspace;
    51     /* using std::hel::isblank; */
    52     /* using std::hel::isprint; */
    53     /* using std::hel::ispunct; */
    54     using std::hel::tolower;
    55     using std::hel::toupper;
     36    using ::isalnum;
     37    using ::isalpha;
     38    using ::islower;
     39    using ::isupper;
     40    using ::isdigit;
     41    using ::isxdigit;
     42    using ::iscntrl;
     43    using ::isgraph;
     44    using ::isspace;
     45    using ::isblank;
     46    using ::isprint;
     47    using ::ispunct;
     48    using ::tolower;
     49    using ::toupper;
    5650}
    5751

  • uspace/lib/cpp/include/cerrno

    r4d51c60 rbc56f30  
    3030#define LIBCPP_CERRNO
    3131
    32 
    33 namespace std::hel
    34 {
    35     extern "C" {
    36         #include <errno.h>
    37     }
    38 }
    39 
    40 namespace std
    41 {
    42     // Note: Only macros are imported here.
    43 }
     32#include <errno.h>
    4433
    4534#endif

  • uspace/lib/cpp/include/cinttypes

    r4d51c60 rbc56f30  
    3030#define LIBCPP_CINTTYPES
    3131
    32 
    33 namespace std::hel
    34 {
    35     extern "C" {
    36         #include <inttypes.h>
    37     }
    38 }
     32#include <cstdint>
     33#include <inttypes.h>
    3934
    4035namespace std
    4136{
    42     using std::hel::imaxdiv_t;
    43     /* using std::hel::abs; */
    44     /* using std::hel::div; */
    45     /* using std::hel::imaxabs; */
    46     /* using std::hel::imaxdiv; */
    47     /* using std::hel::strtoimax; */
    48     /* using std::hel::strtoumax; */
    49     /* using std::hel::wcstoimax; */
    50     /* using std::hel::wcstoumax; */
     37    using ::imaxdiv_t;
     38    using ::imaxabs;
     39    using ::imaxdiv;
     40    using ::strtoimax;
     41    using ::strtoumax;
     42    using ::wcstoimax;
     43    using ::wcstoumax;
    5144}
    5245
    53 using std::hel::imaxdiv_t;
    54 /* using std::hel::abs; */
    55 /* using std::hel::div; */
    56 /* using std::hel::imaxabs; */
    57 /* using std::hel::imaxdiv; */
    58 /* using std::hel::strtoimax; */
    59 /* using std::hel::strtoumax; */
    60 /* using std::hel::wcstoimax; */
    61 /* using std::hel::wcstoumax; */
    62 
    63 #include <cstdint>
    64 
    6546#endif

  • uspace/lib/cpp/include/climits

    r4d51c60 rbc56f30  
    3030#define LIBCPP_CLIMITS
    3131
    32 
    33 namespace std::hel
    34 {
    35     extern "C" {
    36         #include <limits.h>
    37     }
    38 }
    39 
    40 namespace std
    41 {
    42     // Note: Only macros imported here.
    43 }
     32#include <limits.h>
    4433
    4534#endif

  • uspace/lib/cpp/include/csetjmp

    r4d51c60 rbc56f30  
    3030#define LIBCPP_CSETJMP
    3131
    32 
    33 /**
    34  * TODO: Currently the <setjmp.h> header uses
    35  *       _Noreturn, which is not available in C++.
    36  */
    37 
    38 namespace std::hel
    39 {
    40     extern "C" {
    41         //#include <setjmp.h>
    42     }
    43 }
     32#include <setjmp.h>
    4433
    4534namespace std
    4635{
    47     /* using std::hel::jmp_buf; */
    48     /* using std::hel::longjmp; */
     36    using ::jmp_buf;
     37    using ::longjmp;
    4938}
    5039
    51 /* using std::hel::jmp_buf; */
    52 /* using std::hel::longjmp; */
    53 
    5440#endif

  • uspace/lib/cpp/include/cstdarg

    r4d51c60 rbc56f30  
    3030#define LIBCPP_CSTDARG
    3131
    32 
    33 namespace std::hel
    34 {
    35     extern "C" {
    36         #include <stdarg.h>
    37     }
    38 }
     32#include <stdarg.h>
    3933
    4034namespace std
    4135{
    42     using std::hel::va_list;
     36    using ::va_list;
    4337}
    4438
    45 using std::hel::va_list;
    46 
    4739#endif

  • uspace/lib/cpp/include/cstddef

    r4d51c60 rbc56f30  
    3030#define LIBCPP_CSTDDEF
    3131
    32 
    33 namespace std::hel
    34 {
    35     extern "C" {
    36         #include <stddef.h>
    37     }
    38 }
    39 
     32#include <stddef.h>
    4033
    4134namespace std
    4235{
    43     using nullptr_t = decltype(nullptr);
    44 
    45     using std::hel::size_t;
    46     using std::hel::ptrdiff_t;
    47     /* using std::hel::max_align_t; */
     36    using ::nullptr_t;
     37    using ::size_t;
     38    using ::ptrdiff_t;
     39    using ::max_align_t;
    4840}
    4941
    50 using std::nullptr_t;
    51 using std::hel::size_t;
    52 using std::hel::ptrdiff_t;
    53 /* using std::hel::max_align_t; */
    54 
    5542#endif

  • uspace/lib/cpp/include/cstdint

    r4d51c60 rbc56f30  
    3030#define LIBCPP_CSTDINT
    3131
    32 
    33 namespace std::hel
    34 {
    35     extern "C" {
    36         #include <stdint.h>
    37     }
    38 }
     32#include <stdint.h>
    3933
    4034namespace std
    4135{
    42     using int8_t  = std::hel::int8_t;
    43     using int16_t = std::hel::int16_t;
    44     using int32_t = std::hel::int32_t;
    45     using int64_t = std::hel::int64_t;
     36    using ::int8_t;
     37    using ::int16_t;
     38    using ::int32_t;
     39    using ::int64_t;
    4640
    47     using intmax_t = std::hel::intmax_t;
    48     using intptr_t = std::hel::intptr_t;
     41    using ::intmax_t;
     42    using ::intptr_t;
    4943
    50     using int_fast8_t  = std::hel::int_fast8_t;
    51     using int_fast16_t = std::hel::int_fast16_t;
    52     using int_fast32_t = std::hel::int_fast32_t;
    53     using int_fast64_t = std::hel::int_fast64_t;
     44    using ::int_fast8_t;
     45    using ::int_fast16_t;
     46    using ::int_fast32_t;
     47    using ::int_fast64_t;
    5448
    55     using int_least8_t  = std::hel::int_least8_t;
    56     using int_least16_t = std::hel::int_least16_t;
    57     using int_least32_t = std::hel::int_least32_t;
    58     using int_least64_t = std::hel::int_least64_t;
     49    using ::int_least8_t;
     50    using ::int_least16_t;
     51    using ::int_least32_t;
     52    using ::int_least64_t;
    5953
    60     using uint8_t  = std::hel::uint8_t;
    61     using uint16_t = std::hel::uint16_t;
    62     using uint32_t = std::hel::uint32_t;
    63     using uint64_t = std::hel::uint64_t;
     54    using ::uint8_t;
     55    using ::uint16_t;
     56    using ::uint32_t;
     57    using ::uint64_t;
    6458
    65     using uintmax_t = std::hel::uintmax_t;
    66     using uintptr_t = std::hel::uintptr_t;
     59    using ::uintmax_t;
     60    using ::uintptr_t;
    6761
    68     using uint_fast8_t  = std::hel::uint_fast8_t;
    69     using uint_fast16_t = std::hel::uint_fast16_t;
    70     using uint_fast32_t = std::hel::uint_fast32_t;
    71     using uint_fast64_t = std::hel::uint_fast64_t;
     62    using ::uint_fast8_t;
     63    using ::uint_fast16_t;
     64    using ::uint_fast32_t;
     65    using ::uint_fast64_t;
    7266
    73     using uint_least8_t  = std::hel::uint_least8_t;
    74     using uint_least16_t = std::hel::uint_least16_t;
    75     using uint_least32_t = std::hel::uint_least32_t;
    76     using uint_least64_t = std::hel::uint_least64_t;
     67    using ::uint_least8_t;
     68    using ::uint_least16_t;
     69    using ::uint_least32_t;
     70    using ::uint_least64_t;
    7771}
    7872
    79 using int8_t  = std::hel::int8_t;
    80 using int16_t = std::hel::int16_t;
    81 using int32_t = std::hel::int32_t;
    82 using int64_t = std::hel::int64_t;
    83 
    84 using intmax_t = std::hel::intmax_t;
    85 using intptr_t = std::hel::intptr_t;
    86 
    87 using int_fast8_t  = std::hel::int_fast8_t;
    88 using int_fast16_t = std::hel::int_fast16_t;
    89 using int_fast32_t = std::hel::int_fast32_t;
    90 using int_fast64_t = std::hel::int_fast64_t;
    91 
    92 using int_least8_t  = std::hel::int_least8_t;
    93 using int_least16_t = std::hel::int_least16_t;
    94 using int_least32_t = std::hel::int_least32_t;
    95 using int_least64_t = std::hel::int_least64_t;
    96 
    97 using uint8_t  = std::hel::uint8_t;
    98 using uint16_t = std::hel::uint16_t;
    99 using uint32_t = std::hel::uint32_t;
    100 using uint64_t = std::hel::uint64_t;
    101 
    102 using uintmax_t = std::hel::uintmax_t;
    103 using uintptr_t = std::hel::uintptr_t;
    104 
    105 using uint_fast8_t  = std::hel::uint_fast8_t;
    106 using uint_fast16_t = std::hel::uint_fast16_t;
    107 using uint_fast32_t = std::hel::uint_fast32_t;
    108 using uint_fast64_t = std::hel::uint_fast64_t;
    109 
    110 using uint_least8_t  = std::hel::uint_least8_t;
    111 using uint_least16_t = std::hel::uint_least16_t;
    112 using uint_least32_t = std::hel::uint_least32_t;
    113 using uint_least64_t = std::hel::uint_least64_t;
    114 
    11573#endif

  • uspace/lib/cpp/include/cstdio

    r4d51c60 rbc56f30  
    3030#define LIBCPP_CSTDIO
    3131
    32 
    33 namespace std::hel
    34 {
    35     extern "C" {
    36         #include <stdio.h>
    37     }
    38 }
     32#include <stdio.h>
    3933
    4034namespace std
    4135{
    42     using std::hel::FILE;
    43     using std::hel::stdin;
    44     using std::hel::stdout;
    45     using std::hel::stderr;
    46     /* using std::hel::fpos_t */
    47     using std::hel::size_t;
     36    using ::FILE;
     37    using ::stdin;
     38    using ::stdout;
     39    using ::stderr;
     40    using ::fpos_t;
     41    using ::size_t;
    4842
    49     using std::hel::clearerr;
    50     using std::hel::fclose;
    51     using std::hel::feof;
    52     using std::hel::ferror;
    53     using std::hel::fflush;
    54     using std::hel::fgetc;
    55     /* using std::hel::fgetpos; */
    56     using std::hel::fgets;
    57     using std::hel::fopen;
    58     using std::hel::fprintf;
    59     using std::hel::fputc;
    60     using std::hel::fputs;
    61     using std::hel::fread;
    62     using std::hel::freopen;
    63     /* using std::hel::fscanf; */
    64     using std::hel::fseek;
    65     /* using std::hel::fsetpos; */
    66     using std::hel::ftell;
    67     using std::hel::fwrite;
    68     /* using std::hel::getc; */
    69     using std::hel::getchar;
    70     /* using std::hel::perror; */
    71     using std::hel::printf;
    72     /* using std::hel::putc; */
    73     using std::hel::putchar;
    74     using std::hel::puts;
    75     using std::hel::remove;
    76     using std::hel::rename;
    77     using std::hel::rewind;
    78     /* using std::hel::scanf; */
    79     using std::hel::setbuf;
    80     using std::hel::setvbuf;
    81     using std::hel::snprintf;
    82     /* using std::hel::sprintf; */
    83     /* using std::hel::sscanf; */
    84     /* using std::hel::tmpfile; */
    85     /* using std::hel::tmpnam; */
    86     using std::hel::ungetc;
    87     using std::hel::vfprintf;
    88     using std::hel::vprintf;
    89     /* using std::hel::vscanf; */
    90     using std::hel::vsnprintf;
    91     /* using std::hel::vsprintf; */
    92     /* using std::hel::vsscanf; */
     43    using ::clearerr;
     44    using ::fclose;
     45    using ::feof;
     46    using ::ferror;
     47    using ::fflush;
     48    using ::fgetc;
     49    using ::fgetpos;
     50    using ::fgets;
     51    using ::fopen;
     52    using ::fprintf;
     53    using ::fputc;
     54    using ::fputs;
     55    using ::fread;
     56    using ::freopen;
     57    using ::fscanf;
     58    using ::fseek;
     59    using ::fsetpos;
     60    using ::ftell;
     61    using ::fwrite;
     62    using ::getc;
     63    using ::getchar;
     64    using ::perror;
     65    using ::printf;
     66    using ::putc;
     67    using ::putchar;
     68    using ::puts;
     69    using ::remove;
     70    using ::rename;
     71    using ::rewind;
     72    using ::scanf;
     73    using ::setbuf;
     74    using ::setvbuf;
     75    using ::snprintf;
     76    /* using ::sprintf; */
     77    /* using ::sscanf; */
     78    /* using ::tmpfile; */
     79    /* using ::tmpnam; */
     80    using ::ungetc;
     81    using ::vfprintf;
     82    using ::vprintf;
     83    /* using ::vscanf; */
     84    using ::vsnprintf;
     85    /* using ::vsprintf; */
     86    /* using ::vsscanf; */
    9387}
    9488
    95 using std::hel::FILE;
    96 /* using std::hel::fpos_t */
    97 using std::hel::size_t;
    98 
    99 using std::hel::clearerr;
    100 using std::hel::fclose;
    101 using std::hel::feof;
    102 using std::hel::ferror;
    103 using std::hel::fflush;
    104 using std::hel::fgetc;
    105 /* using std::hel::fgetpos; */
    106 using std::hel::fgets;
    107 using std::hel::fopen;
    108 using std::hel::fprintf;
    109 using std::hel::fputc;
    110 using std::hel::fputs;
    111 using std::hel::fread;
    112 using std::hel::freopen;
    113 /* using std::hel::fscanf; */
    114 using std::hel::fseek;
    115 /* using std::hel::fsetpos; */
    116 using std::hel::ftell;
    117 using std::hel::fwrite;
    118 /* using std::hel::getc; */
    119 using std::hel::getchar;
    120 /* using std::hel::perror; */
    121 using std::hel::printf;
    122 /* using std::hel::putc; */
    123 using std::hel::putchar;
    124 using std::hel::puts;
    125 using std::hel::remove;
    126 using std::hel::rename;
    127 using std::hel::rewind;
    128 /* using std::hel::scanf; */
    129 using std::hel::setbuf;
    130 using std::hel::setvbuf;
    131 using std::hel::snprintf;
    132 /* using std::hel::sprintf; */
    133 /* using std::hel::sscanf; */
    134 /* using std::hel::tmpfile; */
    135 /* using std::hel::tmpnam; */
    136 using std::hel::ungetc;
    137 using std::hel::vfprintf;
    138 using std::hel::vprintf;
    139 /* using std::hel::vscanf; */
    140 using std::hel::vsnprintf;
    141 /* using std::hel::vsprintf; */
    142 /* using std::hel::vsscanf; */
    143 
    14489#endif

  • uspace/lib/cpp/include/cstdlib

    r4d51c60 rbc56f30  
    3030#define LIBCPP_CSTDLIB
    3131
    32 
    33 namespace std::hel
    34 {
    35     extern "C" {
    36         #include <stdlib.h>
    37         #include <_bits/ssize_t.h>
    38     }
    39 }
     32#include <stdlib.h>
     33#include <_bits/ssize_t.h>
    4034
    4135namespace std
    4236{
    43     /* using std::hel::div_t; */
    44     /* using std::hel::ldiv_t; */
    45     /* using std::hel::lldiv_t; */
    46     using std::hel::size_t;
     37    /* using ::div_t; */
     38    /* using ::ldiv_t; */
     39    /* using ::lldiv_t; */
     40    using ::size_t;
    4741
    48     using std::hel::abort;
    49     using std::hel::exit;
    50     /* using std::hel::quick_exit; */
    51     /* using std::hel::_Exit; */
    52     using std::hel::atexit;
    53     /* using std::hel::at_quick_exit; */
    54     /* using std::hel::system; */
    55     /* using std::hel::getenv; */
     42    using ::abort;
     43    using ::exit;
     44    /* using ::quick_exit; */
     45    /* using ::_Exit; */
     46    using ::atexit;
     47    /* using ::at_quick_exit; */
     48    /* using ::system; */
     49    /* using ::getenv; */
    5650
    57     using std::hel::malloc;
    58     using std::hel::calloc;
    59     using std::hel::realloc;
    60     using std::hel::free;
     51    using ::malloc;
     52    using ::calloc;
     53    using ::realloc;
     54    using ::free;
    6155
    62     /* using std::hel::atof; */
    63     /* using std::hel::atoi; */
    64     /* using std::hel::atol; */
    65     /* using std::hel::atoll; */
    66     /* using std::hel::strtol; */
    67     /* using std::hel::strtoll; */
    68     /* using std::hel::strtoul; */
    69     /* using std::hel::strtoull; */
    70     /* using std::hel::strtof; */
    71     /* using std::hel::strtod; */
    72     /* using std::hel::strtold; */
     56    /* using ::atof; */
     57    /* using ::atoi; */
     58    /* using ::atol; */
     59    /* using ::atoll; */
     60    /* using ::strtol; */
     61    /* using ::strtoll; */
     62    /* using ::strtoul; */
     63    /* using ::strtoull; */
     64    /* using ::strtof; */
     65    /* using ::strtod; */
     66    /* using ::strtold; */
    7367
    74     /* using std::hel::mblen; */
    75     /* using std::hel::mbtowc; */
    76     /* using std::hel::wctomb; */
    77     /* using std::hel::mbstowcs; */
    78     /* using std::hel::wcstombs; */
     68    /* using ::mblen; */
     69    /* using ::mbtowc; */
     70    /* using ::wctomb; */
     71    /* using ::mbstowcs; */
     72    /* using ::wcstombs; */
    7973
    80     using std::hel::rand;
    81     using std::hel::srand;
    82     using std::hel::qsort;
    83     /* using std::hel::bsearch; */
    84     /* using std::hel::abs; */
    85     /* using std::hel::labs; */
    86     /* using std::hel::llabs; */
    87     /* using std::hel::div; */
    88     /* using std::hel::ldiv; */
    89     /* using std::hel::lldiv; */
     74    using ::rand;
     75    using ::srand;
     76    using ::qsort;
     77    /* using ::bsearch; */
     78    /* using ::abs; */
     79    /* using ::labs; */
     80    /* using ::llabs; */
     81    /* using ::div; */
     82    /* using ::ldiv; */
     83    /* using ::lldiv; */
    9084}
    9185
    92 /* using std::hel::div_t; */
    93 /* using std::hel::ldiv_t; */
    94 /* using std::hel::lldiv_t; */
    95 using std::hel::size_t;
    96 
    97 using std::hel::abort;
    98 using std::hel::exit;
    99 /* using std::hel::quick_exit; */
    100 /* using std::hel::_Exit; */
    101 using std::hel::atexit;
    102 /* using std::hel::at_quick_exit; */
    103 /* using std::hel::system; */
    104 /* using std::hel::getenv; */
    105 
    106 using std::hel::malloc;
    107 using std::hel::calloc;
    108 using std::hel::realloc;
    109 using std::hel::free;
    110 
    111 /* using std::hel::atof; */
    112 /* using std::hel::atoi; */
    113 /* using std::hel::atol; */
    114 /* using std::hel::atoll; */
    115 /* using std::hel::strtol; */
    116 /* using std::hel::strtoll; */
    117 /* using std::hel::strtoul; */
    118 /* using std::hel::strtoull; */
    119 /* using std::hel::strtof; */
    120 /* using std::hel::strtod; */
    121 /* using std::hel::strtold; */
    122 
    123 /* using std::hel::mblen; */
    124 /* using std::hel::mbtowc; */
    125 /* using std::hel::wctomb; */
    126 /* using std::hel::mbstowcs; */
    127 /* using std::hel::wcstombs; */
    128 
    129 using std::hel::rand;
    130 using std::hel::srand;
    131 using std::hel::qsort;
    132 /* using std::hel::bsearch; */
    133 /* using std::hel::abs; */
    134 /* using std::hel::labs; */
    135 /* using std::hel::llabs; */
    136 /* using std::hel::div; */
    137 /* using std::hel::ldiv; */
    138 /* using std::hel::lldiv; */
    139 
    14086#endif

  • uspace/lib/cpp/include/cstring

    r4d51c60 rbc56f30  
    3030#define LIBCPP_CSTRING
    3131
    32 
    33 namespace std::hel
    34 {
    35     extern "C" {
    36         #include <str.h>
    37     }
    38 }
     32#define _REALLY_WANT_STRING_H
     33#include <string.h>
    3934
    4035namespace std
    4136{
    42     using std::hel::size_t;
     37    using ::size_t;
    4338
    44     /* using std::hel::strcpy; */
    45     /* using std::hel::strncpy; */
    46     /* using std::hel::strcat; */
    47     /* using std::hel::strncat; */
    48     /* using std::hel::strxfrm; */
     39    using ::strcpy;
     40    using ::strncpy;
     41    using ::strcat;
     42    using ::strncat;
     43    using ::strxfrm;
    4944
    50     /* using std::hel::strlen; */
    51     /* using std::hel::strcmp; */
    52     /* using std::hel::strncmp; */
    53     /* using std::hel::strcoll; */
    54     /* using std::hel::strchr; */
    55     /* using std::hel::strrchr; */
    56     /* using std::hel::strspn; */
    57     /* using std::hel::strcspn; */
    58     /* using std::hel::strpbrk; */
    59     /* using std::hel::strstr; */
    60     /* using std::hel::strok; */
     45    using ::strlen;
     46    using ::strcmp;
     47    using ::strncmp;
     48    using ::strcoll;
     49    using ::strchr;
     50    using ::strrchr;
     51    using ::strspn;
     52    using ::strcspn;
     53    using ::strpbrk;
     54    using ::strstr;
     55    using ::strtok;
    6156
    62     /* using std::hel::memchr; */
    63     using std::hel::memcmp;
    64     using std::hel::memset;
    65     using std::hel::memcpy;
    66     using std::hel::memmove;
     57    using ::memchr;
     58    using ::memcmp;
     59    using ::memset;
     60    using ::memcpy;
     61    using ::memmove;
    6762
    68     /* using std::hel::strerror; */
     63    using ::strerror;
    6964}
    7065
    71 using std::hel::size_t;
    72 
    73 /* using std::hel::strcpy; */
    74 /* using std::hel::strncpy; */
    75 /* using std::hel::strcat; */
    76 /* using std::hel::strncat; */
    77 /* using std::hel::strxfrm; */
    78 
    79 /* using std::hel::strlen; */
    80 /* using std::hel::strcmp; */
    81 /* using std::hel::strncmp; */
    82 /* using std::hel::strcoll; */
    83 /* using std::hel::strchr; */
    84 /* using std::hel::strrchr; */
    85 /* using std::hel::strspn; */
    86 /* using std::hel::strcspn; */
    87 /* using std::hel::strpbrk; */
    88 /* using std::hel::strstr; */
    89 /* using std::hel::strok; */
    90 
    91 /* using std::hel::memchr; */
    92 using std::hel::memcmp;
    93 using std::hel::memset;
    94 using std::hel::memcpy;
    95 using std::hel::memmove;
    96 
    97 /* using std::hel::strerror; */
    98 
    9966#endif

  • uspace/lib/cpp/include/ctime

    r4d51c60 rbc56f30  
    3030#define LIBCPP_CTIME
    3131
    32 
    33 namespace std::hel
    34 {
    35     extern "C" {
    36         #include <time.h>
    37     }
    38 }
     32#include <time.h>
    3933
    4034namespace std
    4135{
    42     /* using std::hel::clock_t; */
    43     using std::hel::size_t;
    44     using std::hel::time_t;
    45     using std::hel::tm;
    46     /* using std::hel::timespec; */
     36    using ::clock_t;
     37    using ::size_t;
     38    using ::time_t;
     39    using ::tm;
     40    using ::timespec;
    4741
    48     /* using std::hel::clock; */
    49     using std::hel::time;
    50     using std::hel::difftime;
     42    using ::clock;
     43    using ::time;
     44    using ::difftime;
    5145
    52     /* using std::hel::ctime; */
    53     /* using std::hel::asctime; */
    54     using std::hel::strftime;
    55     /* using std::hel::wcsftime; */
    56     /* using std::hel::gmtime; */
    57     /* using std::hel::localtime; */
    58     using std::hel::mktime;
     46    using ::ctime;
     47    using ::asctime;
     48    using ::strftime;
     49    /* using ::wcsftime; */
     50    /* using ::gmtime; */
     51    /* using ::localtime; */
     52    using ::mktime;
    5953}
    6054
    61 /* using std::hel::clock_t; */
    62 using std::hel::size_t;
    63 using std::hel::time_t;
    64 using std::hel::tm;
    65 /* using std::hel::timespec; */
    66 
    67 /* using std::hel::clock; */
    68 using std::hel::time;
    69 using std::hel::difftime;
    70 
    71 /* using std::hel::ctime; */
    72 /* using std::hel::asctime; */
    73 using std::hel::strftime;
    74 /* using std::hel::wcsftime; */
    75 /* using std::hel::gmtime; */
    76 /* using std::hel::localtime; */
    77 using std::hel::mktime;
    78 
    7955#endif

  • uspace/lib/cpp/include/cwchar

    r4d51c60 rbc56f30  
    3030#define LIBCPP_WCHAR
    3131
    32 
    33 namespace std::hel
    34 {
    35     extern "C" {
    36         #include <wchar.h>
    37         #include <time.h>
    38     }
    39 }
     32#include <wchar.h>
     33#include <time.h>
    4034
    4135namespace std
    4236{
    43     /* using std::hel::mbstate_t; */
    44     using std::hel::size_t;
    45     using std::hel::wint_t;
    46     using std::hel::tm;
     37    /* using ::mbstate_t; */
     38    using ::size_t;
     39    using ::wint_t;
     40    using ::tm;
    4741
    48     /* using std::hel::wcscpy; */
    49     /* using std::hel::wcsncpy; */
    50     /* using std::hel::wcscat; */
    51     /* using std::hel::wcsncat; */
    52     /* using std::hel::wcsnxfrm; */
     42    /* using ::wcscpy; */
     43    /* using ::wcsncpy; */
     44    /* using ::wcscat; */
     45    /* using ::wcsncat; */
     46    /* using ::wcsnxfrm; */
    5347
    54     /* using std::hel::wcslen; */
    55     /* using std::hel::wcscmp; */
    56     /* using std::hel::wcsncmp; */
    57     /* using std::hel::wcscoll; */
    58     /* using std::hel::wcschr; */
    59     /* using std::hel::wcsrchr; */
    60     /* using std::hel::wcsspn; */
    61     /* using std::hel::wcscspn; */
    62     /* using std::hel::wcspbrk; */
    63     /* using std::hel::wcsstr; */
    64     /* using std::hel::wcstok; */
     48    /* using ::wcslen; */
     49    /* using ::wcscmp; */
     50    /* using ::wcsncmp; */
     51    /* using ::wcscoll; */
     52    /* using ::wcschr; */
     53    /* using ::wcsrchr; */
     54    /* using ::wcsspn; */
     55    /* using ::wcscspn; */
     56    /* using ::wcspbrk; */
     57    /* using ::wcsstr; */
     58    /* using ::wcstok; */
    6559
    66     /* using std::hel::wmemcpy; */
    67     /* using std::hel::wmemmove; */
    68     /* using std::hel::wmemcmp; */
    69     /* using std::hel::wmemchr; */
    70     /* using std::hel::wmemset; */
     60    /* using ::wmemcpy; */
     61    /* using ::wmemmove; */
     62    /* using ::wmemcmp; */
     63    /* using ::wmemchr; */
     64    /* using ::wmemset; */
    7165
    72     /* using std::hel::msbinit; */
    73     /* using std::hel::btowc; */
    74     /* using std::hel::wctob; */
    75     /* using std::hel::mbrlen; */
    76     /* using std::hel::mbrtowc; */
    77     /* using std::hel::wctomb; */
    78     /* using std::hel::mbsrtowcs; */
    79     /* using std::hel::wcsrtombs; */
     66    /* using ::msbinit; */
     67    /* using ::btowc; */
     68    /* using ::wctob; */
     69    /* using ::mbrlen; */
     70    /* using ::mbrtowc; */
     71    /* using ::wctomb; */
     72    /* using ::mbsrtowcs; */
     73    /* using ::wcsrtombs; */
    8074
    81     /* using std::hel::fgetwc; */
    82     /* using std::hel::getwc; */
    83     /* using std::hel::fgetws; */
    84     /* using std::hel::fputwc; */
    85     /* using std::hel::putwc; */
    86     /* using std::hel::fputws; */
    87     /* using std::hel::getwchar; */
    88     /* using std::hel::putwchar; */
    89     /* using std::hel::ungetwc; */
    90     /* using std::hel::fwide; */
    91     /* using std::hel::wscanf; */
    92     /* using std::hel::fwscanf; */
    93     /* using std::hel::swscanf; */
    94     /* using std::hel::vwscanf; */
    95     /* using std::hel::vfwscanf; */
    96     /* using std::hel::vswscanf; */
    97     /* using std::hel::wprintf; */
    98     /* using std::hel::fwprintf; */
    99     /* using std::hel::swprintf; */
     75    /* using ::fgetwc; */
     76    /* using ::getwc; */
     77    /* using ::fgetws; */
     78    /* using ::fputwc; */
     79    /* using ::putwc; */
     80    /* using ::fputws; */
     81    /* using ::getwchar; */
     82    /* using ::putwchar; */
     83    /* using ::ungetwc; */
     84    /* using ::fwide; */
     85    /* using ::wscanf; */
     86    /* using ::fwscanf; */
     87    /* using ::swscanf; */
     88    /* using ::vwscanf; */
     89    /* using ::vfwscanf; */
     90    /* using ::vswscanf; */
     91    /* using ::wprintf; */
     92    /* using ::fwprintf; */
     93    /* using ::swprintf; */
    10094
    101     /* using std::hel::wcsftime; */
    102     /* using std::hel::wcstol; */
    103     /* using std::hel::wcstoll; */
    104     /* using std::hel::wcstoul; */
    105     /* using std::hel::wcstoull; */
    106     /* using std::hel::wcstof; */
    107     /* using std::hel::wcstod; */
    108     /* using std::hel::wcstold; */
     95    /* using ::wcsftime; */
     96    /* using ::wcstol; */
     97    /* using ::wcstoll; */
     98    /* using ::wcstoul; */
     99    /* using ::wcstoull; */
     100    /* using ::wcstof; */
     101    /* using ::wcstod; */
     102    /* using ::wcstold; */
    109103}
    110104
    111 /* using std::hel::mbstate_t; */
    112 using std::hel::size_t;
    113 using std::hel::wint_t;
    114 using std::hel::tm;
    115 
    116 /* using std::hel::wcscpy; */
    117 /* using std::hel::wcsncpy; */
    118 /* using std::hel::wcscat; */
    119 /* using std::hel::wcsncat; */
    120 /* using std::hel::wcsnxfrm; */
    121 
    122 /* using std::hel::wcslen; */
    123 /* using std::hel::wcscmp; */
    124 /* using std::hel::wcsncmp; */
    125 /* using std::hel::wcscoll; */
    126 /* using std::hel::wcschr; */
    127 /* using std::hel::wcsrchr; */
    128 /* using std::hel::wcsspn; */
    129 /* using std::hel::wcscspn; */
    130 /* using std::hel::wcspbrk; */
    131 /* using std::hel::wcsstr; */
    132 /* using std::hel::wcstok; */
    133 
    134 /* using std::hel::wmemcpy; */
    135 /* using std::hel::wmemmove; */
    136 /* using std::hel::wmemcmp; */
    137 /* using std::hel::wmemchr; */
    138 /* using std::hel::wmemset; */
    139 
    140 /* using std::hel::msbinit; */
    141 /* using std::hel::btowc; */
    142 /* using std::hel::wctob; */
    143 /* using std::hel::mbrlen; */
    144 /* using std::hel::mbrtowc; */
    145 /* using std::hel::wctomb; */
    146 /* using std::hel::mbsrtowcs; */
    147 /* using std::hel::wcsrtombs; */
    148 
    149 /* using std::hel::fgetwc; */
    150 /* using std::hel::getwc; */
    151 /* using std::hel::fgetws; */
    152 /* using std::hel::fputwc; */
    153 /* using std::hel::putwc; */
    154 /* using std::hel::fputws; */
    155 /* using std::hel::getwchar; */
    156 /* using std::hel::putwchar; */
    157 /* using std::hel::ungetwc; */
    158 /* using std::hel::fwide; */
    159 /* using std::hel::wscanf; */
    160 /* using std::hel::fwscanf; */
    161 /* using std::hel::swscanf; */
    162 /* using std::hel::vwscanf; */
    163 /* using std::hel::vfwscanf; */
    164 /* using std::hel::vswscanf; */
    165 /* using std::hel::wprintf; */
    166 /* using std::hel::fwprintf; */
    167 /* using std::hel::swprintf; */
    168 
    169 /* using std::hel::wcsftime; */
    170 /* using std::hel::wcstol; */
    171 /* using std::hel::wcstoll; */
    172 /* using std::hel::wcstoul; */
    173 /* using std::hel::wcstoull; */
    174 /* using std::hel::wcstof; */
    175 /* using std::hel::wcstod; */
    176 /* using std::hel::wcstold; */
    177 
    178105#endif
Note: See TracChangeset for help on using the changeset viewer.