OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [testsuite/] [gdb.c++/] [demangle.exp] - Blame information for rev 1774

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 106 markom 
# Copyright (C) 1992, 1997, 1999 Free Software Foundation, Inc.
2 
 
3 
# This program is free software; you can redistribute it and/or modify
4 
# it under the terms of the GNU General Public License as published by
5 
# the Free Software Foundation; either version 2 of the License, or
6 
# (at your option) any later version.
7 
#
8 
# This program is distributed in the hope that it will be useful,
9 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 
# GNU General Public License for more details.
12 
#
13 
# You should have received a copy of the GNU General Public License
14 
# along with this program; if not, write to the Free Software
15 
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
16 
 
17 
# Please email any bugs, comments, and/or additions to this file to:
18 
# bug-gdb@prep.ai.mit.edu
19 
 
20 
# This file was written by Fred Fish. (fnf@cygnus.com)
21 
 
22 
if $tracelevel then {
23 
    strace $tracelevel
24 
}
25 
 
26 
if { [skip_cplus_tests] } { continue }
27 
 
28 
### The demangling style we last sent to GDB.
29 
set current_demangling_style none
30 
 
31 
### Set GDB's current demangling style to STYLE.  Subsequent calls to
32 
### test_demangle will include STYLE in the test name when reporting
33 
### passes and failures.
34 
proc set_demangling_style {style} {
35 
    global gdb_prompt
36 
    global current_demangling_style
37 
 
38 
    send_gdb "set demangle-style $style\n"
39 
    gdb_expect {
40 
        -re "set demangle-style $style\[\r\n\]+$gdb_prompt $" {
41 
            pass "$style: set demangle-style"
42 
        }
43 
        -re ".*$gdb_prompt $" {
44 
            fail "$style: set demangle-style"
45 
            error "set_demangling_style: set style"
46 
        }
47 
        timeout {
48 
            fail "$style: set demangle-style (timeout)"
49 
            error "set_demangling_style: set style"
50 
        }
51 
    }
52 
 
53 
    send_gdb "show demangle-style\n"
54 
    gdb_expect {
55 
        -re "The current C\[+\]+ demangling style is \"$style\".\r\n$gdb_prompt $" {
56 
            pass "$style: check demangling style"
57 
        }
58 
        -re ".*$gdb_prompt $" {
59 
            fail "$style: check demangling style"
60 
            error "set_demangling_style: check style"
61 
        }
62 
        timeout {
63 
            fail "$style: check demangling style (timeout)"
64 
            error "set_demangling_style: check style"
65 
        }
66 
    }
67 
 
68 
    set current_demangling_style $style
69 
}
70 
 
71 
 
72 
### Utility function for test_demangling and test_demangling_exact.
73 
proc test_demangling_core {tester test result} {
74 
    global current_demangling_style
75 
 
76 
    if {! [regexp {^([^ ]+): (.+)$} $test dummy style name]} {
77 
      error "bad test name passed to test_demangling"
78 
    }
79 
 
80 
    if {[string compare $style $current_demangling_style]} {
81 
        set_demangling_style $style
82 
    }
83 
 
84 
    $tester "maintenance demangle $name" $result $test
85 
}
86 
 
87 
### Demangle an identifier, and check that the result matches a pattern.
88 
###
89 
### TEST should be of the form "STYLE: NAME", where STYLE is the name
90 
### of a demangling style (like "gnu" or "arm"), and NAME is a mangled
91 
### identifier to demangle.  Pass when the result matches the regular
92 
### expression RESULT.  Report passes and fails using TEST as the name
93 
### of the test.
94 
###
95 
### Why don't we just pass the STYLE and NAME as two separate
96 
### arguments, or let the style be a global variable?  That would be
97 
### cleaner.  However, doing it this way means that:
98 
###
99 
### 1) the name of the test, as recorded in the summary and log,
100 
### appears verbatim in the script, and
101 
###
102 
### 2) that test names are unique, even though we try to demangle the same
103 
### identifiers using several different mangling styles.
104 
###
105 
### This makes it a lot easier for people tracking down failures to
106 
### find the one they care about.
107 
 
108 
proc test_demangling {test result} {
109 
    test_demangling_core gdb_test $test $result
110 
}
111 
 
112 
### Like test_demangling, above, except that RESULT is not a regexp,
113 
### but a string that must match exactly.
114 
 
115 
proc test_demangling_exact {test result} {
116 
    test_demangling_core gdb_test_exact $test $result
117 
}
118 
 
119 
 
120 
 
121 
#
122 
#  Test gnu style name demangling
123 
#
124 
 
