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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [testsuite/] [gdb.cp/] [demangle.exp] - Blame information for rev 258

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

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

powered by: WebSVN 2.1.0

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