]> git.saurik.com Git - apple/xnu.git/blob - libsa/c++rem3.c
xnu-792.6.61.tar.gz
[apple/xnu.git] / libsa / c++rem3.c
1 // 45678901234567890123456789012345678901234567890123456789012345678901234567890
2 /*
3
4 Rules specification by
5 Stan Shebs of Apple Computer, Inc 2002
6
7 Parse and remangle implemented by
8 Godfrey van der Linden of Apple Computer, Inc 2002
9
10 Rules for demangling IOKit symbols
11
12 In Darwin versions 1.0 through at least 5.2, IOKit is compiled using
13 GCC version 2. GCC 2's C++ symbol mangling algorithm ultimately
14 derives from the basic scheme described in the Annotated C++ Reference
15 Manual (ARM), section 7.2.1c, with a number of changes, mostly due to
16 the expansion of the language since the ARM was published in 1990.
17
18 This description is not complete. It omits RTTI, thunks, and
19 templates, since they are not allowed in IOKit. The description also
20 mentions mangled name constructs that are not disallowed in IOKit, but
21 that as of Jan 2002, did actually appear in any symbol in the base
22 system.
23
24 A mangled name basically consists of a function name followed
25 by two underscores, optionally followed by a signature computed
26 from the function's argument types. (Note that in Darwin, the
27 compiler adds an additional underscore to all C and C++ symbols.
28 The description assumes this has been removed.)
29
30 <special_or_name> ::= <gnu_special>
31 | <mangled_name>
32
33 <mangled_name> ::= <prefix> [ <signature> ]
34
35 <prefix> ::= [ "_GLOBAL_" [ID] "__" ] <function_name> "__" [ <opinfo> ]
36
37 <function_name> ::= <char> <char>*
38 | NULL
39
40 Questions for Stan (@@@Stan@@@)
41 1> A valid <opinfo> implies a null function name.
42 2> I wonder if an <opinfo> is mutually exclusive with a <function_name> perhaps something like :-
43 <prefix> ::= [ "_GLOBAL_" ("I"|"D") "__" ] ((<function_name> "__") | <opinfo>)
44 3> Do constructors turn up as an opinfo or a NULL function name?
45
46 The optional "_GLOBAL_"("I"|"D")"__" sequence indicates global constructors
47 and destructors, but in practice these do not appear with the mach-o Apple 2.95
48
49 A Null <function_name> indicates a constructor or an operator.
50
51 Since <function_name> may include trailing underscores, the demangler
52 should scan forward until a non-underscore is seen, and then take the
53 last two as the separator between name and signature.
54
55 <function_name> may also include any number of leading underscores, so
56 the demangler needs to add those to <function_name> and look for the
57 "__" following the name.
58
59 <gnu_special> ::= ("_._"|"_$_" ) <class_name> ; destructor
60 | "__vt_" <class_name> ; virtual table
61 | "_" <class_name> ("."|"$") <varname> ; Variable
62
63 <class_name> ::= <counted_class_name>
64 | "Q" <qualified_name>
65 | "K" <qualified_name> ; ignored and illegal
66
67 <counted_class_name> ::= <count> <name>
68
69 <qualified_name> ::= <q_count> <counted_class_name> <counted_class_name>*
70
71 <opinfo> ::= "type" <type>
72 | "__op" <type>
73 | <opname> "__"
74 | "a"
75
76 <opname> ::= "aa" # &&
77 | "aad" # &=
78 | "ad" # &
79 | "adv" # /=
80 | "aer" # ^=
81 | "als" # <<=
82 | "amd" # %=
83 | "ami" # -=
84 | "aml" # *=
85 | "aor" # |=
86 | "apl" # +=
87 | "ars" # >>=
88 | "as" # =
89 | "cl" # ()
90 | "cm" # ,
91 | "cn" # ?:
92 | "co" # ~
93 | "dl" # delete
94 | "dv" # /
95 | "eq" # ==
96 | "er" # ^
97 | "ge" # >=
98 | "gt" # >
99 | "le" # <=
100 | "ls" # <<
101 | "lt" # <
102 | "md" # %
103 | "mi" # -
104 | "ml" # *
105 | "mm" # --
106 | "mn" # <?
107 | "mx" # >?
108 | "ne" # !=
109 | "nt" # !
110 | "nw" # new
111 | "oo" # ||
112 | "or" # |
113 | "pl" # +
114 | "pp" # ++
115 | "rf" # ->
116 | "rm" # ->*
117 | "rs" # >>
118 | "sz" # sizeof
119 | "vc" # []
120 | "vd" # delete[]
121 | "vn" # new[]
122
123 Questions for Stan (@@@Stan@@@)
124 1> What the hell is The "type" & "__op" stuff?
125
126 IOKit has so far only been observed to use operations new ("nw") and
127 delete ("dl").
128
129 The signature is a concatenated list of elements, which are usually
130 argument types, but may include other sorts of things.
131
132 <signature> ::= <qualifier>* <s_element> <argument_types>
133
134 <s_element> ::= <class_name>
135 | "S"
136 | "F" <argument_types> [ "_" <return_type> ]
137
138 Questions for Stan (@@@Stan@@@)
139 1> I think the 'B' phrase should probably read '| "B" <index>'?
140 2> Ambiguous productions for signature
141 OSObject::func(struct timeval fred) => _func__8OSObject7timeval
142 signature could be parsed as
143 <s_element> <s_element> or <s_element> <argument_types>
144 I believe the second one must be the valid production.
145
146 <count> ::= <digit> <digit>*
147
148 <varname> :: <name>
149
150 <name> ::= <char> <char>*
151
152 The <count> is the number of characters in <name>.
153
154 Argument types are a concatenated sequence of types.
155
156 <argument_types> ::= # Empty
157 | <arg_type>+
158 <arg_type> ::= <type> [ "n" <index> ]
159 | "N" <count> <pos>
160 | "T" <index>
161
162 The "N" repeats and "T" references to already-seen typescan only
163 appear if -fno-squangle (no squashed mangling), and in practice aren't
164 seen in IOKit symbols.
165
166 <index> ::= <digit> | <digit> <digit> <digit>* "_"
167
168 Return types are just like any other sort of type.
169
170 <return_type> ::= <type>
171
172 Types consist of a variable number of declarators in front of a basic
173 type.
174
175 <type> ::= <declarator>* <base_type>
176
177 <declarator> ::= "P" ; pointer
178 | "p" ; pointer (but never occurs?)
179 | "R" ; reference (&)
180 | "A" <count> ; array
181 | "T" <index>
182 | "O" <count>
183 | <qualifier>
184
185 The "A" <count> production can produce an ambigous output if it is followed by a counted class name or structure name.
186
187 The "T" reference to a type does not appear in IOKit symbols, nor do
188 the "M" and "O" declarators.
189
190 <base_type> ::= <function_type> ; function
191 | <method_type> ; method
192 | <type_qualifier>* <fund_type_id>
193
194 <function_type> ::= "F" <argument_types> "_" <type>
195
196 <method_type> ::= "M" <class_name> <function_type>
197
198 A qualified name consists of a count of types, followed by all the
199 types concatenated together. For instance, Namespace::Class is
200 Q29Namespace5Class. For more than 9 types (which has not yet occurred
201 in IOKit), the multi-digit count is surrounded by underscores.
202
203 Questions for Stan (@@@Stan@@@)
204 1> Can the types in a qualified name really be generic types or can the set be restricted to just counted class names?
205
206 <q_count> ::= <digit> | "_" <digit> <digit>* "_"
207
208 Fundamental types are single letters representing standard built-in
209 types, optionally preceded by type qualifiers for properties like
210 signedness and constness. For instance, CUi is a const unsigned int.
211
212 <type_qualifier> ::= "S" ; signed (chars only)
213 | "U" ; unsigned (any integral type)
214 | "J" ; __complex
215 | <qualifier>
216
217 <fund_type_id> ::= <class_name>
218 | "b" ; bool
219 | "c" ; char
220 | "d" ; double
221 | "f" ; float
222 | "i" ; int
223 | "l" ; long
224 | "r" ; long double
225 | "s" ; short
226 | "v" ; void
227 | "w" ; wchar_t
228 | "x" ; long long
229 | "G" <count> ; ?????
230 | "e" ; ellipsis
231
232 "G" does not appear in IOKit symbols in this context.
233
234 <qualifier> ::= "C" ; const
235 | "V" ; volatile
236 | "u" ; restrict (C99)
237 | "G" ; struct/union/enum unused by gcc3
238
239 The restrict qualifier has not appeared in IOKit symbols.
240
241 */
242 #if KERNEL
243
244 #include <stdarg.h>
245 #include <string.h>
246
247 #include <sys/systm.h>
248
249 #include <libkern/OSTypes.h>
250
251 #include <libsa/stdlib.h>
252
253 enum { false = 0, true = 1 };
254
255 #else /* !KERNEL */
256
257 #include <unistd.h>
258
259 #include <stdio.h>
260 #include <stdlib.h>
261 #include <string.h>
262
263 #include <CoreFoundation/CoreFoundation.h>
264
265 #endif /* KERNEL */
266
267 #include "c++rem3.h"
268
269 #define STRLEN(s) (sizeof(s)-1)
270 #define APPENDSTR(c, str) do { appendNStr(c, str, STRLEN(str)); } while (0)
271
272 #define MAX_COMPOUND_TYPES 128
273 #define MAX_ENTRIES 256
274 #define MAX_SDICT_ENTRIES 256
275 #define MAX_BDICT_ENTRIES 64
276 #define MAX_RETURN_BUFFER 256
277
278 // Can't be bigger that 16 entries
279 typedef enum NameTypes {
280 kNTUndefined, kNTClass, kNTFunction, kNTFuncEnd,
281 kNTMethod, kNTBuiltIn, kNTDeclarator, kNTArray,
282 kNTKName, kNTSubstitute, kNTSubQualClass
283 } NameTypes;
284
285 typedef struct TypeData {
286 short fStartEntry, fNumEntries;
287 } TypeData;
288
289 typedef struct BaseTypeData {
290 const char *fFundTypeID; // May contain the type itself for kNTBuiltIt
291 unsigned int fLen:16;
292 unsigned int fType:4; // Must fit a NameType
293 unsigned int fVolatile:1;
294 unsigned int fConst:1;
295 unsigned int fSigned:1;
296 unsigned int fUnsigned:1;
297 unsigned int fPseudo:1;
298 unsigned int fQualified:1;
299 } BaseTypeData;
300
301 typedef struct CheckPoint {
302 const char *fInChar;
303 unsigned char fNumI, fNumO, fNumT, fNumB, fNumS;
304 } CheckPoint;
305
306 typedef struct ParseContext {
307 CheckPoint fP;
308 BaseTypeData fInEntries[MAX_ENTRIES]; // Input parsed elements
309 BaseTypeData fOutEntries[MAX_ENTRIES]; // Output parsed elements
310 TypeData fTypeList[MAX_COMPOUND_TYPES]; // Table of types
311 TypeData fSubDict[MAX_SDICT_ENTRIES];
312 TypeData fBDict[MAX_BDICT_ENTRIES]; // B dictionary types
313 BaseTypeData *fCurBaseP;
314 const char *fInStr;
315 char *fOutStrEnd;
316 char *fOutChar;
317 int fInSize;
318 Rem3Return fRetCode;
319 } ParseContext;
320
321 //
322 // The only forward declaration necessary
323 //
324 static Boolean parse_type(ParseContext *c);
325
326 // Helper functions for walking through the string
327 static __inline__ char getNext(ParseContext *c)
328 {
329 return *c->fP.fInChar++;
330 }
331
332 static __inline__ CheckPoint *checkPoint(ParseContext *c)
333 {
334 return &c->fP;
335 }
336
337 static __inline__ void resetTo(ParseContext *c, CheckPoint *chk)
338 {
339 c->fP = *chk;
340 }
341
342 static __inline__ const char *inCharFromCheck(ParseContext *c, CheckPoint *chk)
343 {
344 return chk->fInChar;
345 }
346
347 static __inline__ void advance(ParseContext *c, int len)
348 {
349 c->fP.fInChar += len;
350 }
351
352 static __inline__ Boolean retard(ParseContext *c, int len)
353 {
354 const char *cp = c->fP.fInChar - len;
355 if (cp < c->fInStr)
356 return false;
357
358 c->fP.fInChar = cp;
359 return true;
360 }
361
362 static __inline__ char peekAt(ParseContext *c, int index)
363 {
364 return c->fP.fInChar[index];
365 }
366
367 static __inline__ char peekNext(ParseContext *c)
368 {
369 return peekAt(c, 0);
370 }
371
372 static __inline__ Boolean atEnd(ParseContext *c)
373 {
374 return '\0' == peekNext(c);
375 }
376
377 static __inline__ Boolean hasRemain(ParseContext *c, int len)
378 {
379 return (c->fP.fInChar - c->fInStr + len <= c->fInSize);
380 }
381
382 //
383 // Routines for allocating entries in the various
384 //
385 static __inline__ BaseTypeData *newIn(ParseContext *c)
386 {
387 BaseTypeData *iP;
388
389 if (c->fP.fNumI < MAX_ENTRIES) {
390 iP = &c->fInEntries[c->fP.fNumI++];
391 bzero(iP, sizeof(*iP));
392 c->fCurBaseP = iP;
393 return iP;
394 }
395 else {
396 c->fRetCode = kR3InternalNotRemangled;
397 return NULL;
398 }
399 }
400
401 static __inline__ BaseTypeData *newOut(ParseContext *c)
402 {
403 BaseTypeData *oP;
404
405 if (c->fP.fNumO < MAX_ENTRIES) {
406 oP = &c->fOutEntries[c->fP.fNumO++];
407 return oP;
408 }
409 else {
410 c->fRetCode = kR3InternalNotRemangled;
411 return NULL;
412 }
413 }
414
415 static __inline__ TypeData *
416 newSub(ParseContext *c, int start, int num)
417 {
418 TypeData *sP;
419
420 if (c->fP.fNumS < MAX_SDICT_ENTRIES) {
421 sP = &c->fSubDict[c->fP.fNumS++];
422 sP->fStartEntry = start;
423 sP->fNumEntries = num;
424 return sP;
425 }
426 else {
427 c->fRetCode = kR3InternalNotRemangled;
428 return NULL;
429 }
430 }
431
432 static __inline__ TypeData *
433 newBDict(ParseContext *c, int start, int num)
434 {
435 TypeData *bP;
436
437 if (c->fP.fNumB < MAX_BDICT_ENTRIES) {
438 bP = &c->fBDict[c->fP.fNumB++];
439 bP->fStartEntry = start;
440 bP->fNumEntries = num;
441 return bP;
442 }
443 else {
444 c->fRetCode = kR3InternalNotRemangled;
445 return NULL;
446 }
447 }
448
449 static __inline__ TypeData *
450 newType(ParseContext *c, int start)
451 {
452 TypeData *tP;
453
454 if (c->fP.fNumT < MAX_COMPOUND_TYPES) {
455 tP = &c->fTypeList[c->fP.fNumT++];
456 tP->fStartEntry = start;
457 return tP;
458 }
459 else
460 return NULL;
461 }
462
463 static __inline__ TypeData *
464 dupType(ParseContext *c, TypeData *iTP, int offset)
465 {
466 TypeData *tP = newType(c, iTP->fStartEntry + offset);
467 if (tP)
468 tP->fNumEntries = iTP->fNumEntries;
469
470 return tP;
471 }
472
473 //
474 // Identifier character recognition helpers, can be optimised
475 //
476 static __inline__ Boolean isValidFirstAlphabetic(char c)
477 {
478 if ('a' <= c && c <= 'z')
479 return true;
480 else if ('A' <= c && c <= 'Z')
481 return true;
482 else
483 return false;
484 }
485
486 static __inline__ Boolean isValidFirstChar(char c)
487 {
488 if (isValidFirstAlphabetic(c))
489 return true;
490 else if (c == '_')
491 return true;
492 else
493 return false;
494 }
495
496 static __inline__ Boolean isValidChar(char c)
497 {
498 if (isValidFirstChar(c))
499 return true;
500 else if ('0' <= c && c <= '9')
501 return true;
502 else
503 return false;
504 }
505
506 //
507 // Helper function for recognising characters and strings
508 //
509
510 // Check the current input is the given character
511 static __inline__ Boolean isNext(ParseContext *c, char ch)
512 {
513 if (peekNext(c) == ch) {
514 advance(c, 1);
515 return true;
516 }
517 else
518 return false;
519 }
520
521 // Check the current input is ONE of the characters in str
522 static Boolean charNext(ParseContext *c, char *str)
523 {
524 if (hasRemain(c, 1)) {
525 char ch = peekNext(c);
526 char next;
527
528 while ( (next = *str++) )
529 if (next == ch) {
530 advance(c, 1);
531 return true;
532 }
533 }
534
535 return false;
536 }
537
538 // Check the current input for 'str'
539 static Boolean strNext(ParseContext *c, const char *str)
540 {
541 const char *cp = c->fP.fInChar;
542
543 do {
544 if (!*str) {
545 c->fP.fInChar = (char *) cp;
546 return true;
547 }
548 else if (!*cp)
549 return false;
550
551 } while (*cp++ == *str++);
552
553 return false;
554 }
555
556 //
557 // Qualifier re-encoding
558 //
559 static void
560 decodeQual(BaseTypeData *typeP, int *qualLenP, const char **qualP)
561 {
562 const char *qual;
563 int qualLen;
564
565 if (typeP->fConst && typeP->fVolatile)
566 { qual = "VK"; qualLen = 2; }
567 else if (typeP->fConst)
568 { qual = "K"; qualLen = 1; }
569 else if (typeP->fVolatile)
570 { qual = "V"; qualLen = 1; }
571 else
572 { qual = NULL; qualLen = 0; }
573
574 *qualLenP = qualLen;
575 *qualP = qual;
576 }
577
578
579 //
580 // Output functions
581 //
582
583 static void appendChar(ParseContext *c, char ch)
584 {
585 char *outAddr = c->fOutChar++;
586 if (outAddr < c->fOutStrEnd)
587 *outAddr = ch;
588 }
589
590 static void appendNStr(ParseContext *c, const char *str, int len)
591 {
592 char *outAddr = c->fOutChar;
593
594 c->fOutChar += len;
595 if (c->fOutChar < c->fOutStrEnd)
596 bcopy(str, outAddr, len);
597 }
598
599 static __inline__ void appendStr(ParseContext *c, const char *str)
600 {
601 appendNStr(c, str, strlen(str));
602 }
603
604 static void appendSub(ParseContext *c, int ls)
605 {
606 appendChar(c, 'S');
607 if (ls) {
608 if (--ls >= 36) {
609 int ms;
610
611 ms = ls / 36;
612 appendChar(c, (ms < 10)? '0' + ms : 'A' + ms - 10);
613 ls -= (ms * 36);
614 }
615 appendChar(c, (ls < 10)? '0' + ls : 'A' + ls - 10);
616 }
617 appendChar(c, '_');
618 }
619
620 static Boolean compareTypes(ParseContext *c, int sub, int entry, int numEntries)
621 {
622 TypeData *subP = &c->fSubDict[sub];
623 BaseTypeData *bSP, *bIP;
624 int i;
625
626 if (subP->fNumEntries != numEntries)
627 return false;
628
629 bSP = &c->fInEntries[subP->fStartEntry];
630 bIP = &c->fInEntries[entry];
631
632 for (i = 0; i < numEntries; i++, bSP++, bIP++) {
633 if (bSP->fType != bIP->fType)
634 return false;
635
636 switch (bSP->fType) {
637 case kNTClass:
638 if (bSP->fLen != bIP->fLen)
639 return false;
640 else if (strncmp(bSP->fFundTypeID, bIP->fFundTypeID, bSP->fLen))
641 return false;
642 break;
643
644 case kNTArray:
645 case kNTBuiltIn:
646 case kNTDeclarator:
647 if (bSP->fFundTypeID != bIP->fFundTypeID)
648 return false;
649 break;
650
651 case kNTMethod:
652 case kNTFunction:
653 case kNTUndefined:
654 case kNTKName:
655 break; // OK so far
656
657 default:
658 return false; // Fatal errors
659 }
660 }
661
662 return true;
663 }
664
665 static int searchDict(ParseContext *c, int entry, int numE)
666 {
667 int sub, numSubs = c->fP.fNumS;
668
669 // don't try to substitute the last builtin
670 if (numE == 1 && kNTBuiltIn == c->fInEntries[entry].fType)
671 return -1;
672
673 for (sub = 0; sub < numSubs; sub++)
674 if (compareTypes(c, sub, entry, numE))
675 return sub;
676
677 return -1;
678 }
679
680 static int searchDictClass(ParseContext *c, const char *qname, int len)
681 {
682 TypeData *subP;
683 int sub, numSubs = c->fP.fNumS;
684
685 for (sub = 0, subP = c->fSubDict; sub < numSubs; sub++, subP++) {
686 BaseTypeData *iP = &c->fInEntries[subP->fStartEntry];
687
688 if (kNTClass != iP->fType || iP->fLen != len)
689 continue;
690 if (!strncmp(iP->fFundTypeID, qname, len))
691 return sub;
692 }
693
694 return -1;
695 }
696
697 static Boolean
698 appendQualifiedClass(ParseContext *c, int entry)
699 {
700 BaseTypeData *iP, *oP, *sP, *endSP;
701 const char *cp, *typeID;
702 int sub, subEntry, prefixLen;
703 int q_count;
704
705 int decodeStart = c->fP.fNumI;
706
707 // Scan through the incom
708 iP = &c->fInEntries[entry];
709 endSP = &c->fInEntries[MAX_ENTRIES];
710 sP = &c->fInEntries[decodeStart];
711
712 prefixLen = iP->fLen;
713 typeID = cp = iP->fFundTypeID;
714 for (q_count = 0; sP < endSP && (cp-typeID) < prefixLen; q_count++, sP++) {
715 int count;
716
717 count = strtoul(cp, (char **) &cp, 10);
718 cp += count;
719
720 sP->fType = kNTClass;
721 sP->fFundTypeID = typeID;
722 sP->fLen = cp - typeID;
723 }
724 if (sP >= endSP)
725 return false;
726
727 // Search backwards until I find the first substitution
728 sub = -1;
729 for (subEntry = q_count, sP--; subEntry > 0; subEntry--, sP--) {
730 sub = searchDictClass(c, sP->fFundTypeID, sP->fLen);
731 if (-1 != sub)
732 break;
733 }
734
735 // Now drop the symbol into the output buffer
736 oP = newOut(c);
737 if (!oP)
738 return false;
739
740 if (sub < 0)
741 *oP = *iP; // No sub copy original
742 else {
743 // Substitution found
744 prefixLen = sP->fLen; // Length of substitution
745
746 oP->fType = kNTSubstitute; // Assume complete substitution
747 oP->fLen = sub;
748 oP->fFundTypeID = 0;
749
750 // We have a partial substitution so tag on the unmatched bit
751 if (prefixLen != iP->fLen) {
752 oP->fType = kNTSubQualClass; // Re-characterise as 2 part sub
753
754 oP = newOut(c);
755 if (!oP)
756 return false;
757
758 *oP = *iP; // Duplicate the original
759 oP->fType = kNTSubQualClass;
760 oP->fFundTypeID += prefixLen; // Skip leading substituted text
761 oP->fLen -= prefixLen;
762 }
763 }
764
765 // Finally insert the qualified class names into the dictionary
766 for (subEntry++, sP++; subEntry < q_count; subEntry++, decodeStart++) {
767 c->fInEntries[decodeStart] = *sP++;
768 if (!newSub(c, decodeStart, 1))
769 return false;
770 }
771 c->fP.fNumI = decodeStart;
772
773 if (!newSub(c, entry, 1))
774 return false;
775
776 return true;
777 }
778
779 static int
780 appendType(ParseContext *c, int type)
781 {
782 BaseTypeData *iP, *oP;
783 TypeData *tP;
784 int i, sub;
785 int entry, numE, lastEntry;
786 Boolean found;
787
788 if (type >= c->fP.fNumT)
789 return -1;
790
791 tP = &c->fTypeList[type++];
792 entry = tP->fStartEntry;
793 numE = tP->fNumEntries;
794 lastEntry = entry + numE;
795 iP = 0;
796 for (i = 0, found = false, sub = -1; i < numE; i++) {
797 iP = &c->fInEntries[entry + i];
798 switch (iP->fType) {
799
800 // Function & Builtin can't be compressed alone
801 case kNTFunction:
802 case kNTBuiltIn:
803 i++; // Copy the current entry
804 found = true;
805 break;
806
807 case kNTClass:
808 case kNTMethod:
809 sub = searchDict(c, entry + i, numE - i);
810 if (sub < 0 && !iP->fQualified)
811 i++;
812 found = true;
813 break;
814
815 case kNTDeclarator:
816 case kNTArray:
817 sub = searchDict(c, entry + i, numE - i);
818 found = (sub >= 0);
819 break;
820
821 // Internal error's should never occur
822 case kNTKName:
823 case kNTSubstitute:
824 case kNTSubQualClass:
825 case kNTUndefined:
826 default:
827 return -1;
828 }
829 if (found)
830 break;
831 }
832
833 if (!found)
834 return -1; // Internal error: no terminal symbol?
835
836 // Copy the already input buffer to the output
837 oP = &c->fOutEntries[c->fP.fNumO];
838 if (i) {
839 if (c->fP.fNumO + i >= MAX_ENTRIES)
840 return -1;
841
842 bcopy(&c->fInEntries[entry], oP, i * sizeof(*oP));
843 c->fP.fNumO += i;
844 oP += i;
845 }
846
847 if (sub >= 0) {
848 // We found a substitution
849 oP->fType = kNTSubstitute;
850 oP->fLen = sub;
851 c->fP.fNumO++; // Increment output for the substitution
852
853 // Walk over types that have been substituted
854 while (type < c->fP.fNumT
855 && c->fTypeList[type].fStartEntry < lastEntry)
856 type++;
857 }
858 else switch (iP->fType)
859 {
860 case kNTMethod:
861 type = appendType(c, type); // Class Name
862 if (type < 0)
863 return type;
864 type = appendType(c, type); // Pointer to function
865 if (type < 0)
866 return type;
867 break;
868
869 case kNTFunction:
870 type = appendType(c, type); // Return type
871 if (type < 0)
872 return type;
873
874 // process the argument list
875 do {
876 tP = &c->fTypeList[type];
877 if (tP->fStartEntry < lastEntry) {
878 type = appendType(c, type);
879 if (type < 0)
880 return type;
881 }
882 else
883 break;
884 } while (type < c->fP.fNumT);
885 oP = newOut(c);
886 if (!oP)
887 return -1;
888 oP->fType = kNTFuncEnd;
889 break;
890
891 case kNTBuiltIn:
892 i--; // Do not store the buildit in the dictionary
893 break;
894
895 case kNTClass: // Nothing more to do
896 if (!iP->fQualified)
897 break;
898 else if (appendQualifiedClass(c, entry + i))
899 break;
900 else
901 return -1;
902 }
903
904 // No further substititions to be had update the dictionary
905 for (i += entry; --i >= entry; ) {
906 if (!newSub(c, i, lastEntry - i))
907 return -1;
908 }
909
910 return type;
911 }
912
913 static Boolean appendArgumentList(ParseContext *c)
914 {
915 int i, num;
916
917 c->fRetCode = kR3InternalNotRemangled;
918 // Setup the output entry array
919 num = c->fP.fNumT;
920 for (i = 0; i < num; ) {
921 i = appendType(c, i);
922 if (i < 0)
923 return false;
924 }
925
926 // First pass output uncompressed types
927 for (i = 0, num = c->fP.fNumO; i < num; i++) {
928 BaseTypeData *bP;
929
930 bP = &c->fOutEntries[i];
931
932 if (bP->fPseudo)
933 continue; // Pseudo entry do not output;
934
935 switch (bP->fType) {
936
937 case kNTSubstitute: appendSub(c, bP->fLen); break;
938
939 case kNTSubQualClass:
940 appendChar(c, 'N');
941 appendSub(c, bP->fLen);
942 i++; bP = &c->fOutEntries[i];
943 appendNStr(c, bP->fFundTypeID, bP->fLen);
944 appendChar(c, 'E');
945 break;
946
947 case kNTClass:
948 if (bP->fQualified) {
949 appendChar(c, 'N');
950 appendNStr(c, bP->fFundTypeID, bP->fLen);
951 appendChar(c, 'E');
952 }
953 else
954 appendNStr(c, bP->fFundTypeID, bP->fLen);
955 break;
956
957 case kNTArray: {
958 char numbuf[16]; // Bigger than MAX_LONG + 3
959 int len;
960 len = snprintf(numbuf, sizeof(numbuf),
961 "A%lu_", (unsigned long) bP->fFundTypeID);
962 appendNStr(c, numbuf, len);
963 break;
964 }
965
966 case kNTBuiltIn:
967 case kNTDeclarator: appendChar(c, (int) bP->fFundTypeID); break;
968 case kNTMethod: appendChar(c, 'M'); break;
969 case kNTFunction: appendChar(c, 'F'); break;
970 case kNTFuncEnd: appendChar(c, 'E'); break;
971
972 case kNTUndefined:
973 case kNTKName:
974 default:
975 return false; // Fatal errors
976 }
977 }
978
979 // Successful remangle
980 c->fRetCode = kR3Remangled;
981 return true;
982 }
983
984 //
985 // Parse routines
986 //
987
988 // <count> ::= <digit> <digit>*
989 static Boolean parse_count(ParseContext *c, int *countP)
990 {
991 int count = 0;
992 char ch;
993
994 ch = peekNext(c);
995 if (ch < '1' || ch > '9')
996 return false;
997
998 count = strtol(c->fP.fInChar, (char **) &c->fP.fInChar, 10);
999 if (countP)
1000 *countP = count;
1001
1002 return true;
1003 }
1004
1005
1006 // "n" <index> can cause the following type to be ambiguous as
1007 // n23_Pc... can be
1008 // "n" <digit> <counted_class_name> ...
1009 // | "n" <digit> <digit> '_' <declarator> <fund_type_id> ...
1010 // However as the class '_Pc' is probably going to be unlikely a quick
1011 // check to see if the next field is a valid type would probably clear
1012 // up the abiguity for the majority of cases.
1013 //
1014 // <index> ::= <digit> | <digit> <digit> <digit>* "_"
1015 static Boolean parse_index(ParseContext *c, int *indexP)
1016 {
1017 CheckPoint chk = *checkPoint(c);
1018 char ch0, ch1;
1019 int index;
1020
1021 ch0 = peekAt(c, 0);
1022 ch1 = peekAt(c, 1);
1023
1024 if ( !('0' <= ch0 && ch0 <= '9') )
1025 goto abandonParse;
1026 if ('0' <= ch1 && ch1 <= '9') {
1027 if (!parse_count(c, &index))
1028 goto abandonParse;
1029 if (isNext(c, '_')) {
1030 // @@@ gvdl: Ambiguity check one day
1031 if (indexP)
1032 *indexP = index;
1033 return true;
1034 }
1035 else
1036 resetTo(c, &chk); // Must be the one digit case
1037 }
1038
1039 // One digit case
1040 advance(c, 1);
1041 index = ch0 - '0';
1042
1043 if (indexP)
1044 *indexP = index;
1045 return true;
1046
1047 abandonParse:
1048 return false;
1049 }
1050
1051
1052 // <qualifier> ::= "C" ; const
1053 // | "V" ; volatile
1054 // | "u" ; restrict (C99) unsupported
1055 // | "G" ; struct/union/enum ; unused in gcc3
1056 static Boolean parse_qualifiers(ParseContext *c)
1057 {
1058 BaseTypeData *bP = c->fCurBaseP;
1059
1060 for (;;) {
1061 if (isNext(c, 'C'))
1062 bP->fConst = true; // "C" ; const
1063 else if (isNext(c, 'V'))
1064 bP->fVolatile = true; // "V" ; volatile
1065 else if (isNext(c, 'u'))
1066 return false; // "u" ; restrict (C99)
1067 else if (isNext(c, 'G'))
1068 continue; // "G" ; struct/union/enum ; unused
1069 else
1070 break;
1071 }
1072
1073 return true;
1074 }
1075
1076 // Assumes we have an open fInEntry in fCurBaseP
1077 static Boolean duplicateEntries(ParseContext *c, int start, int numE)
1078 {
1079 BaseTypeData *bIP = &c->fInEntries[start]; // First duplicate entry
1080 BaseTypeData *bP = c->fCurBaseP;
1081 int i;
1082
1083 // Duplicating a method
1084 if (kNTMethod == bIP->fType) {
1085 bP--; // Strip leading 'P' declarator
1086 c->fP.fNumI--;
1087 }
1088
1089 numE--;
1090
1091 // do we have room available for duplication
1092 if (c->fP.fNumI + numE >= MAX_ENTRIES)
1093 return false;
1094
1095 // Copy the parse entries over
1096 bcopy(bIP, bP, (numE + 1) * sizeof(*bP));
1097
1098 // Now we have to duplicate the types for the new entry
1099 for (i = 0; i < c->fP.fNumT; i++) {
1100 TypeData *tP = &c->fTypeList[i];
1101 if (tP->fStartEntry < start)
1102 continue;
1103 else if (tP->fStartEntry <= start + numE)
1104 dupType(c, tP, bP - bIP);
1105 else
1106 break;
1107 }
1108
1109 c->fP.fNumI += numE;
1110 bP += numE;
1111 c->fCurBaseP = bP;
1112
1113 return true;
1114 }
1115
1116 // Must have a valid c->fCurBaseP pointer on entry
1117 // <class_name> ::= <counted_class_name> ; plain class name
1118 // | "Q" <qualified_name> ; qualified name
1119 // | "B" <index> ; compressed name
1120 // | "K" <qualified_name> ; ignored and illegal
1121 // <qualified_name> ::= <q_count> <counted_class_name>+
1122 // <q_count> ::= <digit> | "_" <digit> <digit>* "_"
1123 // <counted_class_name> ::= <count> <name>
1124 // <name> ::= <char> <char>*
1125 static Boolean
1126 parse_class_name(ParseContext *c)
1127 {
1128 BaseTypeData *bP = c->fCurBaseP;
1129 const char *typeId = c->fP.fInChar;
1130 char ch;
1131 int count;
1132
1133 if (parse_count(c, &count)) {
1134
1135 // <counted_class_name> ::= <count> <name>
1136 if (!hasRemain(c, count))
1137 goto abandonParse;
1138
1139 bP->fType = kNTClass;
1140 advance(c, count);
1141
1142 bP->fFundTypeID = typeId;
1143 bP->fLen = c->fP.fInChar - typeId;
1144 }
1145 else {
1146 switch (peekNext(c)) {
1147
1148 case 'Q': {
1149 int i, q_count;
1150
1151 advance(c, 1);
1152
1153 // | "Q" <qualified_name> ; qualified name
1154 // <qualified_name> ::= <q_count> <counted_class_name>+
1155 // <q_count> ::= <digit> | "_" <digit> <digit>* "_"
1156 if ('_' == (ch = getNext(c))) {
1157 advance(c, 1);
1158 if (!parse_count(c, &q_count) || !isNext(c, '_'))
1159 goto abandonParse;
1160 }
1161 else if ('1' <= ch && ch <= '9')
1162 q_count = ch - '0';
1163
1164 if (!q_count)
1165 goto abandonParse;
1166
1167 typeId = c->fP.fInChar;
1168 bP->fType = kNTClass;
1169 bP->fQualified = true;
1170 i = 0;
1171 for (i = 0; i < q_count; i++) {
1172 if (parse_count(c, &count))
1173 advance(c, count);
1174 else
1175 goto abandonParse;
1176 }
1177 bP->fLen = c->fP.fInChar - typeId;
1178 bP->fFundTypeID = typeId;
1179 break;
1180 }
1181
1182 case 'B':
1183 // | "B" <index>
1184 advance(c, 1);
1185
1186 if (!parse_index(c, &count) || count >= c->fP.fNumB)
1187 goto abandonParse;
1188
1189 if (!duplicateEntries(c, c->fBDict[count].fStartEntry,
1190 c->fBDict[count].fNumEntries))
1191 goto abandonParse;
1192 return true;
1193
1194 case 'K': default:
1195 goto abandonParse;
1196 }
1197 }
1198
1199 if (newBDict(c, bP - c->fInEntries, 1))
1200 return true;
1201
1202 abandonParse:
1203 return false;
1204 }
1205
1206 // <fund_type_id> ::= <class_name>
1207 // | "b" ; bool
1208 // | "c" ; char
1209 // | "d" ; double
1210 // | "e" ; ellipsis
1211 // | "f" ; float
1212 // | "i" ; int
1213 // | "l" ; long
1214 // | "r" ; long double
1215 // | "s" ; short
1216 // | "v" ; void
1217 // | "w" ; wchar_t
1218 // | "x" ; long long
1219 // | "G" <count> ; ???
1220 static Boolean parse_fund_type_id(ParseContext *c)
1221 {
1222 BaseTypeData *bP = c->fCurBaseP;
1223
1224 if (!parse_class_name(c)) {
1225 // Use the TypeID pointer as a 4 character buffer
1226 char ch = peekNext(c);
1227
1228 if (bP->fSigned && 'c' != ch)
1229 goto abandonParse; // illegal only chars can be signed
1230
1231 switch (ch) {
1232
1233 case 'b': case 'd': case 'f': case 'v': case 'w': // No map types
1234 break;
1235
1236 case 'c': // character
1237 if (bP->fSigned) ch = 'a';
1238 else if (bP->fUnsigned) ch = 'h';
1239 break;
1240 case 'e': // ellipsis
1241 ch = 'z';
1242 break;
1243 case 'i': // int
1244 if (bP->fUnsigned) ch = 'j';
1245 break;
1246 case 'l': // long
1247 if (bP->fUnsigned) ch = 'm';
1248 break;
1249 case 'r': // long double
1250 ch = 'e';
1251 break;
1252 case 's': // short
1253 if (bP->fUnsigned) ch = 't';
1254 break;
1255 case 'x': // long long
1256 if (bP->fUnsigned) ch = 'y';
1257 break;
1258
1259 case 'G': // Don't understand "G"
1260 default:
1261 goto abandonParse;
1262 }
1263
1264 advance(c, 1); // Consume the input character
1265 bP->fFundTypeID = (void *) (int) ch;
1266 bP->fLen = 0;
1267 bP->fType = kNTBuiltIn;
1268 }
1269
1270 return true;
1271
1272 abandonParse:
1273 return false;
1274 }
1275
1276 // <arg_type> ::= <type> [ "n" <index> ]
1277 // | "N" <count> <pos> ; Not implemented
1278 // | "T" <index> ; Not implemented
1279 static Boolean parse_arg_type(ParseContext *c)
1280 {
1281 // Don't bother to check point as parse_argument_types does it for us
1282
1283 TypeData *typeP;
1284 int repeat = 0;
1285
1286 typeP = &c->fTypeList[c->fP.fNumT]; // Cache type for later repeat
1287 if (!parse_type(c))
1288 return false;
1289
1290 // Now check for a repeat count on this type
1291 if (isNext(c, 'n')) {
1292 if (!parse_index(c, &repeat))
1293 return false;
1294
1295 do {
1296 c->fCurBaseP = newIn(c); // Duplicate requires a fresh type
1297 if (!c->fCurBaseP)
1298 return false;
1299 if (!duplicateEntries(c, typeP->fStartEntry, typeP->fNumEntries))
1300 return false;
1301 } while (--repeat);
1302 }
1303
1304 return true;
1305 }
1306
1307 // <argument_types> ::= # Empty
1308 // | <arg_type>+
1309 static Boolean parse_argument_types(ParseContext *c)
1310 {
1311 if (atEnd(c))
1312 return true;
1313
1314 if (!parse_arg_type(c))
1315 goto abandonParse;
1316
1317 while (!atEnd(c) && parse_arg_type(c))
1318 ;
1319
1320 return true;
1321
1322 // Not a counted class name so reset to checkPoint
1323 abandonParse:
1324 return false;
1325 }
1326
1327 // leaf function so the copy aside buffer isn't on the primary
1328 // recursion stack.
1329 static Boolean
1330 rotateFunction(ParseContext *c, int argStart, int retStart)
1331 {
1332 char returnTypeBuffer[MAX_RETURN_BUFFER];
1333 int numArg, numRet;
1334 int lenArg, lenRet;
1335 char *sArgP, *sRetP;
1336 int i;
1337
1338 TypeData *argTP = &c->fTypeList[argStart];
1339 TypeData *retTP = &c->fTypeList[retStart];
1340
1341 // Rotate around the entries first
1342 numArg = retTP->fStartEntry - argTP->fStartEntry;
1343 numRet = retTP->fNumEntries;
1344 lenArg = numArg * sizeof(BaseTypeData);
1345 lenRet = numRet * sizeof(BaseTypeData);
1346
1347 // Copy the return type into a buffer
1348 if (lenRet > sizeof(returnTypeBuffer))
1349 return false;
1350
1351 sArgP = (char *) (&c->fInEntries[argTP->fStartEntry]);
1352 sRetP = (char *) (&c->fInEntries[retTP->fStartEntry]);
1353
1354 bcopy(sRetP, returnTypeBuffer, lenRet);
1355 bcopy(sArgP, sArgP + lenRet, lenArg);
1356 bcopy(returnTypeBuffer, sArgP, lenRet);
1357
1358 // Retarget the argument and return types for the new entry positions
1359 lenArg = numArg;
1360 lenRet = numRet;
1361 numArg = retStart - argStart;
1362 numRet = c->fP.fNumT - retStart;
1363 for (i = 0; i < numArg; i++)
1364 c->fTypeList[argStart+i].fStartEntry += lenRet;
1365 for (i = 0; i < numRet; i++)
1366 c->fTypeList[retStart+i].fStartEntry -= lenArg;
1367
1368 // Rotate the BDictionary
1369 for (i = 0; i < c->fP.fNumB; i++) {
1370 TypeData *bDP = &c->fBDict[i];
1371 int start = bDP->fStartEntry;
1372
1373 if (start >= argTP->fStartEntry)
1374 bDP->fStartEntry = start + lenRet;
1375 else if (start >= retTP->fStartEntry)
1376 bDP->fStartEntry = start - lenArg;
1377 }
1378
1379 // Finally rotate the retargeted type structures.
1380 lenArg = numArg * sizeof(TypeData);
1381 lenRet = numRet * sizeof(TypeData);
1382
1383 sArgP = (char *) (&c->fTypeList[argStart]);
1384 sRetP = (char *) (&c->fTypeList[retStart]);
1385
1386 bcopy(sRetP, returnTypeBuffer, lenRet);
1387 bcopy(sArgP, sArgP + lenRet, lenArg);
1388 bcopy(returnTypeBuffer, sArgP, lenRet);
1389
1390 return true;
1391 }
1392
1393 // <function_type> ::= "F" <argument_types> "_" <type>
1394 static Boolean parse_function_type(ParseContext *c, Boolean forMethod)
1395 {
1396 TypeData *bDictP = 0;
1397 BaseTypeData *bP = c->fCurBaseP;
1398
1399 int argTypeStart, retTypeStart;
1400
1401 if (!forMethod) {
1402 bDictP = newBDict(c, c->fP.fNumI-1, 0);
1403 if (!bDictP)
1404 goto abandonParse;
1405 }
1406
1407 if (!isNext(c, 'F'))
1408 goto abandonParse;
1409
1410 bP->fType = kNTFunction;
1411
1412 // Note that the argument types will advance the Entry list
1413 argTypeStart = c->fP.fNumT;
1414 if (!parse_argument_types(c))
1415 goto abandonParse;
1416
1417 if (!isNext(c, '_'))
1418 goto abandonParse;
1419
1420 // Parse the return type
1421 retTypeStart = c->fP.fNumT;
1422 if (!parse_type(c))
1423 goto abandonParse;
1424
1425 // gcc3 puts the return code just after the 'F' declaration
1426 // as this impacts the order of the compression I need to rotate
1427 // the return type and the argument types.
1428 if (!rotateFunction(c, argTypeStart, retTypeStart))
1429 goto abandonParse;
1430
1431 if (!forMethod)
1432 bDictP->fNumEntries = c->fP.fNumI - bDictP->fStartEntry;
1433
1434 return true;
1435
1436 abandonParse:
1437 return false;
1438 }
1439
1440 // To convert 2.95 method to a 3.0 method I need to prune the
1441 // first argument of the function type out of the parse tree.
1442 static Boolean cleanMethodFunction(ParseContext *c, int type)
1443 {
1444 TypeData *typeP, *startTP, *endTP;
1445 BaseTypeData *bP;
1446 int i, thisStart, thisEnd, thisLen, funcRemain;
1447
1448 // Get pointer for the return value's type.
1449 startTP = &c->fTypeList[type+1];
1450 endTP = &c->fTypeList[c->fP.fNumT];
1451
1452 // Now look for the first type that starts after the return type
1453 thisEnd = startTP->fStartEntry + startTP->fNumEntries;
1454 for (startTP++; startTP < endTP; startTP++)
1455 if (startTP->fStartEntry >= thisEnd)
1456 break;
1457
1458 if (startTP >= endTP) {
1459 c->fRetCode = kR3InternalNotRemangled;
1460 return false; // Internal error: should never happen
1461 }
1462
1463 // We now have a pointer to the 1st argument in the input list
1464 // we will need to excise the entries from the input list and don't forget
1465 // to remove the associated types from the type list.
1466
1467 thisLen = startTP->fNumEntries;
1468 thisStart = startTP->fStartEntry;
1469 thisEnd = thisStart + thisLen;
1470 funcRemain = c->fP.fNumI - thisEnd;
1471 bP = &c->fInEntries[thisStart];
1472
1473 // If we have no arguments then replace the pointer with a void
1474 if (!funcRemain) {
1475 c->fP.fNumI -= (thisLen - 1);
1476
1477 bP->fFundTypeID = (void *) (int) 'v'; // Void arg list
1478 bP->fLen = 0;
1479 bP->fType = kNTBuiltIn;
1480
1481 // Update the type entry for the void argument list
1482 startTP->fNumEntries = 1;
1483 return true;
1484 }
1485
1486 // Move the argument list down to replace the 'this' pointer
1487 bcopy(bP + thisLen, bP, funcRemain * sizeof(*bP));
1488 c->fP.fNumI -= thisLen;
1489
1490 // And remove the 'this' pointers type
1491
1492 // First walk over all of the types that have to be removed
1493 for (typeP = startTP + 1; typeP < endTP; typeP++)
1494 if (typeP->fStartEntry >= thisEnd)
1495 break;
1496
1497 if (typeP >= endTP) {
1498 c->fRetCode = kR3InternalNotRemangled;
1499 return false; // Internal error Can't be a void argument list.
1500 }
1501
1502 bcopy(typeP, startTP, (char *) endTP - (char *) typeP);
1503
1504 c->fP.fNumT -= typeP - startTP;
1505 endTP = &c->fTypeList[c->fP.fNumT];
1506 for (typeP = startTP ; typeP < endTP; typeP++)
1507 typeP->fStartEntry -= thisLen;
1508
1509 // Finally we can retarget the BDictionary lists
1510 for (i = 0; i < c->fP.fNumB; i++) {
1511 TypeData *bDP = &c->fBDict[i];
1512 int start = bDP->fStartEntry;
1513
1514 if (start < thisStart)
1515 continue;
1516 if (start >= thisEnd)
1517 break;
1518
1519 bDP->fStartEntry = start - thisLen;
1520 }
1521
1522 return true;
1523 }
1524
1525 // <method_type> ::= "M" <class_name> <function_type>
1526 //
1527 // Note this is a very bad function. Gcc3 doesn't doesn't use pointer that
1528 // is immediately before this entry. We will have to delete the 'P' declarator
1529 // that is before the method declaration.
1530 // We will also have to prune the first type in the argument list as Gcc3
1531 // doesn't register the 'this' pointer within the function list.
1532 static Boolean parse_method_type(ParseContext *c)
1533 {
1534 TypeData *bDictP;
1535 TypeData *typeP;
1536 BaseTypeData *bP;
1537
1538 bDictP = newBDict(c, c->fP.fNumI-2, 0);
1539 if (!bDictP)
1540 goto abandonParse;
1541
1542 // Replace 'P' declarator
1543 c->fP.fNumI--;
1544 bP = c->fCurBaseP - 1;
1545
1546 if (!isNext(c, 'M'))
1547 goto abandonParse;
1548
1549 if (bP->fFundTypeID != (void *) (int) 'P')
1550 goto abandonParse;
1551
1552 // Replace the previous 'Pointer' declarator
1553 bP->fType = kNTMethod;
1554 bP->fFundTypeID = NULL;
1555 bP->fLen = 0;
1556
1557 // Grab the method's 'this' type specification
1558 typeP = newType(c, c->fP.fNumI);
1559 if (!newIn(c) || !typeP)
1560 goto abandonParse;
1561
1562 if (!parse_class_name(c))
1563 goto abandonParse;
1564 typeP->fNumEntries = c->fP.fNumI - typeP->fStartEntry;
1565
1566 // Grab the <function_type> specifier
1567 typeP = newType(c, c->fP.fNumI);
1568 if (!newIn(c) || !typeP)
1569 goto abandonParse;
1570
1571 if (!parse_function_type(c, /* forMethod */ true))
1572 goto abandonParse;
1573
1574 if (!cleanMethodFunction(c, typeP - c->fTypeList))
1575 goto abandonParse;
1576 typeP->fNumEntries = c->fP.fNumI - typeP->fStartEntry;
1577
1578 // Finally update the dictionary with the M & 'this'
1579 bDictP->fNumEntries = c->fP.fNumI - bDictP->fStartEntry;
1580
1581 return true;
1582
1583 abandonParse:
1584 return false;
1585 }
1586
1587 static Boolean emitQualifiers(ParseContext *c)
1588 {
1589 BaseTypeData *bP = c->fCurBaseP;
1590
1591 if (bP->fVolatile || bP->fConst) {
1592 Boolean isConst, isVolatile, isSigned, isUnsigned;
1593
1594 isVolatile = bP->fVolatile;
1595 isConst = bP->fConst;
1596 isSigned = bP->fSigned;
1597 isUnsigned = bP->fUnsigned;
1598 bP->fConst = bP->fVolatile = bP->fSigned = bP->fUnsigned = 0;
1599
1600 if (isVolatile) {
1601 bP->fType = kNTDeclarator;
1602 bP->fFundTypeID = (void *) (int) 'V';
1603 bP->fLen = 0;
1604 bP = newIn(c);
1605 if (!bP)
1606 return false;
1607 }
1608 if (isConst) {
1609 bP->fType = kNTDeclarator;
1610 bP->fFundTypeID = (void *) (int) 'K';
1611 bP->fLen = 0;
1612 bP = newIn(c);
1613 if (!bP)
1614 return false;
1615 }
1616 bP->fSigned = isSigned;
1617 bP->fUnsigned = isUnsigned;
1618 }
1619
1620 return true;
1621 }
1622
1623
1624 // <base_type> ::= <function_type> ; function
1625 // | <method_type> ; method
1626 // | <type_qualifier>* <fund_type_id>
1627 // <type_qualifier> ::= "S" ; signed (chars only)
1628 // | "U" ; unsigned (any integral type)
1629 // | "J" ; __complex
1630 // | <qualifier>
1631 static Boolean parse_base_type(ParseContext *c)
1632 {
1633 if ('F' == peekNext(c)) {
1634 if (!parse_function_type(c, /* forMethod */ false))
1635 goto abandonParse;
1636 }
1637 else if ('M' == peekNext(c)) {
1638 if (!parse_method_type(c))
1639 goto abandonParse;
1640 }
1641 else {
1642 // | <type_qualifier>* <fund_type_id>
1643 BaseTypeData *bP = c->fCurBaseP;
1644 for (;;) {
1645 if (isNext(c, 'S'))
1646 // <type_qualifier> ::= "S" ; signed (chars only)
1647 { bP->fSigned = true; continue; }
1648 else if (isNext(c, 'U'))
1649 // | "U" ; unsigned (any integral type)
1650 { bP->fUnsigned = true; continue; }
1651 else if (isNext(c, 'C'))
1652 // | <qualifier>
1653 // <qualifier> ::= "C" ; const
1654 { bP->fConst = true; continue; }
1655 else if (isNext(c, 'V'))
1656 // | "V" ; volatile
1657 { bP->fVolatile = true; continue; }
1658 else if (charNext(c, "Ju"))
1659 goto abandonParse; // Don't support these qualifiers
1660 // | "J" ; __complex
1661 // | "u" ; restrict (C99)
1662 else
1663 break;
1664 }
1665
1666 if (!emitQualifiers(c))
1667 goto abandonParse;
1668
1669 if (!parse_fund_type_id(c))
1670 goto abandonParse;
1671 }
1672 return true;
1673
1674 abandonParse:
1675 return false;
1676 }
1677
1678 // Use the top SDict as a stack of declarators.
1679 // parses <declarator>*
1680 // <declarator> ::= "P" ; pointer
1681 // | "p" ; pointer (but never occurs?)
1682 // | "R" ; reference (&)
1683 // | "A" <count> ; array
1684 // | "T" <index>
1685 // | "O" <count>
1686 // | <qualifier>
1687 //
1688 // As a side-effect the fCurBaseP is setup with any qualifiers on exit
1689 static Boolean parse_declarators(ParseContext *c)
1690 {
1691 int count;
1692 BaseTypeData *dP;
1693
1694 // Note we MUST go through the for loop at least once
1695 for (count = 0; ; count++) {
1696 const char *curDecl;
1697 char ch;
1698
1699 if (!newIn(c))
1700 goto abandonParse;
1701
1702 // <declarator> ::= <qualifier> production
1703 if (!parse_qualifiers(c) || !emitQualifiers(c))
1704 goto abandonParse;
1705
1706 dP = c->fCurBaseP; // Find the current base type pointer
1707
1708 curDecl = c->fP.fInChar;
1709
1710 switch (peekNext(c)) {
1711
1712 case 'P': case 'p': case 'R':
1713 // <declarator> ::= "P" ; pointer
1714 // | "p" ; pointer (but never occurs?)
1715 // | "R" ; reference (&)
1716
1717 dP->fType = kNTDeclarator;
1718 advance(c, 1);
1719
1720 ch = *curDecl;
1721 if ('p' == ch) ch = 'P';
1722 dP->fFundTypeID = (void *) (int) ch;
1723 dP->fLen = 0;
1724 continue; // Go around again
1725
1726 case 'A':
1727 // | "A" <count> ; array
1728 dP->fType = kNTArray;
1729
1730 advance(c, 1); curDecl++;
1731 curDecl = (void *)
1732 strtoul(curDecl, (char **) &c->fP.fInChar, 10);
1733 if (!curDecl)
1734 goto abandonParse;
1735 dP->fFundTypeID = curDecl;
1736 dP->fLen = 0;
1737 continue; // Go around again
1738
1739 case 'T': case 'O':
1740 // | "T" <index> Unsupported
1741 // | "O" <count> Unsupported
1742 goto abandonParse;
1743
1744 default:
1745 break;
1746 }
1747
1748 break;
1749 }
1750
1751 dP->fLen = 0;
1752 return true;
1753
1754 abandonParse:
1755 return false;
1756 }
1757
1758 // <type> ::= <declarator>* <base_type>
1759 static Boolean parse_type(ParseContext *c)
1760 {
1761 CheckPoint chk = *checkPoint(c);
1762 TypeData *typeP = newType(c, c->fP.fNumI);
1763 if (!typeP)
1764 goto abandonParse;
1765
1766 // As a side-effect the fCurBaseP is setup with any qualifiers on exit
1767 if (!parse_declarators(c))
1768 goto abandonParse;
1769
1770 // Merge the last qualifiers into the base type
1771 if (!parse_base_type(c) || kNTUndefined == c->fCurBaseP->fType)
1772 goto abandonParse;
1773
1774 typeP->fNumEntries = c->fP.fNumI - typeP->fStartEntry;
1775 return true;
1776
1777 abandonParse:
1778 resetTo(c, &chk);
1779 return false;
1780 }
1781
1782 // <function_name> ::= <char> <char>*
1783 // No need to check point as an invalid function name is fatal
1784 // Consumes trailing "__".
1785 static Boolean
1786 parse_function_name(ParseContext *c)
1787 {
1788 char ch;
1789
1790 while ( (ch = peekNext(c)) )
1791 {
1792 advance(c, 1);
1793 if ('_' == ch && '_' == peekNext(c)) {
1794 do {
1795 advance(c, 1);
1796 } while ('_' == peekNext(c));
1797 return true;
1798 }
1799 }
1800
1801 return false;
1802 }
1803
1804 // <opinfo> ::= "type" <type>
1805 // | "__op" <type>
1806 // | <opname> "__" ; Implies null function name
1807 // | "a"
1808 // <opname> ::= "aa" # && ==> "aa"
1809 // | "aad" # &= ==> "aN"
1810 // | "ad" # & ==> "ad"
1811 // | "adv" # /= ==> "dV"
1812 // | "aer" # ^= ==> "eO"
1813 // | "als" # <<= ==> "lS"
1814 // | "amd" # %= ==> "rM"
1815 // | "ami" # -= ==> "mI"
1816 // | "aml" # *= ==> "mL
1817 // | "aor" # |= ==> "oR
1818 // | "apl" # += ==> "pL
1819 // | "ars" # >>= ==> "rS
1820 // | "as" # = ==> "aS
1821 // | "cl" # () ==> "cl
1822 // | "cm" # , ==> "cm
1823 // | "cn" # ?: ==> "qu
1824 // | "co" # ~ ==> "co
1825 // | "dl" # delete ==> "dl
1826 // | "dv" # / ==> "dv
1827 // | "eq" # == ==> "eq
1828 // | "er" # ^ ==> "eo
1829 // | "ge" # >= ==> "ge
1830 // | "gt" # > ==> "gt
1831 // | "le" # <= ==> "le
1832 // | "ls" # << ==> "ls
1833 // | "lt" # < ==> "lt
1834 // | "md" # % ==> "rm
1835 // | "mi" # - ==> "mi
1836 // | "ml" # * ==> "ml
1837 // | "mm" # -- ==> "mm
1838 // | "mn" # <? ==> "????????????????
1839 // | "mx" # >? ==> "????????????????
1840 // | "ne" # != ==> "ne
1841 // | "nt" # ! ==> "nt
1842 // | "nw" # new ==> "nw
1843 // | "oo" # || ==> "oo"
1844 // | "or" # | ==> "or
1845 // | "pl" # + ==> "pl
1846 // | "pp" # ++ ==> "pp
1847 // | "rf" # -> ==> "pt
1848 // | "rm" # ->* ==> "pm
1849 // | "rs" # >> ==> "rs
1850 // | "sz" # sizeof ==> "sz
1851 // | "vc" # [] ==> "ix
1852 // | "vd" # delete[] ==> "da
1853 // | "vn" # new[] ==> "na
1854 static struct opMap {
1855 const char *op295, *op3;
1856 } opMapTable[] = {
1857 {"aad", "aN" }, {"adv", "dV" }, {"aer", "eO" }, {"als", "lS" },
1858 {"amd", "rM" }, {"ami", "mI" }, {"aml", "mL" }, {"aor", "oR" },
1859 {"apl", "pL" }, {"ars", "rS" }, {"aa", "aa" }, {"ad", "ad" },
1860 {"as", "aS" }, {"cl", "cl" }, {"cm", "cm" }, {"cn", "qu" },
1861 {"co", "co" }, {"dl", "dl" }, {"dv", "dv" }, {"eq", "eq" },
1862 {"er", "eo" }, {"ge", "ge" }, {"gt", "gt" }, {"le", "le" },
1863 {"ls", "ls" }, {"lt", "lt" }, {"md", "rm" }, {"mi", "mi" },
1864 {"ml", "ml" }, {"mm", "mm" }, {"mn", NULL }, {"mx", NULL },
1865 {"ne", "ne" }, {"nt", "nt" }, {"nw", "nw" }, {"oo", "oo" },
1866 {"or", "or" }, {"pl", "pl" }, {"pp", "pp" }, {"rf", "pt" },
1867 {"rm", "pm" }, {"rs", "rs" }, {"sz", "sz" }, {"vc", "ix" },
1868 {"vd", "da" }, {"vn", "na" },
1869 };
1870
1871 static Boolean parse_opinfo(ParseContext *c, const char **opInfoP)
1872 {
1873 CheckPoint chk = *checkPoint(c);
1874 const char *op;
1875 char ch;
1876 int i;
1877
1878 if ('a' == (ch = peekNext(c))) {
1879 goto abandonParse;
1880 }
1881 else if (strNext(c, "type")) {
1882 goto abandonParse;
1883 }
1884 else if (retard(c, 4) && strNext(c, "____op")) {
1885 // @@@ gvdl: check this out it may change
1886 // <opinfo> ::= "__op" <type>
1887 goto abandonParse;
1888 }
1889
1890 // Failed till now so reset and see if we have an operator
1891 resetTo(c, &chk);
1892
1893 // quick check to see if we may have an operator
1894 if (!strrchr("acdeglmnoprsv", peekNext(c)))
1895 goto abandonParse;
1896
1897 op = NULL;
1898 for (i = 0; i < sizeof(opMapTable)/sizeof(opMapTable[0]); i++) {
1899 if (strNext(c, opMapTable[i].op295)) {
1900 op = opMapTable[i].op3;
1901 break;
1902 }
1903 }
1904 if (!op)
1905 goto abandonParse;
1906
1907 if (!strNext(c, "__")) // Trailing underbars
1908 goto abandonParse;
1909
1910 if (opInfoP)
1911 *opInfoP = op;
1912 return true;
1913
1914 abandonParse:
1915 return false;
1916 }
1917
1918 // <signature> ::= <qualifier>* <s_element> <argument_types>
1919 // <s_element> ::= <class_name>
1920 // | "K" <qualified_name>
1921 // | "S"
1922 // | "F" <argument_types> [ "_" <return_type> ]
1923 // <return_type> ::= <type>
1924 // Treat the prefix's s_element as a full type
1925 static Boolean
1926 parse_signature(ParseContext *c,
1927 const char *func, int funcLen, const char *op)
1928 {
1929 BaseTypeData *bP;
1930 TypeData *tP;
1931
1932 Boolean isFunction = false;
1933
1934 if (isNext(c, 'F')) {
1935 // | "F" <argument_types> [ "_" <return_type> ]
1936
1937 char numbuf[16]; // Bigger than MAX_INT + 4
1938 int len;
1939 isFunction = true;
1940 if (!funcLen)
1941 goto abandonParse;
1942
1943 len = snprintf(numbuf, sizeof(numbuf), "__Z%d", funcLen);
1944
1945 appendNStr(c, numbuf, len);
1946 appendNStr(c, func, funcLen);
1947 }
1948 else if (isNext(c, 'S')) {
1949 // | "S" ; Ignored
1950 goto abandonParse;
1951 }
1952 else {
1953 const char *qual;
1954 int qualLen;
1955
1956 // See if we can find a qualified class reference
1957 tP = newType(c, c->fP.fNumI);
1958 if (!tP)
1959 goto abandonParse;
1960
1961 bP = newIn(c);
1962 if (!bP)
1963 goto abandonParse;
1964
1965 // Parse any qualifiers, store results in *fCurBaseP
1966 bP->fPseudo = true;
1967 if (!parse_qualifiers(c))
1968 goto abandonParse;
1969
1970 if (!parse_class_name(c))
1971 goto abandonParse;
1972
1973 bP = c->fCurBaseP; // class name may have redifined current
1974 tP->fNumEntries = c->fP.fNumI - tP->fStartEntry;
1975
1976 APPENDSTR(c, "__ZN");
1977 decodeQual(bP, &qualLen, &qual);
1978 if (qualLen)
1979 appendNStr(c, qual, qualLen);
1980 appendNStr(c, bP->fFundTypeID, bP->fLen);
1981
1982 if (funcLen) {
1983 char numbuf[16]; // Bigger than MAX_INT + 1
1984 int len;
1985
1986 len = snprintf(numbuf, sizeof(numbuf), "%d", funcLen);
1987 appendNStr(c, numbuf, len);
1988 appendNStr(c, func, funcLen);
1989 }
1990 else if (op)
1991 appendStr(c, op);
1992 else {
1993 // No function & no op means constructor choose one of C1 & C2
1994 APPENDSTR(c, "C2");
1995 }
1996 appendChar(c, 'E');
1997 }
1998
1999 if (atEnd(c)) {
2000 appendChar(c, 'v'); // void argument list
2001 c->fRetCode = kR3Remangled;
2002 return true;
2003 }
2004
2005 c->fCurBaseP = NULL;
2006 if (!parse_argument_types(c))
2007 goto abandonParse;
2008
2009 if (isFunction) {
2010 if (isNext(c, '_')) {
2011 // && !parse_type(c) @@@ gvdl: Unsupported return
2012 c->fRetCode = kR3InternalNotRemangled;
2013 goto abandonParse;
2014 }
2015 }
2016
2017 if (!atEnd(c))
2018 goto abandonParse;
2019
2020 // OK we have a complete and successful parse now output the
2021 // argument list
2022 return appendArgumentList(c);
2023
2024 abandonParse:
2025 return false;
2026 }
2027
2028 // <mangled_name> ::= <prefix> [ <signature> ]
2029 // <prefix> ::= [ "_GLOBAL_" [ID] "__" ] <function_name> "__" [ <opinfo> ]
2030 static Boolean parse_mangled_name(ParseContext *c)
2031 {
2032 CheckPoint chk;
2033 CheckPoint dubBarChk;
2034 const char *func;
2035
2036 // <prefix> parse
2037 if (strNext(c, "_GLOBAL_")) { // Is this GLOBAL static constructor?
2038 // gvdl: can't deal with _GLOBAL_
2039 c->fRetCode = kR3InternalNotRemangled;
2040 return false; // Can't deal with these
2041 }
2042
2043 func = c->fP.fInChar;
2044 for (chk = *checkPoint(c); ; resetTo(c, &dubBarChk)) {
2045 int funcLen;
2046 const char *op = NULL;
2047
2048 if (!parse_function_name(c))
2049 goto abandonParse;
2050 dubBarChk = *checkPoint(c);
2051
2052 // Note that the opInfo may be earlier than the curDoubleBar
2053 // in which case the function name may need to be shrunk later on.
2054 (void) parse_opinfo(c, &op);
2055
2056 if (atEnd(c))
2057 goto abandonParse; // No Signature?
2058
2059 funcLen = inCharFromCheck(c, &dubBarChk) - func - 2;
2060 if (parse_signature(c, func, funcLen, op))
2061 return true;
2062
2063 if (kR3NotRemangled != c->fRetCode)
2064 goto abandonParse;
2065
2066 // If no error then try again maybe another '__' exists
2067 }
2068
2069 abandonParse:
2070 resetTo(c, &chk);
2071 return false;
2072 }
2073
2074 // <gnu_special> ::= ("_._" | "_$_" ) <class_name> ; destructor
2075 // | "__vt_" <class_name> ; virtual table
2076 // | "_" <class_name> ("."|"$") <varname>
2077 static Boolean parse_gnu_special(ParseContext *c)
2078 {
2079 CheckPoint chk = *checkPoint(c);
2080 BaseTypeData *bP = newIn(c);
2081
2082 if (!bP)
2083 return false;
2084
2085 // What do the intel desctructors look like
2086 if (strNext(c, "_._") || strNext(c, "_$_") ) // Is this a destructor
2087 {
2088 if (!parse_class_name(c) || !atEnd(c))
2089 goto abandonParse;
2090 APPENDSTR(c, "__ZN");
2091 appendNStr(c, bP->fFundTypeID, bP->fLen);
2092 APPENDSTR(c, "D2Ev");
2093 c->fRetCode = kR3Remangled;
2094 return true;
2095 }
2096 else if (strNext(c, "__vt_")) // Is it's a vtable?
2097 {
2098 if (!parse_class_name(c) || !atEnd(c))
2099 goto abandonParse;
2100
2101 APPENDSTR(c, "__ZTV");
2102 if (kNTClass != bP->fType)
2103 goto abandonParse;
2104 else if (bP->fQualified) {
2105 appendChar(c, 'N');
2106 appendNStr(c, bP->fFundTypeID, bP->fLen);
2107 appendChar(c, 'E');
2108 }
2109 else
2110 appendNStr(c, bP->fFundTypeID, bP->fLen);
2111
2112 c->fRetCode = kR3Remangled;
2113 return true;
2114 }
2115 else if (isNext(c, '_')) // Maybe it's a variable
2116 {
2117 const char *varname;
2118 int varlen, len;
2119 char numbuf[16]; // Bigger than MAX_INT + 1
2120
2121 if (!parse_class_name(c)) // Loads up the bP structure
2122 goto abandonParse;
2123
2124 if (!isNext(c, '.') && !isNext(c, '$'))
2125 goto abandonParse;
2126
2127 // Parse the variable name now.
2128 varname = c->fP.fInChar;
2129 if (atEnd(c) || !isValidFirstChar(getNext(c)))
2130 goto abandonParse;
2131
2132 while ( !atEnd(c) )
2133 if (!isValidChar(getNext(c)))
2134 goto abandonParse;
2135
2136 varlen = c->fP.fInChar - varname;
2137 len = snprintf(numbuf, sizeof(numbuf), "%d", varlen);
2138
2139 APPENDSTR(c, "__ZN");
2140 appendNStr(c, bP->fFundTypeID, bP->fLen);
2141
2142 appendNStr(c, numbuf, len);
2143 appendNStr(c, varname, varlen);
2144 appendChar(c, 'E');
2145
2146 c->fRetCode = kR3Remangled;
2147 return true;
2148 }
2149
2150 // Oh well it is none of those so give up but reset scan
2151 abandonParse:
2152 resetTo(c, &chk);
2153 return false;
2154 }
2155
2156 // <special_or_name> ::= <gnu_special>
2157 // | <mangled_name>
2158 static Boolean parse_special_or_name(ParseContext *c)
2159 {
2160 Boolean res;
2161
2162
2163 res = (parse_gnu_special(c) || parse_mangled_name(c));
2164 appendChar(c, '\0');
2165
2166 return res;
2167 }
2168
2169 Rem3Return rem3_remangle_name(char *gcc3, int *gcc3size, const char *gcc295)
2170 {
2171 ParseContext *c;
2172 Rem3Return result;
2173 int size;
2174
2175 if (!gcc295 || !gcc3 || !gcc3size)
2176 return kR3BadArgument;
2177
2178 size = strlen(gcc295);
2179 if (size < 2)
2180 return kR3NotRemangled; // Not a valid C++ symbol
2181 else if (*gcc295 != '_')
2182 return kR3NotRemangled; // no leading '_', not valid
2183
2184 c = (ParseContext *) malloc(sizeof(*c));
2185 if (!c)
2186 return kR3InternalNotRemangled;
2187 bzero(c, sizeof(*c));
2188
2189 c->fInSize = size;
2190 c->fInStr = gcc295 + 1; // Strip leading '_'
2191 c->fP.fInChar = c->fInStr;
2192
2193 c->fOutStrEnd = gcc3 + *gcc3size;
2194 c->fOutChar = gcc3;
2195
2196 c->fRetCode = kR3NotRemangled;
2197 (void) parse_special_or_name(c);
2198
2199 result = c->fRetCode;
2200 if (kR3Remangled == result) {
2201 if (c->fOutChar > c->fOutStrEnd)
2202 result = kR3BufferTooSmallRemangled;
2203 *gcc3size = c->fOutChar - gcc3 - 1; // Remove nul from len
2204 }
2205
2206 free(c);
2207
2208 return result;
2209 }