125 
proc test_gnu_style_demangling {} {
126 
    test_demangling "gnu: Abort__FP6EditoriPCc" \
127 
        "Abort\[(\]+Editor \[*\]+, int, (const char|char const) \[*\]+\[)\]+"
128 
    test_demangling_exact "gnu: AddAlignment__9ivTSolverUiP12ivInteractorP7ivTGlue" "ivTSolver::AddAlignment(unsigned int, ivInteractor *, ivTGlue *)"
129 
    test_demangling "gnu: Append__15NameChooserViewPCc" \
130 
        "NameChooserView::Append\[(\]+(const char|char const) \[*\]+\[)\]+"
131 
    test_demangling_exact "gnu: ArrowheadIntersects__9ArrowLineP9ArrowheadR6BoxObjP7Graphic" "ArrowLine::ArrowheadIntersects(Arrowhead *, BoxObj &, Graphic *)"
132 
    test_demangling_exact "gnu: AtEnd__13ivRubberGroup" "ivRubberGroup::AtEnd(void)"
133 
    test_demangling_exact "gnu: BgFilter__9ivTSolverP12ivInteractor" "ivTSolver::BgFilter(ivInteractor *)"
134 
    test_demangling "gnu: BitPatterntoa__FRC10BitPatternccc" \
135 
        "BitPatterntoa\[(\]+(const BitPattern|BitPattern const) &, char, char, char\[)\]+"
136 
    test_demangling_exact "gnu: Check__6UArrayi" "UArray::Check(int)"
137 
    test_demangling_exact "gnu: CoreConstDecls__8TextCodeR7ostream" "TextCode::CoreConstDecls(ostream &)"
138 
    test_demangling_exact "gnu: Detach__8StateVarP12StateVarView" "StateVar::Detach(StateVarView *)"
139 
    test_demangling_exact "gnu: Done__9ComponentG8Iterator" "Component::Done(Iterator)"
140 
    test_demangling "gnu: DrawDestinationTransformedImage__FP7_XImageiiT0iiUlUiiiUiUlUlP4_XGCRC13ivTransformeriiii" \
141 
        "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\[)\]+"
142 
 
143 
    test_demangling "gnu: Edit__12StringEditorPCcii" \
144 
        "StringEditor::Edit\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"
145 
    test_demangling_exact "gnu: Effect__11RelateManipR7ivEvent" "RelateManip::Effect(ivEvent &)"
146 
    test_demangling "gnu: FilterName__FPCc" \
147 
        "FilterName\[(\]+(const char|char const) \[*\]+\[)\]+"
148 
    test_demangling "gnu: Filter__6PSTextPCci" \
149 
        "PSText::Filter\[(\]+(const char|char const) \[*\]+, int\[)\]+"
150 
    test_demangling "gnu: FindColor__7CatalogPCciii" \
151 
        "Catalog::FindColor\[(\]+(const char|char const) \[*\]+, int, int, int\[)\]+"
152 
    test_demangling_exact "gnu: FindFixed__FRP4CNetP4CNet" "FindFixed(CNet *&, CNet *)"
153 
    test_demangling "gnu: FindFont__7CatalogPCcN21" \
154 
        "Catalog::FindFont\[(\]+(const char|char const) \[*\]+, (const char|char const) \[*\]+, (const char|char const) \[*\]+\[)\]+"
155 
    test_demangling_exact "gnu: Fix48_abort__FR8twolongs" "Fix48_abort(twolongs &)"
156 
    test_demangling_exact "gnu: GetBarInfo__15iv2_6_VScrollerP13ivPerspectiveRiT2" "iv2_6_VScroller::GetBarInfo(ivPerspective *, int &, int &)"
157 
    test_demangling_exact "gnu: GetBgColor__C9ivPainter" "ivPainter::GetBgColor(void) const"
158 
 
159 
    test_demangling "gnu: Iisdouble__FPC6IntRep" \
160 
        "Iisdouble\[(\]+(const IntRep|IntRep const) \[*\]+\[)\]+"
161 
    test_demangling_exact "gnu: InsertBody__15H_PullrightMenuii" "H_PullrightMenu::InsertBody(int, int)"
162 
    test_demangling_exact "gnu: InsertCharacter__9TextManipc" "TextManip::InsertCharacter(char)"
163 
 
164 
    test_demangling_exact "gnu: InsertToplevel__7ivWorldP12ivInteractorT1" "ivWorld::InsertToplevel(ivInteractor *, ivInteractor *)"
165 
    test_demangling_exact "gnu: InsertToplevel__7ivWorldP12ivInteractorT1iiUi" "ivWorld::InsertToplevel(ivInteractor *, ivInteractor *, int, int, unsigned int)"
166 
    test_demangling "gnu: IsADirectory__FPCcR4stat" \
167 
        "IsADirectory\[(\]+(const char|char const) \[*\]+, stat &\[)\]+"
168 
    test_demangling_exact "gnu: IsAGroup__FP11GraphicViewP11GraphicComp" "IsAGroup(GraphicView *, GraphicComp *)"
169 
    test_demangling_exact "gnu: IsA__10ButtonCodeUl" "ButtonCode::IsA(unsigned long)"
170 
 
171 
    test_demangling_exact "gnu: ReadName__FR7istreamPc" "ReadName(istream &, char *)"
172 
    test_demangling_exact "gnu: Redraw__13StringBrowseriiii" "StringBrowser::Redraw(int, int, int, int)"
173 
    test_demangling_exact "gnu: Rotate__13ivTransformerf" "ivTransformer::Rotate(float)"
174 
    test_demangling_exact "gnu: Rotated__C13ivTransformerf" "ivTransformer::Rotated(float) const"
175 
    test_demangling_exact "gnu: Round__Ff" "Round(float)"
176 
 
177 
    test_demangling_exact "gnu: SetExport__16MemberSharedNameUi" "MemberSharedName::SetExport(unsigned int)"
178 
    test_demangling_exact "gnu: Set__14ivControlState13ControlStatusUi" "ivControlState::Set(ControlStatus, unsigned int)"
179 
    test_demangling_exact "gnu: Set__5DFacePcii" "DFace::Set(char *, int, int)"
180 
 
181 
    test_demangling_exact "gnu: VConvert__9ivTSolverP12ivInteractorRP8TElementT2" "ivTSolver::VConvert(ivInteractor *, TElement *&, TElement *&)"
182 
    test_demangling_exact "gnu: VConvert__9ivTSolverP7ivTGlueRP8TElement" "ivTSolver::VConvert(ivTGlue *, TElement *&)"
183 
    test_demangling_exact "gnu: VOrder__9ivTSolverUiRP12ivInteractorT2" "ivTSolver::VOrder(unsigned int, ivInteractor *&, ivInteractor *&)"
184 
    test_demangling "gnu: Valid__7CatalogPCcRP4Tool" \
185 
        "Catalog::Valid\[(\]+(const char|char const) \[*\]+, Tool \[*\]+&\[)\]+"
186 
    test_demangling_exact "gnu: _10PageButton\$__both" "PageButton::__both"
187 
    test_demangling_exact "gnu: _3RNG\$singleMantissa" "RNG::singleMantissa"
188 
    test_demangling_exact "gnu: _5IComp\$_release" "IComp::_release"
189 
    test_demangling_exact "gnu: _\$_10BitmapComp" "BitmapComp::~BitmapComp(void)"
190 
 
191 
    test_demangling_exact "gnu: _\$_9__io_defs" "__io_defs::~__io_defs(void)"
192 
    test_demangling_exact "gnu: _\$_Q23foo3bar" "foo::bar::~bar(void)"
193 
    test_demangling_exact "gnu: _\$_Q33foo3bar4bell" "foo::bar::bell::~bell(void)"
194 
    test_demangling_exact "gnu: __10ivTelltaleiP7ivGlyph" "ivTelltale::ivTelltale(int, ivGlyph *)"
195 
    test_demangling_exact "gnu: __10ivViewportiP12ivInteractorUi" "ivViewport::ivViewport(int, ivInteractor *, unsigned int)"
196 
    test_demangling_exact "gnu: __10ostrstream" "ostrstream::ostrstream(void)"
197 
    test_demangling_exact "gnu: __10ostrstreamPcii" "ostrstream::ostrstream(char *, int, int)"
198 
    test_demangling "gnu: __11BasicDialogiPCcP13ivButtonStateN22Ui" \
199 
        "BasicDialog::BasicDialog\[(\]+int, (const char|char const) \[*\]+, ivButtonState \[*\]+, (const char|char const) \[*\]+, (const char|char const) \[*\]+, unsigned int\[)\]+"
200 
    test_demangling_exact "gnu: __11BitmapTablei" "BitmapTable::BitmapTable(int)"
201 
    test_demangling_exact "gnu: __12ViewportCodeP12ViewportComp" "ViewportCode::ViewportCode(ViewportComp *)"
202 
    test_demangling "gnu: __12iv2_6_BorderiPCci" \
203 
        "iv2_6_Border::iv2_6_Border\[(\]+int, (const char|char const) \[*\]+, int\[)\]+"
204 
    test_demangling_exact "gnu: __12iv2_6_Borderii" "iv2_6_Border::iv2_6_Border(int, int)"
205 
    test_demangling "gnu: __12ivBackgroundiP7ivGlyphPC7ivColor" \
206 
        "ivBackground::ivBackground\[(\]+int, ivGlyph \[*\]+, (const ivColor|ivColor const) \[*\]+\[)\]+"
207 
    test_demangling_exact "gnu: __12ivBreak_Listl" "ivBreak_List::ivBreak_List(long)"
208 
    test_demangling "gnu: __14TextInteractoriPCcUi" \
209 
        "TextInteractor::TextInteractor\[(\]+int, (const char|char const) \[*\]+, unsigned int\[)\]+"
210 
    test_demangling_exact "gnu: __14iv2_6_MenuItemiP12ivInteractor" "iv2_6_MenuItem::iv2_6_MenuItem(int, ivInteractor *)"
211 
    test_demangling "gnu: __14iv2_6_MenuItemiPCcP12ivInteractor" \
212 
        "iv2_6_MenuItem::iv2_6_MenuItem\[(\]+int, (const char|char const) \[*\]+, ivInteractor \[*\]+\[)\]+"
213 
 
214 
    test_demangling_exact "gnu: __20DisplayList_IteratorR11DisplayList" "DisplayList_Iterator::DisplayList_Iterator(DisplayList &)"
215 
    test_demangling_exact "gnu: __3fooRT0" "foo::foo(foo &)"
216 
    test_demangling_exact "gnu: __3fooiN31" "foo::foo(int, int, int, int)"
217 
    test_demangling "gnu: __3fooiPCc" \
218 
        "foo::foo\[(\]+int, (const char|char const) \[*\]+\[)\]+"
219 
    test_demangling_exact "gnu: __3fooiRT0iT2iT2" "foo::foo(int, foo &, int, foo &, int, foo &)"
220 
    test_demangling "gnu: __6GetOptiPPcPCc" \
221 
        "GetOpt::GetOpt\[(\]+int, char \[*\]+\[*\]+, (const char|char const) \[*\]+\[)\]+"
222 
    test_demangling_exact "gnu: __6KeyMapPT0" "KeyMap::KeyMap(KeyMap *)"
223 
    test_demangling "gnu: __7ivWorldPCcRiPPcPC12ivOptionDescPC14ivPropertyData" \
224 
        "ivWorld::ivWorld\[(\]+(const char|char const) \[*\]+, int &, char \[*\]+\[*\]+, (const ivOptionDesc|ivOptionDesc const) \[*\]+, (const ivPropertyData|ivPropertyData const) \[*\]+\[)\]+"
225 
    test_demangling "gnu: __7procbufPCci" \
226 
        "procbuf::procbuf\[(\]+(const char|char const) \[*\]+, int\[)\]+"
227 
    test_demangling_exact "gnu: __8ArrowCmdP6EditorUiUi" "ArrowCmd::ArrowCmd(Editor *, unsigned int, unsigned int)"
228 
 
229 
    test_demangling_exact "gnu: __9F_EllipseiiiiP7Graphic" "F_Ellipse::F_Ellipse(int, int, int, int, Graphic *)"
230 
    test_demangling_exact "gnu: __9FrameDataP9FrameCompi" "FrameData::FrameData(FrameComp *, int)"
231 
    test_demangling_exact "gnu: __9HVGraphicP9CanvasVarP7Graphic" "HVGraphic::HVGraphic(CanvasVar *, Graphic *)"
232 
    test_demangling_exact "gnu: __Q23foo3bar" "foo::bar::bar(void)"
233 
    test_demangling_exact "gnu: __Q33foo3bar4bell" "foo::bar::bell::bell(void)"
234 
    test_demangling_exact "gnu: __aa__3fooRT0" "foo::operator&&(foo &)"
235 
    test_demangling_exact "gnu: __aad__3fooRT0" "foo::operator&=(foo &)"
236 
    test_demangling_exact "gnu: __ad__3fooRT0" "foo::operator&(foo &)"
237 
    test_demangling_exact "gnu: __adv__3fooRT0" "foo::operator/=(foo &)"
238 
    test_demangling_exact "gnu: __aer__3fooRT0" "foo::operator^=(foo &)"
239 
    test_demangling_exact "gnu: __als__3fooRT0" "foo::operator<<=(foo &)"
240 
    test_demangling_exact "gnu: __amd__3fooRT0" "foo::operator%=(foo &)"
241 
    test_demangling_exact "gnu: __ami__3fooRT0" "foo::operator-=(foo &)"
242 
    test_demangling_exact "gnu: __aml__3FixRT0" "Fix::operator*=(Fix &)"
243 
    test_demangling_exact "gnu: __aml__5Fix16i" "Fix16::operator*=(int)"
244 
    test_demangling_exact "gnu: __aml__5Fix32RT0" "Fix32::operator*=(Fix32 &)"
245 
    test_demangling_exact "gnu: __aor__3fooRT0" "foo::operator|=(foo &)"
246 
    test_demangling_exact "gnu: __apl__3fooRT0" "foo::operator+=(foo &)"
247 
    test_demangling_exact "gnu: __ars__3fooRT0" "foo::operator>>=(foo &)"
248 
 
249 
    test_demangling_exact "gnu: __as__3fooRT0" "foo::operator=(foo &)"
250 
    test_demangling_exact "gnu: __cl__3fooRT0" "foo::operator()(foo &)"
251 
    test_demangling_exact "gnu: __cl__6Normal" "Normal::operator()(void)"
252 
    test_demangling_exact "gnu: __cl__6Stringii" "String::operator()(int, int)"
253 
    test_demangling_exact "gnu: __cm__3fooRT0" "foo::operator, (foo &)"
254 
    test_demangling_exact "gnu: __co__3foo" "foo::operator~(void)"
255 
    test_demangling_exact "gnu: __dl__3fooPv" "foo::operator delete(void *)"
256 
    test_demangling_exact "gnu: __dv__3fooRT0" "foo::operator/(foo &)"
257 
    test_demangling_exact "gnu: __eq__3fooRT0" "foo::operator==(foo &)"
258 
    test_demangling_exact "gnu: __er__3fooRT0" "foo::operator^(foo &)"
259 
    test_demangling_exact "gnu: __ge__3fooRT0" "foo::operator>=(foo &)"
260 
    test_demangling_exact "gnu: __gt__3fooRT0" "foo::operator>(foo &)"
261 
    test_demangling_exact "gnu: __le__3fooRT0" "foo::operator<=(foo &)"
262 
    test_demangling_exact "gnu: __ls__3fooRT0" "foo::operator<<(foo &)"
263 
    test_demangling_exact "gnu: __ls__FR7ostreamPFR3ios_R3ios" "operator<<(ostream &, ios &(*)(ios &))"
264 
    test_demangling_exact "gnu: __ls__FR7ostreamR3Fix" "operator<<(ostream &, Fix &)"
265 
    test_demangling_exact "gnu: __lt__3fooRT0" "foo::operator<(foo &)"
266 
    test_demangling_exact "gnu: __md__3fooRT0" "foo::operator%(foo &)"
267 
    test_demangling_exact "gnu: __mi__3fooRT0" "foo::operator-(foo &)"
268 
    test_demangling_exact "gnu: __ml__3fooRT0" "foo::operator*(foo &)"
269 
    test_demangling_exact "gnu: __mm__3fooi" "foo::operator--(int)"
270 
 
271 
    test_demangling_exact "gnu: __ne__3fooRT0" "foo::operator!=(foo &)"
272 
    test_demangling "gnu: __ne__FRC7ComplexT0" \
273 
        "operator!=\[(\]+(const Complex|Complex const) &, (const Complex|Complex const) &\[)\]+"
274 
    test_demangling "gnu: __ne__FRC7Complexd" \
275 
        "operator!=\[(\]+(const Complex|Complex const) &, double\[)\]+"
276 
    test_demangling "gnu: __ne__FRC9SubStringRC6String" \
277 
        "operator!=\[(\]+(const SubString|SubString const) &, (const String|String const) &\[)\]+"
278 
    test_demangling_exact "gnu: __nt__3foo" "foo::operator!(void)"
279 
    test_demangling_exact "gnu: __nw__3fooi" "foo::operator new(int)"
280 
    test_demangling_exact "gnu: __oo__3fooRT0" "foo::operator||(foo &)"
281 
    test_demangling_exact "gnu: __opPc__3foo" "foo::operator char *(void)"
282 
    test_demangling_exact "gnu: __opi__3foo" "foo::operator int(void)"
283 
    test_demangling_exact "gnu: __or__3fooRT0" "foo::operator|(foo &)"
284 
    test_demangling_exact "gnu: __pl__3fooRT0" "foo::operator+(foo &)"
285 
    test_demangling_exact "gnu: __pp__3fooi" "foo::operator++(int)"
286 
    test_demangling_exact "gnu: __rf__3foo" "foo::operator->(void)"
287 
    test_demangling_exact "gnu: __rm__3fooRT0" "foo::operator->*(foo &)"
288 
    test_demangling_exact "gnu: __rs__3fooRT0" "foo::operator>>(foo &)"
289 
    test_demangling "gnu: __vc__3fooRT0" "foo::operator\\\[\\\]\\(foo &\\)"
290 
    test_demangling "gnu: _gsub__6StringRC5RegexPCci" \
291 
        "String::_gsub\[(\]+(const Regex|Regex const) &, (const char|char const) \[*\]+, int\[)\]+"
292 
    test_demangling_exact "gnu: _new_Fix__FUs" "_new_Fix(unsigned short)"
293 
 
294 
    # gcc 2.4.5 (and earlier) style virtual tables.  We want to continue to
295 
    # correctly demangle these even if newer compilers use a different form.
296 
    test_demangling_exact "gnu: _vt.foo" "foo virtual table"
297 
    test_demangling_exact "gnu: _vt.foo.bar" "foo::bar virtual table"
298 
    test_demangling_exact "gnu: _vt\$foo" "foo virtual table"
299 
    test_demangling_exact "gnu: _vt\$foo\$bar" "foo::bar virtual table"
300 
 
301 
    test_demangling_exact "gnu: append__7ivGlyphPT0" "ivGlyph::append(ivGlyph *)"
302 
    test_demangling "gnu: arg__FRC7Complex" \
303 
        "arg\[(\]+(const Complex|Complex const) &\[)\]+"
304 
    test_demangling_exact "gnu: clearok__FP7_win_sti" "clearok(_win_st *, int)"
305 
 
306 
    test_demangling_exact "gnu: complexfunc2__FPFPc_i" "complexfunc2(int (*)(char *))"
307 
    test_demangling_exact "gnu: complexfunc3__FPFPFPl_s_i" "complexfunc3(int (*)(short (*)(long *)))"
308 
    test_demangling_exact "gnu: complexfunc4__FPFPFPc_s_i" "complexfunc4(int (*)(short (*)(char *)))"
309 
    test_demangling_exact "gnu: complexfunc5__FPFPc_PFl_i" "complexfunc5(int (*(*)(char *))(long))"
310 
    test_demangling_exact "gnu: complexfunc6__FPFPi_PFl_i" "complexfunc6(int (*(*)(int *))(long))"
311 
    test_demangling_exact "gnu: complexfunc7__FPFPFPc_i_PFl_i" "complexfunc7(int (*(*)(int (*)(char *)))(long))"
312 
    test_demangling "gnu: contains__C9BitStringRC10BitPattern" \
313 
        "BitString::contains\[(\]+(const BitPattern|BitPattern const) &\[)\]+ const"
314 
    test_demangling "gnu: contains__C9BitStringRC12BitSubStringi" \
315 
        "BitString::contains\[(\]+(const BitSubString|BitSubString const) &, int\[)\]+ const"
316 
    test_demangling "gnu: contains__C9BitStringRT0" \
317 
        "BitString::contains\[(\]+(const BitString|BitString const) &\[)\]+ const"
318 
    test_demangling "gnu: div__FPC6IntRepT0P6IntRep" \
319 
        "div\[(\]+(const IntRep|IntRep const) \[*\]+, (const IntRep|IntRep const) \[*\]+, IntRep \[*\]+\[)\]+"
320 
    test_demangling "gnu: div__FPC6IntReplP6IntRep" \
321 
        "div\[(\]+(const IntRep|IntRep const) \[*\]+, long, IntRep \[*\]+\[)\]+"
322 
    test_demangling "gnu: div__FRC8RationalT0R8Rational" \
323 
        "div\[(\]+(const Rational|Rational const) &, (const Rational|Rational const) &, Rational &\[)\]+"
324 
    test_demangling "gnu: divide__FRC7IntegerT0R7IntegerT2" \
325 
        "divide\[(\]+(const Integer|Integer const) &, (const Integer|Integer const) &, Integer &, Integer &\[)\]+"
326 
    test_demangling "gnu: divide__FRC7IntegerlR7IntegerRl" \
327 
        "divide\[(\]+(const Integer|Integer const) &, long, Integer &, long &\[)\]+"
328 
    test_demangling "gnu: enable__14DocumentViewerPCcUi" \
329 
        "DocumentViewer::enable\[(\]+(const char|char const) \[*\]+, unsigned int\[)\]+"
330 
 
331 
    test_demangling_exact "gnu: foo__FiN30" "foo(int, int, int, int)"
332 
    test_demangling_exact "gnu: foo__FiR3fooiT1iT1" "foo(int, foo &, int, foo &, int, foo &)"
333 
    test_demangling_exact "gnu: foo___3barl" "bar::foo_(long)"
334 
    test_demangling_exact "gnu: insert__15ivClippingStacklRP8_XRegion" "ivClippingStack::insert(long, _XRegion *&)"
335 
    test_demangling_exact "gnu: insert__16ChooserInfo_ListlR11ChooserInfo" "ChooserInfo_List::insert(long, ChooserInfo &)"
336 
    test_demangling_exact "gnu: insert__17FontFamilyRepListlRP15ivFontFamilyRep" "FontFamilyRepList::insert(long, ivFontFamilyRep *&)"
337 
    test_demangling_exact "gnu: leaveok__FP7_win_stc" "leaveok(_win_st *, char)"
338 
    test_demangling_exact "gnu: left_mover__C7ivMFKitP12ivAdjustableP7ivStyle" "ivMFKit::left_mover(ivAdjustable *, ivStyle *) const"
339 
    test_demangling "gnu: matches__C9BitStringRC10BitPatterni" \
340 
        "BitString::matches\[(\]+(const BitPattern|BitPattern const) &, int\[)\]+ const"
341 
    test_demangling "gnu: matches__C9SubStringRC5Regex" \
342 
        "SubString::matches\[(\]+(const Regex|Regex const) &\[)\]+ const"
343 
 
344 
    test_demangling_exact "gnu: overload1arg__FSc" "overload1arg(signed char)"
345 
    test_demangling_exact "gnu: overload1arg__FUc" "overload1arg(unsigned char)"
346 
    test_demangling_exact "gnu: overload1arg__FUi" "overload1arg(unsigned int)"
347 
    test_demangling_exact "gnu: overload1arg__FUl" "overload1arg(unsigned long)"
348 
    test_demangling_exact "gnu: overload1arg__FUs" "overload1arg(unsigned short)"
349 
    test_demangling_exact "gnu: overload1arg__Fc" "overload1arg(char)"
350 
    test_demangling_exact "gnu: overload1arg__Fd" "overload1arg(double)"
351 
    test_demangling_exact "gnu: overload1arg__Ff" "overload1arg(float)"
352 
    test_demangling_exact "gnu: overload1arg__Fi" "overload1arg(int)"
353 
    test_demangling_exact "gnu: overload1arg__Fl" "overload1arg(long)"
354 
    test_demangling_exact "gnu: overload1arg__Fs" "overload1arg(short)"
355 
    test_demangling_exact "gnu: overload1arg__Fv" "overload1arg(void)"
356 
    test_demangling_exact "gnu: overloadargs__Fi" "overloadargs(int)"
357 
    test_demangling_exact "gnu: overloadargs__Fii" "overloadargs(int, int)"
358 
    test_demangling_exact "gnu: overloadargs__Fiii" "overloadargs(int, int, int)"
359 
    test_demangling_exact "gnu: overloadargs__Fiiii" "overloadargs(int, int, int, int)"
360 
 
361 
    test_demangling_exact "gnu: overloadargs__Fiiiii" "overloadargs(int, int, int, int, int)"
362 
    test_demangling_exact "gnu: overloadargs__Fiiiiii" "overloadargs(int, int, int, int, int, int)"
363 
    test_demangling_exact "gnu: overloadargs__Fiiiiiii" "overloadargs(int, int, int, int, int, int, int)"
364 
    test_demangling_exact "gnu: overloadargs__Fiiiiiiii" "overloadargs(int, int, int, int, int, int, int, int)"
365 
    test_demangling_exact "gnu: overloadargs__Fiiiiiiiii" "overloadargs(int, int, int, int, int, int, int, int, int)"
366 
    test_demangling_exact "gnu: overloadargs__Fiiiiiiiiii" "overloadargs(int, int, int, int, int, int, int, int, int, int)"
367 
    test_demangling_exact "gnu: overloadargs__Fiiiiiiiiiii" "overloadargs(int, int, int, int, int, int, int, int, int, int, int)"
368 
    test_demangling "gnu: pick__13ivCompositionP8ivCanvasRC12ivAllocationiR5ivHit" \
369 
        "ivComposition::pick\[(\]+ivCanvas \[*\]+, (const ivAllocation|ivAllocation const) &, int, ivHit &\[)\]+"
370 
    test_demangling "gnu: pointer__C11ivHScrollerRC7ivEventRC12ivAllocation" \
371 
        "ivHScroller::pointer\[(\]+(const ivEvent|ivEvent const) &, (const ivAllocation|ivAllocation const) &\[)\]+ const"
372 
    test_demangling_exact "gnu: poke__8ivRasterUlUlffff" "ivRaster::poke(unsigned long, unsigned long, float, float, float, float)"
373 
    test_demangling_exact "gnu: polar__Fdd" "polar(double, double)"
374 
    test_demangling "gnu: read__10osStdInputRPCc" \
375 
        "osStdInput::read\[(\]+(const char|char const) \[*\]+&\[)\]+"
376 
 
377 
    test_demangling_exact "gnu: scale__13ivTransformerff" "ivTransformer::scale(float, float)"
378 
    test_demangling "gnu: scanw__12CursesWindowPCce" \
379 
        "CursesWindow::scanw\[(\]+(const char|char const) \[*\]+,...\[)\]+"
380 
    test_demangling "gnu: scmp__FPCcT0" \
381 
        "scmp\[(\]+(const char|char const) \[*\]+, (const char|char const) \[*\]+\[)\]+"
382 
    test_demangling_exact "gnu: sgetn__7filebufPci" "filebuf::sgetn(char *, int)"
383 
    test_demangling_exact "gnu: shift__FP5_FrepiT0" "shift(_Frep *, int, _Frep *)"
384 
    test_demangling_exact "gnu: test__C6BitSeti" "BitSet::test(int) const"
385 
    test_demangling_exact "gnu: test__C6BitSetii" "BitSet::test(int, int) const"
386 
    test_demangling "gnu: testbit__FRC7Integerl" \
387 
        "testbit\[(\]+(const Integer|Integer const) &, long\[)\]+"
388 
    test_demangling_exact "gnu: text_source__8Documentl" "Document::text_source(long)"
389 
    test_demangling_exact "gnu: variance__6Erlangd" "Erlang::variance(double)"
390 
    test_demangling "gnu: vform__8iostreamPCcPc" \
391 
        "iostream::vform\[(\]+(const char|char const) \[*\]+, char \[*\]+\[)\]+"
392 
    test_demangling_exact "gnu: view__14DocumentViewerP8ItemViewP11TabularItem" "DocumentViewer::view(ItemView *, TabularItem *)"
393 
    test_demangling_exact "gnu: xy_extents__11ivExtensionffff" "ivExtension::xy_extents(float, float, float, float)"
394 
    test_demangling_exact "gnu: zero__8osMemoryPvUi" "osMemory::zero(void *, unsigned int)"
395 
    test_demangling_exact "gnu: _2T4\$N" "T4::N"
396 
    test_demangling_exact "gnu: _Q22T42t1\$N" "T4::t1::N"
397 
    test_demangling_exact "gnu: get__2T1" "T1::get(void)"
398 
    test_demangling_exact "gnu: get__Q22T11a" "T1::a::get(void)"
399 
    test_demangling_exact "gnu: get__Q32T11a1b" "T1::a::b::get(void)"
400 
    test_demangling_exact "gnu: get__Q42T11a1b1c" "T1::a::b::c::get(void)"
401 
    test_demangling_exact "gnu: get__Q52T11a1b1c1d" "T1::a::b::c::d::get(void)"
402 
    test_demangling_exact "gnu: put__2T1i" "T1::put(int)"
403 
    test_demangling_exact "gnu: put__Q22T11ai" "T1::a::put(int)"
404 
    test_demangling_exact "gnu: put__Q32T11a1bi" "T1::a::b::put(int)"
405 
    test_demangling_exact "gnu: put__Q42T11a1b1ci" "T1::a::b::c::put(int)"
406 
    test_demangling_exact "gnu: put__Q52T11a1b1c1di" "T1::a::b::c::d::put(int)"
407 
 
408 
    test_demangling_exact "gnu: bar__3fooPv"       "foo::bar(void *)"
409 
    test_demangling "gnu: bar__3fooPCv" \
410 
        "foo::bar\[(\]+(const void|void const) *\[*\]+\[)\]+"
411 
    test_demangling_exact "gnu: bar__C3fooPv"      "foo::bar(void *) const"
412 
    test_demangling "gnu: bar__C3fooPCv" \
413 
        "foo::bar\[(\]+(const void|void const) *\[*\]+\[)\]+ const"
414 
    test_demangling_exact "gnu: __eq__3fooRT0"     "foo::operator==(foo &)"
415 
    test_demangling "gnu: __eq__3fooRC3foo" \
416 
         "foo::operator==\[(\]+(const foo|foo const) &\[)\]+"
417 
    test_demangling_exact "gnu: __eq__C3fooR3foo"  "foo::operator==(foo &) const"
418 
    test_demangling "gnu: __eq__C3fooRT0" \
419 
           "foo::operator==\[(\]+(const foo|foo const) &\[)\]+ const"
420 
 
421 
    test_demangling_exact "gnu: elem__t6vector1Zdi" "vector::elem(int)"
422 
    test_demangling_exact "gnu: elem__t6vector1Zii" "vector::elem(int)"
423 
    test_demangling_exact "gnu: __t6vector1Zdi"     "vector::vector(int)"
424 
    test_demangling_exact "gnu: __t6vector1Zii"     "vector::vector(int)"
425 
    test_demangling_exact "gnu: _\$_t6vector1Zdi"    "vector::~vector(int)"
426 
    test_demangling_exact "gnu: _\$_t6vector1Zii"    "vector::~vector(int)"
427 
 
428 
    test_demangling_exact "gnu: __nw__t2T11ZcUi" "T1::operator new(unsigned int)"
429 
    test_demangling_exact "gnu: __nw__t2T11Z1tUi" "T1::operator new(unsigned int)"
430 
    test_demangling_exact "gnu: __dl__t2T11ZcPv" "T1::operator delete(void *)"
431 
    test_demangling_exact "gnu: __dl__t2T11Z1tPv" "T1::operator delete(void *)"
432 
    test_demangling_exact "gnu: __t2T11Zci" "T1::T1(int)"
433 
    test_demangling_exact "gnu: __t2T11Zc" "T1::T1(void)"
434 
    test_demangling_exact "gnu: __t2T11Z1ti" "T1::T1(int)"
435 
    test_demangling_exact "gnu: __t2T11Z1t" "T1::T1(void)"
436 
 
437 
    test_demangling_exact "gnu: __Q2t4List1Z10VHDLEntity3Pix" \
438 
        "List::Pix::Pix(void)"
439 
 
440 
    test_demangling_exact "gnu: __Q2t4List1Z10VHDLEntity3PixPQ2t4List1Z10VHDLEntity7element" \
441 
        "List::Pix::Pix(List::element *)"
442 
 
443 
    test_demangling_exact "gnu: __Q2t4List1Z10VHDLEntity3PixRCQ2t4List1Z10VHDLEntity3Pix" \
444 
        "List::Pix::Pix(List::Pix const &)"
445 
 
446 
    test_demangling_exact "gnu: __Q2t4List1Z10VHDLEntity7elementRC10VHDLEntityPT0" \
447 
        "List::element::element(VHDLEntity const &, List::element *)"
448 
 
449 
    test_demangling_exact "gnu: __Q2t4List1Z10VHDLEntity7elementRCQ2t4List1Z10VHDLEntity7element" \
450 
        "List::element::element(List::element const &)"
451 
 
452 
    test_demangling_exact "gnu: __cl__C11VHDLLibraryGt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \
453 
        "VHDLLibrary::operator()(PixX >) const"
454 
 
455 
    test_demangling_exact "gnu: __cl__Ct4List1Z10VHDLEntityRCQ2t4List1Z10VHDLEntity3Pix" \
456 
        "List::operator()(List::Pix const &) const"
457 
 
458 
    test_demangling_exact "gnu: __ne__FPvRCQ2t4List1Z10VHDLEntity3Pix" \
459 
        "operator!=(void *, List::Pix const &)"
460 
 
461 
    test_demangling_exact "gnu: __ne__FPvRCt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \
462 
        "operator!=(void *, PixX > const &)"
463 
 
464 
    test_demangling_exact "gnu: __t4List1Z10VHDLEntityRCt4List1Z10VHDLEntity" \
465 
        "List::List(List const &)"
466 
 
467 
    test_demangling_exact "gnu: __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \
468 
        "PixX >::PixX(void)"
469 
 
470 
    test_demangling_exact "gnu: __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntityP14VHDLLibraryRepGQ2t4List1Z10VHDLEntity3Pix" \
471 
        "PixX >::PixX(VHDLLibraryRep *, List::Pix)"
472 
 
473 
    test_demangling_exact "gnu: __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntityRCt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \
474 
        "PixX >::PixX(PixX > const &)"
475 
 
476 
    test_demangling_exact "gnu: nextE__C11VHDLLibraryRt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \
477 
        "VHDLLibrary::nextE(PixX > &) const"
478 
 
479 
    test_demangling_exact "gnu: next__Ct4List1Z10VHDLEntityRQ2t4List1Z10VHDLEntity3Pix" \
480 
        "List::next(List::Pix &) const"
481 
 
482 
    test_demangling_exact "gnu: _GLOBAL_\$D\$set" "global destructors keyed to set"
483 
 
484 
    test_demangling_exact "gnu: _GLOBAL_\$I\$set" "global constructors keyed to set"
485 
 
486 
    test_demangling_exact "gnu: __as__t5ListS1ZUiRCt5ListS1ZUi" \
487 
        "ListS::operator=(ListS const &)"
488 
 
489 
    test_demangling_exact "gnu: __cl__Ct5ListS1ZUiRCQ2t5ListS1ZUi3Vix" \
490 
        "ListS::operator()(ListS::Vix const &) const"
491 
 
492 
    test_demangling_exact "gnu: __cl__Ct5SetLS1ZUiRCQ2t5SetLS1ZUi3Vix" \
493 
        "SetLS::operator()(SetLS::Vix const &) const"
494 
 
495 
    test_demangling_exact "gnu: __t10ListS_link1ZUiRCUiPT0" \
496 
        "ListS_link::ListS_link(unsigned int const &, ListS_link *)"
497 
 
498 
    test_demangling_exact "gnu: __t10ListS_link1ZUiRCt10ListS_link1ZUi" \
499 
        "ListS_link::ListS_link(ListS_link const &)"
500 
 
501 
    test_demangling_exact "gnu: __t5ListS1ZUiRCt5ListS1ZUi" \
502 
        "ListS::ListS(ListS const &)"
503 
 
504 
    test_demangling_exact "gnu: next__Ct5ListS1ZUiRQ2t5ListS1ZUi3Vix" \
505 
        "ListS::next(ListS::Vix &) const"
506 
 
507 
    test_demangling_exact "gnu: __ne__FPvRCQ2t5SetLS1ZUi3Vix" \
508 
        "operator!=(void *, SetLS::Vix const &)"
509 
    test_demangling_exact "gnu: __t8ListElem1Z5LabelRt4List1Z5Label" \
510 
        "ListElem
511 
    test_demangling_exact "gnu: __t8BDDHookV1ZPcRCPc" \
512 
        "BDDHookV::BDDHookV(char *const &)"
513 
 
514 
    test_demangling_exact "gnu: _vt\$t8BDDHookV1ZPc" "BDDHookV virtual table"
515 
 
516 
    test_demangling_exact "gnu: __ne__FPvRCQ211BDDFunction4VixB" \
517 
        "operator!=(void *, BDDFunction::VixB const &)"
518 
    test_demangling_exact "gnu: __eq__FPvRCQ211BDDFunction4VixB" \
519 
        "operator==(void *, BDDFunction::VixB const &)"
520 
 
521 
    test_demangling_exact "gnu: relativeId__CQ36T_phi210T_preserve8FPC_nextRCQ26T_phi210T_preserveRC10Parameters" \
522 
         "T_phi2::T_preserve::FPC_next::relativeId(T_phi2::T_preserve const &, Parameters const &) const"
523 
 
524 
    test_demangling_exact "gnu: _Utf390_1__1_9223372036854775807__9223372036854775" \
525 
            "Can't demangle \"_Utf390_1__1_9223372036854775807__9223372036854775\""
526 
    test_demangling_exact "gnu: foo__I40" "foo(int64_t)"
527 
    test_demangling_exact "gnu: foo__I_200_" "foo(int512_t)"
528 
    test_demangling_exact "gnu: foo__I_200" "Can't demangle \"foo__I_200\""
529 
 
530 
    ## Buffer overrun.  Should make GDB crash.  Woo hoo!
531 
    test_demangling_exact "gnu: foo__I_4000000000000000000000000000000000000000000000000000000000000000000000000" "Can't demangle \"foo__I_4000000000000000000000000000000000000000000000000000000000000000000000000\""
532 
 
533 
    ## 1999-04-19: "Fix from Dale Hawkins".  Shouldn't segfault.
534 
    test_demangling_exact "gnu: __thunk_64__0RL__list__Q29CosNaming20_proxy_NamingContextUlRPt25_CORBA_Unbounded_Sequence1ZQ29CosNaming7BindingRPQ29CosNaming15BindingIterator" "Can't demangle \"__thunk_64__0RL__list__Q29CosNaming20_proxy_NamingContextUlRPt25_CORBA_Unbounded_Sequence1ZQ29CosNaming7BindingRPQ29CosNaming15BindingIterator\""
535 
}
536 
 
