#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "linear.h"
#include "genC.h"
#include "text.h"
#include "text-util.h"
#include "ri.h"
#include "ri-util.h"
#include "prettyprint.h"
#include "misc.h"
#include "properties.h"

Include dependency graph for unstructured.c:

Functions
static void	decorate_trail (entity module, list trail, hash_table labels)

static text	text_trail (entity module, int margin, list trail, hash_table labels, list *ppdl)

static bool	control_in_trail_p (list l, control c)
	OK, a hash table could be used, as Pierre used too... More...

static bool	appears_first_in_trail (list trail, control c1, control c2)
	returns true if c1 is encountered before c2 in trail, or if c1 == c2 is encountered in trail, false is c2 is encountered first and c2 != c1, core dumps otherwise, if neither c1 nor c2 is in trail More...

static void	set_control_to_label (entity m, control c, hash_table h)
	set_control_to_label allocates label for the control node c in the module m. More...

static string	control_to_label_name (control c, hash_table h)

text	text_unstructured (entity module, const char label, int margin, unstructured u, int num, list ppdl)
	unstructured.c More...

static list	build_trail (list l, control c)
	Any heuristics can be used to build the trail, depth or width first, true or false branch first, lower statement numbering first or not, sorted by statement numbering (but some statements have no number...). More...

list	unstructured_to_trail (unstructured u)

void	dump_trail (list trail)

void	dump_control_to_label_name (hash_table h)

Function Documentation

◆ appears_first_in_trail()

static bool appears_first_in_trail	(	list	l,
		control	c1,
		control	c2
	)

static

returns true if c1 is encountered before c2 in trail, or if c1 == c2 is encountered in trail, false is c2 is encountered first and c2 != c1, core dumps otherwise, if neither c1 nor c2 is in trail

Definition at line 408 of file unstructured.c.

 {
     bool first = false;
     control c = control_undefined;
  
     MAPL(cc, {
         c = CONTROL(CAR(cc));
  
         if(c==c1) {
             first = true;
             break;
         }
         else if(c==c2) {
             first = false;
             break;
         }
     }, trail);
     pips_assert("At least one control should appear in trail", c==c1 || c==c2);
     return first;
 }

References CAR, CONTROL, control_undefined, MAPL, and pips_assert.

Referenced by decorate_trail(), and text_trail().

Here is the caller graph for this function:

◆ build_trail()

static list build_trail	(	list	l,
		control	c
	)

static

Any heuristics can be used to build the trail, depth or width first, true or false branch first, lower statement numbering first or not, sorted by statement numbering (but some statements have no number...).

No simple heuristics seems to be bullet proof.

The exit node must be last in the trace, or an extra node has to be added to reach the continuation of the unstructured (see text_trail()).

For CONS convenience, the list is built in reverse order (and reversed by the caller).

Do not add this artificial node to the trail, follow the left successors only

Add c to the trail if not already in

Follow the false branch in depth first, assuming that IF GOTO's mainly handle exceptions

Definition at line 167 of file unstructured.c.

 {
     control succ = control_undefined;
     int nsucc = 0;
  
     if(check_io_statement_p(control_statement(c)) &&
        !get_bool_property("PRETTYPRINT_CHECK_IO_STATEMENTS")) {
         /* Do not add this artificial node to the trail, follow the left
          * successors only
          */
         pips_assert("Must be a test statement",
                     instruction_test_p(statement_instruction(control_statement(c))));
         debug(3, "build_trail", "Skipping IO check %s",
               statement_identification(control_statement(c)));
         succ = CONTROL(CAR(CDR(control_successors(c))));
         debug(3, "build_trail", "False Successor: %s",
               statement_identification(control_statement(succ)));
         l = build_trail(l, succ);
         succ = CONTROL(CAR(control_successors(c)));
         debug(3, "build_trail", "True Successor: %s",
               statement_identification(control_statement(succ)));
         l = build_trail(l, succ);
     }
     else {
  
         nsucc = gen_length(control_successors(c));
  
         debug(3, "build_trail", "for %s with %d successors\n",
               statement_identification(control_statement(c)),
               nsucc);
         ifdebug(3) {
             int i = 1;
             MAPL(cs, {
                 statement ss = control_statement(CONTROL(CAR(cs)));
                 debug(3, "build_trail", "Successor %d: %s",
                       i++, statement_identification(ss));
             }, control_successors(c));
         }
     
         /* Add c to the trail if not already in */
         if(!control_in_trail_p(l, c)) {
             debug(3, "build_trail", "Add to trail %s",
                   statement_identification(control_statement(c)));
             l = CONS(CONTROL,c,l);
             switch(nsucc) {
             case 0:
                 break;
             case 1:
                 succ = CONTROL(CAR(control_successors(c)));
                 l = build_trail(l, succ);
                 break;
             case 2:
                 /* Follow the false branch in depth first, assuming that IF GOTO's 
                  * mainly handle exceptions */
                 succ = CONTROL(CAR(CDR(control_successors(c))));
                 l = build_trail(l, succ);
                 succ = CONTROL(CAR(control_successors(c)));
                 l = build_trail(l, succ);
                 break;
             default:
                 pips_internal_error("Too many successors (%d) for a control node",
                            nsucc);
             }
         }
         else {
             debug(3, "build_trail", "Already in trail %s",
                   statement_identification(control_statement(c)));
         }
     }
     return l;
 }

