Subversion Repositories openrisc_me

# Copyright (C) 1992, 1997, 1999, 2003, 2004, 2007, 2008, 2009, 2010

# Free Software Foundation, Inc.

# 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 3 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, see .

# This file was written by Fred Fish. (fnf@cygnus.com)

if $tracelevel then {

    strace $tracelevel

}

if { [skip_cplus_tests] } { continue }

### The demangling style we last sent to GDB.

set current_demangling_style none

### Set GDB's current demangling style to STYLE.  Subsequent calls to

### test_demangle will include STYLE in the test name when reporting

### passes and failures.

proc set_demangling_style {style} {

    global gdb_prompt

    global current_demangling_style

    send_gdb "set demangle-style $style\n"

    gdb_expect {

        -re "set demangle-style $style\[\r\n\]+$gdb_prompt $" {

            pass "$style: set demangle-style"

        }

        -re ".*$gdb_prompt $" {

            fail "$style: set demangle-style"

            error "set_demangling_style: set style"

        }

        timeout {

            fail "$style: set demangle-style (timeout)"

            error "set_demangling_style: set style"

        }

    }

    send_gdb "show demangle-style\n"

    gdb_expect {

        -re "The current C\[+\]+ demangling style is \"$style\".\r\n$gdb_prompt $" {

            pass "$style: check demangling style"

        }

        -re ".*$gdb_prompt $" {

            fail "$style: check demangling style"

            error "set_demangling_style: check style"

        }

        timeout {

            fail "$style: check demangling style (timeout)"

            error "set_demangling_style: check style"

        }

    }

    set current_demangling_style $style

}

### Utility function for test_demangling and test_demangling_exact.

proc test_demangling_core {tester test result} {

    global current_demangling_style

    if {! [regexp {^([^ ]+): (.+)$} $test dummy style name]} {

      error "bad test name passed to test_demangling"

    }

    if {[string compare $style $current_demangling_style]} {

        set_demangling_style $style

    }

    $tester "maintenance demangle $name" $result $test

}

### Demangle an identifier, and check that the result matches a pattern.

###

### TEST should be of the form "STYLE: NAME", where STYLE is the name

### of a demangling style (like "gnu" or "arm"), and NAME is a mangled

### identifier to demangle.  Pass when the result matches the regular

### expression RESULT.  Report passes and fails using TEST as the name

### of the test.

###

### Why don't we just pass the STYLE and NAME as two separate

### arguments, or let the style be a global variable?  That would be

### cleaner.  However, doing it this way means that:

###

### 1) the name of the test, as recorded in the summary and log,

### appears verbatim in the script, and

###

### 2) that test names are unique, even though we try to demangle the same

### identifiers using several different mangling styles.

###

### This makes it a lot easier for people tracking down failures to

### find the one they care about.

proc test_demangling {test result} {

    test_demangling_core gdb_test $test $result

}

### Like test_demangling, above, except that RESULT is not a regexp,

### but a string that must match exactly.

proc test_demangling_exact {test result} {

    test_demangling_core gdb_test_exact $test $result

}

#

#  Test gnu style name demangling

#