537 
#
538 
#  Test lucid style name demangling
539 
#
540 
 
541 
proc test_lucid_style_demangling {} {
542 
    test_demangling_exact "lucid: WS__FR7istream" "WS(istream &)"
543 
    test_demangling_exact "lucid: __aa__3fooFR3foo" "foo::operator&&(foo &)"
544 
    test_demangling_exact "lucid: __aad__3fooFR3foo" "foo::operator&=(foo &)"
545 
    test_demangling_exact "lucid: __ad__3fooFR3foo" "foo::operator&(foo &)"
546 
    test_demangling_exact "lucid: __adv__3fooFR3foo" "foo::operator/=(foo &)"
547 
    test_demangling_exact "lucid: __adv__7complexF7complex" "complex::operator/=(complex)"
548 
    test_demangling_exact "lucid: __aer__3fooFR3foo" "foo::operator^=(foo &)"
549 
    test_demangling_exact "lucid: __als__3fooFR3foo" "foo::operator<<=(foo &)"
550 
    test_demangling_exact "lucid: __amd__3fooFR3foo" "foo::operator%=(foo &)"
551 
    test_demangling_exact "lucid: __ami__3fooFR3foo" "foo::operator-=(foo &)"
552 
    test_demangling_exact "lucid: __amu__3fooFR3foo" "foo::operator*=(foo &)"
553 
    test_demangling_exact "lucid: __amu__7complexF7complex" "complex::operator*=(complex)"
554 
    test_demangling_exact "lucid: __aor__3fooFR3foo" "foo::operator|=(foo &)"
555 
    test_demangling_exact "lucid: __apl__3fooFR3foo" "foo::operator+=(foo &)"
556 
    test_demangling_exact "lucid: __ars__3fooFR3foo" "foo::operator>>=(foo &)"
557 
    test_demangling_exact "lucid: __as__18istream_withassignFP9streambuf" "istream_withassign::operator=(streambuf *)"
558 
    test_demangling_exact "lucid: __as__18istream_withassignFR7istream" "istream_withassign::operator=(istream &)"
559 
    test_demangling_exact "lucid: __as__3fooFR3foo" "foo::operator=(foo &)"
560 
    test_demangling_exact "lucid: __as__3iosFR3ios" "ios::operator=(ios &)"
561 
    test_demangling_exact "lucid: __cl__3fooFR3foo" "foo::operator()(foo &)"
562 
    test_demangling_exact "lucid: __cm__3fooFR3foo" "foo::operator, (foo &)"
563 
 
564 
    test_demangling_exact "lucid: __co__3fooFv" "foo::operator~(void)"
565 
    test_demangling_exact "lucid: __ct__10istrstreamFPc" "istrstream::istrstream(char *)"
566 
    test_demangling_exact "lucid: __ct__10istrstreamFPci" "istrstream::istrstream(char *, int)"
567 
    test_demangling_exact "lucid: __ct__10ostrstreamFPciT2" "ostrstream::ostrstream(char *, int, int)"
568 
    test_demangling_exact "lucid: __ct__10ostrstreamFv" "ostrstream::ostrstream(void)"
569 
    test_demangling_exact "lucid: __ct__10smanip_intFPFR3iosi_R3iosi" "smanip_int::smanip_int(ios &(*)(ios &, int), int)"
570 
    test_demangling "lucid: __ct__11c_exceptionFPcRC7complexT2" "c_exception::c_exception\[(\]+char \[*\]+, (const complex|complex const) &, (const complex|complex const) &\[)\]+"
571 
    test_demangling "lucid: __ct__11fstreambaseFPCciT2" "fstreambase::fstreambase\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"
572 
    test_demangling_exact "lucid: __ct__11fstreambaseFi" "fstreambase::fstreambase(int)"
573 
    test_demangling_exact "lucid: __ct__11fstreambaseFiPcT1" "fstreambase::fstreambase(int, char *, int)"
574 
    test_demangling_exact "lucid: __ct__11fstreambaseFv" "fstreambase::fstreambase(void)"
575 
    test_demangling_exact "lucid: __ct__11smanip_longFPFR3iosl_R3iosl" "smanip_long::smanip_long(ios &(*)(ios &, long), long)"
576 
    test_demangling_exact "lucid: __ct__11stdiostreamFP4FILE" "stdiostream::stdiostream(FILE *)"
577 
    test_demangling_exact "lucid: __ct__12strstreambufFPFl_PvPFPv_v" "strstreambuf::strstreambuf(void *(*)(long), void (*)(void *))"
578 
    test_demangling_exact "lucid: __ct__12strstreambufFPUciT1" "strstreambuf::strstreambuf(unsigned char *, int, unsigned char *)"
579 
    test_demangling_exact "lucid: __ct__12strstreambufFPciT1" "strstreambuf::strstreambuf(char *, int, char *)"
580 
    test_demangling_exact "lucid: __ct__12strstreambufFi" "strstreambuf::strstreambuf(int)"
581 
    test_demangling_exact "lucid: __ct__12strstreambufFv" "strstreambuf::strstreambuf(void)"
582 
    test_demangling_exact "lucid: __ct__13strstreambaseFPciT1" "strstreambase::strstreambase(char *, int, char *)"
583 
    test_demangling_exact "lucid: __ct__3fooFR3foo" "foo::foo(foo &)"
584 
 
585 
    test_demangling_exact "lucid: __ct__3fooFi" "foo::foo(int)"
586 
    test_demangling_exact "lucid: __ct__3fooFiN31" "foo::foo(int, int, int, int)"
587 
    test_demangling "lucid: __ct__3fooFiPCc" \
588 
        "foo::foo\[(\]+int, (const char|char const) \[*\]+\[)\]+"
589 
    test_demangling_exact "lucid: __ct__3fooFiR3fooT1T2T1T2" "foo::foo(int, foo &, int, foo &, int, foo &)"
590 
    test_demangling_exact "lucid: __ct__3iosFP9streambuf" "ios::ios(streambuf *)"
591 
    test_demangling_exact "lucid: __ct__7filebufFiPcT1" "filebuf::filebuf(int, char *, int)"
592 
    test_demangling "lucid: __ct__7fstreamFPCciT2" \
593 
        "fstream::fstream\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"
594 
    test_demangling_exact "lucid: __ct__7fstreamFiPcT1" "fstream::fstream(int, char *, int)"
595 
    test_demangling_exact "lucid: __ct__7istreamFP9streambuf" "istream::istream(streambuf *)"
596 
    test_demangling_exact "lucid: __ct__7istreamFP9streambufiP7ostream" "istream::istream(streambuf *, int, ostream *)"
597 
    test_demangling_exact "lucid: __ct__7istreamFiPcT1" "istream::istream(int, char *, int)"
598 
    test_demangling_exact "lucid: __ct__7istreamFiT1P7ostream" "istream::istream(int, int, ostream *)"
599 
    test_demangling_exact "lucid: __ct__7ostreamFP9streambuf" "ostream::ostream(streambuf *)"
600 
    test_demangling_exact "lucid: __ct__7ostreamFiPc" "ostream::ostream(int, char *)"
601 
    test_demangling "lucid: __ct__8ifstreamFPCciT2" \
602 
        "ifstream::ifstream\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"
603 
    test_demangling_exact "lucid: __ct__8ifstreamFiPcT1" "ifstream::ifstream(int, char *, int)"
604 
 
605 
    test_demangling_exact "lucid: __ct__Q23foo3barFv" "foo::bar::bar(void)"
606 
    test_demangling_exact "lucid: __ct__Q33foo3bar4bellFv" "foo::bar::bell::bell(void)"
607 
    test_demangling_exact "lucid: __dl__3fooSFPv" "foo::operator delete(void *) static"
608 
    test_demangling_exact "lucid: __dl__FPv" "operator delete(void *)"
609 
    test_demangling_exact "lucid: __dt__10istrstreamFv" "istrstream::~istrstream(void)"
610 
 
611 
    test_demangling_exact "lucid: __dt__Q23foo3barFv" "foo::bar::~bar(void)"
612 
    test_demangling_exact "lucid: __dt__Q33foo3bar4bellFv" "foo::bar::bell::~bell(void)"
613 
    test_demangling_exact "lucid: __dv__3fooFR3foo" "foo::operator/(foo &)"
614 
    test_demangling_exact "lucid: __dv__F7complexT1" "operator/(complex, complex)"
615 
    test_demangling_exact "lucid: __eq__3fooFR3foo" "foo::operator==(foo &)"
616 
    test_demangling_exact "lucid: __er__3fooFR3foo" "foo::operator^(foo &)"
617 
    test_demangling_exact "lucid: __ge__3fooFR3foo" "foo::operator>=(foo &)"
618 
    test_demangling_exact "lucid: __gt__3fooFR3foo" "foo::operator>(foo &)"
619 
    test_demangling_exact "lucid: __le__3fooFR3foo" "foo::operator<=(foo &)"
620 
    test_demangling_exact "lucid: __ls__3fooFR3foo" "foo::operator<<(foo &)"
621 
    test_demangling_exact "lucid: __ls__7ostreamFP9streambuf" "ostream::operator<<(streambuf *)"
622 
 
623 
    test_demangling "lucid: __ls__7ostreamFPCc" \
624 
        "ostream::operator<<\[(\]+(const char|char const) \[*\]+\[)\]+"
625 
    test_demangling_exact "lucid: __ls__7ostreamFPFR3ios_R3ios" "ostream::operator<<(ios &(*)(ios &))"
626 
    test_demangling_exact "lucid: __ls__7ostreamFPv" "ostream::operator<<(void *)"
627 
    test_demangling_exact "lucid: __ls__7ostreamFUi" "ostream::operator<<(unsigned int)"
628 
    test_demangling_exact "lucid: __ls__7ostreamFUl" "ostream::operator<<(unsigned long)"
629 
    test_demangling_exact "lucid: __ls__7ostreamFd" "ostream::operator<<(double)"
630 
    test_demangling_exact "lucid: __ls__7ostreamFf" "ostream::operator<<(float)"
631 
    test_demangling_exact "lucid: __ls__7ostreamFi" "ostream::operator<<(int)"
632 
    test_demangling_exact "lucid: __ls__7ostreamFl" "ostream::operator<<(long)"
633 
    test_demangling_exact "lucid: __ls__FR7ostream7complex" "operator<<(ostream &, complex)"
634 
    test_demangling_exact "lucid: __lt__3fooFR3foo" "foo::operator<(foo &)"
635 
    test_demangling_exact "lucid: __md__3fooFR3foo" "foo::operator%(foo &)"
636 
    test_demangling_exact "lucid: __mi__3fooFR3foo" "foo::operator-(foo &)"
637 
    test_demangling_exact "lucid: __ml__3fooFR3foo" "foo::operator*(foo &)"
638 
    test_demangling_exact "lucid: __ml__F7complexT1" "operator*(complex, complex)"
639 
    test_demangling_exact "lucid: __mm__3fooFi" "foo::operator--(int)"
640 
    test_demangling_exact "lucid: __ne__3fooFR3foo" "foo::operator!=(foo &)"
641 
    test_demangling_exact "lucid: __nt__3fooFv" "foo::operator!(void)"
642 
    test_demangling_exact "lucid: __nw__3fooSFi" "foo::operator new(int) static"
643 
    test_demangling_exact "lucid: __nw__FUi" "operator new(unsigned int)"
644 
    test_demangling_exact "lucid: __nw__FUiPv" "operator new(unsigned int, void *)"
645 
    test_demangling_exact "lucid: __oo__3fooFR3foo" "foo::operator||(foo &)"
646 
    test_demangling_exact "lucid: __opPc__3fooFv" "foo::operator char *(void)"
647 
    test_demangling_exact "lucid: __opi__3fooFv" "foo::operator int(void)"
648 
    test_demangling_exact "lucid: __or__3fooFR3foo" "foo::operator|(foo &)"
649 
 
650 
    test_demangling_exact "lucid: __pl__3fooFR3foo" "foo::operator+(foo &)"
651 
    test_demangling_exact "lucid: __pp__3fooFi" "foo::operator++(int)"
652 
    test_demangling_exact "lucid: __pt__3fooFv" "foo::operator->(void)"
653 
    test_demangling_exact "lucid: __rm__3fooFR3foo" "foo::operator->*(foo &)"
654 
    test_demangling_exact "lucid: __rs__3fooFR3foo" "foo::operator>>(foo &)"
655 
    test_demangling_exact "lucid: __rs__7istreamFP9streambuf" "istream::operator>>(streambuf *)"
656 
    test_demangling_exact "lucid: __rs__7istreamFPFR3ios_R3ios" "istream::operator>>(ios &(*)(ios &))"
657 
    test_demangling_exact "lucid: __rs__7istreamFPFR7istream_R7istream" "istream::operator>>(istream &(*)(istream &))"
658 
    test_demangling_exact "lucid: __rs__7istreamFPUc" "istream::operator>>(unsigned char *)"
659 
    test_demangling_exact "lucid: __rs__7istreamFPc" "istream::operator>>(char *)"
660 
    test_demangling_exact "lucid: __rs__7istreamFRUi" "istream::operator>>(unsigned int &)"
661 
    test_demangling_exact "lucid: __rs__7istreamFRUl" "istream::operator>>(unsigned long &)"
662 
    test_demangling_exact "lucid: __rs__7istreamFRUs" "istream::operator>>(unsigned short &)"
663 
    test_demangling_exact "lucid: __rs__7istreamFRd" "istream::operator>>(double &)"
664 
    test_demangling_exact "lucid: __rs__7istreamFRf" "istream::operator>>(float &)"
665 
    test_demangling_exact "lucid: __rs__7istreamFRi" "istream::operator>>(int &)"
666 
    test_demangling_exact "lucid: __rs__7istreamFRl" "istream::operator>>(long &)"
667 
    test_demangling_exact "lucid: __rs__7istreamFRs" "istream::operator>>(short &)"
668 
    test_demangling_exact "lucid: __rs__FR7istreamR7complex" "operator>>(istream &, complex &)"
669 
    test_demangling "lucid: __vc__3fooFR3foo" "foo::operator\\\[\\\]\\(foo &\\)"
670 
    test_demangling_exact "lucid: __vtbl__10istrstream" "istrstream virtual table"
671 
    test_demangling_exact "lucid: __vtbl__17ostream__iostream__19iostream_withassign" "iostream_withassign::ostream__iostream virtual table"
672 
 
673 
    test_demangling_exact "lucid: __vtbl__3ios" "ios virtual table"
674 
    test_demangling_exact "lucid: __vtbl__3ios__13strstreambase" "strstreambase::ios virtual table"
675 
 
676 
    # GDB 930414 demangles this as t_cc_main_ (obviously wrong).
677 
    # GDB 930701 gets into an infinite loop.
678 
    # GDB 930727 says "Can't demangle".
679 
    # What is the correct demangling?  FIXME.
680 
    setup_xfail "*-*-*"
681 
    test_demangling_exact "lucid: __vtbl__3foo__vt_cc_main_" ""
682 
 
683 
    test_demangling_exact "lucid: abs__F7complex" "abs(complex)"
684 
    test_demangling_exact "lucid: allocate__9streambufFv" "streambuf::allocate(void)"
685 
    test_demangling_exact "lucid: attach__11fstreambaseFi" "fstreambase::attach(int)"
686 
    test_demangling_exact "lucid: bitalloc__3iosSFv" "ios::bitalloc(void) static"
687 
    test_demangling_exact "lucid: chr__FiT1" "chr(int, int)"
688 
    test_demangling_exact "lucid: complex_error__FR11c_exception" "complex_error(c_exception &)"
689 
    test_demangling_exact "lucid: complexfunc2__FPFPc_i" "complexfunc2(int (*)(char *))"
690 
    test_demangling_exact "lucid: complexfunc3__FPFPFPl_s_i" "complexfunc3(int (*)(short (*)(long *)))"
691 
 
692 
    test_demangling_exact "lucid: complexfunc4__FPFPFPc_s_i" "complexfunc4(int (*)(short (*)(char *)))"
693 
    test_demangling_exact "lucid: complexfunc5__FPFPc_PFl_i" "complexfunc5(int (*(*)(char *))(long))"
694 
    test_demangling_exact "lucid: complexfunc6__FPFPi_PFl_i" "complexfunc6(int (*(*)(int *))(long))"
695 
    test_demangling_exact "lucid: complexfunc7__FPFPFPc_i_PFl_i" "complexfunc7(int (*(*)(int (*)(char *)))(long))"
696 
    test_demangling_exact "lucid: complicated_put__7ostreamFc" "ostream::complicated_put(char)"
697 
    test_demangling_exact "lucid: conv10__FlPc" "conv10(long, char *)"
698 
    test_demangling_exact "lucid: conv16__FUlPc" "conv16(unsigned long, char *)"
699 
    test_demangling_exact "lucid: dec__FR3ios" "dec(ios &)"
700 
    test_demangling_exact "lucid: dec__Fli" "dec(long, int)"
701 
    test_demangling_exact "lucid: dofield__FP7ostreamPciT2T3" "dofield(ostream *, char *, int, char *, int)"
702 
 
703 
    test_demangling_exact "lucid: flags__3iosFl" "ios::flags(long)"
704 
    test_demangling_exact "lucid: flags__3iosFv" "ios::flags(void)"
705 
    test_demangling_exact "lucid: foo__FiN31" "foo(int, int, int, int)"
706 
    test_demangling_exact "lucid: foo__FiR3fooT1T2T1T2" "foo(int, foo &, int, foo &, int, foo &)"
707 
    test_demangling_exact "lucid: foo___3barFl" "bar::foo_(long)"
708 
    test_demangling "lucid: form__FPCce" "form\[(\]+(const char|char const) \[*\]+,...\[)\]+"
709 
    test_demangling_exact "lucid: get__7istreamFPcic" "istream::get(char *, int, char)"
710 
    test_demangling_exact "lucid: get__7istreamFR9streambufc" "istream::get(streambuf &, char)"
711 
    test_demangling_exact "lucid: get_complicated__7istreamFRUc" "istream::get_complicated(unsigned char &)"
712 
    test_demangling_exact "lucid: get_complicated__7istreamFRc" "istream::get_complicated(char &)"
713 
    test_demangling_exact "lucid: getline__7istreamFPUcic" "istream::getline(unsigned char *, int, char)"
714 
    test_demangling_exact "lucid: getline__7istreamFPcic" "istream::getline(char *, int, char)"
715 
 
716 
    test_demangling_exact "lucid: ignore__7istreamFiT1" "istream::ignore(int, int)"
717 
    test_demangling_exact "lucid: init__12strstreambufFPciT1" "strstreambuf::init(char *, int, char *)"
718 
    test_demangling_exact "lucid: init__3iosFP9streambuf" "ios::init(streambuf *)"
719 
    test_demangling_exact "lucid: initcount__13Iostream_init" "Iostream_init::initcount"
720 
    test_demangling_exact "lucid: ipfx__7istreamFi" "istream::ipfx(int)"
721 
    test_demangling_exact "lucid: ls_complicated__7ostreamFUc" "ostream::ls_complicated(unsigned char)"
722 
    test_demangling_exact "lucid: ls_complicated__7ostreamFc" "ostream::ls_complicated(char)"
723 
    test_demangling "lucid: open__11fstreambaseFPCciT2" \
724 
        "fstreambase::open\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"
725 
    test_demangling "lucid: open__7filebufFPCciT2" \
726 
        "filebuf::open\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"
727 
 
728 
    test_demangling_exact "lucid: overload1arg__FSc" "overload1arg(signed char)"
729 
    test_demangling_exact "lucid: overload1arg__FUc" "overload1arg(unsigned char)"
730 
    test_demangling_exact "lucid: overload1arg__FUi" "overload1arg(unsigned int)"
731 
    test_demangling_exact "lucid: overload1arg__FUl" "overload1arg(unsigned long)"
732 
    test_demangling_exact "lucid: overload1arg__FUs" "overload1arg(unsigned short)"
733 
    test_demangling_exact "lucid: overload1arg__Fc" "overload1arg(char)"
734 
    test_demangling_exact "lucid: overload1arg__Fd" "overload1arg(double)"
735 
    test_demangling_exact "lucid: overload1arg__Ff" "overload1arg(float)"
736 
    test_demangling_exact "lucid: overload1arg__Fi" "overload1arg(int)"
737 
    test_demangling_exact "lucid: overload1arg__Fl" "overload1arg(long)"
738 
    test_demangling_exact "lucid: overload1arg__Fs" "overload1arg(short)"
739 
    test_demangling_exact "lucid: overload1arg__Fv" "overload1arg(void)"
740 
    test_demangling_exact "lucid: overloadargs__FiN21" "overloadargs(int, int, int)"
741 
    test_demangling_exact "lucid: overloadargs__FiN31" "overloadargs(int, int, int, int)"
742 
    test_demangling_exact "lucid: overloadargs__FiN41" "overloadargs(int, int, int, int, int)"
743 
    test_demangling_exact "lucid: overloadargs__FiN51" "overloadargs(int, int, int, int, int, int)"
744 
    test_demangling_exact "lucid: overloadargs__FiN61" "overloadargs(int, int, int, int, int, int, int)"
745 
 
746 
    test_demangling_exact "lucid: overloadargs__FiN71" "overloadargs(int, int, int, int, int, int, int, int)"
747 
    test_demangling_exact "lucid: overloadargs__FiN81" "overloadargs(int, int, int, int, int, int, int, int, int)"
748 
    test_demangling_exact "lucid: overloadargs__FiN91" "overloadargs(int, int, int, int, int, int, int, int, int, int)"
749 
    test_demangling_exact "lucid: overloadargs__FiN91N11" "overloadargs(int, int, int, int, int, int, int, int, int, int, int)"
750 
    test_demangling_exact "lucid: overloadargs__FiT1" "overloadargs(int, int)"
751 
    test_demangling_exact "lucid: polar__FdT1" "polar(double, double)"
752 
    test_demangling_exact "lucid: pow__F7complexT1" "pow(complex, complex)"
753 
    test_demangling_exact "lucid: pow__F7complexd" "pow(complex, double)"
754 
    test_demangling_exact "lucid: pow__F7complexi" "pow(complex, int)"
755 
    test_demangling_exact "lucid: pow__Fd7complex" "pow(double, complex)"
756 
    test_demangling_exact "lucid: pstart__FPciT2" "pstart(char *, int, int)"
757 
    test_demangling_exact "lucid: put__7ostreamFc" "ostream::put(char)"
758 
 
759 
    test_demangling_exact "lucid: read__7istreamFPci" "istream::read(char *, int)"
760 
    test_demangling_exact "lucid: resetiosflags__FR3iosl" "resetiosflags(ios &, long)"
761 
    test_demangling_exact "lucid: restore_errno__FRi" "restore_errno(int &)"
762 
    test_demangling_exact "lucid: rs_complicated__7istreamFRUc" "istream::rs_complicated(unsigned char &)"
763 
    test_demangling_exact "lucid: rs_complicated__7istreamFRc" "istream::rs_complicated(char &)"
764 
    test_demangling_exact "lucid: seekg__7istreamFl8seek_dir" "istream::seekg(long, seek_dir)"
765 
    test_demangling_exact "lucid: seekoff__12strstreambufFl8seek_diri" "strstreambuf::seekoff(long, seek_dir, int)"
766 
    test_demangling_exact "lucid: seekoff__9streambufFlQ2_3ios12ios_seek_diri" "streambuf::seekoff(long, ios::ios_seek_dir, int)"
767 
    test_demangling_exact "lucid: seekpos__9streambufFli" "streambuf::seekpos(long, int)"
768 
    test_demangling_exact "lucid: set_new_handler__FPFv_v" "set_new_handler(void (*)(void))"
769 
    test_demangling_exact "lucid: setb__9streambufFPcT1i" "streambuf::setb(char *, char *, int)"
770 
 
771 
    test_demangling_exact "lucid: setb__FR3iosi" "setb(ios &, int)"
772 
    test_demangling_exact "lucid: setbuf__11fstreambaseFPci" "fstreambase::setbuf(char *, int)"
773 
    test_demangling_exact "lucid: setbuf__9streambufFPUci" "streambuf::setbuf(unsigned char *, int)"
774 
    test_demangling_exact "lucid: setbuf__9streambufFPciT2" "streambuf::setbuf(char *, int, int)"
775 
    test_demangling_exact "lucid: setf__3iosFlT1" "ios::setf(long, long)"
776 
    test_demangling_exact "lucid: setfill__FR3iosi" "setfill(ios &, int)"
777 
    test_demangling_exact "lucid: setg__9streambufFPcN21" "streambuf::setg(char *, char *, char *)"
778 
    test_demangling_exact "lucid: setp__9streambufFPcT1" "streambuf::setp(char *, char *)"
779 
 
780 
    test_demangling "lucid: sputn__9streambufFPCci" \
781 
        "streambuf::sputn\[(\]+(const char|char const) \[*\]+, int\[)\]+"
782 
    test_demangling "lucid: str__FPCci" \
783 
        "str\[(\]+(const char|char const) \[*\]+, int\[)\]+"
784 
    test_demangling_exact "lucid: tie__3iosFP7ostream" "ios::tie(ostream *)"
785 
    test_demangling_exact "lucid: uconv10__FUlPc" "uconv10(unsigned long, char *)"
786 
 
787 
    test_demangling "lucid: write__7ostreamFPCci" \
788 
        "ostream::write\[(\]+(const char|char const) \[*\]+, int\[)\]+"
789 
    test_demangling_exact "lucid: xget__7istreamFPc" "istream::xget(char *)"
790 
    test_demangling_exact "lucid: xsgetn__9streambufFPci" "streambuf::xsgetn(char *, int)"
791 
    test_demangling "lucid: xsputn__9streambufFPCci" \
792 
        "streambuf::xsputn\[(\]+(const char|char const) \[*\]+, int\[)\]+"
793 
 
794 
    test_demangling_exact "lucid: _Utf390_1__1_9223372036854775807__9223372036854775" \
795 
            "Can't demangle \"_Utf390_1__1_9223372036854775807__9223372036854775\""
796 
}
797 
 
