;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; LUSH Lisp Universal Shell
;;;   Copyright (C) 2002 Leon Bottou, Yann Le Cun, AT&T Corp, NECI.
;;; Includes parts of TL3:
;;;   Copyright (C) 1987-1999 Leon Bottou and Neuristique.
;;; Includes selected parts of SN3.2:
;;;   Copyright (C) 1991-2001 AT&T Corp.
;;;
;;; Includes information derived from the GSL (Gnu Scientific Library)
;;;   header files which are copyrighted and distributed under the GPL
;;;   by their respective authors.
;;;
;;; This program 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 2 of the License, or
;;; (at your option) any later version.
;;;
;;; This program 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 this program; if not, write to the Free Software
;;; Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(libload "python/python-config")


#? *** pyunicode

;; dummy function that adds Python C header files in C file
(eval `(de dummy_pyunicode () ,python-cpheader-cmd ()))


#? * (dummy_pyunicode)
#? * (pyunicode_fromunicode <u> <size>)
#? * (pyunicode_asunicode <unicode>)
#? * (pyunicode_getsize <unicode>)
#? * (pyunicode_getmax)
#? * (pyunicode_resize <unicode> <length>)
#? * (pyunicode_fromencodedobject <obj> <encoding> <errors>)
#? * (pyunicode_fromobject <obj>)
#? * (pyunicode_fromwidechar <w> <size>)
#? * (pyunicode_aswidechar <unicode> <w> <size>)
#? * (_pyunicode_asdefaultencodedstring <o1> <om>)
#? * (pyunicode_getdefaultencoding)
#? * (pyunicode_setdefaultencoding <encoding>)
#? * (pyunicode_decode <s> <size> <encoding> <errors>)
#? * (pyunicode_encode <s> <size> <encoding> <errors>)
#? * (pyunicode_asencodedstring <unicode> <encoding> <errors>)
#? * (pyunicode_decodeutf7 <string> <length> <errors>)
#? * (pyunicode_encodeutf7 <data> <length> <encodeseto> <encodewhitespace> <errors>)
#? * (pyunicode_decodeutf8 <string> <length> <errors>)
#? * (pyunicode_asutf8string <unicode>)
#? * (pyunicode_encodeutf8 <data> <length> <errors>)
#? * (pyunicode_decodeutf16 <string> <length> <errors> <byteorder>)
#? * (pyunicode_asutf16string <unicode>)
#? * (pyunicode_encodeutf16 <data> <length> <errors> <byteorder>)
#? * (pyunicode_decodeunicodeescape <string> <length> <errors>)
#? * (pyunicode_asunicodeescapestring <unicode>)
#? * (pyunicode_encodeunicodeescape <data> <length>)
#? * (pyunicode_decoderawunicodeescape <string> <length> <errors>)
#? * (pyunicode_asrawunicodeescapestring <unicode>)
#? * (pyunicode_encoderawunicodeescape <data> <length>)
#? * (pyunicode_decodelatin1 <string> <length> <errors>)
#? * (pyunicode_aslatin1string <unicode>)
#? * (pyunicode_encodelatin1 <data> <length> <errors>)
#? * (pyunicode_decodeascii <string> <length> <errors>)
#? * (pyunicode_asasciistring <unicode>)
#? * (pyunicode_encodeascii <data> <length> <errors>)
#? * (pyunicode_decodecharmap <string> <length> <mapping> <errors>)
#? * (pyunicode_ascharmapstring <unicode> <mapping>)
#? * (pyunicode_encodecharmap <data> <length> <mapping> <errors>)
#? * (pyunicode_translatecharmap <data> <length> <table> <errors>)
#? * (pyunicode_encodedecimal <s> <length> <output> <errors>)
#? * (pyunicode_concat <left> <right>)
#? * (pyunicode_split <s> <sep> <maxsplit>)
#? * (pyunicode_splitlines <s> <keepends>)
#? * (pyunicode_translate <str> <table> <errors>)
#? * (pyunicode_join <separator> <seq>)
#? * (pyunicode_tailmatch <str> <substr> <start> <end> <direction>)
#? * (pyunicode_find <str> <substr> <start> <end> <direction>)
#? * (pyunicode_count <str> <substr> <start> <end>)
#? * (pyunicode_replace <str> <substr> <replstr> <maxcount>)
#? * (pyunicode_compare <left> <right>)
#? * (pyunicode_format <format> <args>)
#? * (pyunicode_contains <container> <element>)
#? * (_pyunicode_islowercase <ch>)
#? * (_pyunicode_isuppercase <ch>)
#? * (_pyunicode_istitlecase <ch>)
#? * (_pyunicode_iswhitespace <ch>)
#? * (_pyunicode_islinebreak <ch>)
#? * (_pyunicode_tolowercase <ch>)
#? * (_pyunicode_touppercase <ch>)
#? * (_pyunicode_totitlecase <ch>)
#? * (_pyunicode_todecimaldigit <ch>)
#? * (_pyunicode_todigit <ch>)
#? * (_pyunicode_tonumeric <ch>)
#? * (_pyunicode_isdecimaldigit <ch>)
#? * (_pyunicode_isdigit <ch>)
#? * (_pyunicode_isnumeric <ch>)
#? * (_pyunicode_isalpha <ch>)

;; ********************************************************

(de PyUnicode_FromUnicode (u  size)
    ((-gptr- "const Py_UNICODE *") u)  
    ((-int-) size)  
    (gptr  #{  PyUnicode_FromUnicode(   $u  ,$size )    #} ))   ;; PyObject * -> gptr

(de PyUnicode_AsUnicode ( unicode )
    ((-gptr- "PyObject *") unicode)
    (gptr #{ PyUnicode_AsUnicode(  $unicode ) #} ))     ;; Py_UNICODE * -> gptr

(de PyUnicode_GetSize ( unicode )
    ((-gptr- "PyObject *") unicode )
    (int #{ PyUnicode_GetSize(  $unicode ) #} ))

(de PyUnicode_GetMax  ( )
    (int #{ PyUnicode_GetMax() #} ))          ;; Py_UNICODE -> int

			
(de PyUnicode_Resize ( unicode length )
    ((-gptr-"PyObject **") unicode)  
    ((-int-) length)   
    (int  #{  PyUnicode_Resize(   $unicode   ,$length )  #} ))

(de PyUnicode_FromEncodedObject (obj  encoding  errors )
    ((-gptr-"PyObject *") obj)  
    ((-gptr-"const char *") encoding)  
    ((-gptr-"const char *") errors)   
    (gptr  #{  PyUnicode_FromEncodedObject(   $obj   ,$encoding   ,$errors )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_FromObject (obj )
    ((-gptr-"PyObject *") obj)   
    (gptr  #{  PyUnicode_FromObject(   $obj )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_FromWideChar (w  size )
    ((-gptr-"const wchar_t *") w)  
    ((-int-) size)   
    (gptr  #{  PyUnicode_FromWideChar(   $w   ,$size )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_AsWideChar (unicode  w  size )
    ((-gptr-"PyUnicodeObject *") unicode)  
    ((-gptr-"wchar_t *") w)  
    ((-int-) size)   
    (int  #{  PyUnicode_AsWideChar(   $unicode   ,$w   ,$size )  #} ))

(de _PyUnicode_AsDefaultEncodedString (o1  om )
    ((-gptr-"PyObject *") o1)  
    ((-gptr-"const char *") om)   
    (gptr  #{ _PyUnicode_AsDefaultEncodedString(   $o1   ,$om )  #} ))        ;; PyObject * -> gptr

(de PyUnicode_GetDefaultEncoding ()
    (gptr  #{  PyUnicode_GetDefaultEncoding(  )  #} ))   ;; const char* -> gptr

(de PyUnicode_SetDefaultEncoding (encoding )
    ((-gptr-"const char *") encoding)   
    (int  #{  PyUnicode_SetDefaultEncoding(   $encoding )  #} ))

(de PyUnicode_Decode (s  size  encoding  errors )
    ((-gptr-"const char *") s)  
    ((-int-) size)  
    ((-gptr-"const char *") encoding)  
    ((-gptr-"const char *") errors)   
    (gptr  #{  PyUnicode_Decode(   $s   ,$size   ,$encoding   ,$errors )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_Encode (s  size  encoding  errors )
    ((-gptr-"const Py_UNICODE *") s)  
    ((-int-) size)  
    ((-gptr-"const char *") encoding)  
    ((-gptr-"const char *") errors)   
    (gptr  #{  PyUnicode_Encode(   $s   ,$size   ,$encoding   ,$errors )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_AsEncodedString (unicode  encoding  errors )
    ((-gptr-"PyObject *") unicode)  
    ((-gptr-"const char *") encoding)  
    ((-gptr-"const char *") errors)   
    (gptr  #{  PyUnicode_AsEncodedString(   $unicode   ,$encoding   ,$errors )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_DecodeUTF7 (string  length  errors )
    ((-gptr-"const char *") string)  
    ((-int-) length)  
    ((-gptr-"const char *") errors)   
    (gptr  #{  PyUnicode_DecodeUTF7(   $string   ,$length   ,$errors )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_EncodeUTF7 (data  length  encodeSetO  encodeWhiteSpace  errors )
    ((-gptr-"const Py_UNICODE *") data)  
    ((-int-) length)  
    ((-int-) encodeSetO)  
    ((-int-) encodeWhiteSpace)  
    ((-gptr-"const char *") errors)   
    (gptr  #{  PyUnicode_EncodeUTF7(   $data   ,$length   ,$encodeSetO   ,$encodeWhiteSpace   ,$errors )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_DecodeUTF8 (string  length  errors )
    ((-gptr-"const char *") string)  
    ((-int-) length)  
    ((-gptr-"const char *") errors)   
    (gptr  #{  PyUnicode_DecodeUTF8(   $string   ,$length   ,$errors )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_AsUTF8String (unicode )
    ((-gptr-"PyObject *") unicode)   
    (gptr  #{  PyUnicode_AsUTF8String(   $unicode )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_EncodeUTF8 (data  length  errors )
    ((-gptr-"const Py_UNICODE *") data)  
    ((-int-) length)  
    ((-gptr-"const char *") errors)   
    (gptr  #{  PyUnicode_EncodeUTF8(   $data   ,$length   ,$errors )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_DecodeUTF16 (string  length  errors  byteorder )
    ((-gptr-"const char *") string)  
    ((-int-) length)  
    ((-gptr-"const char *") errors)  
    ((-gptr-"int *") byteorder)   
    (gptr  #{  PyUnicode_DecodeUTF16(   $string   ,$length   ,$errors   ,$byteorder )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_AsUTF16String (unicode )
    ((-gptr-"PyObject *") unicode)   
    (gptr  #{  PyUnicode_AsUTF16String(   $unicode )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_EncodeUTF16 (data  length  errors  byteorder )
    ((-gptr-"const Py_UNICODE *") data)  
    ((-int-) length)  
    ((-gptr-"const char *") errors)  
    ((-int-) byteorder)   
    (gptr  #{  PyUnicode_EncodeUTF16(   $data   ,$length   ,$errors   ,$byteorder )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_DecodeUnicodeEscape (string  length  errors )
    ((-gptr-"const char *") string)  
    ((-int-) length)  
    ((-gptr-"const char *") errors)   
    (gptr  #{  PyUnicode_DecodeUnicodeEscape(   $string   ,$length   ,$errors )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_AsUnicodeEscapeString (unicode )
    ((-gptr-"PyObject *") unicode)   
    (gptr  #{  PyUnicode_AsUnicodeEscapeString(   $unicode )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_EncodeUnicodeEscape (data  length )
    ((-gptr-"const Py_UNICODE *") data)  
    ((-int-) length)   
    (gptr  #{  PyUnicode_EncodeUnicodeEscape(   $data   ,$length )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_DecodeRawUnicodeEscape (string  length  errors )
    ((-gptr-"const char *") string)  
    ((-int-) length)  
    ((-gptr-"const char *") errors)   
    (gptr  #{  PyUnicode_DecodeRawUnicodeEscape(   $string   ,$length   ,$errors )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_AsRawUnicodeEscapeString (unicode )
    ((-gptr-"PyObject *") unicode)   
    (gptr  #{  PyUnicode_AsRawUnicodeEscapeString(   $unicode )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_EncodeRawUnicodeEscape (data  length )
    ((-gptr-"const Py_UNICODE *") data)  
    ((-int-) length)   
    (gptr  #{  PyUnicode_EncodeRawUnicodeEscape(   $data   ,$length )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_DecodeLatin1 (string  length  errors )
    ((-gptr-"const char *") string)  
    ((-int-) length)  
    ((-gptr-"const char *") errors)   
    (gptr  #{  PyUnicode_DecodeLatin1(   $string   ,$length   ,$errors )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_AsLatin1String (unicode )
    ((-gptr-"PyObject *") unicode)   
    (gptr  #{  PyUnicode_AsLatin1String(   $unicode )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_EncodeLatin1 (data  length  errors )
    ((-gptr-"const Py_UNICODE *") data)  
    ((-int-) length)  
    ((-gptr-"const char *") errors)   
    (gptr  #{  PyUnicode_EncodeLatin1(   $data   ,$length   ,$errors )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_DecodeASCII (string  length  errors )
    ((-gptr-"const char *") string)  
    ((-int-) length)  
    ((-gptr-"const char *") errors)   
    (gptr  #{  PyUnicode_DecodeASCII(   $string   ,$length   ,$errors )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_AsASCIIString (unicode )
    ((-gptr-"PyObject *") unicode)   
    (gptr  #{  PyUnicode_AsASCIIString(   $unicode )  #} ))   ;; PyObject * -> gptr

(de PyUnicode_EncodeASCII (data  length  errors )
    ((-gptr-"const Py_UNICODE *") data)  
    ((-int-) length)  
    ((-gptr-"const char *") errors)   
    (gptr  #{  PyUnicode_EncodeASCII(   $data   ,$length   ,$errors )  #} ))       ;; PyObject * -> gptr

(de PyUnicode_DecodeCharmap (string  length  mapping  errors )
    ((-gptr-"const char *") string)  
    ((-int-) length)  
    ((-gptr-"PyObject *") mapping)  
    ((-gptr-"const char *") errors)   
    (gptr  #{  PyUnicode_DecodeCharmap(   $string   ,$length   ,$mapping   ,$errors )  #} ))       ;; PyObject * -> gptr

(de PyUnicode_AsCharmapString (unicode  mapping )
    ((-gptr-"PyObject *") unicode)  
    ((-gptr-"PyObject *") mapping)   
    (gptr  #{  PyUnicode_AsCharmapString(   $unicode   ,$mapping )  #} ))       ;; PyObject * -> gptr

(de PyUnicode_EncodeCharmap (data  length  mapping  errors )
    ((-gptr-"const Py_UNICODE *") data)  
    ((-int-) length)  
    ((-gptr-"PyObject *") mapping)  
    ((-gptr-"const char *") errors)   
    (gptr  #{  PyUnicode_EncodeCharmap(   $data   ,$length   ,$mapping   ,$errors )  #} ))       ;; PyObject * -> gptr

(de PyUnicode_TranslateCharmap (data  length  table  errors )
    ((-gptr-"const Py_UNICODE *") data)  
    ((-int-) length)  
    ((-gptr-"PyObject *") table)  
    ((-gptr-"const char *") errors)   
    (gptr  #{  PyUnicode_TranslateCharmap(   $data   ,$length   ,$table   ,$errors )  #} ))       ;; PyObject * -> gptr

(de PyUnicode_EncodeDecimal (s  length  output  errors )
    ((-gptr-"Py_UNICODE *") s)  
    ((-int-) length)  
    ((-gptr-"char *") output)  
    ((-gptr-"const char *") errors)   
    (int  #{  PyUnicode_EncodeDecimal(   $s   ,$length   ,$output   ,$errors )  #} ))

(de PyUnicode_Concat (left  right )
    ((-gptr-"PyObject *") left)  
    ((-gptr-"PyObject *") right)   
    (gptr  #{  PyUnicode_Concat(   $left   ,$right )  #} ))       ;; PyObject * -> gptr

(de PyUnicode_Split (s  sep  maxsplit )
    ((-gptr-"PyObject *") s)  
    ((-gptr-"PyObject *") sep)  
    ((-int-) maxsplit)   
    (gptr  #{  PyUnicode_Split(   $s   ,$sep   ,$maxsplit )  #} ))       ;; PyObject * -> gptr

(de PyUnicode_Splitlines (s  keepends )
    ((-gptr-"PyObject *") s)  
    ((-int-) keepends)   
    (gptr  #{  PyUnicode_Splitlines(   $s   ,$keepends )  #} ))       ;; PyObject * -> gptr

(de PyUnicode_Translate (str  table  errors )
    ((-gptr-"PyObject *") str)  
    ((-gptr-"PyObject *") table)  
    ((-gptr-"const char *") errors)   
    (gptr  #{  PyUnicode_Translate(   $str   ,$table   ,$errors )  #} ))       ;; PyObject * -> gptr

(de PyUnicode_Join (separator  seq )
    ((-gptr-"PyObject *") separator)  
    ((-gptr-"PyObject *") seq)   
    (gptr  #{  PyUnicode_Join(   $separator   ,$seq )  #} ))       ;; PyObject * -> gptr

(de PyUnicode_Tailmatch (str  substr  start  end  direction )
    ((-gptr-"PyObject *") str)  
    ((-gptr-"PyObject *") substr)  
    ((-int-) start)  
    ((-int-) end)  
    ((-int-) direction)   
    (int  #{  PyUnicode_Tailmatch(   $str   ,$substr   ,$start   ,$end   ,$direction )  #} ))

(de PyUnicode_Find (str  substr  start  end  direction )
    ((-gptr-"PyObject *") str)  
    ((-gptr-"PyObject *") substr)  
    ((-int-) start)  
    ((-int-) end)  
    ((-int-) direction)   
    (int  #{  PyUnicode_Find(   $str   ,$substr   ,$start   ,$end   ,$direction )  #} ))

(de PyUnicode_Count (str  substr  start  end )
    ((-gptr-"PyObject *") str)  
    ((-gptr-"PyObject *") substr)  
    ((-int-) start)  
    ((-int-) end)   
    (int  #{  PyUnicode_Count(   $str   ,$substr   ,$start   ,$end )  #} ))

(de PyUnicode_Replace (str  substr  replstr  maxcount )
    ((-gptr-"PyObject *") str)  
    ((-gptr-"PyObject *") substr)  
    ((-gptr-"PyObject *") replstr)  
    ((-int-) maxcount)   
    (gptr  #{  PyUnicode_Replace(   $str   ,$substr   ,$replstr   ,$maxcount )  #} ))       ;; PyObject * -> gptr

(de PyUnicode_Compare (left  right )
    ((-gptr-"PyObject *") left)  
    ((-gptr-"PyObject *") right)   
    (int  #{  PyUnicode_Compare(   $left   ,$right )  #} ))

(de PyUnicode_Format (format  args )
    ((-gptr-"PyObject *") format)  
    ((-gptr-"PyObject *") args)   
    (gptr  #{  PyUnicode_Format(   $format   ,$args )  #} ))       ;; PyObject * -> gptr

(de PyUnicode_Contains (container  element )
    ((-gptr-"PyObject *") container)  
    ((-gptr-"PyObject *") element)   
    (int  #{  PyUnicode_Contains(   $container   ,$element )  #} ))

(de _PyUnicode_IsLowercase (ch )
    ((-int-) ch)   
    (int  #{ _PyUnicode_IsLowercase(   $ch )  #} ))

(de _PyUnicode_IsUppercase (ch )
    ((Py_UNICODE) ch)   
    (int  #{ _PyUnicode_IsUppercase(   $ch )  #} ))

(de _PyUnicode_IsTitlecase (ch )
    ((Py_UNICODE) ch)   
    (int  #{ _PyUnicode_IsTitlecase(   $ch )  #} ))

(de _PyUnicode_IsWhitespace (ch )
    ((Py_UNICODE) ch)   
    (int  #{ _PyUnicode_IsWhitespace(   $ch )  #} ))

(de _PyUnicode_IsLinebreak (ch )
    ((Py_UNICODE) ch)   
    (int  #{ _PyUnicode_IsLinebreak(   $ch )  #} ))

(de _PyUnicode_ToLowercase (ch )
    ((Py_UNICODE) ch)   
    (int  #{ _PyUnicode_ToLowercase(   $ch )  #} )) ;;Py_UNICODE -> int

(de _PyUnicode_ToUppercase (ch )
    ((Py_UNICODE) ch)   
    (int  #{ _PyUnicode_ToUppercase(   $ch )  #} ))  ;; Py_UNICODE -> int

(de _PyUnicode_ToTitlecase (ch )
    ((Py_UNICODE) ch)   
    (int  #{ _PyUnicode_ToTitlecase(   $ch )  #} ))  ;; Py_UNICODE -> int

(de _PyUnicode_ToDecimalDigit (ch )
    ((Py_UNICODE) ch)   
    (int  #{ _PyUnicode_ToDecimalDigit(   $ch )  #} ))

(de _PyUnicode_ToDigit (ch )
    ((Py_UNICODE) ch)   
    (int  #{ _PyUnicode_ToDigit(   $ch )  #} ))

(de _PyUnicode_ToNumeric (ch )
    ((Py_UNICODE) ch)   
    (double  #{ _PyUnicode_ToNumeric(   $ch )  #} ))

(de _PyUnicode_IsDecimalDigit (ch )
    ((Py_UNICODE) ch)   
    (int  #{ _PyUnicode_IsDecimalDigit(   $ch )  #} ))

(de _PyUnicode_IsDigit (ch )
    ((Py_UNICODE) ch)   
    (int  #{ _PyUnicode_IsDigit(   $ch )  #} ))

(de _PyUnicode_IsNumeric (ch )
    ((Py_UNICODE) ch)   
    (int  #{ _PyUnicode_IsNumeric(   $ch )  #} ))

(de _PyUnicode_IsAlpha (ch )
    ((Py_UNICODE) ch)   
    (int  #{ _PyUnicode_IsAlpha(   $ch )  #} ))

;; ********************************************************

(dhc-make () 
  dummy_pyunicode
  pyunicode_fromunicode
  pyunicode_asunicode
  pyunicode_getsize
  pyunicode_getmax
  pyunicode_resize
  pyunicode_fromencodedobject
  pyunicode_fromobject
  pyunicode_fromwidechar
  pyunicode_aswidechar
  _pyunicode_asdefaultencodedstring
  pyunicode_getdefaultencoding
  pyunicode_setdefaultencoding
  pyunicode_decode
  pyunicode_encode
  pyunicode_asencodedstring
  pyunicode_decodeutf7
  pyunicode_encodeutf7
  pyunicode_decodeutf8
  pyunicode_asutf8string
  pyunicode_encodeutf8
  pyunicode_decodeutf16
  pyunicode_asutf16string
  pyunicode_encodeutf16
  pyunicode_decodeunicodeescape
  pyunicode_asunicodeescapestring
  pyunicode_encodeunicodeescape
  pyunicode_decoderawunicodeescape
  pyunicode_asrawunicodeescapestring
  pyunicode_encoderawunicodeescape
  pyunicode_decodelatin1
  pyunicode_aslatin1string
  pyunicode_encodelatin1
  pyunicode_decodeascii
  pyunicode_asasciistring
  pyunicode_encodeascii
  pyunicode_decodecharmap
  pyunicode_ascharmapstring
  pyunicode_encodecharmap
  pyunicode_translatecharmap
  pyunicode_encodedecimal
  pyunicode_concat
  pyunicode_split
  pyunicode_splitlines
  pyunicode_translate
  pyunicode_join
  pyunicode_tailmatch
  pyunicode_find
  pyunicode_count
  pyunicode_replace
  pyunicode_compare
  pyunicode_format
  pyunicode_contains
  _pyunicode_islowercase
  _pyunicode_isuppercase
  _pyunicode_istitlecase
  _pyunicode_iswhitespace
  _pyunicode_islinebreak
  _pyunicode_tolowercase
  _pyunicode_touppercase
  _pyunicode_totitlecase
  _pyunicode_todecimaldigit
  _pyunicode_todigit
  _pyunicode_tonumeric
  _pyunicode_isdecimaldigit
  _pyunicode_isdigit
  _pyunicode_isnumeric
  _pyunicode_isalpha
)
