view release on metacpan or  search on metacpan

libjit/doc/mangling_rules.txt  view on Meta::CPAN

         # ::std::basic_string

                    ::= Ss
         # ::std::basic_string<char,
                               ::std::char_traits<char>,
                               ::std::allocator<char> >

                    ::= Si
         # ::std::basic_istream<char, ::std::char_traits<char> >

                    ::= So
         # ::std::basic_ostream<char, ::std::char_traits<char> >

                    ::= Sd
         # ::std::basic_iostream<char, ::std::char_traits<char> >

                    ::= S <seq-id> _		# base 36 sequence id
                    ::= S_

<mangled-name>      ::= _Z <encoding>

<encoding>          ::= <function name> <bare-function-type>
                    ::= <data name>

<name>              ::= <unscoped-name>
                    ::= <unscoped-template-name> <template-args>
                    ::= <nested-name>
                    ::= <local-name>

   If IGNORE_LOCAL_SCOPE option to <name> is non-zero, this production of
   <name> is called from <local-name>, which mangles the enclosing scope
   elsewhere and then uses this function to mangle just the part
   underneath the function scope.  So don't use the <local-name>
   production, to avoid an infinite recursion.

<unscoped-name>     ::= <unqualified-name>
                    ::= St <unqualified-name>   # ::std::

<unscoped-template-name> ::= <unscoped-name>
                         ::= <substitution>

<nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
              ::= N [<CV-qualifiers>] <template-prefix> <template-args> E

<CV-qualifiers>     ::= [r] [V] [K]

<prefix>            ::= <prefix> <unqualified-name>>
                    ::= <template-prefix> <template-args>
                    ::= # empty
                    ::= <substitution>

<template-prefix>   ::= <prefix> <template component>
                    ::= <substitution>

<unqualified-name>  ::= <operator-name>
                    ::= <special-name>
                    ::= <source-name>

<source-name>       ::= </length/ number> <identifier>

<number>            ::= [n] </decimal integer/>

<identifier>        ::= </unqualified source code identifier>

<special-name>      ::= C1   # complete object constructor
                    ::= C2   # base object constructor
                    ::= C3   # complete object allocating constructor
                    ::= D0 # deleting (in-charge) destructor
                    ::= D1 # complete object (in-charge) destructor
                    ::= D2 # base object (not-in-charge) destructor
                    ::= CT <type> <offset number> _ <base type>
                    ::= Th <offset number> _ <base encoding>
                    ::= Tv <offset number> _ <vcall offset number> _
                                                            <base encoding>

<discriminator>     := _ <number>

<local-name>        := Z <function encoding> E <entity name> [<discriminator>]
                    := Z <function encoding> E s [<discriminator>]

<type>              ::= <builtin-type>
                    ::= <function-type>
                    ::= <class-enum-type>
                    ::= <array-type>
                    ::= <pointer-to-member-type>
                    ::= <template-param>
                    ::= <substitution>
                    ::= <CV-qualifier>
                    ::= P <type>    # pointer-to
                    ::= R <type>    # reference-to
                    ::= C <type>    # complex pair (C 2000)
                    ::= G <type>    # imaginary (C 2000)     [not supported]
                    ::= U <source-name> <type> # vendor extended type qualifier

<builtin-type>      ::= v   # void
                    ::= b   # bool
                    ::= w   # wchar_t
                    ::= c   # char
                    ::= a   # signed char
                    ::= h   # unsigned char
                    ::= s   # short
                    ::= t   # unsigned short
                    ::= i   # int
                    ::= j   # unsigned int
                    ::= l   # long
                    ::= m   # unsigned long
                    ::= x   # long long, __int64
                    ::= y   # unsigned long long, __int64
                    ::= n   # __int128
                    ::= o   # unsigned __int128
                    ::= f   # float
                    ::= d   # double
                    ::= e   # long double, __float80
                    ::= g   # __float128          [not supported]
                    ::= u <source-name>  # vendor extended type */

<function-type>     ::= F [Y] <bare-function-type> E

<bare-function-type> ::= </signature/ type>+

<class-enum-type>   ::= <name>