798 
#
799 
#  Test arm style name demangling
800 
#
801 
 
802 
proc test_arm_style_demangling {} {
803 
    test_demangling_exact "arm: __dt__21T5__pt__11_PFiPPdPv_iFv" "T5::~T5(void)"
804 
 
805 
    test_demangling_exact "arm: __ct__1cFi" "c::c(int)"
806 
 
807 
    test_demangling_exact "arm: __dt__11T5__pt__2_iFv" "T5::~T5(void)"
808 
 
809 
    test_demangling_exact "arm: __dt__11T5__pt__2_cFv" "T5::~T5(void)"
810 
 
811 
    test_demangling_exact "arm: __ct__2T2Fi" "T2::T2(int)"
812 
    test_demangling_exact "arm: __dt__2T1Fv" "T1::~T1(void)"
813 
 
814 
    test_demangling_exact "arm: __dt__12T5__pt__3_1xFv" "T5::~T5(void)"
815 
 
816 
    test_demangling_exact "arm: __dt__17T5__pt__8_PFcPv_iFv" "T5::~T5(void)"
817 
 
818 
    test_demangling "arm: g__FP1cPC1cT1" \
819 
        "g\[(\]+c *\[*\]+, (const c|c const) *\[*\]+, c *\[*\]+\[)\]+"
820 
    test_demangling "arm: g__FPUlPCUlT1" \
821 
        "g\[(\]+unsigned long \[*\]+, (const unsigned long|unsigned long const) \[*\]+, unsigned long \[*\]+\[)\]+"
822 
    test_demangling "arm: g__FPUiPCUiT1" \
823 
        "g\[(\]+unsigned int \[*\]+, (const unsigned int|unsigned int const) \[*\]+, unsigned int \[*\]+\[)\]+"
824 
    test_demangling "arm: g__FPUsPCUsT1" \
825 
        "g\[(\]+unsigned short \[*\]+, (const unsigned short|unsigned short const) \[*\]+, unsigned short \[*\]+\[)\]+"
826 
    test_demangling "arm: g__FPUcPCUcT1" \
827 
        "g\[(\]+unsigned char \[*\]+, (const unsigned char|unsigned char const) \[*\]+, unsigned char \[*\]+\[)\]+"
828 
    test_demangling "arm: g__F1TPlPClT2" \
829 
        "g\[(\]+T, long \[*\]+, (const long|long const) \[*\]+, long \[*\]+\[)\]+"
830 
    test_demangling "arm: g__F1RRlRClT2" \
831 
        "g\[(\]+R, long &, (const long|long const) &, long &\[)\]+"
832 
    test_demangling "arm: g__F1TPiPCiT2" \
833 
        "g\[(\]+T, int \[*\]+, (const int|int const) \[*\]+, int \[*\]+\[)\]+"
834 
    test_demangling "arm: g__F1RRiRCiT2" \
835 
        "g\[(\]+R, int &, (const int|int const) &, int &\[)\]+"
836 
    test_demangling "arm: g__F1TPsPCsT2" \
837 
        "g\[(\]+T, short \[*\]+, (const short|short const) \[*\]+, short \[*\]+\[)\]+"
838 
    test_demangling "arm: g__F1RRsRCsT2" \
839 
        "g\[(\]+R, short &, (const short|short const) &, short &\[)\]+"
840 
    test_demangling "arm: g__F1TPcPCcT2" \
841 
        "g\[(\]+T, char \[*\]+, (const char|char const) \[*\]+, char \[*\]+\[)\]+"
842 
    test_demangling "arm: g__F1RRcRCcT2" \
843 
        "g\[(\]+R, char &, (const char|char const) &, char &\[)\]+"
844 
 
845 
    test_demangling_exact "arm: __ct__21T5__pt__11_PFiPPdPv_iFi" "T5::T5(int)"
846 
 
847 
    test_demangling "arm: __gt__FRC2T2c" \
848 
        "operator>\[(\]+(const T2|T2 const) &, char\[)\]+"
849 
    test_demangling "arm: __ge__FRC2T2c" \
850 
        "operator>=\[(\]+(const T2|T2 const) &, char\[)\]+"
851 
    test_demangling "arm: __lt__FRC2T2c" \
852 
        "operator<\[(\]+(const T2|T2 const) &, char\[)\]+"
853 
 
854 
    test_demangling "arm: __le__FRC2T2c" \
855 
        "operator<=\[(\]+(const T2|T2 const) &, char\[)\]+"
856 
    test_demangling "arm: __ne__FRC2T2c" \
857 
        "operator!=\[(\]+(const T2|T2 const) &, char\[)\]+"
858 
    test_demangling "arm: __eq__FRC2T2c" \
859 
        "operator==\[(\]+(const T2|T2 const) &, char\[)\]+"
860 
    test_demangling_exact "arm: __amd__FR2T2i" "operator%=(T2 &, int)"
861 
    test_demangling_exact "arm: __adv__FR2T2i" "operator/=(T2 &, int)"
862 
    test_demangling_exact "arm: __amu__FR2T2i" "operator*=(T2 &, int)"
863 
    test_demangling_exact "arm: __ami__FR2T2i" "operator-=(T2 &, int)"
864 
    test_demangling_exact "arm: __apl__FR2T2i" "operator+=(T2 &, int)"
865 
    test_demangling_exact "arm: __nw__2T1SFUi" "T1::operator new(unsigned int) static"
866 
    test_demangling_exact "arm: __dl__2T1SFPv" "T1::operator delete(void *) static"
867 
    test_demangling_exact "arm: put__2T7SFi" "T7::put(int) static"
868 
 
869 
    test_demangling_exact "arm: __dl__12T5__pt__3_1xSFPv" "T5::operator delete(void *) static"
870 
 
871 
    test_demangling_exact "arm: h__FUc" "h(unsigned char)"
872 
    test_demangling_exact "arm: f__Fic" "f(int, char)"
873 
    test_demangling_exact "arm: h__FUi" "h(unsigned int)"
874 
    test_demangling_exact "arm: h__Fci" "h(char, int)"
875 
    test_demangling_exact "arm: h__FUl" "h(unsigned long)"
876 
    test_demangling_exact "arm: h__Fcl" "h(char, long)"
877 
    test_demangling_exact "arm: h__FUs" "h(unsigned short)"
878 
    test_demangling_exact "arm: h__Fcs" "h(char, short)"
879 
    test_demangling "arm: __amd__FR2T2RC2T2" \
880 
        "operator%=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
881 
    test_demangling "arm: __adv__FR2T2RC2T2" \
882 
        "operator/=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
883 
    test_demangling "arm: __amu__FR2T2RC2T2" \
884 
        "operator\[*\]+=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
885 
    test_demangling "arm: __ami__FR2T2RC2T2" \
886 
        "operator-=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
887 
    test_demangling "arm: __apl__FR2T2RC2T2" \
888 
        "operator\[+\]+=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
889 
 
890 
    test_demangling "arm: g__F1SRPUlRPCUlT2" \
891 
        "g\[(\]+S, unsigned long \[*\]+&, (const unsigned long|unsigned long const) \[*\]+&, unsigned long \[*\]+&\[)\]+"
892 
    test_demangling "arm: g__F1SRPUiRPCUiT2" \
893 
        "g\[(\]+S, unsigned int \[*\]+&, (const unsigned int|unsigned int const) \[*\]+&, unsigned int \[*\]+&\[)\]+"
894 
    test_demangling "arm: g__F1SRPUsRPCUsT2" \
895 
        "g\[(\]+S, unsigned short \[*\]+&, (const unsigned short|unsigned short const) \[*\]+&, unsigned short \[*\]+&\[)\]+"
896 
    test_demangling "arm: g__F1SRPUcRPCUcT2" \
897 
        "g\[(\]+S, unsigned char \[*\]+&, (const unsigned char|unsigned char const) \[*\]+&, unsigned char \[*\]+&\[)\]+"
898 
    test_demangling "arm: g__F1T1SRPlRPClT3" \
899 
        "g\[(\]+T, S, long \[*\]+&, (const long|long const) \[*\]+&, long \[*\]+&\[)\]+"
900 
    test_demangling "arm: g__F1T1SRPiRPCiT3" \
901 
        "g\[(\]+T, S, int \[*\]+&, (const int|int const) \[*\]+&, int \[*\]+&\[)\]+"
902 
    test_demangling "arm: g__F1T1SRPcRPCcT3" \
903 
        "g\[(\]+T, S, char \[*\]+&, (const char|char const) \[*\]+&, char \[*\]+&\[)\]+"
904 
 
905 
    test_demangling_exact "arm: X__12T5__pt__3_1x" "T5::X"
906 
 
907 
    test_demangling_exact "arm: __ct__11T5__pt__2_iFi" "T5::T5(int)"
908 
 
909 
    test_demangling_exact "arm: __ct__11T5__pt__2_cFi" "T5::T5(int)"
910 
 
911 
    test_demangling "arm: __gt__FRC2T2T1" \
912 
        "operator>\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
913 
    test_demangling "arm: __ge__FRC2T2T1" \
914 
        "operator>=\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
915 
    test_demangling "arm: __lt__FRC2T2T1" \
916 
        "operator<\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
917 
    test_demangling "arm: __le__FRC2T2T1" \
918 
        "operator<=\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
919 
    test_demangling "arm: __ne__FRC2T2T1" \
920 
        "operator!=\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
921 
    test_demangling "arm: __eq__FRC2T2T1" \
922 
        "operator==\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
923 
    test_demangling "arm: g__FcR1cRC1cT2" \
924 
        "g\[(\]+char, c &, (const c|c const) &, c &\[)\]+"
925 
    test_demangling "arm: g__FcRPdRPCdT2" \
926 
        "g\[(\]+char, double *\[*\]+&, (const double|double const) *\[*\]+&, double *\[*\]+&\[)\]+"
927 
    test_demangling "arm: g__FcRPfRPCfT2" \
928 
        "g\[(\]+char, float *\[*\]+&, (const float|float const) *\[*\]+&, float *\[*\]+&\[)\]+"
929 
    test_demangling_exact "arm: h__FcT1" "h(char, char)"
930 
    test_demangling_exact "arm: f__Ficd" "f(int, char, double)"
931 
    test_demangling "arm: g__F1T1SdRPsRPCsT4" \
932 
        "g\[(\]+T, S, double, short \[*\]+&, (const short|short const) \[*\]+&, short \[*\]+&\[)\]+"
933 
    test_demangling "arm: g__F1cC1cT1" \
934 
        "g\[(\]+c, (const c|c const), c\[)\]+"
935 
    test_demangling "arm: g__FPdPCdT1" \
936 
        "g\[(\]+double *\[*\]+, (const double|double const) *\[*\]+, double *\[*\]+\[)\]+"
937 
    test_demangling "arm: g__FPfPCfT1" \
938 
        "g\[(\]+float *\[*\]+, (const float|float const) *\[*\]+, float *\[*\]+\[)\]+"
939 
 
940 
    test_demangling "arm: g__FUlCUlT1" \
941 
        "g\[(\]+unsigned long, (const unsigned long|unsigned long const), unsigned long\[)\]+"
942 
    test_demangling "arm: g__FPlPClT1" \
943 
        "g\[(\]+long \[*\]+, (const long|long const) \[*\]+, long \[*\]+\[)\]+"
944 
    test_demangling "arm: g__FUiCUiT1" \
945 
        "g\[(\]+unsigned int, (const unsigned int|unsigned int const), unsigned int\[)\]+"
946 
    test_demangling "arm: g__FPiPCiT1" \
947 
        "g\[(\]+int \[*\]+, (const int|int const) \[*\]+, int \[*\]+\[)\]+"
948 
    test_demangling "arm: g__FUsCUsT1" \
949 
        "g\[(\]+unsigned short, (const unsigned short|unsigned short const), unsigned short\[)\]+"
950 
    test_demangling "arm: g__FPsPCsT1" \
951 
        "g\[(\]+short \[*\]+, (const short|short const) \[*\]+, short \[*\]+\[)\]+"
952 
    test_demangling "arm: g__FUcCUcT1" \
953 
        "g\[(\]+unsigned char, (const unsigned char|unsigned char const), unsigned char\[)\]+"
954 
    test_demangling "arm: g__FPcPCcT1" \
955 
        "g\[(\]+char \[*\]+, (const char|char const) \[*\]+, char \[*\]+\[)\]+"
956 
    test_demangling "arm: g__F1TlClT2" \
957 
        "g\[(\]+T, long, (const long|long const), long\[)\]+"
958 
    test_demangling "arm: g__F1TiCiT2" \
959 
        "g\[(\]+T, int, (const int|int const), int\[)\]+"
960 
    test_demangling "arm: g__F1TsCsT2" \
961 
        "g\[(\]+T, short, (const short|short const), short\[)\]+"
962 
    test_demangling "arm: g__F1TcCcT2" \
963 
        "g\[(\]+T, char, (const char|char const), char\[)\]+"
964 
 
965 
    test_demangling_exact "arm: __dl__17T5__pt__8_PFcPv_iSFPv" "T5::operator delete(void *) static"
966 
 
967 
    test_demangling "arm: printf__FPCce" \
968 
        "printf\[(\]+(const char|char const) \[*\]+,...\[)\]+"
969 
 
970 
    test_demangling_exact "arm: X__17T5__pt__8_PFcPv_i" "T5::X"
971 
 
972 
    test_demangling_exact "arm: __ct__12T5__pt__3_1xFi" "T5::T5(int)"
973 
 
974 
    test_demangling "arm: g__F1SRUlRCUlT2" \
975 
        "g\[(\]+S, unsigned long &, (const unsigned long|unsigned long const) &, unsigned long &\[)\]+"
976 
    test_demangling "arm: g__F1SRPlRPClT2" \
977 
        "g\[(\]+S, long \[*\]+&, (const long|long const) \[*\]+&, long \[*\]+&\[)\]+"
978 
    test_demangling "arm: g__F1RRUiRCUiT2" \
979 
        "g\[(\]+R, unsigned int &, (const unsigned int|unsigned int const) &, unsigned int &\[)\]+"
980 
    test_demangling "arm: g__F1SRPiRPCiT2" \
981 
        "g\[(\]+S, int \[*\]+&, (const int|int const) \[*\]+&, int \[*\]+&\[)\]+"
982 
    test_demangling "arm: g__F1RRUsRCUsT2" \
983 
        "g\[(\]+R, unsigned short &, (const unsigned short|unsigned short const) &, unsigned short &\[)\]+"
984 
    test_demangling "arm: g__F1SRPsRPCsT2" \
985 
        "g\[(\]+S, short \[*\]+&, (const short|short const) \[*\]+&, short \[*\]+&\[)\]+"
986 
    test_demangling "arm: g__F1RRUcRCUcT2" \
987 
        "g\[(\]+R, unsigned char &, (const unsigned char|unsigned char const) &, unsigned char &\[)\]+"
988 
    test_demangling "arm: g__F1SRPcRPCcT2" \
989 
        "g\[(\]+S, char \[*\]+&, (const char|char const) \[*\]+&, char \[*\]+&\[)\]+"
990 
    test_demangling "arm: g__F1T1RRlRClT3" \
991 
        "g\[(\]+T, R, long &, (const long|long const) &, long &\[)\]+"
992 
    test_demangling "arm: g__F1T1RRiRCiT3" \
993 
        "g\[(\]+T, R, int &, (const int|int const) &, int &\[)\]+"
994 
    test_demangling "arm: g__F1T1RRsRCsT3" \
995 
        "g\[(\]+T, R, short &, (const short|short const) &, short &\[)\]+"
996 
    test_demangling "arm: g__F1T1RRcRCcT3" \
997 
        "g\[(\]+T, R, char &, (const char|char const) &, char &\[)\]+"
998 
 
999 
    test_demangling_exact "arm: __dl__21T5__pt__11_PFiPPdPv_iSFPv" "T5::operator delete(void *) static"
1000 
 
1001 
    test_demangling_exact "arm: __std__foo" "global destructors keyed to foo"
1002 
 
1003 
    test_demangling_exact "arm: __sti__bar" "global constructors keyed to bar"
1004 
 
1005 
    test_demangling_exact "arm: f__FicdPcPFci_v" "f(int, char, double, char *, void (*)(char, int))"
1006 
    test_demangling_exact "arm: f__FicdPcPFic_v" "f(int, char, double, char *, void (*)(int, char))"
1007 
    test_demangling_exact "arm: get__2T7SFv" "T7::get(void) static"
1008 
 
1009 
    test_demangling_exact "arm: X__21T5__pt__11_PFiPPdPv_i" "T5::X"
1010 
 
1011 
    test_demangling "arm: g__FcRdRCdT2" \
1012 
        "g\[(\]+char, double &, (const double|double const) &, double &\[)\]+"
1013 
    test_demangling "arm: g__FcRfRCfT2" \
1014 
        "g\[(\]+char, float &, (const float|float const) &, float &\[)\]+"
1015 
    test_demangling "arm: __md__FC2T2i" \
1016 
        "operator%\[(\]+(const T2|T2 const), int\[)\]+"
1017 
    test_demangling "arm: __dv__FC2T2i" \
1018 
        "operator/\[(\]+(const T2|T2 const), int\[)\]+"
1019 
    test_demangling "arm: __ml__FC2T2i" \
1020 
        "operator\[*\]+\[(\]+(const T2|T2 const), int\[)\]+"
1021 
    test_demangling "arm: __mi__FC2T2i" \
1022 
        "operator-\[(\]+(const T2|T2 const), int\[)\]+"
1023 
    test_demangling "arm: __pl__FC2T2i" \
1024 
        "operator\[+\]+\[(\]+(const T2|T2 const), int\[)\]+"
1025 
 
1026 
    test_demangling_exact "arm: __dl__11T5__pt__2_iSFPv" "T5::operator delete(void *) static"
1027 
 
1028 
    test_demangling_exact "arm: __dl__11T5__pt__2_cSFPv" "T5::operator delete(void *) static"
1029 
 
1030 
    test_demangling_exact "arm: h__Fc" "h(char)"
1031 
    test_demangling_exact "arm: h__Fd" "h(double)"
1032 
    test_demangling_exact "arm: h__Ff" "h(float)"
1033 
    test_demangling_exact "arm: h__Fi" "h(int)"
1034 
    test_demangling_exact "arm: f__Fi" "f(int)"
1035 
    test_demangling_exact "arm: h__Fl" "h(long)"
1036 
 
1037 
    test_demangling_exact "arm: h__Fs" "h(short)"
1038 
    test_demangling "arm: __md__FC2T2RC2T2" \
1039 
        "operator%\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
1040 
    test_demangling "arm: __dv__FC2T2RC2T2" \
1041 
        "operator/\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
1042 
    test_demangling "arm: __ml__FC2T2RC2T2" \
1043 
        "operator\[*\]+\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
1044 
    test_demangling "arm: __mi__FC2T2RC2T2" \
1045 
        "operator-\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
1046 
    test_demangling "arm: __pl__FC2T2RC2T2" \
1047 
        "operator\[+\]+\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
1048 
    test_demangling "arm: g__FcRP1cRPC1cT2" \
1049 
        "g\[(\]+char, c *\[*\]+&, (const c|c const) *\[*\]+&, c *\[*\]+&\[)\]+"
1050 
 
1051 
    test_demangling_exact "arm: X__11T5__pt__2_c" "T5::X"
1052 
 
1053 
    test_demangling_exact "arm: X__11T5__pt__2_i" "T5::X"
1054 
 
1055 
    test_demangling "arm: g__FdCdT1" \
1056 
        "g\[(\]+double, (const double|double const), double\[)\]+"
1057 
    test_demangling "arm: g__FfCfT1" \
1058 
        "g\[(\]+float, (const float|float const), float\[)\]+"
1059 
    test_demangling "arm: g__FlClT1" \
1060 
        "g\[(\]+long, (const long|long const), long\[)\]+"
1061 
    test_demangling "arm: g__FiCiT1" \
1062 
        "g\[(\]+int, (const int|int const), int\[)\]+"
1063 
    test_demangling "arm: g__FsCsT1" \
1064 
        "g\[(\]+short, (const short|short const), short\[)\]+"
1065 
    test_demangling "arm: g__FcCcT1" \
1066 
        "g\[(\]+char, (const char|char const), char\[)\]+"
1067 
 
1068 
    test_demangling_exact "arm: __ct__17T5__pt__8_PFcPv_iFi" "T5::T5(int)"
1069 
 
1070 
    test_demangling_exact "arm: f__FicdPc" "f(int, char, double, char *)"
1071 
    test_demangling_exact "arm: __nw__FUi" "operator new(unsigned int)"
1072 
    test_demangling_exact "arm: __ct__Q3_2T11a1bSFi" "T1::a::b::b(int) static"
1073 
    test_demangling_exact "arm: __dt__Q3_2T11a1bSFi" "T1::a::b::~b(int) static"
1074 
    test_demangling_exact "arm: put__Q3_2T11a1bSFi" "T1::a::b::put(int) static"
1075 
    test_demangling_exact "arm: get__Q2_2T11aSFv" "T1::a::get(void) static"
1076 
    test_demangling_exact "arm: put__2T1SFi" "T1::put(int) static"
1077 
    test_demangling_exact "arm: put__Q5_2T11a1b1c1dSFi" "T1::a::b::c::d::put(int) static"
1078 
    test_demangling_exact "arm: get__Q4_2T11a1b1cSFv" "T1::a::b::c::get(void) static"
1079 
    test_demangling_exact "arm: put__Q2_2T11aSFi" "T1::a::put(int) static"
1080 
    test_demangling_exact "arm: put__Q4_2T11a1b1cSFi" "T1::a::b::c::put(int) static"
1081 
    test_demangling_exact "arm: get__Q3_2T11a1bSFv" "T1::a::b::get(void) static"
1082 
    test_demangling_exact "arm: get__2T1SFv" "T1::get(void) static"
1083 
    test_demangling_exact "arm: get__Q5_2T11a1b1c1dSFv" "T1::a::b::c::d::get(void) static"
1084 
 
1085 
    test_demangling_exact "arm: __dt__11T1__pt__2_cFv" "T1::~T1(void)"
1086 
 
1087 
    test_demangling_exact "arm: __dt__12T1__pt__3_1tFv" "T1::~T1(void)"
1088 
 
1089 
    test_demangling_exact "arm: __dl__12T1__pt__3_1tSFPv" "T1::operator delete(void *) static"
1090 
 
1091 
    test_demangling_exact "arm: __ct__11T1__pt__2_cFi" "T1::T1(int)"
1092 
 
1093 
    test_demangling_exact "arm: __ct__11T1__pt__2_cFv" "T1::T1(void)"
1094 
 
1095 
    test_demangling_exact "arm: __ct__12T1__pt__3_1tFi" "T1::T1(int)"
1096 
 
1097 
    test_demangling_exact "arm: __ct__12T1__pt__3_1tFv" "T1::T1(void)"
1098 
 
1099 
    test_demangling_exact "arm: __dl__11T1__pt__2_cSFPv" "T1::operator delete(void *) static"
1100 
 
1101 
    test_demangling_exact "arm: bar__3fooFPv"       "foo::bar(void *)"
1102 
    test_demangling "arm: bar__3fooFPCv" \
1103 
             "foo::bar\[(\]+(const void|void const) *\[*\]+\[)\]+"
1104 
    test_demangling_exact "arm: bar__3fooCFPv"      "foo::bar(void *) const"
1105 
    test_demangling "arm: bar__3fooCFPCv" \
1106 
            "foo::bar\[(\]+(const void|void const) *\[*\]+\[)\]+ const"
1107 
    test_demangling_exact "arm: __eq__3fooFR3foo"   "foo::operator==(foo &)"
1108 
    test_demangling "arm: __eq__3fooFRC3foo" \
1109 
         "foo::operator==\[(\]+(const foo|foo const) &\[)\]+"
1110 
    test_demangling_exact "arm: __eq__3fooCFR3foo"  "foo::operator==(foo &) const"
1111 
    test_demangling "arm: __eq__3fooCFRC3foo" \
1112 
        "foo::operator==\[(\]+(const foo|foo const) &\[)\]+ const"
1113 
 
1114 
    test_demangling_exact "arm: elem__15vector__pt__2_dFi" "vector::elem(int)"
1115 
 
1116 
    test_demangling_exact "arm: elem__15vector__pt__2_iFi" "vector::elem(int)"
1117 
 
1118 
    test_demangling_exact "arm: __ct__15vector__pt__2_dFi" "vector::vector(int)"
1119 
 
1120 
    test_demangling_exact "arm: __ct__15vector__pt__2_iFi" "vector::vector(int)"
1121 
 
1122 
    test_demangling_exact "arm: __ct__25DListNode__pt__9_R6RLabelFR6RLabelP25DListNode__pt__9_R6RLabelT2" \
1123 
        "DListNode::DListNode(RLabel &, DListNode *, DListNode *)"
1124 
 
1125 
    test_demangling_exact "arm: bar__3fooFiT16FooBar" "foo::bar(int, int, FooBar)"
1126 
 
1127 
    test_demangling_exact "arm: bar__3fooFPiN51PdN37PcN211T1iN215" \
1128 
      "foo::bar(int *, int *, int *, int *, int *, int *, double *, double *, double *, double *, char *, char *, char *, int *, int, int, int)"
1129 
 
1130 
    test_demangling_exact "arm: _Utf390_1__1_9223372036854775807__9223372036854775" \
1131 
            "Can't demangle \"_Utf390_1__1_9223372036854775807__9223372036854775\""
1132 
}
1133 
 