proc test_gnu_style_demangling {} {

    global gdb_prompt

    test_demangling "gnu: Abort__FP6EditoriPCc" \

        "Abort\[(\]+Editor \[*\]+, int, (const char|char const) \[*\]+\[)\]+"

    test_demangling_exact "gnu: AddAlignment__9ivTSolverUiP12ivInteractorP7ivTGlue" "ivTSolver::AddAlignment(unsigned int, ivInteractor *, ivTGlue *)"

    test_demangling "gnu: Append__15NameChooserViewPCc" \

        "NameChooserView::Append\[(\]+(const char|char const) \[*\]+\[)\]+"

    test_demangling_exact "gnu: ArrowheadIntersects__9ArrowLineP9ArrowheadR6BoxObjP7Graphic" "ArrowLine::ArrowheadIntersects(Arrowhead *, BoxObj &, Graphic *)"

    test_demangling_exact "gnu: AtEnd__13ivRubberGroup" "ivRubberGroup::AtEnd(void)"

    test_demangling_exact "gnu: BgFilter__9ivTSolverP12ivInteractor" "ivTSolver::BgFilter(ivInteractor *)"

    test_demangling "gnu: BitPatterntoa__FRC10BitPatternccc" \

        "BitPatterntoa\[(\]+(const BitPattern|BitPattern const) &, char, char, char\[)\]+"

    test_demangling_exact "gnu: Check__6UArrayi" "UArray::Check(int)"

    test_demangling_exact "gnu: CoreConstDecls__8TextCodeR7ostream" "TextCode::CoreConstDecls(ostream &)"

    test_demangling_exact "gnu: Detach__8StateVarP12StateVarView" "StateVar::Detach(StateVarView *)"

    test_demangling_exact "gnu: Done__9ComponentG8Iterator" "Component::Done(Iterator)"

    test_demangling "gnu: DrawDestinationTransformedImage__FP7_XImageiiT0iiUlUiiiUiUlUlP4_XGCRC13ivTransformeriiii" \

        "DrawDestinationTransformedImage\[(\]+_XImage \[*\]+, int, int, _XImage \[*\]+, int, int, unsigned long, unsigned int, int, int, unsigned int, unsigned long, unsigned long, _XGC \[*\]+, (const ivTransformer|ivTransformer const) &, int, int, int, int\[)\]+"

    test_demangling "gnu: Edit__12StringEditorPCcii" \

        "StringEditor::Edit\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"

    test_demangling_exact "gnu: Effect__11RelateManipR7ivEvent" "RelateManip::Effect(ivEvent &)"

    test_demangling "gnu: FilterName__FPCc" \

        "FilterName\[(\]+(const char|char const) \[*\]+\[)\]+"

    test_demangling "gnu: Filter__6PSTextPCci" \

        "PSText::Filter\[(\]+(const char|char const) \[*\]+, int\[)\]+"

    test_demangling "gnu: FindColor__7CatalogPCciii" \

        "Catalog::FindColor\[(\]+(const char|char const) \[*\]+, int, int, int\[)\]+"

    test_demangling_exact "gnu: FindFixed__FRP4CNetP4CNet" "FindFixed(CNet *&, CNet *)"

    test_demangling "gnu: FindFont__7CatalogPCcN21" \

        "Catalog::FindFont\[(\]+(const char|char const) \[*\]+, (const char|char const) \[*\]+, (const char|char const) \[*\]+\[)\]+"

    test_demangling_exact "gnu: Fix48_abort__FR8twolongs" "Fix48_abort(twolongs &)"

    test_demangling_exact "gnu: GetBarInfo__15iv2_6_VScrollerP13ivPerspectiveRiT2" "iv2_6_VScroller::GetBarInfo(ivPerspective *, int &, int &)"

    test_demangling_exact "gnu: GetBgColor__C9ivPainter" "ivPainter::GetBgColor(void) const"

    test_demangling "gnu: Iisdouble__FPC6IntRep" \

        "Iisdouble\[(\]+(const IntRep|IntRep const) \[*\]+\[)\]+"

    test_demangling_exact "gnu: InsertBody__15H_PullrightMenuii" "H_PullrightMenu::InsertBody(int, int)"

    test_demangling_exact "gnu: InsertCharacter__9TextManipc" "TextManip::InsertCharacter(char)"

    test_demangling_exact "gnu: InsertToplevel__7ivWorldP12ivInteractorT1" "ivWorld::InsertToplevel(ivInteractor *, ivInteractor *)"

    test_demangling_exact "gnu: InsertToplevel__7ivWorldP12ivInteractorT1iiUi" "ivWorld::InsertToplevel(ivInteractor *, ivInteractor *, int, int, unsigned int)"

    test_demangling "gnu: IsADirectory__FPCcR4stat" \

        "IsADirectory\[(\]+(const char|char const) \[*\]+, stat &\[)\]+"

    test_demangling_exact "gnu: IsAGroup__FP11GraphicViewP11GraphicComp" "IsAGroup(GraphicView *, GraphicComp *)"

    test_demangling_exact "gnu: IsA__10ButtonCodeUl" "ButtonCode::IsA(unsigned long)"

    test_demangling_exact "gnu: ReadName__FR7istreamPc" "ReadName(istream &, char *)"

    test_demangling_exact "gnu: Redraw__13StringBrowseriiii" "StringBrowser::Redraw(int, int, int, int)"

    test_demangling_exact "gnu: Rotate__13ivTransformerf" "ivTransformer::Rotate(float)"

    test_demangling_exact "gnu: Rotated__C13ivTransformerf" "ivTransformer::Rotated(float) const"

    test_demangling_exact "gnu: Round__Ff" "Round(float)"

    test_demangling_exact "gnu: SetExport__16MemberSharedNameUi" "MemberSharedName::SetExport(unsigned int)"

    test_demangling_exact "gnu: Set__14ivControlState13ControlStatusUi" "ivControlState::Set(ControlStatus, unsigned int)"

    test_demangling_exact "gnu: Set__5DFacePcii" "DFace::Set(char *, int, int)"

    test_demangling_exact "gnu: VConvert__9ivTSolverP12ivInteractorRP8TElementT2" "ivTSolver::VConvert(ivInteractor *, TElement *&, TElement *&)"

    test_demangling_exact "gnu: VConvert__9ivTSolverP7ivTGlueRP8TElement" "ivTSolver::VConvert(ivTGlue *, TElement *&)"

    test_demangling_exact "gnu: VOrder__9ivTSolverUiRP12ivInteractorT2" "ivTSolver::VOrder(unsigned int, ivInteractor *&, ivInteractor *&)"

    test_demangling "gnu: Valid__7CatalogPCcRP4Tool" \

        "Catalog::Valid\[(\]+(const char|char const) \[*\]+, Tool \[*\]+&\[)\]+"

    test_demangling_exact "gnu: _10PageButton\$__both" "PageButton::__both"

    test_demangling_exact "gnu: _3RNG\$singleMantissa" "RNG::singleMantissa"

    test_demangling_exact "gnu: _5IComp\$_release" "IComp::_release"

    test_demangling_exact "gnu: _\$_10BitmapComp" "BitmapComp::~BitmapComp(void)"

    test_demangling_exact "gnu: _\$_9__io_defs" "__io_defs::~__io_defs(void)"

    test_demangling_exact "gnu: _\$_Q23foo3bar" "foo::bar::~bar(void)"

    test_demangling_exact "gnu: _\$_Q33foo3bar4bell" "foo::bar::bell::~bell(void)"

    test_demangling_exact "gnu: __10ivTelltaleiP7ivGlyph" "ivTelltale::ivTelltale(int, ivGlyph *)"

    test_demangling_exact "gnu: __10ivViewportiP12ivInteractorUi" "ivViewport::ivViewport(int, ivInteractor *, unsigned int)"

    test_demangling_exact "gnu: __10ostrstream" "ostrstream::ostrstream(void)"

    test_demangling_exact "gnu: __10ostrstreamPcii" "ostrstream::ostrstream(char *, int, int)"

    test_demangling "gnu: __11BasicDialogiPCcP13ivButtonStateN22Ui" \

        "BasicDialog::BasicDialog\[(\]+int, (const char|char const) \[*\]+, ivButtonState \[*\]+, (const char|char const) \[*\]+, (const char|char const) \[*\]+, unsigned int\[)\]+"

    test_demangling_exact "gnu: __11BitmapTablei" "BitmapTable::BitmapTable(int)"

    test_demangling_exact "gnu: __12ViewportCodeP12ViewportComp" "ViewportCode::ViewportCode(ViewportComp *)"

    test_demangling "gnu: __12iv2_6_BorderiPCci" \

        "iv2_6_Border::iv2_6_Border\[(\]+int, (const char|char const) \[*\]+, int\[)\]+"

    test_demangling_exact "gnu: __12iv2_6_Borderii" "iv2_6_Border::iv2_6_Border(int, int)"

    test_demangling "gnu: __12ivBackgroundiP7ivGlyphPC7ivColor" \

        "ivBackground::ivBackground\[(\]+int, ivGlyph \[*\]+, (const ivColor|ivColor const) \[*\]+\[)\]+"

    test_demangling_exact "gnu: __12ivBreak_Listl" "ivBreak_List::ivBreak_List(long)"

    test_demangling "gnu: __14TextInteractoriPCcUi" \

        "TextInteractor::TextInteractor\[(\]+int, (const char|char const) \[*\]+, unsigned int\[)\]+"

    test_demangling_exact "gnu: __14iv2_6_MenuItemiP12ivInteractor" "iv2_6_MenuItem::iv2_6_MenuItem(int, ivInteractor *)"

    test_demangling "gnu: __14iv2_6_MenuItemiPCcP12ivInteractor" \

        "iv2_6_MenuItem::iv2_6_MenuItem\[(\]+int, (const char|char const) \[*\]+, ivInteractor \[*\]+\[)\]+"

    test_demangling_exact "gnu: __20DisplayList_IteratorR11DisplayList" "DisplayList_Iterator::DisplayList_Iterator(DisplayList &)"

    test_demangling_exact "gnu: __3fooRT0" "foo::foo(foo &)"

    test_demangling_exact "gnu: __3fooiN31" "foo::foo(int, int, int, int)"

    test_demangling "gnu: __3fooiPCc" \

        "foo::foo\[(\]+int, (const char|char const) \[*\]+\[)\]+"

    test_demangling_exact "gnu: __3fooiRT0iT2iT2" "foo::foo(int, foo &, int, foo &, int, foo &)"

    test_demangling "gnu: __6GetOptiPPcPCc" \

        "GetOpt::GetOpt\[(\]+int, char \[*\]+\[*\]+, (const char|char const) \[*\]+\[)\]+"

    test_demangling_exact "gnu: __6KeyMapPT0" "KeyMap::KeyMap(KeyMap *)"

    test_demangling "gnu: __7ivWorldPCcRiPPcPC12ivOptionDescPC14ivPropertyData" \

        "ivWorld::ivWorld\[(\]+(const char|char const) \[*\]+, int &, char \[*\]+\[*\]+, (const ivOptionDesc|ivOptionDesc const) \[*\]+, (const ivPropertyData|ivPropertyData const) \[*\]+\[)\]+"

    test_demangling "gnu: __7procbufPCci" \

        "procbuf::procbuf\[(\]+(const char|char const) \[*\]+, int\[)\]+"

    test_demangling_exact "gnu: __8ArrowCmdP6EditorUiUi" "ArrowCmd::ArrowCmd(Editor *, unsigned int, unsigned int)"

    test_demangling_exact "gnu: __9F_EllipseiiiiP7Graphic" "F_Ellipse::F_Ellipse(int, int, int, int, Graphic *)"

    test_demangling_exact "gnu: __9FrameDataP9FrameCompi" "FrameData::FrameData(FrameComp *, int)"

    test_demangling_exact "gnu: __9HVGraphicP9CanvasVarP7Graphic" "HVGraphic::HVGraphic(CanvasVar *, Graphic *)"

    test_demangling_exact "gnu: __Q23foo3bar" "foo::bar::bar(void)"

    test_demangling_exact "gnu: __Q33foo3bar4bell" "foo::bar::bell::bell(void)"

    test_demangling_exact "gnu: __aa__3fooRT0" "foo::operator&&(foo &)"

    test_demangling_exact "gnu: __aad__3fooRT0" "foo::operator&=(foo &)"

    test_demangling_exact "gnu: __ad__3fooRT0" "foo::operator&(foo &)"

    test_demangling_exact "gnu: __adv__3fooRT0" "foo::operator/=(foo &)"

    test_demangling_exact "gnu: __aer__3fooRT0" "foo::operator^=(foo &)"

    test_demangling_exact "gnu: __als__3fooRT0" "foo::operator<<=(foo &)"

    test_demangling_exact "gnu: __amd__3fooRT0" "foo::operator%=(foo &)"

    test_demangling_exact "gnu: __ami__3fooRT0" "foo::operator-=(foo &)"

    test_demangling_exact "gnu: __aml__3FixRT0" "Fix::operator*=(Fix &)"

    test_demangling_exact "gnu: __aml__5Fix16i" "Fix16::operator*=(int)"

    test_demangling_exact "gnu: __aml__5Fix32RT0" "Fix32::operator*=(Fix32 &)"

    test_demangling_exact "gnu: __aor__3fooRT0" "foo::operator|=(foo &)"

    test_demangling_exact "gnu: __apl__3fooRT0" "foo::operator+=(foo &)"

    test_demangling_exact "gnu: __ars__3fooRT0" "foo::operator>>=(foo &)"

    test_demangling_exact "gnu: __as__3fooRT0" "foo::operator=(foo &)"

    test_demangling_exact "gnu: __cl__3fooRT0" "foo::operator()(foo &)"

    test_demangling_exact "gnu: __cl__6Normal" "Normal::operator()(void)"

    test_demangling_exact "gnu: __cl__6Stringii" "String::operator()(int, int)"

    test_demangling_exact "gnu: __cm__3fooRT0" "foo::operator, (foo &)"

    test_demangling_exact "gnu: __co__3foo" "foo::operator~(void)"

    test_demangling_exact "gnu: __dl__3fooPv" "foo::operator delete(void *)"

    test_demangling_exact "gnu: __dv__3fooRT0" "foo::operator/(foo &)"

    test_demangling_exact "gnu: __eq__3fooRT0" "foo::operator==(foo &)"

    test_demangling_exact "gnu: __er__3fooRT0" "foo::operator^(foo &)"

    test_demangling_exact "gnu: __ge__3fooRT0" "foo::operator>=(foo &)"

    test_demangling_exact "gnu: __gt__3fooRT0" "foo::operator>(foo &)"

    test_demangling_exact "gnu: __le__3fooRT0" "foo::operator<=(foo &)"

    test_demangling_exact "gnu: __ls__3fooRT0" "foo::operator<<(foo &)"

    test_demangling_exact "gnu: __ls__FR7ostreamPFR3ios_R3ios" "operator<<(ostream &, ios &(*)(ios &))"

    test_demangling_exact "gnu: __ls__FR7ostreamR3Fix" "operator<<(ostream &, Fix &)"

    test_demangling_exact "gnu: __lt__3fooRT0" "foo::operator<(foo &)"

    test_demangling_exact "gnu: __md__3fooRT0" "foo::operator%(foo &)"

    test_demangling_exact "gnu: __mi__3fooRT0" "foo::operator-(foo &)"

    test_demangling_exact "gnu: __ml__3fooRT0" "foo::operator*(foo &)"

    test_demangling_exact "gnu: __mm__3fooi" "foo::operator--(int)"

    test_demangling_exact "gnu: __ne__3fooRT0" "foo::operator!=(foo &)"

    test_demangling "gnu: __ne__FRC7ComplexT0" \

        "operator!=\[(\]+(const Complex|Complex const) &, (const Complex|Complex const) &\[)\]+"

    test_demangling "gnu: __ne__FRC7Complexd" \

        "operator!=\[(\]+(const Complex|Complex const) &, double\[)\]+"

    test_demangling "gnu: __ne__FRC9SubStringRC6String" \

        "operator!=\[(\]+(const SubString|SubString const) &, (const String|String const) &\[)\]+"

    test_demangling_exact "gnu: __nt__3foo" "foo::operator!(void)"

    test_demangling_exact "gnu: __nw__3fooi" "foo::operator new(int)"

    test_demangling_exact "gnu: __oo__3fooRT0" "foo::operator||(foo &)"

    test_demangling_exact "gnu: __opPc__3foo" "foo::operator char *(void)"

    test_demangling_exact "gnu: __opi__3foo" "foo::operator int(void)"

    test_demangling_exact "gnu: __or__3fooRT0" "foo::operator|(foo &)"

    test_demangling_exact "gnu: __pl__3fooRT0" "foo::operator+(foo &)"

    test_demangling_exact "gnu: __pp__3fooi" "foo::operator++(int)"

    test_demangling_exact "gnu: __rf__3foo" "foo::operator->(void)"

    test_demangling_exact "gnu: __rm__3fooRT0" "foo::operator->*(foo &)"

    test_demangling_exact "gnu: __rs__3fooRT0" "foo::operator>>(foo &)"

    test_demangling "gnu: __vc__3fooRT0" "foo::operator\\\[\\\]\\(foo &\\)"

    test_demangling "gnu: _gsub__6StringRC5RegexPCci" \

        "String::_gsub\[(\]+(const Regex|Regex const) &, (const char|char const) \[*\]+, int\[)\]+"

    test_demangling_exact "gnu: _new_Fix__FUs" "_new_Fix(unsigned short)"

    # gcc 2.4.5 (and earlier) style virtual tables.  We want to continue to

    # correctly demangle these even if newer compilers use a different form.

    test_demangling_exact "gnu: _vt.foo" "foo virtual table"

    test_demangling_exact "gnu: _vt.foo.bar" "foo::bar virtual table"

    test_demangling_exact "gnu: _vt\$foo" "foo virtual table"

    test_demangling_exact "gnu: _vt\$foo\$bar" "foo::bar virtual table"

    test_demangling_exact "gnu: append__7ivGlyphPT0" "ivGlyph::append(ivGlyph *)"

    test_demangling "gnu: arg__FRC7Complex" \

        "arg\[(\]+(const Complex|Complex const) &\[)\]+"

    test_demangling_exact "gnu: clearok__FP7_win_sti" "clearok(_win_st *, int)"

    test_demangling_exact "gnu: complexfunc2__FPFPc_i" "complexfunc2(int (*)(char *))"

    test_demangling_exact "gnu: complexfunc3__FPFPFPl_s_i" "complexfunc3(int (*)(short (*)(long *)))"

    test_demangling_exact "gnu: complexfunc4__FPFPFPc_s_i" "complexfunc4(int (*)(short (*)(char *)))"

    test_demangling_exact "gnu: complexfunc5__FPFPc_PFl_i" "complexfunc5(int (*(*)(char *))(long))"

    test_demangling_exact "gnu: complexfunc6__FPFPi_PFl_i" "complexfunc6(int (*(*)(int *))(long))"

    test_demangling_exact "gnu: complexfunc7__FPFPFPc_i_PFl_i" "complexfunc7(int (*(*)(int (*)(char *)))(long))"

    test_demangling "gnu: contains__C9BitStringRC10BitPattern" \

        "BitString::contains\[(\]+(const BitPattern|BitPattern const) &\[)\]+ const"

    test_demangling "gnu: contains__C9BitStringRC12BitSubStringi" \

        "BitString::contains\[(\]+(const BitSubString|BitSubString const) &, int\[)\]+ const"

    test_demangling "gnu: contains__C9BitStringRT0" \

        "BitString::contains\[(\]+(const BitString|BitString const) &\[)\]+ const"

    test_demangling "gnu: div__FPC6IntRepT0P6IntRep" \

        "div\[(\]+(const IntRep|IntRep const) \[*\]+, (const IntRep|IntRep const) \[*\]+, IntRep \[*\]+\[)\]+"

    test_demangling "gnu: div__FPC6IntReplP6IntRep" \

        "div\[(\]+(const IntRep|IntRep const) \[*\]+, long, IntRep \[*\]+\[)\]+"

    test_demangling "gnu: div__FRC8RationalT0R8Rational" \

        "div\[(\]+(const Rational|Rational const) &, (const Rational|Rational const) &, Rational &\[)\]+"

    test_demangling "gnu: divide__FRC7IntegerT0R7IntegerT2" \

        "divide\[(\]+(const Integer|Integer const) &, (const Integer|Integer const) &, Integer &, Integer &\[)\]+"

    test_demangling "gnu: divide__FRC7IntegerlR7IntegerRl" \

        "divide\[(\]+(const Integer|Integer const) &, long, Integer &, long &\[)\]+"

    test_demangling "gnu: enable__14DocumentViewerPCcUi" \

        "DocumentViewer::enable\[(\]+(const char|char const) \[*\]+, unsigned int\[)\]+"

    test_demangling_exact "gnu: foo__FiN30" "foo(int, int, int, int)"

    test_demangling_exact "gnu: foo__FiR3fooiT1iT1" "foo(int, foo &, int, foo &, int, foo &)"

    test_demangling_exact "gnu: foo___3barl" "bar::foo_(long)"

    test_demangling_exact "gnu: insert__15ivClippingStacklRP8_XRegion" "ivClippingStack::insert(long, _XRegion *&)"

    test_demangling_exact "gnu: insert__16ChooserInfo_ListlR11ChooserInfo" "ChooserInfo_List::insert(long, ChooserInfo &)"

    test_demangling_exact "gnu: insert__17FontFamilyRepListlRP15ivFontFamilyRep" "FontFamilyRepList::insert(long, ivFontFamilyRep *&)"

    test_demangling_exact "gnu: leaveok__FP7_win_stc" "leaveok(_win_st *, char)"

    test_demangling_exact "gnu: left_mover__C7ivMFKitP12ivAdjustableP7ivStyle" "ivMFKit::left_mover(ivAdjustable *, ivStyle *) const"

    test_demangling "gnu: matches__C9BitStringRC10BitPatterni" \

        "BitString::matches\[(\]+(const BitPattern|BitPattern const) &, int\[)\]+ const"

    test_demangling "gnu: matches__C9SubStringRC5Regex" \

        "SubString::matches\[(\]+(const Regex|Regex const) &\[)\]+ const"

    test_demangling_exact "gnu: overload1arg__FSc" "overload1arg(signed char)"

    test_demangling_exact "gnu: overload1arg__FUc" "overload1arg(unsigned char)"

    test_demangling_exact "gnu: overload1arg__FUi" "overload1arg(unsigned int)"

    test_demangling_exact "gnu: overload1arg__FUl" "overload1arg(unsigned long)"

    test_demangling_exact "gnu: overload1arg__FUs" "overload1arg(unsigned short)"

    test_demangling_exact "gnu: overload1arg__Fc" "overload1arg(char)"

    test_demangling_exact "gnu: overload1arg__Fd" "overload1arg(double)"

    test_demangling_exact "gnu: overload1arg__Ff" "overload1arg(float)"

    test_demangling_exact "gnu: overload1arg__Fi" "overload1arg(int)"

    test_demangling_exact "gnu: overload1arg__Fl" "overload1arg(long)"

    test_demangling_exact "gnu: overload1arg__Fs" "overload1arg(short)"

    test_demangling_exact "gnu: overload1arg__Fv" "overload1arg(void)"

    test_demangling_exact "gnu: overloadargs__Fi" "overloadargs(int)"

    test_demangling_exact "gnu: overloadargs__Fii" "overloadargs(int, int)"

    test_demangling_exact "gnu: overloadargs__Fiii" "overloadargs(int, int, int)"

    test_demangling_exact "gnu: overloadargs__Fiiii" "overloadargs(int, int, int, int)"

    test_demangling_exact "gnu: overloadargs__Fiiiii" "overloadargs(int, int, int, int, int)"

    test_demangling_exact "gnu: overloadargs__Fiiiiii" "overloadargs(int, int, int, int, int, int)"

    test_demangling_exact "gnu: overloadargs__Fiiiiiii" "overloadargs(int, int, int, int, int, int, int)"

    test_demangling_exact "gnu: overloadargs__Fiiiiiiii" "overloadargs(int, int, int, int, int, int, int, int)"

    test_demangling_exact "gnu: overloadargs__Fiiiiiiiii" "overloadargs(int, int, int, int, int, int, int, int, int)"

    test_demangling_exact "gnu: overloadargs__Fiiiiiiiiii" "overloadargs(int, int, int, int, int, int, int, int, int, int)"

    test_demangling_exact "gnu: overloadargs__Fiiiiiiiiiii" "overloadargs(int, int, int, int, int, int, int, int, int, int, int)"

    test_demangling "gnu: pick__13ivCompositionP8ivCanvasRC12ivAllocationiR5ivHit" \

        "ivComposition::pick\[(\]+ivCanvas \[*\]+, (const ivAllocation|ivAllocation const) &, int, ivHit &\[)\]+"

    test_demangling "gnu: pointer__C11ivHScrollerRC7ivEventRC12ivAllocation" \

        "ivHScroller::pointer\[(\]+(const ivEvent|ivEvent const) &, (const ivAllocation|ivAllocation const) &\[)\]+ const"

    test_demangling_exact "gnu: poke__8ivRasterUlUlffff" "ivRaster::poke(unsigned long, unsigned long, float, float, float, float)"

    test_demangling_exact "gnu: polar__Fdd" "polar(double, double)"

    test_demangling "gnu: read__10osStdInputRPCc" \

        "osStdInput::read\[(\]+(const char|char const) \[*\]+&\[)\]+"

    test_demangling_exact "gnu: scale__13ivTransformerff" "ivTransformer::scale(float, float)"

    test_demangling "gnu: scanw__12CursesWindowPCce" \

        "CursesWindow::scanw\[(\]+(const char|char const) \[*\]+,...\[)\]+"

    test_demangling "gnu: scmp__FPCcT0" \

        "scmp\[(\]+(const char|char const) \[*\]+, (const char|char const) \[*\]+\[)\]+"

    test_demangling_exact "gnu: sgetn__7filebufPci" "filebuf::sgetn(char *, int)"

    test_demangling_exact "gnu: shift__FP5_FrepiT0" "shift(_Frep *, int, _Frep *)"

    test_demangling_exact "gnu: test__C6BitSeti" "BitSet::test(int) const"

    test_demangling_exact "gnu: test__C6BitSetii" "BitSet::test(int, int) const"

    test_demangling "gnu: testbit__FRC7Integerl" \

        "testbit\[(\]+(const Integer|Integer const) &, long\[)\]+"

    test_demangling_exact "gnu: text_source__8Documentl" "Document::text_source(long)"

    test_demangling_exact "gnu: variance__6Erlangd" "Erlang::variance(double)"

    test_demangling "gnu: vform__8iostreamPCcPc" \

        "iostream::vform\[(\]+(const char|char const) \[*\]+, char \[*\]+\[)\]+"

    test_demangling_exact "gnu: view__14DocumentViewerP8ItemViewP11TabularItem" "DocumentViewer::view(ItemView *, TabularItem *)"

    test_demangling_exact "gnu: xy_extents__11ivExtensionffff" "ivExtension::xy_extents(float, float, float, float)"

    test_demangling_exact "gnu: zero__8osMemoryPvUi" "osMemory::zero(void *, unsigned int)"

    test_demangling_exact "gnu: _2T4\$N" "T4::N"

    test_demangling_exact "gnu: _Q22T42t1\$N" "T4::t1::N"

    test_demangling_exact "gnu: get__2T1" "T1::get(void)"

    test_demangling_exact "gnu: get__Q22T11a" "T1::a::get(void)"

    test_demangling_exact "gnu: get__Q32T11a1b" "T1::a::b::get(void)"

    test_demangling_exact "gnu: get__Q42T11a1b1c" "T1::a::b::c::get(void)"

    test_demangling_exact "gnu: get__Q52T11a1b1c1d" "T1::a::b::c::d::get(void)"

    test_demangling_exact "gnu: put__2T1i" "T1::put(int)"

    test_demangling_exact "gnu: put__Q22T11ai" "T1::a::put(int)"

    test_demangling_exact "gnu: put__Q32T11a1bi" "T1::a::b::put(int)"

    test_demangling_exact "gnu: put__Q42T11a1b1ci" "T1::a::b::c::put(int)"

    test_demangling_exact "gnu: put__Q52T11a1b1c1di" "T1::a::b::c::d::put(int)"

    test_demangling_exact "gnu: bar__3fooPv"       "foo::bar(void *)"

    test_demangling "gnu: bar__3fooPCv" \

        "foo::bar\[(\]+(const void|void const) *\[*\]+\[)\]+"

    test_demangling_exact "gnu: bar__C3fooPv"      "foo::bar(void *) const"

    test_demangling "gnu: bar__C3fooPCv" \

        "foo::bar\[(\]+(const void|void const) *\[*\]+\[)\]+ const"

    test_demangling_exact "gnu: __eq__3fooRT0"     "foo::operator==(foo &)"

    test_demangling "gnu: __eq__3fooRC3foo" \

         "foo::operator==\[(\]+(const foo|foo const) &\[)\]+"

    test_demangling_exact "gnu: __eq__C3fooR3foo"  "foo::operator==(foo &) const"

    test_demangling "gnu: __eq__C3fooRT0" \

           "foo::operator==\[(\]+(const foo|foo const) &\[)\]+ const"

    test_demangling_exact "gnu: elem__t6vector1Zdi" "vector::elem(int)"

    test_demangling_exact "gnu: elem__t6vector1Zii" "vector::elem(int)"

    test_demangling_exact "gnu: __t6vector1Zdi"     "vector::vector(int)"

    test_demangling_exact "gnu: __t6vector1Zii"     "vector::vector(int)"

    test_demangling_exact "gnu: _\$_t6vector1Zdi"    "vector::~vector(int)"

    test_demangling_exact "gnu: _\$_t6vector1Zii"    "vector::~vector(int)"

    test_demangling_exact "gnu: __nw__t2T11ZcUi" "T1::operator new(unsigned int)"

    test_demangling_exact "gnu: __nw__t2T11Z1tUi" "T1::operator new(unsigned int)"

    test_demangling_exact "gnu: __dl__t2T11ZcPv" "T1::operator delete(void *)"

    test_demangling_exact "gnu: __dl__t2T11Z1tPv" "T1::operator delete(void *)"

    test_demangling_exact "gnu: __t2T11Zci" "T1::T1(int)"

    test_demangling_exact "gnu: __t2T11Zc" "T1::T1(void)"

    test_demangling_exact "gnu: __t2T11Z1ti" "T1::T1(int)"

    test_demangling_exact "gnu: __t2T11Z1t" "T1::T1(void)"

    test_demangling_exact "gnu: __Q2t4List1Z10VHDLEntity3Pix" \

        "List::Pix::Pix(void)"

    test_demangling_exact "gnu: __Q2t4List1Z10VHDLEntity3PixPQ2t4List1Z10VHDLEntity7element" \

        "List::Pix::Pix(List::element *)"

    test_demangling_exact "gnu: __Q2t4List1Z10VHDLEntity3PixRCQ2t4List1Z10VHDLEntity3Pix" \

        "List::Pix::Pix(List::Pix const &)"

    test_demangling_exact "gnu: __Q2t4List1Z10VHDLEntity7elementRC10VHDLEntityPT0" \

        "List::element::element(VHDLEntity const &, List::element *)"

    test_demangling_exact "gnu: __Q2t4List1Z10VHDLEntity7elementRCQ2t4List1Z10VHDLEntity7element" \

        "List::element::element(List::element const &)"

    test_demangling_exact "gnu: __cl__C11VHDLLibraryGt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \

        "VHDLLibrary::operator()(PixX >) const"

    test_demangling_exact "gnu: __cl__Ct4List1Z10VHDLEntityRCQ2t4List1Z10VHDLEntity3Pix" \

        "List::operator()(List::Pix const &) const"

    test_demangling_exact "gnu: __ne__FPvRCQ2t4List1Z10VHDLEntity3Pix" \

        "operator!=(void *, List::Pix const &)"

    test_demangling_exact "gnu: __ne__FPvRCt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \

        "operator!=(void *, PixX > const &)"

    test_demangling_exact "gnu: __t4List1Z10VHDLEntityRCt4List1Z10VHDLEntity" \

        "List::List(List const &)"

    test_demangling_exact "gnu: __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \

        "PixX >::PixX(void)"

    test_demangling_exact "gnu: __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntityP14VHDLLibraryRepGQ2t4List1Z10VHDLEntity3Pix" \

        "PixX >::PixX(VHDLLibraryRep *, List::Pix)"

    test_demangling_exact "gnu: __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntityRCt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \

        "PixX >::PixX(PixX > const &)"

    test_demangling_exact "gnu: nextE__C11VHDLLibraryRt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \

        "VHDLLibrary::nextE(PixX > &) const"

    test_demangling_exact "gnu: next__Ct4List1Z10VHDLEntityRQ2t4List1Z10VHDLEntity3Pix" \

        "List::next(List::Pix &) const"

    test_demangling_exact "gnu: _GLOBAL_\$D\$set" "global destructors keyed to set"

    test_demangling_exact "gnu: _GLOBAL_\$I\$set" "global constructors keyed to set"

    test_demangling_exact "gnu: __as__t5ListS1ZUiRCt5ListS1ZUi" \

        "ListS::operator=(ListS const &)"

    test_demangling_exact "gnu: __cl__Ct5ListS1ZUiRCQ2t5ListS1ZUi3Vix" \

        "ListS::operator()(ListS::Vix const &) const"

    test_demangling_exact "gnu: __cl__Ct5SetLS1ZUiRCQ2t5SetLS1ZUi3Vix" \

        "SetLS::operator()(SetLS::Vix const &) const"

    test_demangling_exact "gnu: __t10ListS_link1ZUiRCUiPT0" \

        "ListS_link::ListS_link(unsigned int const &, ListS_link *)"

    test_demangling_exact "gnu: __t10ListS_link1ZUiRCt10ListS_link1ZUi" \

        "ListS_link::ListS_link(ListS_link const &)"

    test_demangling_exact "gnu: __t5ListS1ZUiRCt5ListS1ZUi" \

        "ListS::ListS(ListS const &)"

    test_demangling_exact "gnu: next__Ct5ListS1ZUiRQ2t5ListS1ZUi3Vix" \

        "ListS::next(ListS::Vix &) const"

    test_demangling_exact "gnu: __ne__FPvRCQ2t5SetLS1ZUi3Vix" \

        "operator!=(void *, SetLS::Vix const &)"

    test_demangling_exact "gnu: __t8ListElem1Z5LabelRt4List1Z5Label" \

        "ListElem::ListElem(List &)"

    test_demangling_exact "gnu: __t8BDDHookV1ZPcRCPc" \

        "BDDHookV::BDDHookV(char *const &)"

    test_demangling_exact "gnu: _vt\$t8BDDHookV1ZPc" "BDDHookV virtual table"

    test_demangling_exact "gnu: __ne__FPvRCQ211BDDFunction4VixB" \

        "operator!=(void *, BDDFunction::VixB const &)"

    test_demangling_exact "gnu: __eq__FPvRCQ211BDDFunction4VixB" \

        "operator==(void *, BDDFunction::VixB const &)"

    test_demangling_exact "gnu: relativeId__CQ36T_phi210T_preserve8FPC_nextRCQ26T_phi210T_preserveRC10Parameters" \

         "T_phi2::T_preserve::FPC_next::relativeId(T_phi2::T_preserve const &, Parameters const &) const"

    test_demangling_exact "gnu: _Utf390_1__1_9223372036854775807__9223372036854775" \

            "Can't demangle \"_Utf390_1__1_9223372036854775807__9223372036854775\""

    test_demangling_exact "gnu: foo__I40" "foo(int64_t)"

    test_demangling_exact "gnu: foo__I_200_" "foo(int512_t)"

    test_demangling_exact "gnu: foo__I_200" "Can't demangle \"foo__I_200\""

    ## Buffer overrun.  Should make GDB crash.  Woo hoo!

    test_demangling_exact "gnu: foo__I_4000000000000000000000000000000000000000000000000000000000000000000000000" "Can't demangle \"foo__I_4000000000000000000000000000000000000000000000000000000000000000000000000\""

    ## 1999-04-19: "Fix from Dale Hawkins".  Shouldn't segfault.

    # Accept even a dubious demangling; the string is ambiguous.

    send_gdb "maintenance demangle __thunk_64__0RL__list__Q29CosNaming20_proxy_NamingContextUlRPt25_CORBA_Unbounded_Sequence1ZQ29CosNaming7BindingRPQ29CosNaming15BindingIterator\n"

    gdb_expect {

        -re "virtual function thunk \\(delta:-64\\) for CosNaming::_proxy_NamingContext::_0RL__list\\(unsigned long, _CORBA_Unbounded_Sequence \\*\\&, CosNaming::BindingIterator \\*\\&\\)\r\n$gdb_prompt $" {

                pass "gnu: __thunk_64__0RL__list__Q29CosNaming20_proxy_NamingContextUlRPt25_CORBA_Unbounded_Sequence1ZQ29CosNaming7BindingRPQ29CosNaming15BindingIterator"

        }

        -re ".*Can't demangle \"__thunk_64__0RL__list__Q29CosNaming20_proxy_NamingContextUlRPt25_CORBA_Unbounded_Sequence1ZQ29CosNaming7BindingRPQ29CosNaming15BindingIterator\"\r\n$gdb_prompt $" {

                pass "gnu: __thunk_64__0RL__list__Q29CosNaming20_proxy_NamingContextUlRPt25_CORBA_Unbounded_Sequence1ZQ29CosNaming7BindingRPQ29CosNaming15BindingIterator"

        }

        -re ".*$gdb_prompt $" {

                fail "gnu: __thunk_64__0RL__list__Q29CosNaming20_proxy_NamingContextUlRPt25_CORBA_Unbounded_Sequence1ZQ29CosNaming7BindingRPQ29CosNaming15BindingIterator"

        }

        timeout {

                fail "gnu: __thunk_64__0RL__list__Q29CosNaming20_proxy_NamingContextUlRPt25_CORBA_Unbounded_Sequence1ZQ29CosNaming7BindingRPQ29CosNaming15BindingIterator (timeout)"

        }

    }

}

