Changeset c729a60 in mainline


Ignore:
Timestamp:
2018-07-05T21:41:19Z (6 years ago)
Author:
Dzejrou <dzejrou@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
5732648
Parents:
9cb221b
git-author:
Dzejrou <dzejrou@…> (2017-12-17 14:54:03)
git-committer:
Dzejrou <dzejrou@…> (2018-07-05 21:41:19)
Message:

cpp: added basic implementation of num_put, fixed minor errors and added undefined functions

Location:
uspace/lib/cpp/include/internal
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/cpp/include/internal/locale.hpp

    r9cb221b rc729a60  
    3030#define LIBCPP_INTERNAL_LOCALE
    3131
    32 #include <string>
     32#include <impl/string.hpp>
    3333
    3434namespace std

  • uspace/lib/cpp/include/internal/locale/ctype.hpp

    r9cb221b rc729a60  
    3232#include <cctype>
    3333#include <internal/locale.hpp>
    34 #include <string>
     34#include <impl/string.hpp>
    3535
    3636namespace std

  • uspace/lib/cpp/include/internal/locale/num_put.hpp

    r9cb221b rc729a60  
    4848            using iter_type = OutputIterator;
    4949
    50             explicit num_put(size_t refs = 0);
     50            explicit num_put(size_t refs = 0)
     51            { /* DUMMY BODY */ }
    5152
    5253            iter_type put(iter_type it, ios_base& base, char_type fill, bool v) const
    … …  
    9091            }
    9192
    92             ~num_put();
     93            ~num_put()
     94            { /* DUMMY BODY */ }
    9395
    9496        protected:
    … …  
    112114            iter_type do_put(iter_type it, ios_base& base, char_type fill, long v) const
    113115            {
    114                 // TODO: implement
     116                auto basefield = (base.flags() & ios_base::basefield);
     117                auto uppercase = (base.flags() & ios_base::uppercase);
     118
     119                int ret{};
     120                if (basefield == ios_base::oct)
     121                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%lo", v);
     122                else if ((basefield == ios_base::hex) && !uppercase)
     123                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%lx", v);
     124                else if (basefield == ios_base::hex)
     125                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%lX", v);
     126                else
     127                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%ld", v);
     128
     129                return put_adjusted_buffer_(it, base, fill, ret);
    115130            }
    116131
    117132            iter_type do_put(iter_type it, ios_base& base, char_type fill, long long v) const
    118133            {
    119                 // TODO: implement
     134                auto basefield = (base.flags() & ios_base::basefield);
     135                auto uppercase = (base.flags() & ios_base::uppercase);
     136
     137                int ret{};
     138                if (basefield == ios_base::oct)
     139                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%llo", v);
     140                else if ((basefield == ios_base::hex) && !uppercase)
     141                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%llx", v);
     142                else if (basefield == ios_base::hex)
     143                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%llX", v);
     144                else
     145                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%lld", v);
     146
     147                return put_adjusted_buffer_(it, base, fill, ret);
    120148            }
    121149
    122150            iter_type do_put(iter_type it, ios_base& base, char_type fill, unsigned long v) const
    123151            {
    124                 // TODO: implement
     152                auto basefield = (base.flags() & ios_base::basefield);
     153                auto uppercase = (base.flags() & ios_base::uppercase);
     154
     155                int ret{};
     156                if (basefield == ios_base::oct)
     157                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%lo", v);
     158                else if ((basefield == ios_base::hex) && !uppercase)
     159                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%lx", v);
     160                else if (basefield == ios_base::hex)
     161                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%lX", v);
     162                else
     163                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%lu", v);
     164
     165                return put_adjusted_buffer_(it, base, fill, ret);
    125166            }
    126167
    127168            iter_type do_put(iter_type it, ios_base& base, char_type fill, unsigned long long v) const
    128169            {
    129                 // TODO: implement
     170                auto basefield = (base.flags() & ios_base::basefield);
     171                auto uppercase = (base.flags() & ios_base::uppercase);
     172
     173                // TODO: showbase
     174                int ret{};
     175                if (basefield == ios_base::oct)
     176                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%llo", v);
     177                else if ((basefield == ios_base::hex) && !uppercase)
     178                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%llx", v);
     179                else if (basefield == ios_base::hex)
     180                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%llX", v);
     181                else
     182                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%llu", v);
     183
     184                return put_adjusted_buffer_(it, base, fill, ret);
    130185            }
    131186
    132187            iter_type do_put(iter_type it, ios_base& base, char_type fill, double v) const
    133188            {
    134                 // TODO: implement
     189                auto floatfield = (base.flags() & ios_base::floatfield);
     190                auto uppercase = (base.flags() & ios_base::uppercase);
     191
     192                // TODO: showbase
     193                // TODO: precision
     194                int ret{};
     195                if (floatfield == ios_base::fixed)
     196                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%f", v);
     197                else if (floatfield == ios_base::scientific && !uppercase)
     198                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%e", v);
     199                else if (floatfield == ios_base::scientific)
     200                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%E", v);
     201                else if (floatfield == (ios_base::fixed | ios_base::scientific) && !uppercase)
     202                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%a", v);
     203                else if (floatfield == (ios_base::fixed | ios_base::scientific))
     204                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%A", v);
     205                else if (!uppercase)
     206                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%g", v);
     207                else
     208                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%G", v);
     209
     210                return put_adjusted_buffer_(it, base, fill, ret);
    135211            }
    136212
    137213            iter_type do_put(iter_type it, ios_base& base, char_type fill, long double v) const
    138214            {
    139                 // TODO: implement
     215                /**
     216                 * Note: Long double is not support at the moment in snprintf.
     217                 */
     218                auto floatfield = (base.flags() & ios_base::floatfield);
     219                auto uppercase = (base.flags() & ios_base::uppercase);
     220
     221                // TODO: showbase
     222                // TODO: precision
     223                int ret{};
     224                if (floatfield == ios_base::fixed)
     225                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%Lf", v);
     226                else if (floatfield == ios_base::scientific && !uppercase)
     227                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%Le", v);
     228                else if (floatfield == ios_base::scientific)
     229                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%LE", v);
     230                else if (floatfield == (ios_base::fixed | ios_base::scientific) && !uppercase)
     231                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%La", v);
     232                else if (floatfield == (ios_base::fixed | ios_base::scientific))
     233                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%LA", v);
     234                else if (!uppercase)
     235                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%Lg", v);
     236                else
     237                    ret = snprintf(base.buffer_, ios_base::buffer_size_, "%LG", v);
     238
     239                return put_adjusted_buffer_(it, base, fill, ret);
    140240            }
    141241
    142242            iter_type do_put(iter_type it, ios_base& base, char_type fill, const void* v) const
    143243            {
    144                 // TODO: implement
     244                int ret = snprintf(base.buffer_, ios_base::buffer_size_, "%p", v);
     245
     246                return put_adjusted_buffer_(it, base, fill, ret);
     247            }
     248
     249        private:
     250            iter_type put_adjusted_buffer_(iter_type it, ios_base& base, char_type fill, size_t size) const
     251            {
     252                auto adjustfield = (base.flags() & ios_base::adjustfield);
     253
     254                size_t to_fill{};
     255                size_t width = static_cast<size_t>(base.width());
     256
     257                if (base.width() > 0 && size < width)
     258                    to_fill = width - size;
     259
     260                if (to_fill > 0)
     261                {
     262                    if (adjustfield == ios_base::left)
     263                    {
     264                        it = put_buffer_(it, base, fill, 0, size);
     265                        for (size_t i = 0; i < to_fill; ++i)
     266                            *it++ = fill;
     267                    }
     268                    else if (adjustfield == ios_base::right)
     269                    {
     270                        for (size_t i = 0; i < to_fill; ++i)
     271                            *it++ = fill;
     272                        it = put_buffer_(it, base, fill, 0, size);
     273                    }
     274                    else if (adjustfield == ios_base::internal)
     275                    {
     276                        // TODO: pad after - or 0x/0X
     277                    }
     278                    else
     279                    {
     280                        for (size_t i = 0; i < to_fill; ++i)
     281                            *it++ = fill;
     282                        it = put_buffer_(it, base, fill, 0, size);
     283                    }
     284                }
     285                else
     286                    it = put_buffer_(it, base, fill, 0, size);
     287                base.width(0);
     288
     289                return it;
     290            }
     291
     292            iter_type put_buffer_(iter_type it, ios_base& base, char_type fill, size_t start, size_t size) const
     293            {
     294                const auto& loc = base.getloc();
     295                const auto& ct = use_facet<ctype<char_type>>(loc);
     296                const auto& punct = use_facet<numpunct<char_type>>(loc);
     297
     298                for (size_t i = start; i < size; ++i)
     299                {
     300                    if (base.buffer_[i] == '.')
     301                        *it++ = punct.decimal_point();
     302                    else
     303                        *it++ = ct.widen(base.buffer_[i]);
     304                    // TODO: Should do grouping & thousands_sep, but that's a low
     305                    //       priority for now.
     306                }
     307
     308                return it;
    145309            }
    146310    };

  • uspace/lib/cpp/include/internal/locale/numpunct.hpp

    r9cb221b rc729a60  
    9090            using string_type = basic_string<char>;
    9191
    92             explicit numpunct(size_t refs = 0);
     92            explicit numpunct(size_t refs = 0)
     93            { /* DUMMY BODY */ }
    9394
    9495            char_type decimal_point() const
    … …  
    117118            }
    118119
    119             ~numpunct();
     120            ~numpunct()
     121            { /* DUMMY BODY */ }
    120122
    121123        protected:
Note: See TracChangeset for help on using the changeset viewer.