checklist

gcc-you can use this code to learn something about gcc, and inquire further into linux,

V     int compare(const charT* s) const;
V     int compare(size_type pos1, size_type n1,
                  const charT* s, size_type n2 = npos) const;
    };
   }

   21.4  Null-terminated sequence utilities               [lib.c.strings]

                    Table 10--Header <cctype> synopsis

            isalnum   isdigit   isprint   isupper    tolower
X           isalpha   isgraph   ispunct   isxdigit   toupper
            iscntrl   islower   isspace

                   Table 11--Header <cwctype> synopsis

X  Macro:     WEOF <cwctype>
X  Types:     wctrans_t   wctype_t   wint_t <cwctype>
   Functions:
X  iswalnum   iswctype    iswlower   iswspace    towctrans   wctrans
X  iswalpha   iswdigit    iswprint   iswupper    towlower    wctype
X  iswcntrl   iswgraph    iswpunct   iswxdigit   towupper

                   Table 12--Header <cstring> synopsis

X           Macro:    NULL <cstring>
X           Type:     size_t <cstring>
            Functions:
X           memchr    strcat    strcspn    strncpy   strtok
X           memcmp    strchr    strerror   strpbrk   strxfrm
X           memcpy    strcmp    strlen     strrchr
X           memmove   strcoll   strncat    strspn
X           memset    strcpy    strncmp    strstr

                    Table 13--Header <cwchar> synopsis
   Macros:    NULL <cwchar>   WCHAR_MAX         WCHAR_MIN   WEOF <cwchar>
   Types:     mbstate_t       wint_t <cwchar>   size_t
   Functions:
X  btowc      getwchar        ungetwc           wcscpy      wcsrtombs   wmemchr
X  fgetwc     mbrlen          vfwprintf         wcscspn     wcsspn      wmemcmp
X  fgetws     mbrtowc         vswprintf         wcsftime    wcsstr      wmemcpy
X  fputwc     mbsinit         vwprintf          wcslen      wcstod      wmemmove
X  fputws     mbsrtowcs       wcrtomb           wcsncat     wcstok      wmemset
X  fwide      putwc           wcscat            wcsncmp     wcstol      wprintf
X  fwprintf   putwchar        wcschr            wcsncpy     wcstoul     wscanf
X  fwscanf    swprintf        wcscmp            wcspbrk     wcsxfrm
X  getwc      swscanf         wcscoll           wcsrchr     wctob

                   Table 14--Header <cstdlib> synopsis

               Macros:   MB_CUR_MAX
               Functions:
X              atol      mblen        strtod    wctomb
X              atof      mbstowcs     strtol    wcstombs
X              atoi      mbtowc       strtoul

X  const char* strchr(const char* s, int c);
X       char* strchr(      char* s, int c);

X  const char* strpbrk(const char* s1, const char* s2);
X       char* strpbrk(      char* s1, const char* s2);

X  const char* strrchr(const char* s, int c);
X       char* strrchr(      char* s, int c);

X  const char* strstr(const char* s1, const char* s2);
X       char* strstr(      char* s1, const char* s2);

X  const void* memchr(const void* s, int c, size_t n);
X       void* memchr(      void* s, int c, size_t n);

X  const wchar_t* wcschr(const wchar_t* s, wchar_t c);
X       wchar_t* wcschr(      wchar_t* s, wchar_t c);

X  const wchar_t* wcspbrk(const wchar_t* s1, const wchar_t* s2);
X       wchar_t* wcspbrk(      wchar_t* s1, const wchar_t* s2);

X  const wchar_t* wcsrchr(const wchar_t* s, wchar_t c);
X       wchar_t* wcsrchr(      wchar_t* s, wchar_t c);

X  const wchar_t* wcsstr(const wchar_t* s1, const wchar_t* s2);
X       wchar_t* wcsstr(      wchar_t* s1, const wchar_t* s2);

X  const wchar_t* wmemchr(const wchar_t* s, wchar_t c, size_t n);
X       wchar_t* wmemchr(      wchar_t* s, wchar_t c, size_t n);

   [for initial efforts on the above, see shadow/string.h]

   22.1  Locales                                            [lib.locales]

   Header <locale> synopsis

    // _lib.locale_, locale:
T   class locale;
T   template <class Facet> const Facet& use_facet(const locale&);
T   template <class Facet> bool         has_facet(const locale&) throw();

    // _lib.locale.convenience_, convenience interfaces:
T   template <class charT> bool isspace (charT c, const locale& loc);
T   template <class charT> bool isprint (charT c, const locale& loc);
T   template <class charT> bool iscntrl (charT c, const locale& loc);
T   template <class charT> bool isupper (charT c, const locale& loc);
T   template <class charT> bool islower (charT c, const locale& loc);
T   template <class charT> bool isalpha (charT c, const locale& loc);
T   template <class charT> bool isdigit (charT c, const locale& loc);
T   template <class charT> bool ispunct (charT c, const locale& loc);
T   template <class charT> bool isxdigit(charT c, const locale& loc);
T   template <class charT> bool isalnum (charT c, const locale& loc);
T   template <class charT> bool isgraph (charT c, const locale& loc);
T   template <class charT> charT toupper(charT c, const locale& loc);
T   template <class charT> charT tolower(charT c, const locale& loc);
    // _lib.category.ctype_ and _lib.facet.ctype.special_, ctype:
    class ctype_base;
T   template <class charT> class ctype;
T   template <>            class ctype<char>;             // specialization
S   template <class charT> class ctype_byname;
S   template <>            class ctype_byname<char>;      // specialization
T   class codecvt_base;
X   template <class internT, class externT, class stateT> class codecvt;
S   template <class internT, class externT, class stateT> class codecvt_byname;
    // _lib.category.numeric_ and _lib.facet.numpunct_, numeric:
X   template <class charT, class InputIterator>  class num_get;
X   template <class charT, class OutputIterator> class num_put;
T   template <class charT> class numpunct;
S   template <class charT> class numpunct_byname;
    // _lib.category.collate_, collation:
T   template <class charT> class collate;
S   template <class charT> class collate_byname;
    // _lib.category.time_, date and time:
T   class time_base;
S   template <class charT, class InputIterator>  class time_get;
S   template <class charT, class InputIterator>  class time_get_byname;
S   template <class charT, class OutputIterator> class time_put;
S   template <class charT, class OutputIterator> class time_put_byname;
    // _lib.category.monetary_, money:
T   class money_base;
S   template <class charT, class InputIterator>  class money_get;
S   template <class charT, class OutputIterator> class money_put;
S   template <class charT, bool Intl> class moneypunct;
S   template <class charT, bool Intl> class moneypunct_byname;
    // _lib.category.messages_, message retrieval:
T   class messages_base;
S   template <class charT> class messages;
S   template <class charT> class messages_byname;


   22.1.1  Class locale                                      [lib.locale]

X   class locale {
    public:
      // types:
T     class facet;
T     class id;
T     typedef int category;
T     static const category   // values assigned here are for exposition only
T       none     = 0,
T       collate  = 0x010, ctype    = 0x020,
T       monetary = 0x040, numeric  = 0x080,
T       time     = 0x100, messages = 0x200,
T       all = collate | ctype | monetary | numeric | time  | messages;
      // construct/copy/destroy:
T     locale() throw()
T     locale(const locale& other) throw()
X     explicit locale(const char* std_name);
X     locale(const locale& other, const char* std_name, category);
T     template <class Facet> locale(const locale& other, Facet* f);
T     locale(const locale& other, const locale& one, category);
T    ~locale() throw();           // non-virtual
T     const locale& operator=(const locale& other) throw();
T     template <class Facet> locale combine(const locale& other) const;
      // locale operations:
X     basic_string<char>                  name() const;
T     bool operator==(const locale& other) const;
T     bool operator!=(const locale& other) const;
T     template <class charT, class Traits, class Allocator>
        bool operator()(const basic_string<charT,Traits,Allocator>& s1,
                        const basic_string<charT,Traits,Allocator>& s2) const;
      // global locale objects:
T     static       locale  global(const locale&);
T     static const locale& classic();
    };

   22.1.1.1  locale types                              [lib.locale.types]

   22.1.1.1.1  Type locale::category                [lib.locale.category]

T  typedef int category;

T   none, collate, ctype, monetary, numeric, time, and messages

      [required locale members]
T     collate<char>, collate<wchar_t>
T     ctype<char>, ctype<wchar_t>
T     codecvt<char,char,mbstate_t>,
S     codecvt<wchar_t,char,mbstate_t>
T     moneypunct<char>, moneypunct<wchar_t>
T     moneypunct<char,true>, moneypunct<wchar_t,true>,
S     money_get<char>, money_get<wchar_t
S     money_put<char>, money_put<wchar_t>
T     numpunct<char>, numpunct<wchar_t>,
X     num_get<char>, num_get<wchar_t>
X     num_put<char>, num_put<wchar_t>
S     time_get<char>, time_get<wchar_t>,
S     time_put<char>, time_put<wchar_t>
S     messages<char>, messages<wchar_t>

      [required instantiations]