1134 
proc test_hp_style_demangling {} {
1135 
 
1136 
    # HP aCC mangling style is based on ARM for all the basic stuff,
1137 
    # so first we use some of the ARM tests here.  Later we have HP-specific
1138 
    # tests.
1139 
 
1140 
    test_demangling "hp: g__FP1cPC1cT1" \
1141 
        "g\[(\]+c *\[*\]+, (const c|c const) *\[*\]+, c *\[*\]+\[)\]+"
1142 
    test_demangling "hp: g__FPUlPCUlT1" \
1143 
        "g\[(\]+unsigned long \[*\]+, (const unsigned long|unsigned long const) \[*\]+, unsigned long \[*\]+\[)\]+"
1144 
    test_demangling "hp: g__FPUiPCUiT1" \
1145 
        "g\[(\]+unsigned int \[*\]+, (const unsigned int|unsigned int const) \[*\]+, unsigned int \[*\]+\[)\]+"
1146 
    test_demangling "hp: g__FPUsPCUsT1" \
1147 
        "g\[(\]+unsigned short \[*\]+, (const unsigned short|unsigned short const) \[*\]+, unsigned short \[*\]+\[)\]+"
1148 
    test_demangling "hp: g__FPUcPCUcT1" \
1149 
        "g\[(\]+unsigned char \[*\]+, (const unsigned char|unsigned char const) \[*\]+, unsigned char \[*\]+\[)\]+"
1150 
    test_demangling "hp: g__F1TPlPClT2" \
1151 
        "g\[(\]+T, long \[*\]+, (const long|long const) \[*\]+, long \[*\]+\[)\]+"
1152 
    test_demangling "hp: g__F1RRlRClT2" \
1153 
        "g\[(\]+R, long &, (const long|long const) &, long &\[)\]+"
1154 
    test_demangling "hp: g__F1TPiPCiT2" \
1155 
        "g\[(\]+T, int \[*\]+, (const int|int const) \[*\]+, int \[*\]+\[)\]+"
1156 
    test_demangling "hp: g__F1RRiRCiT2" \
1157 
        "g\[(\]+R, int &, (const int|int const) &, int &\[)\]+"
1158 
    test_demangling "hp: g__F1TPsPCsT2" \
1159 
        "g\[(\]+T, short \[*\]+, (const short|short const) \[*\]+, short \[*\]+\[)\]+"
1160 
    test_demangling "hp: g__F1RRsRCsT2" \
1161 
        "g\[(\]+R, short &, (const short|short const) &, short &\[)\]+"
1162 
    test_demangling "hp: g__F1TPcPCcT2" \
1163 
        "g\[(\]+T, char \[*\]+, (const char|char const) \[*\]+, char \[*\]+\[)\]+"
1164 
    test_demangling "hp: g__F1RRcRCcT2" \
1165 
        "g\[(\]+R, char &, (const char|char const) &, char &\[)\]+"
1166 
 
1167 
    test_demangling "hp: __gt__FRC2T2c" \
1168 
        "operator>\[(\]+(const T2|T2 const) &, char\[)\]+"
1169 
    test_demangling "hp: __ge__FRC2T2c" \
1170 
        "operator>=\[(\]+(const T2|T2 const) &, char\[)\]+"
1171 
    test_demangling "hp: __lt__FRC2T2c" \
1172 
        "operator<\[(\]+(const T2|T2 const) &, char\[)\]+"
1173 
 
1174 
    test_demangling "hp: __le__FRC2T2c" \
1175 
        "operator<=\[(\]+(const T2|T2 const) &, char\[)\]+"
1176 
    test_demangling "hp: __ne__FRC2T2c" \
1177 
        "operator!=\[(\]+(const T2|T2 const) &, char\[)\]+"
1178 
    test_demangling "hp: __eq__FRC2T2c" \
1179 
        "operator==\[(\]+(const T2|T2 const) &, char\[)\]+"
1180 
    test_demangling_exact "hp: __amd__FR2T2i" "operator%=(T2 &, int)"
1181 
    test_demangling_exact "hp: __adv__FR2T2i" "operator/=(T2 &, int)"
1182 
    test_demangling_exact "hp: __amu__FR2T2i" "operator*=(T2 &, int)"
1183 
    test_demangling_exact "hp: __ami__FR2T2i" "operator-=(T2 &, int)"
1184 
    test_demangling_exact "hp: __apl__FR2T2i" "operator+=(T2 &, int)"
1185 
    test_demangling_exact "hp: __nw__2T1SFUi" "T1::operator new(unsigned int) static"
1186 
    test_demangling_exact "hp: __dl__2T1SFPv" "T1::operator delete(void *) static"
1187 
    test_demangling_exact "hp: put__2T7SFi" "T7::put(int) static"
1188 
 
1189 
    test_demangling_exact "hp: h__FUc" "h(unsigned char)"
1190 
    test_demangling_exact "hp: f__Fic" "f(int, char)"
1191 
    test_demangling_exact "hp: h__FUi" "h(unsigned int)"
1192 
    test_demangling_exact "hp: h__Fci" "h(char, int)"
1193 
    test_demangling_exact "hp: h__FUl" "h(unsigned long)"
1194 
    test_demangling_exact "hp: h__Fcl" "h(char, long)"
1195 
    test_demangling_exact "hp: h__FUs" "h(unsigned short)"
1196 
    test_demangling_exact "hp: h__Fcs" "h(char, short)"
1197 
    test_demangling "hp: __amd__FR2T2RC2T2" \
1198 
        "operator%=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
1199 
    test_demangling "hp: __adv__FR2T2RC2T2" \
1200 
        "operator/=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
1201 
    test_demangling "hp: __amu__FR2T2RC2T2" \
1202 
        "operator\[*\]+=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
1203 
    test_demangling "hp: __ami__FR2T2RC2T2" \
1204 
        "operator-=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
1205 
    test_demangling "hp: __apl__FR2T2RC2T2" \
1206 
        "operator\[+\]+=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
1207 
 
1208 
    test_demangling "hp: g__F1SRPUlRPCUlT2" \
1209 
        "g\[(\]+S, unsigned long \[*\]+&, (const unsigned long|unsigned long const) \[*\]+&, unsigned long \[*\]+&\[)\]+"
1210 
    test_demangling "hp: g__F1SRPUiRPCUiT2" \
1211 
        "g\[(\]+S, unsigned int \[*\]+&, (const unsigned int|unsigned int const) \[*\]+&, unsigned int \[*\]+&\[)\]+"
1212 
    test_demangling "hp: g__F1SRPUsRPCUsT2" \
1213 
        "g\[(\]+S, unsigned short \[*\]+&, (const unsigned short|unsigned short const) \[*\]+&, unsigned short \[*\]+&\[)\]+"
1214 
    test_demangling "hp: g__F1SRPUcRPCUcT2" \
1215 
        "g\[(\]+S, unsigned char \[*\]+&, (const unsigned char|unsigned char const) \[*\]+&, unsigned char \[*\]+&\[)\]+"
1216 
    test_demangling "hp: g__F1T1SRPlRPClT3" \
1217 
        "g\[(\]+T, S, long \[*\]+&, (const long|long const) \[*\]+&, long \[*\]+&\[)\]+"
1218 
    test_demangling "hp: g__F1T1SRPiRPCiT3" \
1219 
        "g\[(\]+T, S, int \[*\]+&, (const int|int const) \[*\]+&, int \[*\]+&\[)\]+"
1220 
    test_demangling "hp: g__F1T1SRPcRPCcT3" \
1221 
        "g\[(\]+T, S, char \[*\]+&, (const char|char const) \[*\]+&, char \[*\]+&\[)\]+"
1222 
 
1223 
 
1224 
    test_demangling "hp: __gt__FRC2T2T1" \
1225 
        "operator>\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
1226 
    test_demangling "hp: __ge__FRC2T2T1" \
1227 
        "operator>=\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
1228 
    test_demangling "hp: __lt__FRC2T2T1" \
1229 
        "operator<\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
1230 
    test_demangling "hp: __le__FRC2T2T1" \
1231 
        "operator<=\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
1232 
    test_demangling "hp: __ne__FRC2T2T1" \
1233 
        "operator!=\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
1234 
    test_demangling "hp: __eq__FRC2T2T1" \
1235 
        "operator==\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
1236 
    test_demangling "hp: g__FcR1cRC1cT2" \
1237 
        "g\[(\]+char, c &, (const c|c const) &, c &\[)\]+"
1238 
    test_demangling "hp: g__FcRPdRPCdT2" \
1239 
        "g\[(\]+char, double *\[*\]+&, (const double|double const) *\[*\]+&, double *\[*\]+&\[)\]+"
1240 
    test_demangling "hp: g__FcRPfRPCfT2" \
1241 
        "g\[(\]+char, float *\[*\]+&, (const float|float const) *\[*\]+&, float *\[*\]+&\[)\]+"
1242 
    test_demangling_exact "hp: h__FcT1" "h(char, char)"
1243 
    test_demangling_exact "hp: f__Ficd" "f(int, char, double)"
1244 
    test_demangling "hp: g__F1T1SdRPsRPCsT4" \
1245 
        "g\[(\]+T, S, double, short \[*\]+&, (const short|short const) \[*\]+&, short \[*\]+&\[)\]+"
1246 
    test_demangling "hp: g__F1cC1cT1" \
1247 
        "g\[(\]+c, (const c|c const), c\[)\]+"
1248 
    test_demangling "hp: g__FPdPCdT1" \
1249 
        "g\[(\]+double *\[*\]+, (const double|double const) *\[*\]+, double *\[*\]+\[)\]+"
1250 
    test_demangling "hp: g__FPfPCfT1" \
1251 
        "g\[(\]+float *\[*\]+, (const float|float const) *\[*\]+, float *\[*\]+\[)\]+"
1252 
 
1253 
    test_demangling "hp: g__FUlCUlT1" \
1254 
        "g\[(\]+unsigned long, (const unsigned long|unsigned long const), unsigned long\[)\]+"
1255 
    test_demangling "hp: g__FPlPClT1" \
1256 
        "g\[(\]+long \[*\]+, (const long|long const) \[*\]+, long \[*\]+\[)\]+"
1257 
    test_demangling "hp: g__FUiCUiT1" \
1258 
        "g\[(\]+unsigned int, (const unsigned int|unsigned int const), unsigned int\[)\]+"
1259 
    test_demangling "hp: g__FPiPCiT1" \
1260 
        "g\[(\]+int \[*\]+, (const int|int const) \[*\]+, int \[*\]+\[)\]+"
1261 
    test_demangling "hp: g__FUsCUsT1" \
1262 
        "g\[(\]+unsigned short, (const unsigned short|unsigned short const), unsigned short\[)\]+"
1263 
    test_demangling "hp: g__FPsPCsT1" \
1264 
        "g\[(\]+short \[*\]+, (const short|short const) \[*\]+, short \[*\]+\[)\]+"
1265 
    test_demangling "hp: g__FUcCUcT1" \
1266 
        "g\[(\]+unsigned char, (const unsigned char|unsigned char const), unsigned char\[)\]+"
1267 
    test_demangling "hp: g__FPcPCcT1" \
1268 
        "g\[(\]+char \[*\]+, (const char|char const) \[*\]+, char \[*\]+\[)\]+"
1269 
    test_demangling "hp: g__F1TlClT2" \
1270 
        "g\[(\]+T, long, (const long|long const), long\[)\]+"
1271 
    test_demangling "hp: g__F1TiCiT2" \
1272 
        "g\[(\]+T, int, (const int|int const), int\[)\]+"
1273 
    test_demangling "hp: g__F1TsCsT2" \
1274 
        "g\[(\]+T, short, (const short|short const), short\[)\]+"
1275 
    test_demangling "hp: g__F1TcCcT2" \
1276 
        "g\[(\]+T, char, (const char|char const), char\[)\]+"
1277 
 
1278 
    test_demangling "hp: printf__FPCce" \
1279 
        "printf\[(\]+(const char|char const) \[*\]+,...\[)\]+"
1280 
 
1281 
 
1282 
    test_demangling "hp: g__F1SRUlRCUlT2" \
1283 
        "g\[(\]+S, unsigned long &, (const unsigned long|unsigned long const) &, unsigned long &\[)\]+"
1284 
    test_demangling "hp: g__F1SRPlRPClT2" \
1285 
        "g\[(\]+S, long \[*\]+&, (const long|long const) \[*\]+&, long \[*\]+&\[)\]+"
1286 
    test_demangling "hp: g__F1RRUiRCUiT2" \
1287 
        "g\[(\]+R, unsigned int &, (const unsigned int|unsigned int const) &, unsigned int &\[)\]+"
1288 
    test_demangling "hp: g__F1SRPiRPCiT2" \
1289 
        "g\[(\]+S, int \[*\]+&, (const int|int const) \[*\]+&, int \[*\]+&\[)\]+"
1290 
    test_demangling "hp: g__F1RRUsRCUsT2" \
1291 
        "g\[(\]+R, unsigned short &, (const unsigned short|unsigned short const) &, unsigned short &\[)\]+"
1292 
    test_demangling "hp: g__F1SRPsRPCsT2" \
1293 
        "g\[(\]+S, short \[*\]+&, (const short|short const) \[*\]+&, short \[*\]+&\[)\]+"
1294 
    test_demangling "hp: g__F1RRUcRCUcT2" \
1295 
        "g\[(\]+R, unsigned char &, (const unsigned char|unsigned char const) &, unsigned char &\[)\]+"
1296 
    test_demangling "hp: g__F1SRPcRPCcT2" \
1297 
        "g\[(\]+S, char \[*\]+&, (const char|char const) \[*\]+&, char \[*\]+&\[)\]+"
1298 
    test_demangling "hp: g__F1T1RRlRClT3" \
1299 
        "g\[(\]+T, R, long &, (const long|long const) &, long &\[)\]+"
1300 
    test_demangling "hp: g__F1T1RRiRCiT3" \
1301 
        "g\[(\]+T, R, int &, (const int|int const) &, int &\[)\]+"
1302 
    test_demangling "hp: g__F1T1RRsRCsT3" \
1303 
        "g\[(\]+T, R, short &, (const short|short const) &, short &\[)\]+"
1304 
    test_demangling "hp: g__F1T1RRcRCcT3" \
1305 
        "g\[(\]+T, R, char &, (const char|char const) &, char &\[)\]+"
1306 
 
1307 
 
1308 
    test_demangling_exact "hp: f__FicdPcPFci_v" "f(int, char, double, char *, void (*)(char, int))"
1309 
    test_demangling_exact "hp: f__FicdPcPFic_v" "f(int, char, double, char *, void (*)(int, char))"
1310 
    test_demangling_exact "hp: get__2T7SFv" "T7::get(void) static"
1311 
 
1312 
 
1313 
    test_demangling "hp: g__FcRdRCdT2" \
1314 
        "g\[(\]+char, double &, (const double|double const) &, double &\[)\]+"
1315 
    test_demangling "hp: g__FcRfRCfT2" \
1316 
        "g\[(\]+char, float &, (const float|float const) &, float &\[)\]+"
1317 
    test_demangling "hp: __md__FC2T2i" \
1318 
        "operator%\[(\]+(const T2|T2 const), int\[)\]+"
1319 
    test_demangling "hp: __dv__FC2T2i" \
1320 
        "operator/\[(\]+(const T2|T2 const), int\[)\]+"
1321 
    test_demangling "hp: __ml__FC2T2i" \
1322 
        "operator\[*\]+\[(\]+(const T2|T2 const), int\[)\]+"
1323 
    test_demangling "hp: __mi__FC2T2i" \
1324 
        "operator-\[(\]+(const T2|T2 const), int\[)\]+"
1325 
    test_demangling "hp: __pl__FC2T2i" \
1326 
        "operator\[+\]+\[(\]+(const T2|T2 const), int\[)\]+"
1327 
 
1328 
 
1329 
    test_demangling_exact "hp: h__Fc" "h(char)"
1330 
    test_demangling_exact "hp: h__Fd" "h(double)"
1331 
    test_demangling_exact "hp: h__Ff" "h(float)"
1332 
    test_demangling_exact "hp: h__Fi" "h(int)"
1333 
    test_demangling_exact "hp: f__Fi" "f(int)"
1334 
    test_demangling_exact "hp: h__Fl" "h(long)"
1335 
 
1336 
    test_demangling_exact "hp: h__Fs" "h(short)"
1337 
    test_demangling "hp: __md__FC2T2RC2T2" \
1338 
        "operator%\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
1339 
    test_demangling "hp: __dv__FC2T2RC2T2" \
1340 
        "operator/\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
1341 
    test_demangling "hp: __ml__FC2T2RC2T2" \
1342 
        "operator\[*\]+\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
1343 
    test_demangling "hp: __mi__FC2T2RC2T2" \
1344 
        "operator-\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
1345 
    test_demangling "hp: __pl__FC2T2RC2T2" \
1346 
        "operator\[+\]+\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
1347 
    test_demangling "hp: g__FcRP1cRPC1cT2" \
1348 
        "g\[(\]+char, c *\[*\]+&, (const c|c const) *\[*\]+&, c *\[*\]+&\[)\]+"
1349 
 
1350 
 
1351 
    test_demangling "hp: g__FdCdT1" \
1352 
        "g\[(\]+double, (const double|double const), double\[)\]+"
1353 
    test_demangling "hp: g__FfCfT1" \
1354 
        "g\[(\]+float, (const float|float const), float\[)\]+"
1355 
    test_demangling "hp: g__FlClT1" \
1356 
        "g\[(\]+long, (const long|long const), long\[)\]+"
1357 
    test_demangling "hp: g__FiCiT1" \
1358 
        "g\[(\]+int, (const int|int const), int\[)\]+"
1359 
    test_demangling "hp: g__FsCsT1" \
1360 
        "g\[(\]+short, (const short|short const), short\[)\]+"
1361 
    test_demangling "hp: g__FcCcT1" \
1362 
        "g\[(\]+char, (const char|char const), char\[)\]+"
1363 
 
1364 
 
1365 
    test_demangling_exact "hp: f__FicdPc" "f(int, char, double, char *)"
1366 
    test_demangling_exact "hp: __nw__FUi" "operator new(unsigned int)"
1367 
    test_demangling_exact "hp: __ct__Q3_2T11a1bSFi" "T1::a::b::b(int) static"
1368 
    test_demangling_exact "hp: __dt__Q3_2T11a1bSFi" "T1::a::b::~b(int) static"
1369 
    test_demangling_exact "hp: put__Q3_2T11a1bSFi" "T1::a::b::put(int) static"
1370 
    test_demangling_exact "hp: get__Q2_2T11aSFv" "T1::a::get(void) static"
1371 
    test_demangling_exact "hp: put__2T1SFi" "T1::put(int) static"
1372 
    test_demangling_exact "hp: put__Q5_2T11a1b1c1dSFi" "T1::a::b::c::d::put(int) static"
1373 
    test_demangling_exact "hp: get__Q4_2T11a1b1cSFv" "T1::a::b::c::get(void) static"
1374 
    test_demangling_exact "hp: put__Q2_2T11aSFi" "T1::a::put(int) static"
1375 
    test_demangling_exact "hp: put__Q4_2T11a1b1cSFi" "T1::a::b::c::put(int) static"
1376 
    test_demangling_exact "hp: get__Q3_2T11a1bSFv" "T1::a::b::get(void) static"
1377 
    test_demangling_exact "hp: get__2T1SFv" "T1::get(void) static"
1378 
    test_demangling_exact "hp: get__Q5_2T11a1b1c1dSFv" "T1::a::b::c::d::get(void) static"
1379 
 
1380 
 
1381 
    test_demangling_exact "hp: bar__3fooFPv"       "foo::bar(void *)"
1382 
    test_demangling "hp: bar__3fooFPCv" \
1383 
             "foo::bar\[(\]+(const void|void const) *\[*\]+\[)\]+"
1384 
    test_demangling_exact "hp: bar__3fooCFPv"      "foo::bar(void *) const"
1385 
    test_demangling "hp: bar__3fooCFPCv" \
1386 
            "foo::bar\[(\]+(const void|void const) *\[*\]+\[)\]+ const"
1387 
    test_demangling_exact "hp: __eq__3fooFR3foo"   "foo::operator==(foo &)"
1388 
    test_demangling "hp: __eq__3fooFRC3foo" \
1389 
         "foo::operator==\[(\]+(const foo|foo const) &\[)\]+"
1390 
    test_demangling_exact "hp: __eq__3fooCFR3foo"  "foo::operator==(foo &) const"
1391 
    test_demangling "hp: __eq__3fooCFRC3foo" \
1392 
        "foo::operator==\[(\]+(const foo|foo const) &\[)\]+ const"
1393 
 
1394 
    test_demangling_exact "hp: bar__3fooFiT16FooBar" "foo::bar(int, int, FooBar)"
1395 
 
1396 
    test_demangling_exact "hp: bar__3fooFPiN51PdN37PcN211T1iN215" \
1397 
      "foo::bar(int *, int *, int *, int *, int *, int *, double *, double *, double *, double *, char *, char *, char *, int *, int, int, int)"
1398 
 
1399 
 
1400 
    # HP aCC specific tests. HP aCC demangling does not use __pt__ for
1401 
    # template specifications.  There are other differences as well.
1402 
 
1403 
    test_demangling_exact "hp: __dt__2T5XTPFiPPdPv_i__Fv" "T5::~T5(void)"
1404 
 
1405 
    test_demangling_exact "hp: __ct__1cFi" "c::c(int)"
1406 
 
1407 
    test_demangling_exact "hp: __dt__2T5XTi__Fv" "T5::~T5(void)"
1408 
 
1409 
    test_demangling_exact "hp: __dt__2T5XTc__Fv" "T5::~T5(void)"
1410 
 
1411 
    test_demangling_exact "hp: __ct__2T2Fi" "T2::T2(int)"
1412 
    test_demangling_exact "hp: __dt__2T1Fv" "T1::~T1(void)"
1413 
 
1414 
    test_demangling_exact "hp: __dt__2T5XT1x__Fv" "T5::~T5(void)"
1415 
 
1416 
    test_demangling_exact "hp: __dt__2T5XTPFcPv_i__Fv" "T5::~T5(void)"
1417 
 
1418 
    test_demangling_exact "hp: __ct__2T5XTPFiPPdPv_i__Fi" "T5::T5(int)"
1419 
 
1420 
    test_demangling_exact "hp: __dl__2T5XT1x__SFPv" "T5::operator delete(void *) static"
1421 
 
1422 
    test_demangling_exact "hp: X__2T5XT1x" "T5::X"
1423 
 
1424 
    test_demangling_exact "hp: __ct__2T5XTi__Fi" "T5::T5(int)"
1425 
 
1426 
    test_demangling_exact "hp: __ct__2T5XTc__Fi" "T5::T5(int)"
1427 
 
1428 
    test_demangling_exact "hp: __dl__2T5XTPFcPv_i__SFPv" "T5::operator delete(void *) static"
1429 
 
1430 
    test_demangling_exact "hp: X__2T5XTPFcPv_i" "T5::X"
1431 
 
1432 
    test_demangling_exact "hp: __ct__2T5XT1x__Fi" "T5::T5(int)"
1433 
 
1434 
    test_demangling_exact "hp: __dl__2T5XTPFiPPdPv_i__SFPv" "T5::operator delete(void *) static"
1435 
    test_demangling_exact "hp: X__2T5XTPFiPPdPv_i" "T5::X"
1436 
 
1437 
    test_demangling_exact "hp: __dl__2T5XTi__SFPv" "T5::operator delete(void *) static"
1438 
 
1439 
    test_demangling_exact "hp: __dl__2T5XTc__SFPv" "T5::operator delete(void *) static"
1440 
 
1441 
    test_demangling_exact "hp: X__2T5XTc" "T5::X"
1442 
 
1443 
    test_demangling_exact "hp: X__2T5XTi" "T5::X"
1444 
 
1445 
    test_demangling_exact "hp: __ct__2T5XTPFcPv_i__Fi" "T5::T5(int)"
1446 
 
1447 
    test_demangling_exact "hp: __dt__2T1XTc__Fv" "T1::~T1(void)"
1448 
 
1449 
    test_demangling_exact "hp: __dt__2T1XT1t__Fv" "T1::~T1(void)"
1450 
 
1451 
    test_demangling_exact "hp: __dl__2T1XT1t__SFPv" "T1::operator delete(void *) static"
1452 
 
1453 
    test_demangling_exact "hp: __ct__2T1XTc__Fi" "T1::T1(int)"
1454 
 
1455 
    test_demangling_exact "hp: __ct__2T1XTc__Fv" "T1::T1(void)"
1456 
 
1457 
    test_demangling_exact "hp: __ct__2T1XT1t__Fi" "T1::T1(int)"
1458 
 
1459 
    test_demangling_exact "hp: __ct__2T1XT1t__Fv" "T1::T1(void)"
1460 
 
1461 
    test_demangling_exact "hp: __dl__2T1XTc__SFPv" "T1::operator delete(void *) static"
1462 
 
1463 
    test_demangling_exact "hp: elem__6vectorXTd__Fi" "vector::elem(int)"
1464 
 
1465 
    test_demangling_exact "hp: elem__6vectorXTi__Fi" "vector::elem(int)"
1466 
 
1467 
    test_demangling_exact "hp: __ct__6vectorXTd__Fi" "vector::vector(int)"
1468 
 
1469 
    test_demangling_exact "hp: __ct__6vectorXTi__Fi" "vector::vector(int)"
1470 
 
1471 
    test_demangling_exact "hp: __ct__9DListNodeXTR6RLabel__FR6RLabelP9DListNodeXTR6RLabel_T2" \
1472 
        "DListNode::DListNode(RLabel &, DListNode *, DListNode *)"
1473 
 
1474 
 
1475 
    # Absolute integer constants in template args
1476 
 
1477 
    test_demangling_exact "hp: elem__6vectorXTiUP34__Fi" "vector::elem(int)"
1478 
    test_demangling_exact "hp: elem__6vectorXUP2701Td__Fi" "vector<2701U,double>::elem(int)"
1479 
    test_demangling_exact "hp: elem__6vectorXTiSP334__Fi" "vector::elem(int)"
1480 
    test_demangling_exact "hp: elem__6vectorXTiSN67__Fi" "vector::elem(int)"
1481 
    test_demangling_exact "hp: elem__6vectorXTiSM__SCFPPd" "vector::elem(double **) static const"
1482 
    test_demangling_exact "hp: elem__6vectorXTiSN67UP4000TRs__Fi" "vector::elem(int)"
1483 
    test_demangling_exact "hp: elem__6vectorXTiSN67TRdTFPv_i__Fi" "vector::elem(int)"
1484 
    test_demangling_exact "hp: X__6vectorXTiSN67TdTPvUP5TRs" "vector::X"
1485 
 
1486 
    # Named constants in template args
1487 
 
1488 
    test_demangling_exact "hp: elem__6vectorXTiA3foo__Fi" "vector::elem(int)"
1489 
    test_demangling_exact "hp: elem__6vectorXTiA3fooTPvA5Label__FiPPvT2" "vector::elem(int, void **, void **)"
1490 
    test_demangling_exact "hp: elem__6vectorXTiSN42A3foo__Fi" "vector::elem(int)"
1491 
 
1492 
    # Alternate entry points for functions
1493 
 
1494 
    test_demangling_exact "hp: __ct__2T5XTPFcPv_i__Fi_2" "T5::T5(int)"
1495 
    test_demangling_exact "hp: __ct__2T5XTPFcPv_i__Fi_19" "T5::T5(int)"
1496 
    test_demangling_exact "hp: f__FicdPcPFci_v_34" "f(int, char, double, char *, void (*)(char, int))"
1497 
 
1498 
 
1499 
    # Template partial specializations
1500 
 
1501 
# FIXME!  The # characters don't go through expect, and backslashes don't seem to work.
1502 
#    test_demangling_exact "hp: spec__13Spec<#1,#1.*>XTiTPi_FPi" "Spec::spec(int *)"
1503 
#    test_demangling_exact "hp: spec__16Spec<#1,#1.&,#1>XTiTRiTi_FPi" "Spec::spec(int *)"
1504 
# Fake test -- replace # with %
1505 
    test_demangling_exact "hp: spec__13Spec<%1,%1.*>XTiTPi_FPi" "Spec::spec(int *)"
1506 
    test_demangling_exact "hp: spec__16Spec<%1,%1.&,%1>XTiTRiTi_FPi" "Spec::spec(int *)"
1507 
 
1508 
    # Global template functions
1509 
 
1510 
    test_demangling_exact "hp: add__XTc_FcT1" "add(char, char)"
1511 
    test_demangling_exact "hp: add__XTcSP9A5label_FcPPlT1" "add(char, long **, char)"
1512 
    test_demangling_exact "hp: add__XTPfTFPd_f_FcT1" "add(char, char)"
1513 
 
1514 
    # Template for template arg
1515 
 
1516 
    test_demangling_exact "hp: unLink__12basic_stringXTcT18string_char_traitsXTc_T9allocator_Fv" "basic_string,allocator>::unLink(void)"
1517 
 
1518 
    test_demangling_exact "hp: _Utf390_1__1_9223372036854775807__9223372036854775" \
1519 
            "Can't demangle \"_Utf390_1__1_9223372036854775807__9223372036854775\""
1520 
}
1521 
 