References CAR, CDR, check_io_statement_p(), CONS, CONTROL, control_in_trail_p(), control_statement, control_successors, control_undefined, debug(), gen_length(), get_bool_property(), ifdebug, instruction_test_p, MAPL, pips_assert, pips_internal_error, statement_identification(), and statement_instruction.

Referenced by unstructured_to_trail().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ control_in_trail_p()

static bool control_in_trail_p	(	list	l,
		control	c
	)

static

OK, a hash table could be used, as Pierre used too...

but the order is lost. You need both ordered and direct accesses. Easy to add later if too slow.

Definition at line 283 of file unstructured.c.

 {
     bool found = gen_find_eq(c, l) != gen_chunk_undefined;
     return found;
 }

References gen_chunk_undefined, and gen_find_eq().

Referenced by build_trail(), decorate_trail(), and unstructured_to_trail().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ control_to_label_name()

static string control_to_label_name	(	control	c,
		hash_table	h
	)

static

Definition at line 480 of file unstructured.c.

 {
     char* l;
     statement st = control_statement(c) ;
  
     if ((l = hash_get(h, (char *) c)) == HASH_UNDEFINED_VALUE) {
         debug(3, "control_to_label_name", "Retrieves no label for stmt %s\n",
               statement_identification(st));
         l = string_undefined;
     }
     else {
         debug(3, "control_to_label_name", "Retrieves label %s for stmt %s\n",
               l, statement_identification(st));
         l = strdup(local_name(l)+sizeof(LABEL_PREFIX)-1);
     }
  
     return l;
 }

References control_statement, debug(), hash_get(), HASH_UNDEFINED_VALUE, LABEL_PREFIX, local_name(), statement_identification(), strdup(), and string_undefined.

Referenced by text_trail().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decorate_trail()

static void decorate_trail	(	entity	module,
		list	trail,
		hash_table	labels
	)

static

No need for a label, it must be the exit node... Should be asserted The exit node may have two successors

The real successor is the false successor of the IO check

If the statement "really" has a continuation (e.g. not a STOP or a RETURN)

