home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / updates / update20.zoo / gprof / diffs
Encoding:
Text File  |  1992-04-19  |  14.4 KB  |  681 lines
  1. *** 1.7    1992/03/18 03:41:26
  2. --- Changelog    1992/04/19 16:55:39
  3. ***************
  4. *** 51,53 ****
  5. --- 51,58 ----
  6.       various fixes from the net. gprof -s should work better now.
  7.   
  8.   ------------------------------- Patchlevel 6 ---------------------------
  9. + 
  10. + cplusdem.c:: ++jrb
  11. +         fix up demangler as per util diffs
  12. + 
  13. + ------------------------------- Patchlevel 7 ---------------------------
  14. *** 1.8    1992/03/18 03:41:26
  15. --- PatchLev.h    1992/04/19 16:55:40
  16. ***************
  17. *** 1,4 ****
  18. ! #define    PatchLevel "06"
  19.   
  20.   /*
  21.    *    the Patch Level above is to identify the version
  22. --- 1,4 ----
  23. ! #define    PatchLevel "07"
  24.   
  25.   /*
  26.    *    the Patch Level above is to identify the version
  27. *** 1.1    1992/03/08 17:48:29
  28. --- cplusdem.c    1992/04/19 16:55:40
  29. ***************
  30. *** 166,171 ****
  31. --- 166,177 ----
  32.     "cm", ",",            /* ansi */
  33.     "nop", "",            /* old (for operator=) */
  34.     "as", "=",            /* ansi */
  35. +   "cond", "?:",            /* old */
  36. +   "cn", "?:",            /* psuedo-ansi */
  37. +   "max", ">?",            /* old */
  38. +   "mx", ">?",            /* psuedo-ansi */
  39. +   "min", "<?",            /* old */
  40. +   "mn", "<?",            /* psuedo-ansi */
  41.   };
  42.   
  43.   /* Beware: these aren't '\0' terminated. */
  44. ***************
  45. *** 186,194 ****
  46.   static void string_appends (string *p, string *s);
  47.   static void string_appendn (string *p, const char *s, int n);
  48.   static void string_prepend (string *p, const char *s);
  49. - #if 0
  50.   static void string_prepends (string *p, string *s);
  51. - #endif
  52.   static void string_prependn (string *p, const char *s, int n);
  53.   static int get_count (const char **type, int *count);
  54.   static int do_args (const char **type, string *decl);
  55. --- 192,198 ----
  56. ***************
  57. *** 195,200 ****
  58. --- 199,207 ----
  59.   static int do_type (const char **type, string *result);
  60.   static int do_arg (const char **type, string *result);
  61.   static int do_args (const char **type, string *decl);
  62. + static int do_cuv_prefix (const char **type, string *result, int *non_empty);
  63. + static int do_builtin_type (const char **type, string *result, int *non_empty);
  64. + static int do_template_args (const char **type, string *result);
  65.   static void munge_function_name (string *name);
  66.   static void remember_type (const char *type, int len);
  67.   #else
  68. ***************
  69. *** 214,219 ****
  70. --- 221,229 ----
  71.   static int do_type ();
  72.   static int do_arg ();
  73.   static int do_args ();
  74. + static int do_cuv_prefix ();
  75. + static int do_builtin_type ();
  76. + static int do_template_args ();
  77.   static void munge_function_name ();
  78.   static void remember_type ();
  79.   #endif
  80. ***************
  81. *** 275,286 ****
  82.         destructor = 1;
  83.         p = type;
  84.       }
  85. -       /* static data member */
  86. -       else if (*type != '_' && (strchr (type, CPLUS_MARKER) != NULL))
  87. -     {
  88. -       static_type = 1;
  89. -       p = type;
  90. -     }
  91.         /* virtual table "_vt$"  */
  92.         else if (type[0] == '_' && type[1] == 'v' && type[2] == 't' && type[3] == CPLUS_MARKER)
  93.       {
  94. --- 285,290 ----
  95. ***************
  96. *** 290,295 ****
  97. --- 294,305 ----
  98.         strcat (tem, " virtual table");
  99.         return tem;
  100.       }
  101. +       /* static data member */
  102. +       else if (type[0] == '_' && type[1] != '_' && (strchr (type, CPLUS_MARKER) != NULL))
  103. +     {
  104. +       static_type = 1;
  105. +       p = type + 1;
  106. +     }
  107.         else return NULL;
  108.       }
  109.   
  110. ***************
  111. *** 323,334 ****
  112.         string_appendn (&decl, "", 1);
  113.         munge_function_name (&decl);
  114.         if (decl.b[0] == '_')
  115. !         {
  116. !           string_delete (&decl);
  117. !           return NULL;
  118. !         }
  119. !       else
  120. !         p += 2;
  121.       }
  122.         else
  123.       {
  124. --- 333,340 ----
  125.         string_appendn (&decl, "", 1);
  126.         munge_function_name (&decl);
  127.         if (decl.b[0] == '_')
  128. !         decl.p--;
  129. !       p += 2;
  130.       }
  131.         else
  132.       {
  133. ***************
  134. *** 351,363 ****
  135.       {
  136.       case 'C':
  137.         /* a const member function */
  138. !       if (!isdigit (p[1]))
  139.       {
  140.         string_delete (&decl);
  141.         return NULL;
  142.       }
  143. -       p += 1;
  144. -       const_flag = 1;
  145.         /* fall through */
  146.       case '0':
  147.       case '1':
  148. --- 357,371 ----
  149.       {
  150.       case 'C':
  151.         /* a const member function */
  152. !       p += 1;
  153. !       const_flag = 1;
  154. !       if (*p == 't')
  155. !     goto template;
  156. !       if (!isdigit (*p))
  157.       {
  158.         string_delete (&decl);
  159.         return NULL;
  160.       }
  161.         /* fall through */
  162.       case '0':
  163.       case '1':
  164. ***************
  165. *** 416,597 ****
  166.         break;
  167.       /* template additions */
  168.       case 't':
  169.         p += 1;
  170.         {
  171. !     int r, i;
  172. !     int non_empty = 0;
  173.       string tname;
  174.       string trawname;
  175.       
  176. -     string temp;
  177. -     int need_comma = 0;
  178. -     
  179.       string_init(&tname);
  180.       string_init(&trawname);
  181. !     
  182.       /* get template name */
  183.       if (!get_simple_count (&p, &r))
  184.         {
  185. !         string_delete (&decl);
  186. !         return 0;
  187.         }
  188.       string_appendn (&tname, p, r);
  189.       string_appendn (&trawname, p, r);
  190. -     string_appendn (&trawname, "", 1);
  191.       p += r;
  192.       string_append (&tname, "<");
  193. !     /* get size of template parameter list */
  194. !     if (!get_count (&p, &r))
  195. !       return 0;
  196. !     for (i = 0; i < r; i++)
  197.         {
  198. !         if (need_comma)
  199. !           string_append (&tname, ", ");
  200. !         /* Z for type parameters */
  201. !         if (*p == 'Z')
  202. !           {
  203. !         p += 1;
  204. !         
  205. !         success = do_type (&p, &temp);
  206. !         string_appendn (&temp, "", 1);
  207. !         if (success)
  208. !           string_append (&tname, temp.b);
  209. !         string_delete(&temp);
  210. !         if (!success)
  211. !           break;
  212. !           }
  213. !         /* otherwise, value parameter */
  214. !         else
  215. !           {
  216. !         const char *old_p  = p;
  217. !         int is_pointer = 0;
  218. !         int is_real = 0;
  219. !         int is_integral = 0;
  220. !         int done = 0;
  221. ! 
  222. !         success = do_type (&p, &temp);
  223. !         string_appendn (&temp, "", 1);
  224. !         if (success)
  225. !           string_append (&tname, temp.b);
  226. !         string_delete(&temp);
  227. !         if (!success)
  228. !           break;
  229. !         string_append (&tname, "=");
  230. !         while (*old_p && !done)
  231. !           {    
  232. !             switch (*old_p)
  233. !               {
  234. !               case 'P':
  235. !               case 'R':
  236. !             done = is_pointer = 1;
  237. !             break;
  238. !               case 'C':    /* const */
  239. !               case 'U':    /* unsigned */
  240. !               case 'V':    /* volatile */
  241. !               case 'F':    /* function */
  242. !               case 'M':    /* member function */
  243. !               case 'O':    /* ??? */
  244. !             old_p++;
  245. !             continue;
  246. !               case 'Q':    /* repetition of following */
  247. !               case 'T':    /* remembered type */
  248. !             abort();
  249. !             break;
  250. !               case 'v':    /* void */
  251. !             abort();
  252. !             break;
  253. !               case 'x':    /* long long */
  254. !               case 'l':    /* long */
  255. !               case 'i':    /* int */
  256. !               case 's':    /* short */
  257. !               case 'c':    /* char */
  258. !             done = is_integral = 1;
  259. !             break;
  260. !               case 'r':    /* long double */
  261. !               case 'd':    /* double */
  262. !               case 'f':    /* float */
  263. !             done = is_real = 1;
  264. !             break;
  265. !               default:
  266. !             abort();
  267. !               }
  268. !           }
  269. !         if (is_integral)
  270. !           {
  271. !             if (*p == 'm')
  272. !               {
  273. !             string_appendn (&tname, "-", 1);
  274. !             p++;
  275. !               }
  276. !             while (isdigit (*p))    
  277. !               {
  278. !             string_appendn (&tname, p, 1);
  279. !             p++;
  280. !               }
  281. !           }
  282. !         else if (is_real)
  283. !           {
  284. !             if (*p == 'm')
  285. !               {
  286. !             string_appendn (&tname, "-", 1);
  287. !             p++;
  288. !               }
  289. !             while (isdigit (*p))    
  290. !               {
  291. !             string_appendn (&tname, p, 1);
  292. !             p++;
  293. !               }
  294. !             if (*p == '.') /* fraction */
  295. !               {
  296. !             string_appendn (&tname, ".", 1);
  297. !             p++;
  298. !             while (isdigit (*p))    
  299. !               {
  300. !                 string_appendn (&tname, p, 1);
  301. !                 p++;
  302. !               }
  303. !               }
  304. !             if (*p == 'e') /* exponent */
  305. !               {
  306. !             string_appendn (&tname, "e", 1);
  307. !             p++;
  308. !             while (isdigit (*p))    
  309. !               {
  310. !                 string_appendn (&tname, p, 1);
  311. !                 p++;
  312. !               }
  313. !               }
  314. !           }
  315. !         else if (is_pointer)
  316. !           {
  317. !             int symbol_len;
  318. !             
  319. !             if (!get_count (&p, &symbol_len))
  320. !               {
  321. !             success = 0;
  322. !             break;
  323. !               }
  324. !             string_appendn (&tname, p, symbol_len);
  325. !             p += symbol_len;
  326. !           }
  327. !           }
  328. !         need_comma = 1;
  329.         }
  330.       string_append (&tname, ">::");
  331.       if (destructor)
  332.         string_append(&tname, "~");
  333. !     if (constructor || destructor) {
  334. !       string_appendn (&trawname, "", 1);
  335. !       string_append (&tname, trawname.b);
  336. !     }
  337.       string_delete(&trawname);
  338. !     
  339.       if (!success) {
  340.         string_delete(&tname);
  341.         return 0;
  342.       }
  343. !     string_appendn (&tname, "", 1);
  344. !     string_prepend (&decl, tname.b);
  345.       string_delete (&tname);
  346.   
  347.       if (static_type)
  348. --- 424,468 ----
  349.         break;
  350.       /* template additions */
  351.       case 't':
  352. +     template:
  353.         p += 1;
  354.         {
  355. !     int r;
  356.       string tname;
  357.       string trawname;
  358.       
  359.       string_init(&tname);
  360.       string_init(&trawname);
  361. ! 
  362.       /* get template name */
  363.       if (!get_simple_count (&p, &r))
  364.         {
  365. !         success = 0;
  366. !         break;
  367.         }
  368.       string_appendn (&tname, p, r);
  369.       string_appendn (&trawname, p, r);
  370.       p += r;
  371.       string_append (&tname, "<");
  372. !     success = do_template_args (&p, &tname);
  373. !     if (!success)
  374.         {
  375. !         string_delete (&tname);
  376. !         string_delete (&trawname);
  377. !         break;
  378.         }
  379.       string_append (&tname, ">::");
  380.       if (destructor)
  381.         string_append(&tname, "~");
  382. !     if (constructor || destructor)
  383. !       string_appends (&tname, &trawname);
  384.       string_delete(&trawname);
  385. ! 
  386.       if (!success) {
  387.         string_delete(&tname);
  388.         return 0;
  389.       }
  390. !     string_prepends (&decl, &tname);
  391.       string_delete (&tname);
  392.   
  393.       if (static_type)
  394. ***************
  395. *** 602,609 ****
  396.         }
  397.       else
  398.         success = do_args (&p, &decl);
  399. !     break;
  400.         }
  401.       }
  402.   
  403.     for (i = 0; i < ntypes; i++)
  404. --- 473,482 ----
  405.         }
  406.       else
  407.         success = do_args (&p, &decl);
  408. !     if (const_flag)
  409. !       string_append (&decl, " const");
  410.         }
  411. +       break;
  412.       }
  413.   
  414.     for (i = 0; i < ntypes; i++)
  415. ***************
  416. *** 686,692 ****
  417.       case 'Q':
  418.         n = (*type)[1] - '0';
  419.         if (n < 0 || n > 9)
  420. !         success = 0;
  421.         *type += 2;
  422.         while (n-- > 0)
  423.           do_type (type, result);
  424. --- 559,568 ----
  425.       case 'Q':
  426.         n = (*type)[1] - '0';
  427.         if (n < 0 || n > 9)
  428. !         {
  429. !           success = 0;
  430. !           break;
  431. !         }
  432.         *type += 2;
  433.         while (n-- > 0)
  434.           do_type (type, result);
  435. ***************
  436. *** 842,850 ****
  437.       }
  438.   }
  439.   
  440. ! int
  441.   do_cuv_prefix (type, result, non_empty)
  442. !      char **type;
  443.        string* result;
  444.        int* non_empty;
  445.   {
  446. --- 718,726 ----
  447.       }
  448.   }
  449.   
  450. ! static int
  451.   do_cuv_prefix (type, result, non_empty)
  452. !      const char **type;
  453.        string* result;
  454.        int* non_empty;
  455.   {
  456. ***************
  457. *** 887,895 ****
  458.     return success;
  459.   }
  460.   
  461. ! int
  462.   do_builtin_type (type, result, non_empty)
  463. !      char **type;
  464.        string* result;
  465.        int *non_empty;
  466.   {
  467. --- 763,771 ----
  468.     return success;
  469.   }
  470.   
  471. ! static int
  472.   do_builtin_type (type, result, non_empty)
  473. !      const char **type;
  474.        string* result;
  475.        int *non_empty;
  476.   {
  477. ***************
  478. *** 991,996 ****
  479. --- 867,890 ----
  480.         string_appendn (result, *type, n);
  481.         *type += n;
  482.         break;
  483. +     case 't':
  484. +       *type += 1;
  485. +       /* get template name */
  486. +       if (!get_simple_count (type, &n))
  487. +     {
  488. +       success = 0;
  489. +       break;
  490. +     }
  491. +       if (*non_empty)
  492. +     string_append (result, " ");
  493. +       string_appendn (result, *type, n);
  494. +       *type += n;
  495. +       string_append (result, "<");
  496. +       if (!do_template_args (type, result))
  497. +     success = 0;
  498. +       else
  499. +     string_append (result, ">");
  500. +       break;
  501.       default:
  502.         success = 0;
  503.         break;
  504. ***************
  505. *** 998,1003 ****
  506. --- 892,1045 ----
  507.     return success;
  508.   }
  509.   
  510. + static int
  511. + do_template_args (type, result)
  512. +      const char **type;
  513. +      string *result;
  514. + {
  515. +   int r, i;
  516. + 
  517. +   string temp;
  518. +   int need_comma = 0;
  519. +   int success;
  520. + 
  521. +   /* get size of template parameter list */
  522. +   if (!get_count (type, &r))
  523. +     return 0;
  524. +   for (i = 0; i < r; i++)
  525. +     {
  526. +       if (need_comma)
  527. +     string_append (result, ", ");
  528. +       /* Z for type parameters */
  529. +       if (**type == 'Z')
  530. +     {
  531. +       *type += 1;
  532. + 
  533. +       success = do_type (type, &temp);
  534. +       if (success)
  535. +         string_appends (result, &temp);
  536. +       string_delete(&temp);
  537. +       if (!success)
  538. +         break;
  539. +     }
  540. +       /* otherwise, value parameter */
  541. +       else
  542. +     {
  543. +       const char *old_p  = *type;
  544. +       int is_pointer = 0;
  545. +       int is_real = 0;
  546. +       int is_integral = 0;
  547. +       int done = 0;
  548. + 
  549. +       success = do_type (type, &temp);
  550. +       if (success)
  551. +         string_appends (result, &temp);
  552. +       string_delete(&temp);
  553. +       if (!success)
  554. +         break;
  555. +       string_append (result, "=");
  556. +       while (*old_p && !done)
  557. +         {    
  558. +           switch (*old_p)
  559. +         {
  560. +         case 'P':
  561. +         case 'R':
  562. +           done = is_pointer = 1;
  563. +           break;
  564. +         case 'C':    /* const */
  565. +         case 'U':    /* unsigned */
  566. +         case 'V':    /* volatile */
  567. +         case 'F':    /* function */
  568. +         case 'M':    /* member function */
  569. +         case 'O':    /* ??? */
  570. +           old_p++;
  571. +           continue;
  572. +         case 'Q':    /* repetition of following */
  573. +         case 'T':    /* remembered type */
  574. +           abort();
  575. +           break;
  576. +         case 'v':    /* void */
  577. +           abort();
  578. +           break;
  579. +         case 'x':    /* long long */
  580. +         case 'l':    /* long */
  581. +         case 'i':    /* int */
  582. +         case 's':    /* short */
  583. +         case 'c':    /* char */
  584. +           done = is_integral = 1;
  585. +           break;
  586. +         case 'r':    /* long double */
  587. +         case 'd':    /* double */
  588. +         case 'f':    /* float */
  589. +           done = is_real = 1;
  590. +           break;
  591. +         default:
  592. +           abort();
  593. +         }
  594. +         }
  595. +       if (is_integral)
  596. +         {
  597. +           if (**type == 'm')
  598. +         {
  599. +           string_appendn (result, "-", 1);
  600. +           *type++;
  601. +         }
  602. +           while (isdigit (**type))    
  603. +         {
  604. +           string_appendn (result, *type, 1);
  605. +           *type++;
  606. +         }
  607. +         }
  608. +       else if (is_real)
  609. +         {
  610. +           if (**type == 'm')
  611. +         {
  612. +           string_appendn (result, "-", 1);
  613. +           *type++;
  614. +         }
  615. +           while (isdigit (**type))    
  616. +         {
  617. +           string_appendn (result, *type, 1);
  618. +           *type++;
  619. +         }
  620. +           if (**type == '.')    /* fraction */
  621. +         {
  622. +           string_appendn (result, ".", 1);
  623. +           *type++;
  624. +           while (isdigit (**type))    
  625. +             {
  626. +               string_appendn (result, *type, 1);
  627. +               *type++;
  628. +             }
  629. +         }
  630. +           if (**type == 'e')    /* exponent */
  631. +         {
  632. +           string_appendn (result, "e", 1);
  633. +           *type++;
  634. +           while (isdigit (**type))    
  635. +             {
  636. +               string_appendn (result, *type, 1);
  637. +               *type++;
  638. +             }
  639. +         }
  640. +         }
  641. +       else if (is_pointer)
  642. +         {
  643. +           int symbol_len;
  644. + 
  645. +           if (!get_count (type, &symbol_len))
  646. +         {
  647. +           success = 0;
  648. +           break;
  649. +         }
  650. +           string_appendn (result, *type, symbol_len);
  651. +           *type += symbol_len;
  652. +         }
  653. +     }
  654. +       need_comma = 1;
  655. +     }
  656. + }
  657. + 
  658.   /* `result' will be initialised in do_type; it will be freed on failure */
  659.   
  660.   static int
  661. ***************
  662. *** 1321,1327 ****
  663.     string_prependn (p, s, strlen (s));
  664.   }
  665.   
  666. - #if 0
  667.   static void
  668.   string_prepends (p, s)
  669.        string *p, *s;
  670. --- 1363,1368 ----
  671. ***************
  672. *** 1330,1336 ****
  673.       return;
  674.     string_prependn (p, s->b, s->p - s->b);
  675.   }
  676. - #endif
  677.   
  678.   static void
  679.   string_prependn (p, s, n)
  680. --- 1371,1376 ----
  681.