#

#  Test lucid style name demangling

#

proc test_lucid_style_demangling {} {

    test_demangling_exact "lucid: WS__FR7istream" "WS(istream &)"

    test_demangling_exact "lucid: __aa__3fooFR3foo" "foo::operator&&(foo &)"

    test_demangling_exact "lucid: __aad__3fooFR3foo" "foo::operator&=(foo &)"

    test_demangling_exact "lucid: __ad__3fooFR3foo" "foo::operator&(foo &)"

    test_demangling_exact "lucid: __adv__3fooFR3foo" "foo::operator/=(foo &)"

    test_demangling_exact "lucid: __adv__7complexF7complex" "complex::operator/=(complex)"

    test_demangling_exact "lucid: __aer__3fooFR3foo" "foo::operator^=(foo &)"

    test_demangling_exact "lucid: __als__3fooFR3foo" "foo::operator<<=(foo &)"

    test_demangling_exact "lucid: __amd__3fooFR3foo" "foo::operator%=(foo &)"

    test_demangling_exact "lucid: __ami__3fooFR3foo" "foo::operator-=(foo &)"

    test_demangling_exact "lucid: __amu__3fooFR3foo" "foo::operator*=(foo &)"

    test_demangling_exact "lucid: __amu__7complexF7complex" "complex::operator*=(complex)"

    test_demangling_exact "lucid: __aor__3fooFR3foo" "foo::operator|=(foo &)"

    test_demangling_exact "lucid: __apl__3fooFR3foo" "foo::operator+=(foo &)"

    test_demangling_exact "lucid: __ars__3fooFR3foo" "foo::operator>>=(foo &)"

    test_demangling_exact "lucid: __as__18istream_withassignFP9streambuf" "istream_withassign::operator=(streambuf *)"

    test_demangling_exact "lucid: __as__18istream_withassignFR7istream" "istream_withassign::operator=(istream &)"

    test_demangling_exact "lucid: __as__3fooFR3foo" "foo::operator=(foo &)"

    test_demangling_exact "lucid: __as__3iosFR3ios" "ios::operator=(ios &)"

    test_demangling_exact "lucid: __cl__3fooFR3foo" "foo::operator()(foo &)"

    test_demangling_exact "lucid: __cm__3fooFR3foo" "foo::operator, (foo &)"

    test_demangling_exact "lucid: __co__3fooFv" "foo::operator~(void)"

    test_demangling_exact "lucid: __ct__10istrstreamFPc" "istrstream::istrstream(char *)"

    test_demangling_exact "lucid: __ct__10istrstreamFPci" "istrstream::istrstream(char *, int)"

    test_demangling_exact "lucid: __ct__10ostrstreamFPciT2" "ostrstream::ostrstream(char *, int, int)"

    test_demangling_exact "lucid: __ct__10ostrstreamFv" "ostrstream::ostrstream(void)"

    test_demangling_exact "lucid: __ct__10smanip_intFPFR3iosi_R3iosi" "smanip_int::smanip_int(ios &(*)(ios &, int), int)"

    test_demangling "lucid: __ct__11c_exceptionFPcRC7complexT2" "c_exception::c_exception\[(\]+char \[*\]+, (const complex|complex const) &, (const complex|complex const) &\[)\]+"

    test_demangling "lucid: __ct__11fstreambaseFPCciT2" "fstreambase::fstreambase\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"

    test_demangling_exact "lucid: __ct__11fstreambaseFi" "fstreambase::fstreambase(int)"

    test_demangling_exact "lucid: __ct__11fstreambaseFiPcT1" "fstreambase::fstreambase(int, char *, int)"

    test_demangling_exact "lucid: __ct__11fstreambaseFv" "fstreambase::fstreambase(void)"

    test_demangling_exact "lucid: __ct__11smanip_longFPFR3iosl_R3iosl" "smanip_long::smanip_long(ios &(*)(ios &, long), long)"

    test_demangling_exact "lucid: __ct__11stdiostreamFP4FILE" "stdiostream::stdiostream(FILE *)"

    test_demangling_exact "lucid: __ct__12strstreambufFPFl_PvPFPv_v" "strstreambuf::strstreambuf(void *(*)(long), void (*)(void *))"

    test_demangling_exact "lucid: __ct__12strstreambufFPUciT1" "strstreambuf::strstreambuf(unsigned char *, int, unsigned char *)"

    test_demangling_exact "lucid: __ct__12strstreambufFPciT1" "strstreambuf::strstreambuf(char *, int, char *)"

    test_demangling_exact "lucid: __ct__12strstreambufFi" "strstreambuf::strstreambuf(int)"

    test_demangling_exact "lucid: __ct__12strstreambufFv" "strstreambuf::strstreambuf(void)"

    test_demangling_exact "lucid: __ct__13strstreambaseFPciT1" "strstreambase::strstreambase(char *, int, char *)"

    test_demangling_exact "lucid: __ct__3fooFR3foo" "foo::foo(foo &)"

    test_demangling_exact "lucid: __ct__3fooFi" "foo::foo(int)"

    test_demangling_exact "lucid: __ct__3fooFiN31" "foo::foo(int, int, int, int)"

    test_demangling "lucid: __ct__3fooFiPCc" \

        "foo::foo\[(\]+int, (const char|char const) \[*\]+\[)\]+"

    test_demangling_exact "lucid: __ct__3fooFiR3fooT1T2T1T2" "foo::foo(int, foo &, int, foo &, int, foo &)"

    test_demangling_exact "lucid: __ct__3iosFP9streambuf" "ios::ios(streambuf *)"

    test_demangling_exact "lucid: __ct__7filebufFiPcT1" "filebuf::filebuf(int, char *, int)"

    test_demangling "lucid: __ct__7fstreamFPCciT2" \

        "fstream::fstream\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"

    test_demangling_exact "lucid: __ct__7fstreamFiPcT1" "fstream::fstream(int, char *, int)"

    test_demangling_exact "lucid: __ct__7istreamFP9streambuf" "istream::istream(streambuf *)"

    test_demangling_exact "lucid: __ct__7istreamFP9streambufiP7ostream" "istream::istream(streambuf *, int, ostream *)"

    test_demangling_exact "lucid: __ct__7istreamFiPcT1" "istream::istream(int, char *, int)"

    test_demangling_exact "lucid: __ct__7istreamFiT1P7ostream" "istream::istream(int, int, ostream *)"

    test_demangling_exact "lucid: __ct__7ostreamFP9streambuf" "ostream::ostream(streambuf *)"

    test_demangling_exact "lucid: __ct__7ostreamFiPc" "ostream::ostream(int, char *)"

    test_demangling "lucid: __ct__8ifstreamFPCciT2" \

        "ifstream::ifstream\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"

    test_demangling_exact "lucid: __ct__8ifstreamFiPcT1" "ifstream::ifstream(int, char *, int)"

    test_demangling_exact "lucid: __ct__Q23foo3barFv" "foo::bar::bar(void)"

    test_demangling_exact "lucid: __ct__Q33foo3bar4bellFv" "foo::bar::bell::bell(void)"

    test_demangling_exact "lucid: __dl__3fooSFPv" "foo::operator delete(void *) static"

    test_demangling_exact "lucid: __dl__FPv" "operator delete(void *)"

    test_demangling_exact "lucid: __dt__10istrstreamFv" "istrstream::~istrstream(void)"

    test_demangling_exact "lucid: __dt__Q23foo3barFv" "foo::bar::~bar(void)"

    test_demangling_exact "lucid: __dt__Q33foo3bar4bellFv" "foo::bar::bell::~bell(void)"

    test_demangling_exact "lucid: __dv__3fooFR3foo" "foo::operator/(foo &)"

    test_demangling_exact "lucid: __dv__F7complexT1" "operator/(complex, complex)"

    test_demangling_exact "lucid: __eq__3fooFR3foo" "foo::operator==(foo &)"

    test_demangling_exact "lucid: __er__3fooFR3foo" "foo::operator^(foo &)"

    test_demangling_exact "lucid: __ge__3fooFR3foo" "foo::operator>=(foo &)"

    test_demangling_exact "lucid: __gt__3fooFR3foo" "foo::operator>(foo &)"

    test_demangling_exact "lucid: __le__3fooFR3foo" "foo::operator<=(foo &)"

    test_demangling_exact "lucid: __ls__3fooFR3foo" "foo::operator<<(foo &)"

    test_demangling_exact "lucid: __ls__7ostreamFP9streambuf" "ostream::operator<<(streambuf *)"

    test_demangling "lucid: __ls__7ostreamFPCc" \

        "ostream::operator<<\[(\]+(const char|char const) \[*\]+\[)\]+"

    test_demangling_exact "lucid: __ls__7ostreamFPFR3ios_R3ios" "ostream::operator<<(ios &(*)(ios &))"

    test_demangling_exact "lucid: __ls__7ostreamFPv" "ostream::operator<<(void *)"

    test_demangling_exact "lucid: __ls__7ostreamFUi" "ostream::operator<<(unsigned int)"

    test_demangling_exact "lucid: __ls__7ostreamFUl" "ostream::operator<<(unsigned long)"

    test_demangling_exact "lucid: __ls__7ostreamFd" "ostream::operator<<(double)"

    test_demangling_exact "lucid: __ls__7ostreamFf" "ostream::operator<<(float)"

    test_demangling_exact "lucid: __ls__7ostreamFi" "ostream::operator<<(int)"

    test_demangling_exact "lucid: __ls__7ostreamFl" "ostream::operator<<(long)"

    test_demangling_exact "lucid: __ls__FR7ostream7complex" "operator<<(ostream &, complex)"

    test_demangling_exact "lucid: __lt__3fooFR3foo" "foo::operator<(foo &)"

    test_demangling_exact "lucid: __md__3fooFR3foo" "foo::operator%(foo &)"

    test_demangling_exact "lucid: __mi__3fooFR3foo" "foo::operator-(foo &)"

    test_demangling_exact "lucid: __ml__3fooFR3foo" "foo::operator*(foo &)"

    test_demangling_exact "lucid: __ml__F7complexT1" "operator*(complex, complex)"

    test_demangling_exact "lucid: __mm__3fooFi" "foo::operator--(int)"

    test_demangling_exact "lucid: __ne__3fooFR3foo" "foo::operator!=(foo &)"

    test_demangling_exact "lucid: __nt__3fooFv" "foo::operator!(void)"

    test_demangling_exact "lucid: __nw__3fooSFi" "foo::operator new(int) static"

    test_demangling_exact "lucid: __nw__FUi" "operator new(unsigned int)"

    test_demangling_exact "lucid: __nw__FUiPv" "operator new(unsigned int, void *)"

    test_demangling_exact "lucid: __oo__3fooFR3foo" "foo::operator||(foo &)"

    test_demangling_exact "lucid: __opPc__3fooFv" "foo::operator char *(void)"

    test_demangling_exact "lucid: __opi__3fooFv" "foo::operator int(void)"

    test_demangling_exact "lucid: __or__3fooFR3foo" "foo::operator|(foo &)"

    test_demangling_exact "lucid: __pl__3fooFR3foo" "foo::operator+(foo &)"

    test_demangling_exact "lucid: __pp__3fooFi" "foo::operator++(int)"

    test_demangling_exact "lucid: __pt__3fooFv" "foo::operator->(void)"

    test_demangling_exact "lucid: __rm__3fooFR3foo" "foo::operator->*(foo &)"

    test_demangling_exact "lucid: __rs__3fooFR3foo" "foo::operator>>(foo &)"

    test_demangling_exact "lucid: __rs__7istreamFP9streambuf" "istream::operator>>(streambuf *)"

    test_demangling_exact "lucid: __rs__7istreamFPFR3ios_R3ios" "istream::operator>>(ios &(*)(ios &))"

    test_demangling_exact "lucid: __rs__7istreamFPFR7istream_R7istream" "istream::operator>>(istream &(*)(istream &))"

    test_demangling_exact "lucid: __rs__7istreamFPUc" "istream::operator>>(unsigned char *)"

    test_demangling_exact "lucid: __rs__7istreamFPc" "istream::operator>>(char *)"

    test_demangling_exact "lucid: __rs__7istreamFRUi" "istream::operator>>(unsigned int &)"

    test_demangling_exact "lucid: __rs__7istreamFRUl" "istream::operator>>(unsigned long &)"

    test_demangling_exact "lucid: __rs__7istreamFRUs" "istream::operator>>(unsigned short &)"

    test_demangling_exact "lucid: __rs__7istreamFRd" "istream::operator>>(double &)"

    test_demangling_exact "lucid: __rs__7istreamFRf" "istream::operator>>(float &)"

    test_demangling_exact "lucid: __rs__7istreamFRi" "istream::operator>>(int &)"

    test_demangling_exact "lucid: __rs__7istreamFRl" "istream::operator>>(long &)"

    test_demangling_exact "lucid: __rs__7istreamFRs" "istream::operator>>(short &)"

    test_demangling_exact "lucid: __rs__FR7istreamR7complex" "operator>>(istream &, complex &)"

    test_demangling "lucid: __vc__3fooFR3foo" "foo::operator\\\[\\\]\\(foo &\\)"

    test_demangling_exact "lucid: __vtbl__10istrstream" "istrstream virtual table"

    test_demangling_exact "lucid: __vtbl__17ostream__iostream__19iostream_withassign" "iostream_withassign::ostream__iostream virtual table"

    test_demangling_exact "lucid: __vtbl__3ios" "ios virtual table"

    test_demangling_exact "lucid: __vtbl__3ios__13strstreambase" "strstreambase::ios virtual table"

    # GDB 930414 demangles this as t_cc_main_ (obviously wrong).

    # GDB 930701 gets into an infinite loop.

    # GDB 930727 says "Can't demangle".

    # What is the correct demangling?  FIXME.

    # NOTE: carlton/2003-01-17: No, don't FIXME, just obsolete lucid.

    # I'm KFAILing this rather than deleting it for form's sake.

    setup_kfail "gdb/945" "*-*-*"

    test_demangling_exact "lucid: __vtbl__3foo__vt_cc_main_" ""

    test_demangling_exact "lucid: abs__F7complex" "abs(complex)"

    test_demangling_exact "lucid: allocate__9streambufFv" "streambuf::allocate(void)"

    test_demangling_exact "lucid: attach__11fstreambaseFi" "fstreambase::attach(int)"

    test_demangling_exact "lucid: bitalloc__3iosSFv" "ios::bitalloc(void) static"

    test_demangling_exact "lucid: chr__FiT1" "chr(int, int)"

    test_demangling_exact "lucid: complex_error__FR11c_exception" "complex_error(c_exception &)"

    test_demangling_exact "lucid: complexfunc2__FPFPc_i" "complexfunc2(int (*)(char *))"

    test_demangling_exact "lucid: complexfunc3__FPFPFPl_s_i" "complexfunc3(int (*)(short (*)(long *)))"

    test_demangling_exact "lucid: complexfunc4__FPFPFPc_s_i" "complexfunc4(int (*)(short (*)(char *)))"

    test_demangling_exact "lucid: complexfunc5__FPFPc_PFl_i" "complexfunc5(int (*(*)(char *))(long))"

    test_demangling_exact "lucid: complexfunc6__FPFPi_PFl_i" "complexfunc6(int (*(*)(int *))(long))"

    test_demangling_exact "lucid: complexfunc7__FPFPFPc_i_PFl_i" "complexfunc7(int (*(*)(int (*)(char *)))(long))"

    test_demangling_exact "lucid: complicated_put__7ostreamFc" "ostream::complicated_put(char)"

    test_demangling_exact "lucid: conv10__FlPc" "conv10(long, char *)"

    test_demangling_exact "lucid: conv16__FUlPc" "conv16(unsigned long, char *)"

    test_demangling_exact "lucid: dec__FR3ios" "dec(ios &)"

    test_demangling_exact "lucid: dec__Fli" "dec(long, int)"

    test_demangling_exact "lucid: dofield__FP7ostreamPciT2T3" "dofield(ostream *, char *, int, char *, int)"

    test_demangling_exact "lucid: flags__3iosFl" "ios::flags(long)"

    test_demangling_exact "lucid: flags__3iosFv" "ios::flags(void)"

    test_demangling_exact "lucid: foo__FiN31" "foo(int, int, int, int)"

    test_demangling_exact "lucid: foo__FiR3fooT1T2T1T2" "foo(int, foo &, int, foo &, int, foo &)"

    test_demangling_exact "lucid: foo___3barFl" "bar::foo_(long)"

    test_demangling "lucid: form__FPCce" "form\[(\]+(const char|char const) \[*\]+,...\[)\]+"

    test_demangling_exact "lucid: get__7istreamFPcic" "istream::get(char *, int, char)"

    test_demangling_exact "lucid: get__7istreamFR9streambufc" "istream::get(streambuf &, char)"

    test_demangling_exact "lucid: get_complicated__7istreamFRUc" "istream::get_complicated(unsigned char &)"

    test_demangling_exact "lucid: get_complicated__7istreamFRc" "istream::get_complicated(char &)"

    test_demangling_exact "lucid: getline__7istreamFPUcic" "istream::getline(unsigned char *, int, char)"

    test_demangling_exact "lucid: getline__7istreamFPcic" "istream::getline(char *, int, char)"

    test_demangling_exact "lucid: ignore__7istreamFiT1" "istream::ignore(int, int)"

    test_demangling_exact "lucid: init__12strstreambufFPciT1" "strstreambuf::init(char *, int, char *)"

    test_demangling_exact "lucid: init__3iosFP9streambuf" "ios::init(streambuf *)"

    test_demangling_exact "lucid: initcount__13Iostream_init" "Iostream_init::initcount"

    test_demangling_exact "lucid: ipfx__7istreamFi" "istream::ipfx(int)"

    test_demangling_exact "lucid: ls_complicated__7ostreamFUc" "ostream::ls_complicated(unsigned char)"

    test_demangling_exact "lucid: ls_complicated__7ostreamFc" "ostream::ls_complicated(char)"

    test_demangling "lucid: open__11fstreambaseFPCciT2" \

        "fstreambase::open\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"

    test_demangling "lucid: open__7filebufFPCciT2" \

        "filebuf::open\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"

    test_demangling_exact "lucid: overload1arg__FSc" "overload1arg(signed char)"

    test_demangling_exact "lucid: overload1arg__FUc" "overload1arg(unsigned char)"

    test_demangling_exact "lucid: overload1arg__FUi" "overload1arg(unsigned int)"

    test_demangling_exact "lucid: overload1arg__FUl" "overload1arg(unsigned long)"

    test_demangling_exact "lucid: overload1arg__FUs" "overload1arg(unsigned short)"

    test_demangling_exact "lucid: overload1arg__Fc" "overload1arg(char)"

    test_demangling_exact "lucid: overload1arg__Fd" "overload1arg(double)"

    test_demangling_exact "lucid: overload1arg__Ff" "overload1arg(float)"

    test_demangling_exact "lucid: overload1arg__Fi" "overload1arg(int)"

    test_demangling_exact "lucid: overload1arg__Fl" "overload1arg(long)"

    test_demangling_exact "lucid: overload1arg__Fs" "overload1arg(short)"

    test_demangling_exact "lucid: overload1arg__Fv" "overload1arg(void)"

    test_demangling_exact "lucid: overloadargs__FiN21" "overloadargs(int, int, int)"

    test_demangling_exact "lucid: overloadargs__FiN31" "overloadargs(int, int, int, int)"

    test_demangling_exact "lucid: overloadargs__FiN41" "overloadargs(int, int, int, int, int)"

    test_demangling_exact "lucid: overloadargs__FiN51" "overloadargs(int, int, int, int, int, int)"

    test_demangling_exact "lucid: overloadargs__FiN61" "overloadargs(int, int, int, int, int, int, int)"

    test_demangling_exact "lucid: overloadargs__FiN71" "overloadargs(int, int, int, int, int, int, int, int)"

    test_demangling_exact "lucid: overloadargs__FiN81" "overloadargs(int, int, int, int, int, int, int, int, int)"

    test_demangling_exact "lucid: overloadargs__FiN91" "overloadargs(int, int, int, int, int, int, int, int, int, int)"

    test_demangling_exact "lucid: overloadargs__FiN91N11" "overloadargs(int, int, int, int, int, int, int, int, int, int, int)"

    test_demangling_exact "lucid: overloadargs__FiT1" "overloadargs(int, int)"

    test_demangling_exact "lucid: polar__FdT1" "polar(double, double)"

    test_demangling_exact "lucid: pow__F7complexT1" "pow(complex, complex)"

    test_demangling_exact "lucid: pow__F7complexd" "pow(complex, double)"

    test_demangling_exact "lucid: pow__F7complexi" "pow(complex, int)"

    test_demangling_exact "lucid: pow__Fd7complex" "pow(double, complex)"

    test_demangling_exact "lucid: pstart__FPciT2" "pstart(char *, int, int)"

    test_demangling_exact "lucid: put__7ostreamFc" "ostream::put(char)"

    test_demangling_exact "lucid: read__7istreamFPci" "istream::read(char *, int)"

    test_demangling_exact "lucid: resetiosflags__FR3iosl" "resetiosflags(ios &, long)"

    test_demangling_exact "lucid: restore_errno__FRi" "restore_errno(int &)"

    test_demangling_exact "lucid: rs_complicated__7istreamFRUc" "istream::rs_complicated(unsigned char &)"

    test_demangling_exact "lucid: rs_complicated__7istreamFRc" "istream::rs_complicated(char &)"

    test_demangling_exact "lucid: seekg__7istreamFl8seek_dir" "istream::seekg(long, seek_dir)"

    test_demangling_exact "lucid: seekoff__12strstreambufFl8seek_diri" "strstreambuf::seekoff(long, seek_dir, int)"

    test_demangling_exact "lucid: seekoff__9streambufFlQ2_3ios12ios_seek_diri" "streambuf::seekoff(long, ios::ios_seek_dir, int)"

    test_demangling_exact "lucid: seekpos__9streambufFli" "streambuf::seekpos(long, int)"

    test_demangling_exact "lucid: set_new_handler__FPFv_v" "set_new_handler(void (*)(void))"

    test_demangling_exact "lucid: setb__9streambufFPcT1i" "streambuf::setb(char *, char *, int)"

    test_demangling_exact "lucid: setb__FR3iosi" "setb(ios &, int)"

    test_demangling_exact "lucid: setbuf__11fstreambaseFPci" "fstreambase::setbuf(char *, int)"

    test_demangling_exact "lucid: setbuf__9streambufFPUci" "streambuf::setbuf(unsigned char *, int)"

    test_demangling_exact "lucid: setbuf__9streambufFPciT2" "streambuf::setbuf(char *, int, int)"

    test_demangling_exact "lucid: setf__3iosFlT1" "ios::setf(long, long)"

    test_demangling_exact "lucid: setfill__FR3iosi" "setfill(ios &, int)"

    test_demangling_exact "lucid: setg__9streambufFPcN21" "streambuf::setg(char *, char *, char *)"

    test_demangling_exact "lucid: setp__9streambufFPcT1" "streambuf::setp(char *, char *)"

    test_demangling "lucid: sputn__9streambufFPCci" \

        "streambuf::sputn\[(\]+(const char|char const) \[*\]+, int\[)\]+"

    test_demangling "lucid: str__FPCci" \

        "str\[(\]+(const char|char const) \[*\]+, int\[)\]+"

    test_demangling_exact "lucid: tie__3iosFP7ostream" "ios::tie(ostream *)"

    test_demangling_exact "lucid: uconv10__FUlPc" "uconv10(unsigned long, char *)"

    test_demangling "lucid: write__7ostreamFPCci" \

        "ostream::write\[(\]+(const char|char const) \[*\]+, int\[)\]+"

    test_demangling_exact "lucid: xget__7istreamFPc" "istream::xget(char *)"

    test_demangling_exact "lucid: xsgetn__9streambufFPci" "streambuf::xsgetn(char *, int)"

    test_demangling "lucid: xsputn__9streambufFPCci" \

        "streambuf::xsputn\[(\]+(const char|char const) \[*\]+, int\[)\]+"

    test_demangling_exact "lucid: _Utf390_1__1_9223372036854775807__9223372036854775" \

            "Can't demangle \"_Utf390_1__1_9223372036854775807__9223372036854775\""

}

