Merge branch 'vendor/GCC50' - gcc 5.0 snapshot 1 FEB 2015
[dragonfly.git] / contrib / gcc-5.0 / gcc / tree-browser.c
1 /* Tree browser.
2    Copyright (C) 2002-2015 Free Software Foundation, Inc.
3    Contributed by Sebastian Pop <s.pop@laposte.net>
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3.  If not see
19 <http://www.gnu.org/licenses/>.  */
20
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "hash-table.h"
25 #include "hash-set.h"
26 #include "machmode.h"
27 #include "vec.h"
28 #include "double-int.h"
29 #include "input.h"
30 #include "alias.h"
31 #include "symtab.h"
32 #include "options.h"
33 #include "wide-int.h"
34 #include "inchash.h"
35 #include "tree.h"
36 #include "tree-pretty-print.h"
37 #include "print-tree.h"
38
39 #define TB_OUT_FILE stdout
40 #define TB_IN_FILE stdin
41 #define TB_NIY fprintf (TB_OUT_FILE, "Sorry this command is not yet implemented.\n")
42 #define TB_WF fprintf (TB_OUT_FILE, "Warning, this command failed.\n")
43
44 /* Structures for handling Tree Browser's commands.  */
45 #define DEFTBCODE(COMMAND, STRING, HELP)   COMMAND,
46 enum TB_Comm_code {
47 #include "tree-browser.def"
48   TB_UNUSED_COMMAND
49 };
50 #undef DEFTBCODE
51 typedef enum TB_Comm_code TB_CODE;
52
53 struct tb_command {
54   const char *help_msg;
55   const char *comm_text;
56   size_t comm_len;
57   TB_CODE comm_code;
58 };
59
60 #define DEFTBCODE(code, str, help) { help, str, sizeof (str) - 1, code },
61 static const struct tb_command tb_commands[] =
62 {
63 #include "tree-browser.def"
64 };
65 #undef DEFTBCODE
66
67 #define TB_COMMAND_LEN(N) (tb_commands[N].comm_len)
68 #define TB_COMMAND_TEXT(N) (tb_commands[N].comm_text)
69 #define TB_COMMAND_CODE(N) (tb_commands[N].comm_code)
70 #define TB_COMMAND_HELP(N) (tb_commands[N].help_msg)
71
72
73 /* Next structure is for parsing TREE_CODEs.  */
74 struct tb_tree_code {
75   enum tree_code code;
76   const char *code_string;
77   size_t code_string_len;
78 };
79
80 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) { SYM, STRING, sizeof (STRING) - 1 },
81 #define END_OF_BASE_TREE_CODES \
82   { LAST_AND_UNUSED_TREE_CODE, "@dummy", sizeof ("@dummy") - 1 },
83 static const struct tb_tree_code tb_tree_codes[] =
84 {
85 #include "all-tree.def"
86 };
87 #undef DEFTREECODE
88 #undef END_OF_BASE_TREE_CODES
89
90 #define TB_TREE_CODE(N) (tb_tree_codes[N].code)
91 #define TB_TREE_CODE_TEXT(N) (tb_tree_codes[N].code_string)
92 #define TB_TREE_CODE_LEN(N) (tb_tree_codes[N].code_string_len)
93
94
95 /* Function declarations.  */
96
97 static long TB_getline (char **, long *, FILE *);
98 static TB_CODE TB_get_command (char *);
99 static enum tree_code TB_get_tree_code (char *);
100 static tree find_node_with_code (tree *, int *, void *);
101 static tree store_child_info (tree *, int *, void *);
102 static void TB_update_up (tree);
103 static tree TB_current_chain_node (tree);
104 static tree TB_prev_expr (tree);
105 static tree TB_next_expr (tree);
106 static tree TB_up_expr (tree);
107 static tree TB_first_in_bind (tree);
108 static tree TB_last_in_bind (tree);
109 static tree TB_history_prev (void);
110
111 /* FIXME: To be declared in a .h file.  */
112 void browse_tree (tree);
113
114 /* Hashtable helpers.  */
115 struct tree_upper_hasher : pointer_hash<tree_node>
116 {
117   static inline bool equal (const value_type &, const compare_type &);
118 };
119
120 inline bool
121 tree_upper_hasher::equal (const value_type &parent, const compare_type &node)
122 {
123   if (parent == NULL || node == NULL)
124     return 0;
125
126   if (EXPR_P (parent))
127     {
128       int n = TREE_OPERAND_LENGTH (parent);
129       int i;
130       for (i = 0; i < n; i++)
131         if (node == TREE_OPERAND (parent, i))
132           return true;
133     }
134   return false;
135 }
136
137 /* Static variables.  */
138 static hash_table<tree_upper_hasher> *TB_up_ht;
139 static vec<tree, va_gc> *TB_history_stack;
140 static int TB_verbose = 1;
141
142
143 /* Entry point in the Tree Browser.  */
144
145 void
146 browse_tree (tree begin)
147 {
148   tree head;
149   TB_CODE tbc = TB_UNUSED_COMMAND;
150   ssize_t rd;
151   char *input = NULL;
152   long input_size = 0;
153
154   fprintf (TB_OUT_FILE, "\nTree Browser\n");
155
156 #define TB_SET_HEAD(N) do {                                           \
157   vec_safe_push (TB_history_stack, N);                                \
158   head = N;                                                           \
159   if (TB_verbose)                                                     \
160     if (head)                                                         \
161       {                                                               \
162         print_generic_expr (TB_OUT_FILE, head, 0);                    \
163         fprintf (TB_OUT_FILE, "\n");                                  \
164       }                                                               \
165 } while (0)
166
167   TB_SET_HEAD (begin);
168
169   /* Store in a hashtable information about previous and upper statements.  */
170   {
171     TB_up_ht = new hash_table<tree_upper_hasher> (1023);
172     TB_update_up (head);
173   }
174
175   while (24)
176     {
177       fprintf (TB_OUT_FILE, "TB> ");
178       rd = TB_getline (&input, &input_size, TB_IN_FILE);
179
180       if (rd == -1)
181         /* EOF.  */
182         goto ret;
183
184       if (rd != 1)
185         /* Get a new command.  Otherwise the user just pressed enter, and thus
186            she expects the last command to be reexecuted.  */
187         tbc = TB_get_command (input);
188
189       switch (tbc)
190         {
191         case TB_UPDATE_UP:
192           TB_update_up (head);
193           break;
194
195         case TB_MAX:
196           if (head && (INTEGRAL_TYPE_P (head)
197                        || TREE_CODE (head) == REAL_TYPE
198                        || TREE_CODE (head) == FIXED_POINT_TYPE))
199             TB_SET_HEAD (TYPE_MAX_VALUE (head));
200           else
201             TB_WF;
202           break;
203
204         case TB_MIN:
205           if (head && (INTEGRAL_TYPE_P (head)
206                        || TREE_CODE (head) == REAL_TYPE
207                        || TREE_CODE (head) == FIXED_POINT_TYPE))
208             TB_SET_HEAD (TYPE_MIN_VALUE (head));
209           else
210             TB_WF;
211           break;
212
213         case TB_ELT:
214           if (head && TREE_CODE (head) == TREE_VEC)
215             {
216               /* This command takes another argument: the element number:
217                  for example "elt 1".  */
218               TB_NIY;
219             }
220           else if (head && TREE_CODE (head) == VECTOR_CST)
221             {
222               /* This command takes another argument: the element number:
223                  for example "elt 1".  */
224               TB_NIY;
225             }
226           else
227             TB_WF;
228           break;
229
230         case TB_VALUE:
231           if (head && TREE_CODE (head) == TREE_LIST)
232             TB_SET_HEAD (TREE_VALUE (head));
233           else
234             TB_WF;
235           break;
236
237         case TB_PURPOSE:
238           if (head && TREE_CODE (head) == TREE_LIST)
239             TB_SET_HEAD (TREE_PURPOSE (head));
240           else
241             TB_WF;
242           break;
243
244         case TB_IMAG:
245           if (head && TREE_CODE (head) == COMPLEX_CST)
246             TB_SET_HEAD (TREE_IMAGPART (head));
247           else
248             TB_WF;
249           break;
250
251         case TB_REAL:
252           if (head && TREE_CODE (head) == COMPLEX_CST)
253             TB_SET_HEAD (TREE_REALPART (head));
254           else
255             TB_WF;
256           break;
257
258         case TB_BLOCK:
259           if (head && TREE_CODE (head) == BIND_EXPR)
260             TB_SET_HEAD (TREE_OPERAND (head, 2));
261           else
262             TB_WF;
263           break;
264
265         case TB_SUBBLOCKS:
266           if (head && TREE_CODE (head) == BLOCK)
267             TB_SET_HEAD (BLOCK_SUBBLOCKS (head));
268           else
269             TB_WF;
270           break;
271
272         case TB_SUPERCONTEXT:
273           if (head && TREE_CODE (head) == BLOCK)
274             TB_SET_HEAD (BLOCK_SUPERCONTEXT (head));
275           else
276             TB_WF;
277           break;
278
279         case TB_VARS:
280           if (head && TREE_CODE (head) == BLOCK)
281             TB_SET_HEAD (BLOCK_VARS (head));
282           else if (head && TREE_CODE (head) == BIND_EXPR)
283             TB_SET_HEAD (TREE_OPERAND (head, 0));
284           else
285             TB_WF;
286           break;
287
288         case TB_REFERENCE_TO_THIS:
289           if (head && TYPE_P (head))
290             TB_SET_HEAD (TYPE_REFERENCE_TO (head));
291           else
292             TB_WF;
293           break;
294
295         case TB_POINTER_TO_THIS:
296           if (head && TYPE_P (head))
297             TB_SET_HEAD (TYPE_POINTER_TO (head));
298           else
299             TB_WF;
300           break;
301
302         case TB_BASETYPE:
303           if (head && TREE_CODE (head) == OFFSET_TYPE)
304             TB_SET_HEAD (TYPE_OFFSET_BASETYPE (head));
305           else
306             TB_WF;
307           break;
308
309         case TB_ARG_TYPES:
310           if (head && (TREE_CODE (head) == FUNCTION_TYPE
311                        || TREE_CODE (head) == METHOD_TYPE))
312             TB_SET_HEAD (TYPE_ARG_TYPES (head));
313           else
314             TB_WF;
315           break;
316
317         case TB_METHOD_BASE_TYPE:
318           if (head && (TREE_CODE (head) == FUNCTION_TYPE
319                        || TREE_CODE (head) == METHOD_TYPE)
320               && TYPE_METHOD_BASETYPE (head))
321             TB_SET_HEAD (TYPE_METHOD_BASETYPE (head));
322           else
323             TB_WF;
324           break;
325
326         case TB_FIELDS:
327           if (head && (TREE_CODE (head) == RECORD_TYPE
328                        || TREE_CODE (head) == UNION_TYPE
329                        || TREE_CODE (head) == QUAL_UNION_TYPE))
330             TB_SET_HEAD (TYPE_FIELDS (head));
331           else
332             TB_WF;
333           break;
334
335         case TB_DOMAIN:
336           if (head && TREE_CODE (head) == ARRAY_TYPE)
337             TB_SET_HEAD (TYPE_DOMAIN (head));
338           else
339             TB_WF;
340           break;
341
342         case TB_VALUES:
343           if (head && TREE_CODE (head) == ENUMERAL_TYPE)
344             TB_SET_HEAD (TYPE_VALUES (head));
345           else
346             TB_WF;
347           break;
348
349         case TB_ARG_TYPE:
350           if (head && TREE_CODE (head) == PARM_DECL)
351             TB_SET_HEAD (DECL_ARG_TYPE (head));
352           else
353             TB_WF;
354           break;
355
356         case TB_INITIAL:
357           if (head && DECL_P (head))
358             TB_SET_HEAD (DECL_INITIAL (head));
359           else
360             TB_WF;
361           break;
362
363         case TB_RESULT:
364           if (head && DECL_P (head))
365             TB_SET_HEAD (DECL_RESULT_FLD (head));
366           else
367             TB_WF;
368           break;
369
370         case TB_ARGUMENTS:
371           if (head && DECL_P (head))
372             TB_SET_HEAD (DECL_ARGUMENTS (head));
373           else
374             TB_WF;
375           break;
376
377         case TB_ABSTRACT_ORIGIN:
378           if (head && DECL_P (head))
379             TB_SET_HEAD (DECL_ABSTRACT_ORIGIN (head));
380           else if (head && TREE_CODE (head) == BLOCK)
381             TB_SET_HEAD (BLOCK_ABSTRACT_ORIGIN (head));
382           else
383             TB_WF;
384           break;
385
386         case TB_ATTRIBUTES:
387           if (head && DECL_P (head))
388             TB_SET_HEAD (DECL_ATTRIBUTES (head));
389           else if (head && TYPE_P (head))
390             TB_SET_HEAD (TYPE_ATTRIBUTES (head));
391           else
392             TB_WF;
393           break;
394
395         case TB_CONTEXT:
396           if (head && DECL_P (head))
397             TB_SET_HEAD (DECL_CONTEXT (head));
398           else if (head && TYPE_P (head)
399                    && TYPE_CONTEXT (head))
400             TB_SET_HEAD (TYPE_CONTEXT (head));
401           else
402             TB_WF;
403           break;
404
405         case TB_OFFSET:
406           if (head && TREE_CODE (head) == FIELD_DECL)
407             TB_SET_HEAD (DECL_FIELD_OFFSET (head));
408           else
409             TB_WF;
410           break;
411
412         case TB_BIT_OFFSET:
413           if (head && TREE_CODE (head) == FIELD_DECL)
414             TB_SET_HEAD (DECL_FIELD_BIT_OFFSET (head));
415           else
416             TB_WF;
417           break;
418
419         case TB_UNIT_SIZE:
420           if (head && DECL_P (head))
421             TB_SET_HEAD (DECL_SIZE_UNIT (head));
422           else if (head && TYPE_P (head))
423             TB_SET_HEAD (TYPE_SIZE_UNIT (head));
424           else
425             TB_WF;
426           break;
427
428         case TB_SIZE:
429           if (head && DECL_P (head))
430             TB_SET_HEAD (DECL_SIZE (head));
431           else if (head && TYPE_P (head))
432             TB_SET_HEAD (TYPE_SIZE (head));
433           else
434             TB_WF;
435           break;
436
437         case TB_TYPE:
438           if (head && TREE_TYPE (head))
439             TB_SET_HEAD (TREE_TYPE (head));
440           else
441             TB_WF;
442           break;
443
444         case TB_DECL_SAVED_TREE:
445           if (head && TREE_CODE (head) == FUNCTION_DECL
446               && DECL_SAVED_TREE (head))
447             TB_SET_HEAD (DECL_SAVED_TREE (head));
448           else
449             TB_WF;
450           break;
451
452         case TB_BODY:
453           if (head && TREE_CODE (head) == BIND_EXPR)
454             TB_SET_HEAD (TREE_OPERAND (head, 1));
455           else
456             TB_WF;
457           break;
458
459         case TB_CHILD_0:
460           if (head && EXPR_P (head) && TREE_OPERAND (head, 0))
461             TB_SET_HEAD (TREE_OPERAND (head, 0));
462           else
463             TB_WF;
464           break;
465
466         case TB_CHILD_1:
467           if (head && EXPR_P (head) && TREE_OPERAND (head, 1))
468             TB_SET_HEAD (TREE_OPERAND (head, 1));
469           else
470             TB_WF;
471           break;
472
473         case TB_CHILD_2:
474           if (head && EXPR_P (head) && TREE_OPERAND (head, 2))
475             TB_SET_HEAD (TREE_OPERAND (head, 2));
476           else
477             TB_WF;
478           break;
479
480         case TB_CHILD_3:
481           if (head && EXPR_P (head) && TREE_OPERAND (head, 3))
482             TB_SET_HEAD (TREE_OPERAND (head, 3));
483           else
484             TB_WF;
485           break;
486
487         case TB_PRINT:
488           if (head)
489             debug_tree (head);
490           else
491             TB_WF;
492           break;
493
494         case TB_PRETTY_PRINT:
495           if (head)
496             {
497               print_generic_stmt (TB_OUT_FILE, head, 0);
498               fprintf (TB_OUT_FILE, "\n");
499             }
500           else
501             TB_WF;
502           break;
503
504         case TB_SEARCH_NAME:
505
506           break;
507
508         case TB_SEARCH_CODE:
509           {
510             enum tree_code code;
511             char *arg_text;
512
513             arg_text = strchr (input, ' ');
514             if (arg_text == NULL)
515               {
516                 fprintf (TB_OUT_FILE, "First argument is missing.  This isn't a valid search command.  \n");
517                 break;
518               }
519             code = TB_get_tree_code (arg_text + 1);
520
521             /* Search in the subtree a node with the given code.  */
522             {
523               tree res;
524
525               res = walk_tree (&head, find_node_with_code, &code, NULL);
526               if (res == NULL_TREE)
527                 {
528                   fprintf (TB_OUT_FILE, "There's no node with this code (reachable via the walk_tree function from this node).\n");
529                 }
530               else
531                 {
532                   fprintf (TB_OUT_FILE, "Achoo!  I got this node in the tree.\n");
533                   TB_SET_HEAD (res);
534                 }
535             }
536             break;
537           }
538
539 #define TB_MOVE_HEAD(FCT) do {       \
540   if (head)                          \
541     {                                \
542       tree t;                        \
543       t = FCT (head);                \
544       if (t)                         \
545         TB_SET_HEAD (t);             \
546       else                           \
547         TB_WF;                       \
548     }                                \
549   else                               \
550     TB_WF;                           \
551 } while (0)
552
553         case TB_FIRST:
554           TB_MOVE_HEAD (TB_first_in_bind);
555           break;
556
557         case TB_LAST:
558           TB_MOVE_HEAD (TB_last_in_bind);
559           break;
560
561         case TB_UP:
562           TB_MOVE_HEAD (TB_up_expr);
563           break;
564
565         case TB_PREV:
566           TB_MOVE_HEAD (TB_prev_expr);
567           break;
568
569         case TB_NEXT:
570           TB_MOVE_HEAD (TB_next_expr);
571           break;
572
573         case TB_HPREV:
574           /* This command is a little bit special, since it deals with history
575              stack.  For this reason it should keep the "head = ..." statement
576              and not use TB_MOVE_HEAD.  */
577           if (head)
578             {
579               tree t;
580               t = TB_history_prev ();
581               if (t)
582                 {
583                   head = t;
584                   if (TB_verbose)
585                     {
586                       print_generic_expr (TB_OUT_FILE, head, 0);
587                       fprintf (TB_OUT_FILE, "\n");
588                     }
589                 }
590               else
591                 TB_WF;
592             }
593           else
594             TB_WF;
595           break;
596
597         case TB_CHAIN:
598           /* Don't go further if it's the last node in this chain.  */
599           if (head && TREE_CODE (head) == BLOCK)
600             TB_SET_HEAD (BLOCK_CHAIN (head));
601           else if (head && TREE_CHAIN (head))
602             TB_SET_HEAD (TREE_CHAIN (head));
603           else
604             TB_WF;
605           break;
606
607         case TB_FUN:
608           /* Go up to the current function declaration.  */
609           TB_SET_HEAD (current_function_decl);
610           fprintf (TB_OUT_FILE, "Current function declaration.\n");
611           break;
612
613         case TB_HELP:
614           /* Display a help message.  */
615           {
616             int i;
617             fprintf (TB_OUT_FILE, "Possible commands are:\n\n");
618             for (i = 0; i < TB_UNUSED_COMMAND; i++)
619               {
620                 fprintf (TB_OUT_FILE, "%20s  -  %s\n", TB_COMMAND_TEXT (i), TB_COMMAND_HELP (i));
621               }
622           }
623           break;
624
625         case TB_VERBOSE:
626           if (TB_verbose == 0)
627             {
628               TB_verbose = 1;
629               fprintf (TB_OUT_FILE, "Verbose on.\n");
630             }
631           else
632             {
633               TB_verbose = 0;
634               fprintf (TB_OUT_FILE, "Verbose off.\n");
635             }
636           break;
637
638         case TB_EXIT:
639         case TB_QUIT:
640           /* Just exit from this function.  */
641           goto ret;
642
643         default:
644           TB_NIY;
645         }
646     }
647
648  ret:;
649   delete TB_up_ht;
650   TB_up_ht = NULL;
651   return;
652 }
653
654
655 /* Search the first node in this BIND_EXPR.  */
656
657 static tree
658 TB_first_in_bind (tree node)
659 {
660   tree t;
661
662   if (node == NULL_TREE)
663     return NULL_TREE;
664
665   while ((t = TB_prev_expr (node)))
666     node = t;
667
668   return node;
669 }
670
671 /* Search the last node in this BIND_EXPR.  */
672
673 static tree
674 TB_last_in_bind (tree node)
675 {
676   tree t;
677
678   if (node == NULL_TREE)
679     return NULL_TREE;
680
681   while ((t = TB_next_expr (node)))
682     node = t;
683
684   return node;
685 }
686
687 /* Search the parent expression for this node.  */
688
689 static tree
690 TB_up_expr (tree node)
691 {
692   tree res;
693   if (node == NULL_TREE)
694     return NULL_TREE;
695
696   res = TB_up_ht->find (node);
697   return res;
698 }
699
700 /* Search the previous expression in this BIND_EXPR.  */
701
702 static tree
703 TB_prev_expr (tree node)
704 {
705   node = TB_current_chain_node (node);
706
707   if (node == NULL_TREE)
708     return NULL_TREE;
709
710   node = TB_up_expr (node);
711   if (node && TREE_CODE (node) == COMPOUND_EXPR)
712     return node;
713   else
714     return NULL_TREE;
715 }
716
717 /* Search the next expression in this BIND_EXPR.  */
718
719 static tree
720 TB_next_expr (tree node)
721 {
722   node = TB_current_chain_node (node);
723
724   if (node == NULL_TREE)
725     return NULL_TREE;
726
727   node = TREE_OPERAND (node, 1);
728   return node;
729 }
730
731 static tree
732 TB_current_chain_node (tree node)
733 {
734   if (node == NULL_TREE)
735     return NULL_TREE;
736
737   if (TREE_CODE (node) == COMPOUND_EXPR)
738     return node;
739
740   node = TB_up_expr (node);
741   if (node)
742     {
743       if (TREE_CODE (node) == COMPOUND_EXPR)
744         return node;
745
746       node = TB_up_expr (node);
747       if (TREE_CODE (node) == COMPOUND_EXPR)
748         return node;
749     }
750
751   return NULL_TREE;
752 }
753
754 /* For each node store in its children nodes that the current node is their
755    parent.  This function is used by walk_tree.  */
756
757 static tree
758 store_child_info (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
759                   void *data ATTRIBUTE_UNUSED)
760 {
761   tree node;
762   tree_node **slot;
763
764   node = *tp;
765
766   /* 'node' is the parent of 'TREE_OPERAND (node, *)'.  */
767   if (EXPR_P (node))
768     {
769       int n = TREE_OPERAND_LENGTH (node);
770       int i;
771       for (i = 0; i < n; i++)
772         {
773           tree op = TREE_OPERAND (node, i);
774           slot = TB_up_ht->find_slot (op, INSERT);
775           *slot = node;
776         }
777     }
778
779   /* Never stop walk_tree.  */
780   return NULL_TREE;
781 }
782
783 /* Update information about upper expressions in the hash table.  */
784
785 static void
786 TB_update_up (tree node)
787 {
788   while (node)
789     {
790       walk_tree (&node, store_child_info, NULL, NULL);
791
792       /* Walk function's body.  */
793       if (TREE_CODE (node) == FUNCTION_DECL)
794         if (DECL_SAVED_TREE (node))
795           walk_tree (&DECL_SAVED_TREE (node), store_child_info, NULL, NULL);
796
797       /* Walk rest of the chain.  */
798       node = TREE_CHAIN (node);
799     }
800   fprintf (TB_OUT_FILE, "Up/prev expressions updated.\n");
801 }
802
803 /* Parse the input string for determining the command the user asked for.  */
804
805 static TB_CODE
806 TB_get_command (char *input)
807 {
808   unsigned int mn, size_tok;
809   int comp;
810   char *space;
811
812   space = strchr (input, ' ');
813   if (space != NULL)
814     size_tok = strlen (input) - strlen (space);
815   else
816     size_tok = strlen (input) - 1;
817
818   for (mn = 0; mn < TB_UNUSED_COMMAND; mn++)
819     {
820       if (size_tok != TB_COMMAND_LEN (mn))
821         continue;
822
823       comp = memcmp (input, TB_COMMAND_TEXT (mn), TB_COMMAND_LEN (mn));
824       if (comp == 0)
825         /* Here we just determined the command.  If this command takes
826            an argument, then the argument is determined later.  */
827         return TB_COMMAND_CODE (mn);
828     }
829
830   /* Not a valid command.  */
831   return TB_UNUSED_COMMAND;
832 }
833
834 /* Parse the input string for determining the tree code.  */
835
836 static enum tree_code
837 TB_get_tree_code (char *input)
838 {
839   unsigned int mn, size_tok;
840   int comp;
841   char *space;
842
843   space = strchr (input, ' ');
844   if (space != NULL)
845     size_tok = strlen (input) - strlen (space);
846   else
847     size_tok = strlen (input) - 1;
848
849   for (mn = 0; mn < LAST_AND_UNUSED_TREE_CODE; mn++)
850     {
851       if (size_tok != TB_TREE_CODE_LEN (mn))
852         continue;
853
854       comp = memcmp (input, TB_TREE_CODE_TEXT (mn), TB_TREE_CODE_LEN (mn));
855       if (comp == 0)
856         {
857           fprintf (TB_OUT_FILE, "%s\n", TB_TREE_CODE_TEXT (mn));
858           return TB_TREE_CODE (mn);
859         }
860     }
861
862   /* This isn't a valid code.  */
863   return LAST_AND_UNUSED_TREE_CODE;
864 }
865
866 /* Find a node with a given code.  This function is used as an argument to
867    walk_tree.  */
868
869 static tree
870 find_node_with_code (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
871                      void *data)
872 {
873   enum tree_code *code;
874   code = (enum tree_code *) data;
875   if (*code == TREE_CODE (*tp))
876     return *tp;
877
878   return NULL_TREE;
879 }
880
881 /* Returns a pointer to the last visited node.  */
882
883 static tree
884 TB_history_prev (void)
885 {
886   if (!vec_safe_is_empty (TB_history_stack))
887     {
888       tree last = TB_history_stack->last ();
889       TB_history_stack->pop ();
890       return last;
891     }
892   return NULL_TREE;
893 }
894
895 /* Read up to (and including) a '\n' from STREAM into *LINEPTR
896    (and null-terminate it). *LINEPTR is a pointer returned from malloc
897    (or NULL), pointing to *N characters of space.  It is realloc'd as
898    necessary.  Returns the number of characters read (not including the
899    null terminator), or -1 on error or EOF.
900    This function comes from sed (and is supposed to be a portable version
901    of getline).  */
902
903 static long
904 TB_getline (char **lineptr, long *n, FILE *stream)
905 {
906   char *line, *p;
907   long size, copy;
908
909   if (lineptr == NULL || n == NULL)
910     {
911       errno = EINVAL;
912       return -1;
913     }
914
915   if (ferror (stream))
916     return -1;
917
918   /* Make sure we have a line buffer to start with.  */
919   if (*lineptr == NULL || *n < 2) /* !seen and no buf yet need 2 chars.  */
920     {
921 #ifndef MAX_CANON
922 #define MAX_CANON       256
923 #endif
924       line = (char *) xrealloc (*lineptr, MAX_CANON);
925       if (line == NULL)
926         return -1;
927       *lineptr = line;
928       *n = MAX_CANON;
929     }
930
931   line = *lineptr;
932   size = *n;
933
934   copy = size;
935   p = line;
936
937   while (1)
938     {
939       long len;
940
941       while (--copy > 0)
942         {
943           register int c = getc (stream);
944           if (c == EOF)
945             goto lose;
946           else if ((*p++ = c) == '\n')
947             goto win;
948         }
949
950       /* Need to enlarge the line buffer.  */
951       len = p - line;
952       size *= 2;
953       line = (char *) xrealloc (line, size);
954       if (line == NULL)
955         goto lose;
956       *lineptr = line;
957       *n = size;
958       p = line + len;
959       copy = size - len;
960     }
961
962  lose:
963   if (p == *lineptr)
964     return -1;
965
966   /* Return a partial line since we got an error in the middle.  */
967  win:
968 #if defined(WIN32) || defined(_WIN32) || defined(__CYGWIN__) || defined(MSDOS)
969   if (p - 2 >= *lineptr && p[-2] == '\r')
970     p[-2] = p[-1], --p;
971 #endif
972   *p = '\0';
973   return p - *lineptr;
974 }