1522 
 
1523 
proc catch_demangling_errors {command} {
1524 
    if {[catch $command result]} {
1525 
        puts "ERROR: demangle.exp: while running $command: $result"
1526 
    }
1527 
}
1528 
 
1529 
# Test support for different demangling styles.  Note that this does
1530 
# not depend upon running the test program and does not depend upon
1531 
# gdb being able to lookup any C++ symbols.  It simply calls the
1532 
# internal demangler with synthesized strings and tests the results.
1533 
 
1534 
proc do_tests {} {
1535 
    global prms_id
1536 
    global bug_id
1537 
    global subdir
1538 
    global gdb_prompt
1539 
 
1540 
    set prms_id 0
1541 
    set bug_id 0
1542 
 
1543 
    # Start with a fresh gdb.
1544 
 
1545 
    gdb_exit
1546 
    gdb_start
1547 
 
1548 
    send_gdb "set language c++\n"
1549 
    gdb_expect -re "$gdb_prompt $"
1550 
    send_gdb "set width 0\n"
1551 
    gdb_expect -re "$gdb_prompt $"
1552 
 
1553 
    # Using catch_demangling_errors this way ensures that, if one of
1554 
    # the functions raises a Tcl error, then it'll get reported, and
1555 
    # the rest of the functions will still run.
1556 
    catch_demangling_errors test_lucid_style_demangling
1557 
    catch_demangling_errors test_gnu_style_demangling
1558 
    catch_demangling_errors test_arm_style_demangling
1559 
    catch_demangling_errors test_hp_style_demangling
1560 
}
1561 
 
1562 
do_tests

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.