#

#  Test arm style name demangling

#

proc test_arm_style_demangling {} {

    test_demangling_exact "arm: __dt__21T5__pt__11_PFiPPdPv_iFv" "T5::~T5(void)"

    test_demangling_exact "arm: __ct__1cFi" "c::c(int)"

    test_demangling_exact "arm: __dt__11T5__pt__2_iFv" "T5::~T5(void)"

    test_demangling_exact "arm: __dt__11T5__pt__2_cFv" "T5::~T5(void)"

    test_demangling_exact "arm: __ct__2T2Fi" "T2::T2(int)"

    test_demangling_exact "arm: __dt__2T1Fv" "T1::~T1(void)"

    test_demangling_exact "arm: __dt__12T5__pt__3_1xFv" "T5::~T5(void)"

    test_demangling_exact "arm: __dt__17T5__pt__8_PFcPv_iFv" "T5::~T5(void)"

    test_demangling "arm: g__FP1cPC1cT1" \

        "g\[(\]+c *\[*\]+, (const c|c const) *\[*\]+, c *\[*\]+\[)\]+"

    test_demangling "arm: g__FPUlPCUlT1" \

        "g\[(\]+unsigned long \[*\]+, (const unsigned long|unsigned long const) \[*\]+, unsigned long \[*\]+\[)\]+"

    test_demangling "arm: g__FPUiPCUiT1" \

        "g\[(\]+unsigned int \[*\]+, (const unsigned int|unsigned int const) \[*\]+, unsigned int \[*\]+\[)\]+"

    test_demangling "arm: g__FPUsPCUsT1" \

        "g\[(\]+unsigned short \[*\]+, (const unsigned short|unsigned short const) \[*\]+, unsigned short \[*\]+\[)\]+"

    test_demangling "arm: g__FPUcPCUcT1" \

        "g\[(\]+unsigned char \[*\]+, (const unsigned char|unsigned char const) \[*\]+, unsigned char \[*\]+\[)\]+"

    test_demangling "arm: g__F1TPlPClT2" \

        "g\[(\]+T, long \[*\]+, (const long|long const) \[*\]+, long \[*\]+\[)\]+"

    test_demangling "arm: g__F1RRlRClT2" \

        "g\[(\]+R, long &, (const long|long const) &, long &\[)\]+"

    test_demangling "arm: g__F1TPiPCiT2" \

        "g\[(\]+T, int \[*\]+, (const int|int const) \[*\]+, int \[*\]+\[)\]+"

    test_demangling "arm: g__F1RRiRCiT2" \

        "g\[(\]+R, int &, (const int|int const) &, int &\[)\]+"

    test_demangling "arm: g__F1TPsPCsT2" \

        "g\[(\]+T, short \[*\]+, (const short|short const) \[*\]+, short \[*\]+\[)\]+"

    test_demangling "arm: g__F1RRsRCsT2" \

        "g\[(\]+R, short &, (const short|short const) &, short &\[)\]+"

    test_demangling "arm: g__F1TPcPCcT2" \

        "g\[(\]+T, char \[*\]+, (const char|char const) \[*\]+, char \[*\]+\[)\]+"

    test_demangling "arm: g__F1RRcRCcT2" \

        "g\[(\]+R, char &, (const char|char const) &, char &\[)\]+"

    test_demangling_exact "arm: __ct__21T5__pt__11_PFiPPdPv_iFi" "T5::T5(int)"

    test_demangling "arm: __gt__FRC2T2c" \

        "operator>\[(\]+(const T2|T2 const) &, char\[)\]+"

    test_demangling "arm: __ge__FRC2T2c" \

        "operator>=\[(\]+(const T2|T2 const) &, char\[)\]+"

    test_demangling "arm: __lt__FRC2T2c" \

        "operator<\[(\]+(const T2|T2 const) &, char\[)\]+"

    test_demangling "arm: __le__FRC2T2c" \

        "operator<=\[(\]+(const T2|T2 const) &, char\[)\]+"

    test_demangling "arm: __ne__FRC2T2c" \

        "operator!=\[(\]+(const T2|T2 const) &, char\[)\]+"

    test_demangling "arm: __eq__FRC2T2c" \

        "operator==\[(\]+(const T2|T2 const) &, char\[)\]+"

    test_demangling_exact "arm: __amd__FR2T2i" "operator%=(T2 &, int)"

    test_demangling_exact "arm: __adv__FR2T2i" "operator/=(T2 &, int)"

    test_demangling_exact "arm: __amu__FR2T2i" "operator*=(T2 &, int)"

    test_demangling_exact "arm: __ami__FR2T2i" "operator-=(T2 &, int)"

    test_demangling_exact "arm: __apl__FR2T2i" "operator+=(T2 &, int)"

    test_demangling_exact "arm: __nw__2T1SFUi" "T1::operator new(unsigned int) static"

    test_demangling_exact "arm: __dl__2T1SFPv" "T1::operator delete(void *) static"

    test_demangling_exact "arm: put__2T7SFi" "T7::put(int) static"

    test_demangling_exact "arm: __dl__12T5__pt__3_1xSFPv" "T5::operator delete(void *) static"

    test_demangling_exact "arm: h__FUc" "h(unsigned char)"

    test_demangling_exact "arm: f__Fic" "f(int, char)"

    test_demangling_exact "arm: h__FUi" "h(unsigned int)"

    test_demangling_exact "arm: h__Fci" "h(char, int)"

    test_demangling_exact "arm: h__FUl" "h(unsigned long)"

    test_demangling_exact "arm: h__Fcl" "h(char, long)"

    test_demangling_exact "arm: h__FUs" "h(unsigned short)"

    test_demangling_exact "arm: h__Fcs" "h(char, short)"

    test_demangling "arm: __amd__FR2T2RC2T2" \

        "operator%=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"

    test_demangling "arm: __adv__FR2T2RC2T2" \

        "operator/=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"

    test_demangling "arm: __amu__FR2T2RC2T2" \

        "operator\[*\]+=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"

    test_demangling "arm: __ami__FR2T2RC2T2" \

        "operator-=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"

    test_demangling "arm: __apl__FR2T2RC2T2" \

        "operator\[+\]+=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"

    test_demangling "arm: g__F1SRPUlRPCUlT2" \

        "g\[(\]+S, unsigned long \[*\]+&, (const unsigned long|unsigned long const) \[*\]+&, unsigned long \[*\]+&\[)\]+"

    test_demangling "arm: g__F1SRPUiRPCUiT2" \

        "g\[(\]+S, unsigned int \[*\]+&, (const unsigned int|unsigned int const) \[*\]+&, unsigned int \[*\]+&\[)\]+"

    test_demangling "arm: g__F1SRPUsRPCUsT2" \

        "g\[(\]+S, unsigned short \[*\]+&, (const unsigned short|unsigned short const) \[*\]+&, unsigned short \[*\]+&\[)\]+"

    test_demangling "arm: g__F1SRPUcRPCUcT2" \

        "g\[(\]+S, unsigned char \[*\]+&, (const unsigned char|unsigned char const) \[*\]+&, unsigned char \[*\]+&\[)\]+"

    test_demangling "arm: g__F1T1SRPlRPClT3" \

        "g\[(\]+T, S, long \[*\]+&, (const long|long const) \[*\]+&, long \[*\]+&\[)\]+"

    test_demangling "arm: g__F1T1SRPiRPCiT3" \

        "g\[(\]+T, S, int \[*\]+&, (const int|int const) \[*\]+&, int \[*\]+&\[)\]+"

    test_demangling "arm: g__F1T1SRPcRPCcT3" \

        "g\[(\]+T, S, char \[*\]+&, (const char|char const) \[*\]+&, char \[*\]+&\[)\]+"

    test_demangling_exact "arm: X__12T5__pt__3_1x" "T5::X"

    test_demangling_exact "arm: __ct__11T5__pt__2_iFi" "T5::T5(int)"

    test_demangling_exact "arm: __ct__11T5__pt__2_cFi" "T5::T5(int)"

    test_demangling "arm: __gt__FRC2T2T1" \

        "operator>\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"