if(statement_does_return(control_statement(c)) && !(check_io_statement_p(control_statement(succ)) && !get_bool_property("PRETTYPRINT_CHECK_IO_STATEMENTS"))) {

the control successor is the textual successor

A label must be associated with the control successor

Is there a textual successor?

This may happen after restructuring

succ2 must be labelled

succ1 must be labelled

Both successors must be labelled

Both successors must be textual predecessors

Definition at line 290 of file unstructured.c.

 {
     list cc = NIL;
  
     pips_assert("trail cannot be empty", !ENDP(trail));
  
     for(cc=trail; !ENDP(cc); POP(cc)) {
         control c = CONTROL(CAR(cc));
         int nsucc = gen_length(control_successors(c));
  
         debug(3, "decorate_trail", "Processing statement %s with %d successors\n",
               statement_identification(control_statement(c)), nsucc);
  
         switch(nsucc) {
         case 0:
             /* No need for a label, it must be the exit node... Should be asserted
              * The exit node may have two successors
              */
             break;
         case 1: {
             control succ = CONTROL(CAR(control_successors(c)));
  
             if(check_io_statement_p(control_statement(succ)) &&
                  !get_bool_property("PRETTYPRINT_CHECK_IO_STATEMENTS")) {
               /* The real successor is the false successor of the IO check */
               succ = CONTROL(CAR(CDR(control_successors(succ))));
               if(check_io_statement_p(control_statement(succ)) &&
                  !get_bool_property("PRETTYPRINT_CHECK_IO_STATEMENTS")) {
                 /* The real successor is the false successor of the IO check */
                 succ = CONTROL(CAR(CDR(control_successors(succ))));
               }
               pips_assert("The successor is not a check io statement",
                           !check_io_statement_p(control_statement(succ)));
             }
  
             /* If the statement "really" has a continuation (e.g. not a STOP
              * or a RETURN)
              */
             /* if(statement_does_return(control_statement(c)) &&
                !(check_io_statement_p(control_statement(succ)) &&
                !get_bool_property("PRETTYPRINT_CHECK_IO_STATEMENTS"))) { */
             if(statement_does_return(control_statement(c))) {
                 if(!ENDP(CDR(cc))) {
                     control tsucc = CONTROL(CAR(CDR(cc)));
                     if(tsucc==succ) {
                         /* the control successor is the textual successor */
                         break;
                     }
                 }
                 /* A label must be associated with the control successor */
                 pips_assert("Successor must be in trail",
                             control_in_trail_p(trail, succ));
                 set_control_to_label(module, succ, labels);
             }
             break;
         }
         case 2: {
             control succ1 = CONTROL(CAR(control_successors(c)));
             control succ2 = CONTROL(CAR(CDR(control_successors(c))));
  
             debug(3, "decorate_trail", "Successor 1 %s",
                   statement_identification(control_statement(succ1)));
             debug(3, "decorate_trail", "Successor 2 %s",
                   statement_identification(control_statement(succ2)));
  
             /* Is there a textual successor? */
             if(!ENDP(CDR(cc))) {
                 control tsucc = CONTROL(CAR(CDR(cc)));
                 if(tsucc==succ1) {
                     if(tsucc==succ2) {
                         /* This may happen after restructuring */
                         ;
                     }
                     else {
                         /* succ2 must be labelled */
                         pips_assert("Successor 2 must be in trail",
                                     control_in_trail_p(trail, succ2));
                         set_control_to_label(module, succ2, labels);
                     }
                 }
                 else {
                     if(tsucc==succ2) {
                         /* succ1 must be labelled */
                         pips_assert("Successor 1 must be in trail",
                                     control_in_trail_p(trail, succ1));
                         set_control_to_label(module, succ1, labels);
                     }
                     else {
                         /* Both successors must be labelled */
                         pips_assert("Successor 1 must be in trail",
                                     control_in_trail_p(trail, succ1));
                         set_control_to_label(module, succ1, labels);
                         pips_assert("Successor 2 must be in trail",
                                     control_in_trail_p(trail, succ2));
                         set_control_to_label(module, succ2, labels);
                     }
                 }
             }
             else {
                 /* Both successors must be textual predecessors */
                 pips_assert("succ1 before c", appears_first_in_trail(trail, succ1, c));
                 pips_assert("succ2 before c", appears_first_in_trail(trail, succ2, c));
                 set_control_to_label(module, succ1, labels);
                 set_control_to_label(module, succ2, labels);
             }
             break;
         }
         default:
             pips_internal_error("Too many successors for a control node");
         }
     }
 }

References appears_first_in_trail(), CAR, CDR, check_io_statement_p(), CONTROL, control_in_trail_p(), control_statement, control_successors, debug(), ENDP, gen_length(), get_bool_property(), module, NIL, pips_assert, pips_internal_error, POP, set_control_to_label(), statement_does_return(), and statement_identification().

Referenced by text_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dump_control_to_label_name()

void dump_control_to_label_name ( hash_table h )

Definition at line 500 of file unstructured.c.

 {
     int i = 0;
  
     fprintf(stderr,"[dump_control_to_label_name] Begin\n");
     HASH_MAP(c,l,{
         fprintf(stderr, "Label %s -> %s", (char *) l,
                 (char *) statement_identification(control_statement((control) c)));
         i++;
     }, h);
     fprintf(stderr,"[dump_control_to_label_name] %d labels, end\n", i);
 }

References control_statement, fprintf(), HASH_MAP, and statement_identification().

Referenced by text_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dump_trail()

void dump_trail ( list trail )

Parameters

trail rail

Definition at line 263 of file unstructured.c.

 {
     if(ENDP(trail)) {
         fprintf(stderr, "[dump_trail] trail is empty\n");
     }
     else {
         fprintf(stderr, "[dump_trail] begin\n");
         MAPL(cc, {
             statement s = control_statement(CONTROL(CAR(cc)));
             fprintf(stderr, "[dump_trail] %s", statement_identification(s));
         }, trail);
         fprintf(stderr, "[dump_trail] end\n");
     }
 }

References CAR, CONTROL, control_statement, ENDP, fprintf(), MAPL, and statement_identification().

Referenced by c_unstructured(), and text_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_control_to_label()

static void set_control_to_label	(	entity	m,
		control	c,
		hash_table	h
	)

static

set_control_to_label allocates label for the control node c in the module m.

h maps controls to label names. Computes a new label name if necessary.

There is no guarantee that a label generated here appears eventually in the text produced.

There is no guarantee that a label generated here is jumped at.

memory leak in debug code: statement_identification().

Definition at line 441 of file unstructured.c.

 {
     char* l;
     statement st = control_statement(c) ;
  
     if ((l = hash_get(h, (char *) c)) == HASH_UNDEFINED_VALUE) {
         const char* label = entity_name( statement_to_label( st )) ;
         if(empty_global_label_p( label )) {
             char * lname = new_label_local_name(m);
             const char * module_name = 
                 entity_undefined_p(m) ?
                 GENERATED_LABEL_MODULE_NAME:
                 module_local_name(m);
                 
             asprintf(&l,"%s" MODULE_SEP_STRING "%s",module_name,lname);
             free(lname);
         }
         else {
             l=strdup(label);
         }
  
         /* memory leak in debug code: statement_identification(). */
         pips_debug(3, "Associates label %s to stmt %s\n",
                 l, statement_identification(st));
         hash_put(h, (char *) c, l) ;
     }
     else {
         debug(3, "set_control_to_label", "Retrieves label %s for stmt %s\n",
               l, statement_identification(st));
     }
  
     pips_assert("set_control_to_label", strcmp(local_name(l), LABEL_PREFIX) != 0) ;
     pips_assert("set_control_to_label", strcmp(local_name(l), "") != 0) ;
     pips_assert("set_control_to_label", strcmp(local_name(l), "=") != 0) ;
  
     return;
 }

References asprintf, control_statement, debug(), empty_global_label_p(), entity_name, entity_undefined_p, free(), GENERATED_LABEL_MODULE_NAME, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, LABEL_PREFIX, lname(), local_name(), module_local_name(), module_name(), MODULE_SEP_STRING, new_label_local_name(), pips_assert, pips_debug, statement_identification(), statement_to_label(), and strdup().

Referenced by decorate_trail().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ text_trail()

static text text_trail	(	entity	module,
		int	margin,
		list	trail,
		hash_table	labels,
		list *	ppdl
	)

static

Is a label needed?

Perform the very same tests as in decorate_trail() The successor may have a label but not need a GOTO to be reached.

Build the statement text with enclosing braces if necessary in C and skip parasitic continues

The real successor is the false successor of the IO check

Build the statement text with enclosing braces if necessary in C and skip parasitic continues

If the statement "really" has a continuation (e.g. not a STOP or a RETURN)

if(statement_does_return(st) && !(check_io_statement_p(control_statement(succ)) && !get_bool_property("PRETTYPRINT_CHECK_IO_STATEMENTS")) ) {

the control successor is the textual successor

A GOTO must be generated to reach the control successor

Is there a textual successor?

This may happen after restructuring

succ2 must be reached by GOTO

succ1 must be reached by GOTO

Both successors must be labelled

Both successors must be textual predecessors

Definition at line 513 of file unstructured.c.

                                                                                               {
   list cc = NIL;
   text r = make_text(NIL);
  
   pips_assert("trail cannot be empty", !ENDP(trail));
  
   for (cc = trail; !ENDP(cc); POP(cc)) {
     control c = CONTROL(CAR(cc));
     string l = string_undefined;
     int nsucc = gen_length(control_successors(c));
     statement st = control_statement(c);
  
     pips_debug(3, "Processing statement %s", statement_identification(st));
  
     /* Is a label needed? */
     if ((l = control_to_label_name(c, labels)) != string_undefined) {
       if (strcmp(l, label_local_name(statement_to_label(control_statement(c))))
           != 0) {
         list pc = NIL;
         switch (get_prettyprint_language_tag()) {
           case is_language_fortran:
           case is_language_fortran95:
             pc = CHAIN_SWORD(pc, "CONTINUE");
             break;
           case is_language_c:
             pc = CHAIN_SWORD(pc, ";");
             break;
           default:
             pips_internal_error("Language unknown !");
             break;
         }
         sentence s = make_sentence(is_sentence_unformatted,
                                    make_unformatted(NULL, 0, margin, pc));
         unformatted_label(sentence_unformatted(s)) = l;
         ADD_SENTENCE_TO_TEXT(r, s);
         pips_debug(3,
                    "Label %s generated for stmt %s\n",
                    l,
                    statement_identification(control_statement(c)));
       }
     }
  
     /* Perform the very same tests as in decorate_trail()
      * The successor may have a label but not need a GOTO to be reached.
      */
  
     switch(nsucc) {
     case 0: {
       /* Build the statement text with enclosing braces if necessary in
          C and skip parasitic continues */
       MERGE_TEXTS(r, text_statement_enclosed(module, margin, st, one_liner_p(st), true, ppdl));
     }
         break;
       case 1: {
         control succ = CONTROL(CAR(control_successors(c)));
  
         if (check_io_statement_p(control_statement(succ))
             && !get_bool_property("PRETTYPRINT_CHECK_IO_STATEMENTS")) {
           /* The real successor is the false successor of the IO check */
           succ = CONTROL(CAR(CDR(control_successors(succ))));
           if (check_io_statement_p(control_statement(succ))
               && !get_bool_property("PRETTYPRINT_CHECK_IO_STATEMENTS")) {
             /* The real successor is the false successor of the IO check */
             succ = CONTROL(CAR(CDR(control_successors(succ))));
           }
           pips_assert("The successor is not a check io statement",
               !check_io_statement_p(control_statement(succ)));
         }
  
         /* Build the statement text with enclosing braces if necessary in
            C and skip parasitic continues */
         list pdl = NIL;
         MERGE_TEXTS(r, text_statement_enclosed(module, margin, st, one_liner_p(st), true, &pdl));
         gen_free_list(pdl);
  
         /* If the statement "really" has a continuation (e.g. not a STOP
          * or a RETURN)
          */
         /* if(statement_does_return(st) &&
          !(check_io_statement_p(control_statement(succ)) &&
          !get_bool_property("PRETTYPRINT_CHECK_IO_STATEMENTS")) ) { */
         if (statement_does_return(st)) {
           if (!ENDP(CDR(cc))) {
             control tsucc = CONTROL(CAR(CDR(cc)));
             if (tsucc == succ) {
               /* the control successor is the textual successor */
               break;
             }
           }
           /* A GOTO must be generated to reach the control successor */
           l = control_to_label_name(succ, labels);
           pips_assert("Must be labelled", l!= string_undefined);
           ADD_SENTENCE_TO_TEXT(r, sentence_goto_label(module, NULL,
                   margin, l, 0));
         }
         break;
       }
       case 2: {
         control succ1 = CONTROL(CAR(control_successors(c)));
         control succ2 = CONTROL(CAR(CDR(control_successors(c))));
         instruction i = statement_instruction(st);
         test t = test_undefined;
         unformatted u = unformatted_undefined;
         list pc = NIL;
         sentence s = sentence_undefined;
         string comments = statement_comments(st);
         text r1 = make_text(NIL);
         bool no_endif = false;
  
         pips_assert("must be a test", instruction_test_p(i));
  
         MERGE_TEXTS(r, init_text_statement(module, margin, st));
         if (!string_undefined_p(comments)) {
           switch(get_prettyprint_language_tag()) {
           case is_language_fortran:
           case is_language_fortran95:
             ADD_SENTENCE_TO_TEXT(r, make_sentence(is_sentence_formatted,
                                                   strdup(comments)));
             break;
           case is_language_c: {
             text ct = C_comment_to_text(margin, comments);
             MERGE_TEXTS(r, ct);
           }
             break;
           default:
             pips_internal_error("Language unknown !");
             break;
           }
         }
  
         switch (get_prettyprint_language_tag()) {
           case is_language_fortran:
           case is_language_fortran95:
             pc = CHAIN_SWORD(NIL, "IF (");
             break;
           case is_language_c:
             pc = CHAIN_SWORD(NIL, "if (");
             break;
           default:
             pips_internal_error("Language unknown !");
             break;
         }
         t = instruction_test(i);
         pc = gen_nconc(pc, words_expression(test_condition(t), ppdl));
  
         /* Is there a textual successor? */
         if (!ENDP(CDR(cc))) {
           control tsucc = CONTROL(CAR(CDR(cc)));
           if (tsucc == succ1) {
             if (tsucc == succ2) {
               /* This may happen after restructuring */
               ;
             } else {
               /* succ2 must be reached by GOTO */
               l = control_to_label_name(succ2, labels);
               pips_assert("Must be labelled", l!= string_undefined);
               switch (get_prettyprint_language_tag()) {
                 case is_language_fortran:
                 case is_language_fortran95:
                   ADD_SENTENCE_TO_TEXT(r1,
                                        MAKE_ONE_WORD_SENTENCE(margin,"ELSE"));
                   break;
                 case is_language_c:
                   ADD_SENTENCE_TO_TEXT(r1, MAKE_ONE_WORD_SENTENCE(margin,"}"));
                   ADD_SENTENCE_TO_TEXT(r1, MAKE_ONE_WORD_SENTENCE(margin,
                                                                   "else {" ));
                   break;
                 default:
                   pips_internal_error("Language unknown !");
                   break;
               }
               ADD_SENTENCE_TO_TEXT(r1, sentence_goto_label(module, NULL,
                                                            margin+INDENTATION,
                                                            l, 0));
             }
           } else {
             if (tsucc == succ2) {
               /* succ1 must be reached by GOTO */
               l = control_to_label_name(succ1, labels);
               pips_assert("Must be labelled", l!= string_undefined);
               no_endif = true;
             } else {
               /* Both successors must be labelled */
               l = control_to_label_name(succ1, labels);
               pips_assert("Must be labelled", l!= string_undefined);
               ADD_SENTENCE_TO_TEXT(r1, sentence_goto_label(module, NULL,
                       margin+INDENTATION,
                       l, 0));
               switch (get_prettyprint_language_tag()) {
                 case is_language_fortran:
                 case is_language_fortran95:
                   ADD_SENTENCE_TO_TEXT(r1,
                                        MAKE_ONE_WORD_SENTENCE(margin,"ELSE"));
                   break;
                 case is_language_c:
                   ADD_SENTENCE_TO_TEXT(r1, MAKE_ONE_WORD_SENTENCE(margin,"}"));
                   ADD_SENTENCE_TO_TEXT(r1, MAKE_ONE_WORD_SENTENCE(margin,
                                                                   "else {" ));
                   break;
                 default:
                   pips_internal_error("Language unknown !");
                   break;
               }
               l = control_to_label_name(succ2, labels);
               pips_assert("Must be labelled", l!= string_undefined);
               ADD_SENTENCE_TO_TEXT(r1, sentence_goto_label(module, NULL,
                       margin+INDENTATION,
                       l, 0));
             }
           }
         } else {
           /* Both successors must be textual predecessors */
           pips_assert("succ1 before c", appears_first_in_trail(trail, succ1, c));
           pips_assert("succ1 before c", appears_first_in_trail(trail, succ2, c));
           l = control_to_label_name(succ1, labels);
           pips_assert("Must be labelled", l!= string_undefined);
           ADD_SENTENCE_TO_TEXT(r1, sentence_goto_label(module, NULL,
                   margin+INDENTATION,
                   l, 0));
           switch (get_prettyprint_language_tag()) {
             case is_language_fortran:
             case is_language_fortran95:
               ADD_SENTENCE_TO_TEXT(r1, MAKE_ONE_WORD_SENTENCE(margin,"ELSE"));
               break;
             case is_language_c:
               ADD_SENTENCE_TO_TEXT(r1, MAKE_ONE_WORD_SENTENCE(margin,"}"));
               ADD_SENTENCE_TO_TEXT(r1, MAKE_ONE_WORD_SENTENCE(margin,"else {" ));
               break;
             default:
               pips_internal_error("Language unknown !");
               break;
           }
           l = control_to_label_name(succ2, labels);
           pips_assert("Must be labelled", l!= string_undefined);
           ADD_SENTENCE_TO_TEXT(r1, sentence_goto_label(module, NULL,
                   margin+INDENTATION,
                   l, 0));
         }
  
         if (no_endif) {
           pc = CHAIN_SWORD(pc, ") ");
           pc = gen_nconc(pc, words_goto_label(l));
         } else {
           switch (get_prettyprint_language_tag()) {
             case is_language_fortran:
             case is_language_fortran95:
               pc = CHAIN_SWORD(pc, ") THEN");
               break;
             case is_language_c:
               pc = CHAIN_SWORD(pc, ") {");
               break;
             default:
               pips_internal_error("Language unknown !");
               break;
           }
         }
         u = make_unformatted(NULL, statement_number(st), margin, pc);
  
         if (!empty_global_label_p(entity_name( statement_label( st )))) {
           /*
            string ln = control_to_label_name(c, labels);
            if(string_undefined_p(ln)) {
            entity lab = statement_label(st);
            print_statement(st);
            pips_assert("c must have been encountered before", !string_undefined_p(ln));
            }
            unformatted_label(u) = strdup(ln);
            */
           unformatted_label(u) = strdup(label_local_name(statement_label(st)));
         }
  
         s = make_sentence(is_sentence_unformatted, u);
         ADD_SENTENCE_TO_TEXT(r, s);
         MERGE_TEXTS(r, r1);
         if (!no_endif) {
           switch (get_prettyprint_language_tag()) {
             case is_language_fortran:
             case is_language_fortran95:
               ADD_SENTENCE_TO_TEXT(r, MAKE_ONE_WORD_SENTENCE(margin, "ENDIF"));
               break;
             case is_language_c:
               ADD_SENTENCE_TO_TEXT(r, MAKE_ONE_WORD_SENTENCE(margin, "}"));
               break;
             default:
               pips_internal_error("Language unknown !");
               break;
           }
         }
         break;
       }
       default:
         pips_internal_error("Too many successors for a control node");
     }
   }
  
   return r;
 }

References ADD_SENTENCE_TO_TEXT, appears_first_in_trail(), C_comment_to_text(), CAR, CDR, CHAIN_SWORD, check_io_statement_p(), CONTROL, control_statement, control_successors, control_to_label_name(), empty_global_label_p(), ENDP, entity_name, gen_free_list(), gen_length(), gen_nconc(), get_bool_property(), get_prettyprint_language_tag(), INDENTATION, init_text_statement(), instruction_test, instruction_test_p, is_language_c, is_language_fortran, is_language_fortran95, is_sentence_formatted, is_sentence_unformatted, label_local_name(), MAKE_ONE_WORD_SENTENCE, make_sentence(), make_text(), make_unformatted(), MERGE_TEXTS, module, NIL, one_liner_p(), pips_assert, pips_debug, pips_internal_error, POP, sentence_goto_label(), sentence_undefined, sentence_unformatted, statement_comments, statement_does_return(), statement_identification(), statement_instruction, statement_label, statement_number, statement_to_label(), strdup(), string_undefined, string_undefined_p, test_condition, test_undefined, text_statement_enclosed(), unformatted_label, unformatted_undefined, words_expression(), and words_goto_label().

Referenced by text_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ text_unstructured()

text text_unstructured	(	entity	module,
		const char *	label,
		int	margin,
		unstructured	u,
		int	num,
		list *	ppdl
	)

unstructured.c

build an arbitrary reverse trail of control nodes

decorate control nodes with labels when necessary

generate text with labels and goto's

Parameters

module	odule
label	abel
margin	argin
num	um
ppdl	pdl

Definition at line 55 of file unstructured.c.

 {
     text r = make_text(NIL);
     hash_table labels = hash_table_make(hash_pointer, 0) ;
  
     debug(2, "text_unstructured", "Begin for unstructured %p\n", u);
    
     ifdebug(3) {
         list blocks = NIL;
         control cexit = unstructured_exit(u) ;
         control centry = unstructured_control(u) ;
  
         fprintf(stderr,"Unstructured %p (%p, %p)\n", u, centry, cexit) ;
         CONTROL_MAP( n, {
             statement st = control_statement(n) ;
  
             /*
               fprintf(stderr, "\n%*sNode %p (%s)\n--\n", margin, "",
               (unsigned int) n, control_to_label_name(n, labels)) ;
               */
             fprintf(stderr, "\n%*sNode %p (%s)\n--\n", margin, "",
                     n, statement_identification(st));
             ifdebug(9) {
               list pdl = NIL;
               print_text(stderr, text_statement(module,margin,st,&pdl));
               gen_free_list(pdl);
             }
             fprintf(stderr, "--\n%*sPreds:", margin, "");
             MAPL(ps,{
                 int so = statement_ordering(control_statement(CONTROL(CAR(ps))));
                 fprintf(stderr,"%p (%d,%d), ", CONTROL(CAR(ps)),
                         ORDERING_NUMBER(so), ORDERING_STATEMENT(so));
             }, control_predecessors(n));
             fprintf(stderr, "\n%*sSuccs:", margin, "") ;
             MAPL(ss,{
                 int so = statement_ordering(control_statement(CONTROL(CAR(ss))));
                 fprintf(stderr,"%p (%d,%d), ", CONTROL(CAR(ss)),
                         ORDERING_NUMBER(so), ORDERING_STATEMENT(so));
             }, control_successors(n));
             fprintf(stderr, "\n\n") ;
         }, centry , blocks) ;
         gen_free_list(blocks);
     }
  
     if (get_bool_property("PRETTYPRINT_UNSTRUCTURED_AS_A_GRAPH"))
     {
         output_a_graph_view_of_the_unstructured
             (r, module, label, margin, u, num);
     }
     else {
         list trail = NIL;
  
         if(get_bool_property("PRETTYPRINT_UNSTRUCTURED")) {
             list pbeg = CHAIN_SWORD(NIL, "BEGIN UNSTRUCTURED");
             unformatted unf = make_unformatted(strdup(get_comment_sentinel()), num, margin, pbeg);
  
             ADD_SENTENCE_TO_TEXT(r, 
                                  make_sentence(is_sentence_unformatted, unf));
         }
  
         /* build an arbitrary reverse trail of control nodes */
         trail = unstructured_to_trail(u);
         debug(3, "text_unstructured", "Trail length: %d\n", gen_length(trail));
  
         trail = gen_nreverse(trail);
  
         ifdebug(3)
             dump_trail(trail);
  
         /* decorate control nodes with labels when necessary */
         decorate_trail(module, trail, labels);
  
         ifdebug(3)
             dump_control_to_label_name(labels);
  
         /* generate text with labels and goto's */
  
         MERGE_TEXTS(r, text_trail(module, margin, trail, labels, ppdl));
  
         if(get_bool_property("PRETTYPRINT_UNSTRUCTURED")) {
             list pend = CHAIN_SWORD(NIL, "END UNSTRUCTURED");
             unformatted unf = make_unformatted(strdup(get_comment_sentinel()), num, margin, pend);
             ADD_SENTENCE_TO_TEXT(r, 
                                  make_sentence(is_sentence_unformatted, unf));
         }
         gen_free_list(trail);
     }
  
     hash_table_free(labels) ;
  
     debug(2, "text_unstructured", "End for unstructured %p\n", u);
  
     return(r) ;
 }

References ADD_SENTENCE_TO_TEXT, blocks, CAR, CHAIN_SWORD, CONTROL, CONTROL_MAP, control_predecessors, control_statement, control_successors, debug(), decorate_trail(), dump_control_to_label_name(), dump_trail(), fprintf(), gen_free_list(), gen_length(), gen_nreverse(), get_bool_property(), get_comment_sentinel(), hash_pointer, hash_table_free(), hash_table_make(), ifdebug, is_sentence_unformatted, make_sentence(), make_text(), make_unformatted(), MAPL, MERGE_TEXTS, module, NIL, num, ORDERING_NUMBER, ORDERING_STATEMENT, output_a_graph_view_of_the_unstructured(), print_text(), statement_identification(), statement_ordering, strdup(), text_statement(), text_trail(), unstructured_control, unstructured_exit, and unstructured_to_trail().

Referenced by text_instruction().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unstructured_to_trail()

list unstructured_to_trail ( unstructured u )

The exit node must be first (i.e. last) to reach the continuation of the unstructured, or never reached (e.g. because the program loops forever or stops in the unstructured).

Definition at line 240 of file unstructured.c.

 {
     list trail = NIL;
     control centry = unstructured_control(u) ;
     control cexit = unstructured_exit(u) ;
  
     trail = build_trail(trail, centry);
  
         /* The exit node *must* be first (i.e. last) to reach the continuation
          * of the unstructured, or never reached (e.g. because the program loops
          * forever or stops in the unstructured).
          */
     if(control_in_trail_p(trail, cexit)) {
         if(cexit!=CONTROL(CAR(trail))) {
             gen_remove(&trail, cexit);
             trail = CONS(CONTROL, cexit, trail);
         }
     }
  
     return trail;
 }

References build_trail(), CAR, CONS, CONTROL, control_in_trail_p(), gen_remove(), NIL, unstructured_control, and unstructured_exit.

Referenced by c_unstructured(), ensure_comment_consistency(), last_statement(), new_points_to_unstructured(), and text_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

Functions

Function Documentation

◆ appears_first_in_trail()

◆ build_trail()

◆ control_in_trail_p()

◆ control_to_label_name()

◆ decorate_trail()

◆ dump_control_to_label_name()

◆ dump_trail()

◆ set_control_to_label()

◆ text_trail()

◆ text_unstructured()

◆ unstructured_to_trail()