S    collate_byname<char>, collate_byname<wchar_t>
S    ctype_byname<char>, ctype_byname<wchar_t>
S    codecvt_byname<char,char,mbstate_t>,
S    codecvt_byname<wchar_t,char,mbstate_t>
S    moneypunct_byname<char,International>,
S    moneypunct_byname<wchar_t,International>,
S    money_get<C,InputIterator>,
S    money_put<C,OutputIterator>
S    numpunct_byname<char>, numpunct_byname<wchar_t>
X    num_get<C,InputIterator>, num_put<C,OutputIterator>
S    time_get<char,InputIterator>,
S    time_get_byname<char,InputIterator>,
S    time_get<wchar_t,OutputIterator>,
S    time_get_byname<wchar_t,OutputIterator>,
S    time_put<char,OutputIterator>,
S    time_put_byname<char,OutputIterator>,
S    time_put<wchar_t,OutputIterator>
S    time_put_byname<wchar_t,OutputIterator>
S    messages_byname<char>, messages_byname<wchar_t>


   22.1.1.1.2  Class locale::facet                     [lib.locale.facet]

T   class locale::facet {
    protected:
T     explicit facet(size_t refs = 0);
T     virtual ~facet();
    private:
T     facet(const facet&);                // not defined
T     void operator=(const facet&);       // not defined
    };
   }


   22.1.1.1.3  Class locale::id                           [lib.locale.id]

T   class locale::id {
    public:
T     id();
    private:
T     void operator=(const id&);  // not defined
T     id(const id&);              // not defined
    };
   }


   22.2.1  The ctype category                        [lib.category.ctype]

T   class ctype_base {
    public:
T     enum mask {         // numeric values are for exposition only.
T       space=, print=, cntrl=, upper=, lower=,
T       alpha=, digit=, punct=, xdigit=,
T       alnum=, graph=
      };
    };


   22.2.1.1  Template class ctype                      [lib.locale.ctype]

T   template <class charT>
    class ctype : public locale::facet, public ctype_base {
    public:
T     typedef charT char_type;
T     explicit ctype(size_t refs = 0);
T     bool         is(mask m, charT c) const;
T     const charT* is(const charT* low, const charT* high, mask* vec) const;
T     const charT* scan_is(mask m,
                           const charT* low, const charT* high) const;
T     const charT* scan_not(mask m,
                            const charT* low, const charT* high) const;
T     charT        toupper(charT c) const;
T     const charT* toupper(charT* low, const charT* high) const;
T     charT        tolower(charT c) const;
T     const charT* tolower(charT* low, const charT* high) const;
T     charT        widen(char c) const;
T     const char*  widen(const char* low, const char* high, charT* to) const;
T     char         narrow(charT c, char dfault) const;
T     const charT* narrow(const charT* low, const charT*, char dfault,
                          char* to) const;
T     static locale::id id;

    protected:
T    ~ctype();                    // virtual
T     virtual bool         do_is(mask m, charT c) const;
T     virtual const charT* do_is(const charT* low, const charT* high,
                                 mask* vec) const;
T     virtual const charT* do_scan_is(mask m,
                              const charT* low, const charT* high) const;
T     virtual const charT* do_scan_not(mask m,
                              const charT* low, const charT* high) const;
T     virtual charT        do_toupper(charT) const;
T     virtual const charT* do_toupper(charT* low, const charT* high) const;
T     virtual charT        do_tolower(charT) const;
T     virtual const charT* do_tolower(charT* low, const charT* high) const;
T     virtual charT        do_widen(char) const;
T     virtual const char*  do_widen(const char* low, const char* high,
                                    charT* dest) const;
T     virtual char         do_narrow(charT, char dfault) const;
T     virtual const charT* do_narrow(const charT* low, const charT* high,
                                     char dfault, char* dest) const;
    };


   22.2.1.2  Template class ctype_byname        [lib.locale.ctype.byname]

X   template <class charT>
    class ctype_byname : public ctype<charT> {
    public:
T     typedef ctype<charT>::mask mask;
S     explicit ctype_byname(const char*, size_t refs = 0);
    protected:
S    ~ctype_byname();             // virtual
S     virtual bool         do_is(mask m, charT c) const;
S     virtual const charT* do_is(const charT* low, const charT* high,
                                 mask* vec) const;
S     virtual const char*  do_scan_is(mask m,
                               const charT* low, const charT* high) const;
S     virtual const char*  do_scan_not(mask m,
                               const charT* low, const charT* high) const;
S     virtual charT        do_toupper(charT) const;
S     virtual const charT* do_toupper(charT* low, const charT* high) const;
S     virtual charT        do_tolower(charT) const;
S     virtual const charT* do_tolower(charT* low, const