attachment_pretty_print.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "linear.h"
#include "genC.h"
#include "misc.h"
#include "properties.h"
#include "naming.h"
#include "text-util.h"
#include "word_attachment.h"
#include "constants.h"

Include dependency graph for attachment_pretty_print.c:

Go to the source code of this file.

Macros
#define	ADD_AN_ATTACHMENT_TO_A_MAPPING(a, a_char, a_mapping)
	Use to create or extend the attachment list of a character: More...

Typedefs
typedef char *	void_star
	Used in word_to_attachments: More...

Enumerations
enum	{ POSITION_UNDEFINED = -1 }

Functions
static const char *	module_local_name (entity e)
	Declare the various mapping between the words and attachments: More...
void	begin_attachment_prettyprint (void)
	The translation functions between unique names and objects: More...
void	end_attachment_prettyprint (void)
	Clean the things related with the attachment of properties: More...
static void	attach_to_character_region (char *begin_char, char *end_char, attachee at)
	Attach something from begin_char up to end_char: More...
static void	attach_to_word_list (string begin_word, string end_word, attachee at)
	Attach something to a word list, from begin_word to end_word: More...
static void	attach_to_words (list l, attachee a)
	Attach something to all the words of the list given in argument: More...
static void	attach_to_sentence_list (sentence begin, sentence end, attachee a)
	Attach something to a sentence list: More...
static void	attach_to_sentence (sentence s, attachee a)
	Attach something to a sentence: More...
static void	attach_to_sentence_up_to_end_of_text (sentence s, text t, attachee a)
	Attach something to a sentence up to the end of the given text: More...
static void	attach_to_text (text t, attachee a)
	Attach something to all a text: More...
void	attach_loop_to_sentence_up_to_end_of_text (sentence s, text t, loop l)
	The user interface: More...
sentence	attach_head_to_sentence (sentence s, entity module)
	Attach the PROGRAM/FUNCTION head: More...
void	attach_reference_to_word_list (string begin_word, string end_word, reference r)
	Attach a module usage (CALL or function call): More...
void	attach_regular_call_to_word (string word, call c)
	Attach a reference: More...
void	attach_declaration_to_words (list l, entity e)
	Attach a declaration to all the words of the given list: More...
void	attach_declaration_type_to_words (list l, string declaration_type)
	Attach a declaration type to all the words of the given list. More...
void	attach_declaration_size_type_to_words (list l, string declaration_type, int size)
	Attach a declaration type with its size to all the words of the given list. More...
void	attach_statement_information_to_text (text t, statement s)
	Attach some statement information to text: More...
void	attach_decoration_to_text (text t)
	Attach a decoration: More...
void	attach_cumulated_effects_decoration_to_text (text t)
	Attach a cumulated effects decoration: More...
void	attach_proper_effects_decoration_to_text (text t)
	Attach a proper effects decoration: More...
void	attach_preconditions_decoration_to_text (text t)
	Attach a preconditions decoration: More...
void	attach_total_preconditions_decoration_to_text (text __attribute__((unused)) t)
	Attach a total preconditions decoration: More...
void	attach_transformers_decoration_to_text (text t)
	Attach a transformers decoration: More...
static void	deal_with_attachment_boundary (char *a_character, int position_in_the_output, attachments(*load_word_to_attachments_boundary)(void_star), bool(*bound_word_to_attachments_boundary_p)(void_star))
	Try to find some attachments in the given character. More...
void	deal_with_attachments_at_this_character (char *a_character, int position_in_the_output)
	Try to find some attachments in the given character that are printed out. More...
void	deal_with_attachments_in_this_string (string a_string, int position_in_the_output)
	Try to find some attachments in the given string. More...
void	deal_with_attachments_in_this_string_length (string a_string, int position_in_the_output, int a_length)
	Try to find some attachments in the a_length first characters of the given string. More...
void	relocate_attachments (char *source, char *new_position)
	Many pretty-printers format their own pseudo-comment by their own and move in memory words that have attachments on them. More...
char *	strcat_word_and_migrate_attachments (char *target, const char *source)
	Concatenate source to target and update the source attachments to point to the new location: More...
char *	strdup_and_migrate_attachments (char *a_string)
	Duplicate a string and update the attachments to point to the new returned string: More...
static void	output_an_attachment (FILE *output_file, attachment a)
	Output an attachment to the output file: More...
static int	compare_attachment_for_qsort (const void *xp, const void *yp)
	The function used by qsort to compare 2 attachment structures: More...
static void	output_the_attachments_in_a_sorted_order (FILE *output_file)
	Output the attachment in a sorted order with less precise property first: More...
static bool	put_an_attachment_in_the_list (attachment a)
	Add the attachment to the intermediate list: More...
static void	rewrite_an_attachment (attachment __attribute__((unused)) a)
	Nothing to do... More...
static void	init_output_the_attachments_for_emacs (FILE *output_file)
	Begin the Emacs Lisp file: More...
static void	output_the_attachments_for_emacs (FILE *output_file)
	Output the list of all the attachments found in the text file with Emacs Lisp syntax: More...
void	write_an_attachment_file (string file_name)
	Add the attachment in Emacs mode by creating a twin file that is decorated with Emacs properties: More...

Variables
static bool	is_emacs_pretty_print_asked
	To store the fact a prettyprinter ask for Emacs attachments: More...
list	attachments_before_sorting = NIL
	To store the attachment before sorting: More...

Macro Definition Documentation

ADD_AN_ATTACHMENT_TO_A_MAPPING

#define ADD_AN_ATTACHMENT_TO_A_MAPPING	(		a,
			a_char,
			a_mapping
	)

Value:

  if (bound_##a_mapping##_p(a_char)) {                    \
    attachments ats = load_##a_mapping(a_char);                 \
      list l = attachments_attachment(ats);               \
      l = CONS(ATTACHMENT, a, l);                         \
      attachments_attachment(ats) = l;                    \
  }                                                       \
  else {                                                  \
    store_##a_mapping(a_char,                             \
                      make_attachments(CONS(ATTACHMENT,         \
                                            a,            \
                                            NIL)));       \
}

Use to create or extend the attachment list of a character:

Definition at line 179 of file attachment_pretty_print.c.

Typedef Documentation

void_star

typedef char* void_star

Used in word_to_attachments:

Definition at line 42 of file attachment_pretty_print.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
POSITION_UNDEFINED

Definition at line 50 of file attachment_pretty_print.c.

{POSITION_UNDEFINED = -1};

Function Documentation

attach_cumulated_effects_decoration_to_text()

void attach_cumulated_effects_decoration_to_text

(

text

t

)

Attach a cumulated effects decoration:

Definition at line 416 of file attachment_pretty_print.c.

{
    if (is_emacs_pretty_print_asked)
        attach_to_text(t, make_attachee(is_attachee_cumulated_effects, UU));
}

References attach_to_text(), is_attachee_cumulated_effects, is_emacs_pretty_print_asked, make_attachee(), and UU.

Here is the call graph for this function:

attach_declaration_size_type_to_words()

void attach_declaration_size_type_to_words	(	list	l,
		string	declaration_type,
		int	size
	)

Attach a declaration type with its size to all the words of the given list.

No need to use strdup():

Parameters

declaration_type	eclaration_type
size	ize

Definition at line 374 of file attachment_pretty_print.c.

{
    if (is_emacs_pretty_print_asked) {
        char * size_char = int2a(size);
        attach_declaration_type_to_words(l,
                                         concatenate(declaration_type,
                                                     "*",
                                                     size_char,
                                                     NIL));
        free(size_char);
    }
}

References attach_declaration_type_to_words(), concatenate(), free(), int2a(), is_emacs_pretty_print_asked, and NIL.

Referenced by text_entity_declaration().

Here is the call graph for this function:

Here is the caller graph for this function:

attach_declaration_to_words()

void attach_declaration_to_words	(	list	l,
		entity	e
	)

Attach a declaration to all the words of the given list:

Definition at line 348 of file attachment_pretty_print.c.

{
    if (is_emacs_pretty_print_asked)
        attach_to_words(l,
                        make_attachee(is_attachee_declaration, e));
}

References attach_to_words(), is_attachee_declaration, is_emacs_pretty_print_asked, and make_attachee().

Referenced by words_declaration().

Here is the call graph for this function:

Here is the caller graph for this function:

attach_declaration_type_to_words()

void attach_declaration_type_to_words	(	list	l,
		string	declaration_type
	)

Attach a declaration type to all the words of the given list.

No need to use strdup(). May accept an empty list:

Parameters

declaration_type

eclaration_type

Definition at line 360 of file attachment_pretty_print.c.

{
    if (is_emacs_pretty_print_asked)
        if (l != NIL)
            attach_to_words(l,
                            make_attachee(is_attachee_type,
                                          strdup(declaration_type)));
}

References attach_to_words(), is_attachee_type, is_emacs_pretty_print_asked, make_attachee(), NIL, and strdup().

Referenced by attach_declaration_size_type_to_words(), and text_entity_declaration().

Here is the call graph for this function:

Here is the caller graph for this function:

attach_decoration_to_text()

void attach_decoration_to_text

(

text

t

)

Attach a decoration:

Some prettyprinters such as effects generate NULL text... Just ignore.

Definition at line 405 of file attachment_pretty_print.c.

{
    if (is_emacs_pretty_print_asked && text_sentences(t) != NIL)
        /* Some prettyprinters such as effects generate NULL
           text... Just ignore. */
        attach_to_text(t, make_attachee(is_attachee_decoration, UU));
}

References attach_to_text(), is_attachee_decoration, is_emacs_pretty_print_asked, make_attachee(), NIL, text_sentences, and UU.

Referenced by get_semantic_text(), and init_text_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

attach_head_to_sentence()

sentence attach_head_to_sentence	(	sentence	s,
		entity	module
	)

Attach the PROGRAM/FUNCTION head:

Parameters

module

odule

Definition at line 313 of file attachment_pretty_print.c.

{
  if (is_emacs_pretty_print_asked)
    attach_to_sentence(s, make_attachee(is_attachee_module_head, module));
 
  return s;
}

References attach_to_sentence(), is_attachee_module_head, is_emacs_pretty_print_asked, make_attachee(), and module.

Referenced by ensure_comment_consistency().

Here is the call graph for this function:

Here is the caller graph for this function:

attach_loop_to_sentence_up_to_end_of_text()

void attach_loop_to_sentence_up_to_end_of_text	(	sentence	s,
		text	t,
		loop	l
	)

The user interface:

Attach a loop:

Definition at line 302 of file attachment_pretty_print.c.

{
  if (is_emacs_pretty_print_asked)
    attach_to_sentence_up_to_end_of_text(s, t,
                                         make_attachee(is_attachee_loop,
                                                       l));
}

References attach_to_sentence_up_to_end_of_text(), is_attachee_loop, is_emacs_pretty_print_asked, and make_attachee().

Referenced by text_loop_default().

Here is the call graph for this function:

Here is the caller graph for this function:

attach_preconditions_decoration_to_text()

void attach_preconditions_decoration_to_text

(

text

t

)

Attach a preconditions decoration:

Definition at line 434 of file attachment_pretty_print.c.

{
  if (is_emacs_pretty_print_asked)
    attach_to_text(t, make_attachee(is_attachee_preconditions, UU));
}

References attach_to_text(), is_attachee_preconditions, is_emacs_pretty_print_asked, make_attachee(), and UU.

Referenced by get_semantic_text(), and semantic_to_text().

Here is the call graph for this function:

Here is the caller graph for this function:

attach_proper_effects_decoration_to_text()

void attach_proper_effects_decoration_to_text

(

text

t

)

Attach a proper effects decoration:

Definition at line 425 of file attachment_pretty_print.c.

{
    if (is_emacs_pretty_print_asked)
        attach_to_text(t, make_attachee(is_attachee_proper_effects, UU));
}

References attach_to_text(), is_attachee_proper_effects, is_emacs_pretty_print_asked, make_attachee(), and UU.

Here is the call graph for this function:

attach_reference_to_word_list()

void attach_reference_to_word_list	(	string	begin_word,
		string	end_word,
		reference	r
	)

Attach a module usage (CALL or function call):

Parameters

begin_word	egin_word
end_word	nd_word

Definition at line 324 of file attachment_pretty_print.c.

{
  if (is_emacs_pretty_print_asked)
    attach_to_word_list(begin_word,
                        end_word,
                        make_attachee(is_attachee_reference, r));
}

References attach_to_word_list(), is_attachee_reference, is_emacs_pretty_print_asked, and make_attachee().

Referenced by effect_words_reference(), and words_any_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

attach_regular_call_to_word()

void attach_regular_call_to_word	(	string	word,
		call	c
	)

Attach a reference:

Parameters

word

ord

Definition at line 337 of file attachment_pretty_print.c.

{
  if (is_emacs_pretty_print_asked)
    attach_to_word_list(word,
                        word,
                        make_attachee(is_attachee_call, c));
}

References attach_to_word_list(), is_attachee_call, is_emacs_pretty_print_asked, and make_attachee().

Referenced by words_genuine_regular_call().

Here is the call graph for this function:

Here is the caller graph for this function:

attach_statement_information_to_text()

void attach_statement_information_to_text	(	text	t,
		statement	s
	)

Attach some statement information to text:

Some prettyprinters such as effects generate NULL text... Just ignore.

Definition at line 392 of file attachment_pretty_print.c.

{
    if (is_emacs_pretty_print_asked && text_sentences(t) != NIL)
        /* Some prettyprinters such as effects generate NULL
           text... Just ignore. */
        attach_to_text(t, make_attachee(is_attachee_statement_line_number,
                                        (void*) statement_number(s)));
}

References attach_to_text(), is_attachee_statement_line_number, is_emacs_pretty_print_asked, make_attachee(), NIL, statement_number, and text_sentences.

Here is the call graph for this function:

attach_to_character_region()

static void attach_to_character_region ( char *  begin_char, char *  end_char, attachee  at  )

static

Attach something from begin_char up to end_char:

Attach the begin to the first character:

Attach the end to the last character:

Definition at line 197 of file attachment_pretty_print.c.

{
  // We do not know the position of the attachement in the output file yet:
  attachment a = make_attachment(at, POSITION_UNDEFINED, POSITION_UNDEFINED);
 
  debug_on("ATTACHMENT_DEBUG_LEVEL");
  debug(6, "attach_to_character_region",
        "Attach attachment %p (attachee %p, tag %d) from \"%c\" (%p) to \"%c\" (%p)\n",
        a, at, attachee_tag(at),
        *begin_char, begin_char,
        *end_char, end_char);
 
  /* Attach the begin to the first character: */
  ADD_AN_ATTACHMENT_TO_A_MAPPING(a,
                                 begin_char,
                                 word_to_attachments_begin);
 
  /* Attach the end to the last character: */
  ADD_AN_ATTACHMENT_TO_A_MAPPING(a,
                                 end_char,
                                 word_to_attachments_end);
  debug_off();
}

References ADD_AN_ATTACHMENT_TO_A_MAPPING, attachee_tag, debug(), debug_off, debug_on, make_attachment(), and POSITION_UNDEFINED.

Referenced by attach_to_word_list().

Here is the call graph for this function:

Here is the caller graph for this function:

attach_to_sentence()

static void attach_to_sentence ( sentence  s, attachee  a  )

static

Attach something to a sentence:

Definition at line 271 of file attachment_pretty_print.c.

{
    attach_to_sentence_list(s, s, a);
}

References attach_to_sentence_list().

Referenced by attach_head_to_sentence().

Here is the call graph for this function:

Here is the caller graph for this function:

attach_to_sentence_list()

static void attach_to_sentence_list ( sentence  begin, sentence  end, attachee  a  )

static

Attach something to a sentence list:

Definition at line 259 of file attachment_pretty_print.c.

{
  attach_to_word_list(first_word_of_sentence(begin),
                      last_word_of_sentence(end),
                      a);
}

References attach_to_word_list(), end, first_word_of_sentence(), and last_word_of_sentence().

Referenced by attach_to_sentence(), attach_to_sentence_up_to_end_of_text(), and attach_to_text().

Here is the call graph for this function:

Here is the caller graph for this function:

attach_to_sentence_up_to_end_of_text()

static void attach_to_sentence_up_to_end_of_text ( sentence  s, text  t, attachee  a  )

static

Attach something to a sentence up to the end of the given text:

Definition at line 280 of file attachment_pretty_print.c.

{
  attach_to_sentence_list(s, SENTENCE(CAR(gen_last(text_sentences(t)))), a);
}

References attach_to_sentence_list(), CAR, gen_last(), SENTENCE, and text_sentences.

Referenced by attach_loop_to_sentence_up_to_end_of_text().

Here is the call graph for this function:

Here is the caller graph for this function:

attach_to_text()

static void attach_to_text ( text  t, attachee  a  )

static

Attach something to all a text:

Definition at line 290 of file attachment_pretty_print.c.

{
  attach_to_sentence_list(SENTENCE(CAR(text_sentences(t))),
                          SENTENCE(CAR(gen_last(text_sentences(t)))),
                          a);
}

References attach_to_sentence_list(), CAR, gen_last(), SENTENCE, and text_sentences.

Referenced by attach_cumulated_effects_decoration_to_text(), attach_decoration_to_text(), attach_preconditions_decoration_to_text(), attach_proper_effects_decoration_to_text(), attach_statement_information_to_text(), and attach_transformers_decoration_to_text().

Here is the call graph for this function:

Here is the caller graph for this function:

attach_to_word_list()

static void attach_to_word_list ( string  begin_word, string  end_word, attachee  at  )

static

Attach something to a word list, from begin_word to end_word:

Attach from the first character of the first word up to the last character of the last word:

Definition at line 227 of file attachment_pretty_print.c.

{
  debug_on("ATTACHMENT_DEBUG_LEVEL");
  debug(6, "attach_to_word_list",
        "Attach attachee %p from \"%s\" (%p) to \"%s\" (%p)\n",
        at,
        begin_word, begin_word,
        end_word, end_word);
 
  /* Attach from the first character of the first word up to the
     last character of the last word: */
  attach_to_character_region(begin_word,
                             end_word + strlen(end_word) - 1,
                             at);
  debug_off();
}

References attach_to_character_region(), debug(), debug_off, and debug_on.

Referenced by attach_reference_to_word_list(), attach_regular_call_to_word(), attach_to_sentence_list(), and attach_to_words().

Here is the call graph for this function:

Here is the caller graph for this function:

attach_to_words()

static void attach_to_words ( list  l, attachee  a  )

static

Attach something to all the words of the list given in argument:

Definition at line 248 of file attachment_pretty_print.c.

{
  attach_to_word_list(STRING(CAR(l)),
                      STRING(CAR(gen_last(l))),
                      a);
}

References attach_to_word_list(), CAR, gen_last(), and STRING.

Referenced by attach_declaration_to_words(), and attach_declaration_type_to_words().

Here is the call graph for this function:

Here is the caller graph for this function:

attach_total_preconditions_decoration_to_text()

void attach_total_preconditions_decoration_to_text

(

text __attribute__((unused))

t

)

Attach a total preconditions decoration:

Definition at line 442 of file attachment_pretty_print.c.

{
  if (is_emacs_pretty_print_asked)
    pips_internal_error("not implemented yet");
}

References is_emacs_pretty_print_asked, and pips_internal_error.

Referenced by get_semantic_text(), and semantic_to_text().

Here is the caller graph for this function:

attach_transformers_decoration_to_text()

void attach_transformers_decoration_to_text

(

text

t

)

Attach a transformers decoration:

Definition at line 451 of file attachment_pretty_print.c.

{
  if (is_emacs_pretty_print_asked)
    attach_to_text(t, make_attachee(is_attachee_transformers, UU));
}

References attach_to_text(), is_attachee_transformers, is_emacs_pretty_print_asked, make_attachee(), and UU.

Referenced by get_semantic_text(), and semantic_to_text().

Here is the call graph for this function:

Here is the caller graph for this function:

begin_attachment_prettyprint()

void begin_attachment_prettyprint

(

void

)

The translation functions between unique names and objects:

Initialize some things related with the attachment of propertie. To be conservative, if a prettyprinter does not call begin_attachment_prettyprint(), all the attachment stuff is disable. Thus, old prettyprinter can go on without Emacs mode:

Definition at line 145 of file attachment_pretty_print.c.

{
  if (get_bool_property("PRETTYPRINT_ADD_EMACS_PROPERTIES")) {
    is_emacs_pretty_print_asked = true;
    // word_text_attachment_mapping = hash_table_make(hash_pointer, 0);
    // Initialize the local mapings:
    init_word_to_attachments_begin();
    init_word_to_attachments_end();
  }
}

References get_bool_property(), and is_emacs_pretty_print_asked.

Referenced by print_code_or_source(), print_code_semantics(), and print_parallelized_code_common().

Here is the call graph for this function:

Here is the caller graph for this function:

compare_attachment_for_qsort()

static int compare_attachment_for_qsort ( const void *  xp, const void *  yp  )

static

The function used by qsort to compare 2 attachment structures:

Sort according attachment x begins before y:

Sort according attachment x ends after y:

If they have the same range, sort according to the type:

Definition at line 779 of file attachment_pretty_print.c.

{
    attachment x = *(attachment *) xp;
    attachment y = *(attachment *) yp;
 
    if (attachment_begin(x) != attachment_begin(y))
        /* Sort according attachment x begins before y: */
        return attachment_begin(x) - attachment_begin(y);
 
    if (attachment_end(x) != attachment_end(y))
        /* Sort according attachment x ends after y: */
        return attachment_end(y) - attachment_begin(x);
 
    /* If they have the same range, sort according to the type: */
    return attachee_tag(attachment_attachee(x))
        - attachee_tag(attachment_attachee(y));
}

References attachee_tag, attachment_attachee, attachment_begin, attachment_end, and x.

Referenced by output_the_attachments_in_a_sorted_order().

Here is the caller graph for this function:

deal_with_attachment_boundary()

static void deal_with_attachment_boundary ( char *  a_character, int  position_in_the_output, attachments(*)(void_star)  load_word_to_attachments_boundary, bool(*)(void_star)  bound_word_to_attachments_boundary_p  )

static

Try to find some attachments in the given character.

If any, note the boundary position, that is a start or an end according to the functions given in parameters:

Well, this word is an attachment boundary:

Remind the position of the boundary of the attachment:

Definition at line 462 of file attachment_pretty_print.c.

{
  debug(8, "deal_with_attachment_boundary",
        "Looking for \"%c\" (%p) at %d\n",
        *a_character,a_character, position_in_the_output);
 
  if (bound_word_to_attachments_boundary_p(a_character)) {
    /* Well, this word is an attachment boundary: */
    list some_attachments =
      attachments_attachment(load_word_to_attachments_boundary(a_character));
    MAP(ATTACHMENT, an_attachment,
    {
      debug(4, "deal_with_attachment_boundary",
            "*** Found attachment = %p for \"%c\" (%p) at %d\n",
            an_attachment, *a_character,
            a_character, position_in_the_output);
 
      /* Remind the position of the boundary of the
         attachment: */
      if (load_word_to_attachments_boundary
          == load_word_to_attachments_begin)
        attachment_begin(an_attachment) = position_in_the_output;
      else
        attachment_end(an_attachment) = position_in_the_output;
    },
        some_attachments);
  };
}

References ATTACHMENT, attachment_begin, attachment_end, attachments_attachment, debug(), MAP, and position_in_the_output.

Referenced by deal_with_attachments_at_this_character().

Here is the call graph for this function:

Here is the caller graph for this function:

deal_with_attachments_at_this_character()

void deal_with_attachments_at_this_character	(	char *	a_character,
		int	position_in_the_output
	)

Try to find some attachments in the given character that are printed out.

If any, note the boundary position.

Look for attachment starts:

Look for attachment ends:

Parameters

a_character	_character
position_in_the_output	osition_in_the_output

Definition at line 498 of file attachment_pretty_print.c.

{
    if (is_emacs_pretty_print_asked) {
        debug_on("ATTACHMENT_DEBUG_LEVEL");
 
        /* Look for attachment starts: */
        debug(8, "deal_with_attachment_boundaries",
              "Looking for attachment starts\n");
        deal_with_attachment_boundary(a_character,
                                      position_in_the_output,
                                      load_word_to_attachments_begin,
                                      bound_word_to_attachments_begin_p);
        /* Look for attachment ends: */
        debug(8, "deal_with_attachment_boundaries",
              "Looking for attachment ends\n");
        deal_with_attachment_boundary(a_character,
                                      position_in_the_output,
                                      load_word_to_attachments_end,
                                      bound_word_to_attachments_end_p);    
        debug_off();
    }
}

References deal_with_attachment_boundary(), debug(), debug_off, debug_on, is_emacs_pretty_print_asked, and position_in_the_output.

Referenced by deal_with_attachments_in_this_string(), deal_with_attachments_in_this_string_length(), and print_sentence().

Here is the call graph for this function:

Here is the caller graph for this function:

deal_with_attachments_in_this_string()

void deal_with_attachments_in_this_string	(	string	a_string,
		int	position_in_the_output
	)

Try to find some attachments in the given string.

If any, note the boundary position.

Parameters

a_string	_string
position_in_the_output	osition_in_the_output

Definition at line 526 of file attachment_pretty_print.c.

{
    int i;
    
    for(i = 0; a_string[i] != '\0'; i++)
        deal_with_attachments_at_this_character(&a_string[i],
                                                position_in_the_output + i);
}

References a_string, deal_with_attachments_at_this_character(), and position_in_the_output.

Referenced by print_sentence().

Here is the call graph for this function:

Here is the caller graph for this function:

deal_with_attachments_in_this_string_length()

void deal_with_attachments_in_this_string_length	(	string	a_string,
		int	position_in_the_output,
		int	a_length
	)

Try to find some attachments in the a_length first characters of the given string.

If any, note the boundary position.

Parameters

a_string	_string
position_in_the_output	osition_in_the_output
a_length	_length

Definition at line 540 of file attachment_pretty_print.c.

{
    int i;
    
    for(i = 0; i < a_length; i++) {
        pips_assert("Length is too big since end of string encountered",
                    a_string[i] != '\0');
        deal_with_attachments_at_this_character(&a_string[i],
                                                position_in_the_output + i);
    }
}

References a_string, deal_with_attachments_at_this_character(), pips_assert, and position_in_the_output.

Referenced by print_sentence().

Here is the call graph for this function:

Here is the caller graph for this function:

end_attachment_prettyprint()

void end_attachment_prettyprint

(

void

)

Clean the things related with the attachment of properties:

Strings in attachments should already have been freed by print_sentence and attachement it-self (witout "s") by output_an_attachment():

Should be OK since output_the_attachments_for_emacs() has already unlinked the attachment from ord_to_attachments_begin:

ree_names_of_almost_everything_in_a_module();

Definition at line 159 of file attachment_pretty_print.c.

{
  if (is_emacs_pretty_print_asked) {
    is_emacs_pretty_print_asked = false;
 
    /* Strings in attachments should already have been freed by
       print_sentence and attachement it-self (witout "s") by
       output_an_attachment(): */
    close_word_to_attachments_begin();
    /* Should be OK since output_the_attachments_for_emacs() has
       already unlinked the attachment from
       ord_to_attachments_begin: */
    close_word_to_attachments_end();
 
    /*free_names_of_almost_everything_in_a_module();*/
  }
}

References is_emacs_pretty_print_asked.

Referenced by print_code_or_source(), print_code_semantics(), and print_parallelized_code_common().

Here is the caller graph for this function:

init_output_the_attachments_for_emacs()

static void init_output_the_attachments_for_emacs ( FILE *  output_file )

static

Begin the Emacs Lisp file:

Begin a string with Emacs Lisp properties:

Definition at line 853 of file attachment_pretty_print.c.

{
    /* Begin a string with Emacs Lisp properties: */
    fprintf(output_file, "(insert \"");
}

References fprintf().

Referenced by write_an_attachment_file().

Here is the call graph for this function:

Here is the caller graph for this function:

module_local_name()

static const char* module_local_name ( entity  e )

static

Declare the various mapping between the words and attachments:

Returns the module local user name FC: DUPLICATED FROM ri-util TO AVOID A DEPENDENCY

No difference between modules and other entities, except for prefixes

Definition at line 74 of file attachment_pretty_print.c.

{
  /* No difference between modules and other entities, except for prefixes */
  const char* name = local_name(entity_name(e));
 
  return (name
   + strspn(name, F95MODULE_PREFIX MAIN_PREFIX BLOCKDATA_PREFIX COMMON_PREFIX));
}

References BLOCKDATA_PREFIX, COMMON_PREFIX, entity_name, F95MODULE_PREFIX, local_name(), and MAIN_PREFIX.

Referenced by output_an_attachment().

Here is the call graph for this function:

Here is the caller graph for this function:

output_an_attachment()

static void output_an_attachment ( FILE *  output_file, attachment  a  )

static

Output an attachment to the output file:

Begin an Emacs Lisp properties. + 1 since in a buffer (and not a string). (end + 1) + 1 since the property is set between start and end in Emacs.Use backquoting to evaluate keymaps later:

Evaluate the keymap:

Evaluate the keymap:

Output the address as a string because Emacs cannot store 32-bit numbers:

End an Emacs Lisp properties:

Definition at line 636 of file attachment_pretty_print.c.

{
    attachee at = attachment_attachee(a);
    int begin = attachment_begin(a);
    int end = attachment_end(a);
    
    pips_debug(5, "begin: %d, end: %d, attachment %p (attachee %p)\n",
               begin, end, a, at);
 
    if (begin == POSITION_UNDEFINED || end == POSITION_UNDEFINED)
    {
        pips_user_warning("begin and end should be initialized.\n");
        return;
    }
                
    /* Begin an Emacs Lisp properties. + 1 since in a buffer (and not
       a string). (end + 1) + 1 since the property is set between
       start and end in Emacs.Use backquoting to evaluate keymaps
       later: */
    fprintf(output_file, "(add-text-properties %d %d `(", begin + 1, end + 2);
 
    switch(attachee_tag(at))
    {
    case is_attachee_reference:
        {           
            reference r = attachee_reference(at);
            pips_debug(5, "\treference %p\n", r);
            /* Evaluate the keymap: */
            fprintf(output_file, "face epips-face-reference mouse-face epips-mouse-face-reference local-map ,epips-reference-keymap epips-property-reference \"%p\" epips-property-reference-variable \"%p\"",
                    r, reference_variable(r));
            break;
        }
        
    case is_attachee_call:
        {           
            call c = attachee_call(at);
            pips_debug(5, "\treference %p\n", c);
            /* Evaluate the keymap: */
            fprintf(output_file, "face epips-face-call mouse-face epips-mouse-face-call local-map ,epips-call-keymap epips-property-call \"%p\"",
                    c);
            break;
        }
        
    case is_attachee_declaration:
        {           
            entity e = attachee_declaration(at);
            pips_debug(5, "\tdeclaration %p\n", e);
            /* Output the address as a string because Emacs cannot
               store 32-bit numbers: */
            fprintf(output_file, "face epips-face-declaration epips-property-declaration \"%p\"",
                    e);
            break;
        }      
        
    case is_attachee_type: 
        {           
            string s = attachee_type(at);
            pips_debug(5, "\ttype \"%s\"\n", s);
            fprintf(output_file, "epips-property-type \"%s\"", s);
            break;
        }
        
    case is_attachee_loop: 
        {           
            loop l = attachee_loop(at);
            pips_debug(5, "\tloop %p\n", l);
            if (execution_parallel_p(loop_execution(l)))
                fprintf(output_file, "face epips-face-parallel-loop ");
            fprintf(output_file, "epips-property-loop \"%p\"", l);
            break;
        }
 
    case is_attachee_module_head:
        {
            entity head = attachee_module_head(at);
            pips_debug(5, "\tmodule_head %p\n", head);
            fprintf(output_file,
                    "face epips-face-module-head epips-module-head-name \"%s\"",
                    module_local_name(head));
            break;
        }
 
    case is_attachee_decoration:
        {
            pips_debug(5, "\tdecoration\n");
            fprintf(output_file,
                    "invisible epips-invisible-decoration");
            break;
        }
 
    case is_attachee_preconditions:
        {
            pips_debug(5, "\tpreconditions\n");
            fprintf(output_file,
                    "face epips-face-preconditions invisible epips-invisible-preconditions");
            break;
        }
 
    case is_attachee_transformers:
        {
            pips_debug(5, "\ttransformers\n");
            fprintf(output_file,
                    "face epips-face-transformers invisible epips-invisible-transformers");
            break;
        }
        
    case is_attachee_cumulated_effects:
        {
            pips_debug(5, "\tcumulated-effect\n");
            fprintf(output_file,
                    "face epips-face-cumulated-effect invisible epips-invisible-cumulated-effect");
            break;
        }
        
    case is_attachee_proper_effects:
        {
            pips_debug(5, "\tproper-effect\n");
            fprintf(output_file,
                    "face epips-face-proper-effect invisible epips-invisible-proper-effect");
            break;
        }
 
    case is_attachee_statement_line_number:
        {
            int line_number = attachee_statement_line_number(at);
 
            pips_debug(5, "\tstatement_line_number %d\n", line_number);
            fprintf(output_file, "epips-line-number %d", line_number);
            break;
        }
 
    default:
        pips_internal_error("attachee_tag inconsistent");
    }
 
    /* End an Emacs Lisp properties: */
    fprintf(output_file, "))\n");
}

References attachee_call, attachee_declaration, attachee_loop, attachee_module_head, attachee_reference, attachee_statement_line_number, attachee_tag, attachee_type, attachment_attachee, attachment_begin, attachment_end, end, execution_parallel_p, fprintf(), is_attachee_call, is_attachee_cumulated_effects, is_attachee_declaration, is_attachee_decoration, is_attachee_loop, is_attachee_module_head, is_attachee_preconditions, is_attachee_proper_effects, is_attachee_reference, is_attachee_statement_line_number, is_attachee_transformers, is_attachee_type, loop_execution, module_local_name(), pips_debug, pips_internal_error, pips_user_warning, POSITION_UNDEFINED, and reference_variable.

Referenced by output_the_attachments_in_a_sorted_order().

Here is the call graph for this function:

Here is the caller graph for this function:

output_the_attachments_for_emacs()

static void output_the_attachments_for_emacs ( FILE *  output_file )

static

Output the list of all the attachments found in the text file with Emacs Lisp syntax:

End the string part:

Enumerate all the attachments:

Now we try to output the stuff in a decent order:

Just for fun, the previous gen_recurse will also recurse through the words of the mapping but it is not deep and thus it does not worth using a gen_multi_recurse with a string_domain and a filter returning always stop to avoid this unnecessary recursion.

Unlink the attachment from attachments to avoid double free later since referenced both by word_to_attachments_begin and word_to_attachments_end:

End the property part:

fprintf(output_file, "\n\t)\n)\n");

Definition at line 863 of file attachment_pretty_print.c.

{
    debug_on("ATTACHMENT_DEBUG_LEVEL");
 
    /* End the string part: */
    fprintf(output_file, "\")\n");
 
    /* Enumerate all the attachments: */
    gen_multi_recurse(get_word_to_attachments_begin(),
                      attachment_domain,
                      put_an_attachment_in_the_list,
                      rewrite_an_attachment,
                      NULL);
 
    /* Now we try to output the stuff in a decent order: */
    output_the_attachments_in_a_sorted_order(output_file);
 
    /* Just for fun, the previous gen_recurse will also recurse
       through the words of the mapping but it is not deep and thus it
       does not worth using a gen_multi_recurse with a string_domain
       and a filter returning always stop to avoid this unnecessary
       recursion. */
 
    WORD_TO_ATTACHMENTS_MAP(word_pointer, attachment_list,
    {
        pips_debug(6, "Key %p, value %p\n", word_pointer, attachment_list);
        /* Unlink the attachment from
           attachments to avoid double free
           later since referenced both by
           word_to_attachments_begin and
           word_to_attachments_end: */
        MAPL(ats,
             {
                 ATTACHMENT_(CAR(ats)) = attachment_undefined;
             },
             attachments_attachment(attachment_list));
    },
                            get_word_to_attachments_begin());
 
    /* End the property part: */
    /* fprintf(output_file, "\n\t)\n)\n"); */
 
    debug_off();
}

References ATTACHMENT_, attachment_domain, attachment_undefined, attachments_attachment, CAR, debug_off, debug_on, fprintf(), gen_multi_recurse(), MAPL, output_the_attachments_in_a_sorted_order(), pips_debug, put_an_attachment_in_the_list(), rewrite_an_attachment(), and WORD_TO_ATTACHMENTS_MAP.

Referenced by write_an_attachment_file().

Here is the call graph for this function:

Here is the caller graph for this function:

output_the_attachments_in_a_sorted_order()

static void output_the_attachments_in_a_sorted_order ( FILE *  output_file )

static

Output the attachment in a sorted order with less precise property first:

The attachments them self will be removed later:

Definition at line 802 of file attachment_pretty_print.c.

{
    attachment * as;
    int i;
    
    int number_of_attachments = gen_length(attachments_before_sorting);
    
    as = (attachment *) malloc(number_of_attachments*sizeof(attachment));
    i = 0;
    MAP(ATTACHMENT, a, {
        as[i++] = a;
    }, attachments_before_sorting);
 
    qsort((char *)as,
          number_of_attachments,
          sizeof(attachment),
          compare_attachment_for_qsort);
 
    for(i = 0; i < number_of_attachments; i++) {
        output_an_attachment(output_file, as[i]);
    }
 
    /* The attachments them self will be removed later: */
    gen_free_list(attachments_before_sorting);
    attachments_before_sorting = NIL;
}

References ATTACHMENT, attachments_before_sorting, compare_attachment_for_qsort(), gen_free_list(), gen_length(), malloc(), MAP, NIL, and output_an_attachment().

Referenced by output_the_attachments_for_emacs().

Here is the call graph for this function:

Here is the caller graph for this function:

put_an_attachment_in_the_list()

static bool put_an_attachment_in_the_list ( attachment  a )

static

Add the attachment to the intermediate list:

We do not want to go on the recursion:

Definition at line 832 of file attachment_pretty_print.c.

{
    attachments_before_sorting = CONS(ATTACHMENT,
                                      a,
                                      attachments_before_sorting);
 
    /* We do not want to go on the recursion: */
    return false;
}

References ATTACHMENT, attachments_before_sorting, and CONS.

Referenced by output_the_attachments_for_emacs().

Here is the caller graph for this function:

relocate_attachments()

void relocate_attachments	(	char *	source,
		char *	new_position
	)

Many pretty-printers format their own pseudo-comment by their own and move in memory words that have attachments on them.

To be able to track them up to the output, we need to overload the movement function to keep track of these.

Parameters

source	ource
new_position	ew_position

Definition at line 560 of file attachment_pretty_print.c.

{
    int i;
    int source_length = strlen(source);
 
    debug_on("ATTACHMENT_DEBUG_LEVEL");
 
    pips_debug(5, "source = \"%s\" (%p), new_position = \"%s\" (%p)\n",
               source, source,
               new_position, new_position);
    
    for(i = 0; i < source_length; i++) {
        if (bound_word_to_attachments_begin_p(source + i)) {
            pips_debug(4, "Relocating begin of attachment from %p to %p\n",
                       source + i,
                       new_position + i);
            pips_assert("There is already an attachment on the target",
                        !bound_word_to_attachments_begin_p(new_position + i));
            store_word_to_attachments_begin(new_position + i,
                                            load_word_to_attachments_begin(source + i));
            delete_word_to_attachments_begin(source + i);
        }
        if (bound_word_to_attachments_end_p(source + i)) {
            pips_debug(4, "Relocating end of attachment from %p to %p\n",
                       source + i,
                       new_position + i);
            pips_assert("There is already an attachment on the target",
                        !bound_word_to_attachments_end_p(new_position + i));
            store_word_to_attachments_end(new_position + i,
                                          load_word_to_attachments_end(source + i));
            delete_word_to_attachments_end(source + i);
        }
    }
    debug_off();
}

References debug_off, debug_on, pips_assert, and pips_debug.

Referenced by strcat_word_and_migrate_attachments(), and strdup_and_migrate_attachments().

Here is the caller graph for this function:

rewrite_an_attachment()

static void rewrite_an_attachment ( attachment __attribute__((unused))  a )

static

Nothing to do...

Definition at line 845 of file attachment_pretty_print.c.

{
    return;
}

Referenced by output_the_attachments_for_emacs().

Here is the caller graph for this function:

strcat_word_and_migrate_attachments()

char* strcat_word_and_migrate_attachments	(	char *	target,
		const char *	source
	)

Concatenate source to target and update the source attachments to point to the new location:

The actual copy:

The actual copy:

Parameters

target	arget
source	ource

Definition at line 601 of file attachment_pretty_print.c.

{
    char * new_string;
    
    if (is_emacs_pretty_print_asked) {
        int target_length = strlen(target);
 
        /* The actual copy: */
        new_string = strcat(target, source);
        relocate_attachments((char*)source, target + target_length);
    }
    else
        /* The actual copy: */
        new_string = strcat(target, source);
        
    return new_string;
}

References is_emacs_pretty_print_asked, and relocate_attachments().

Referenced by words_join().

Here is the call graph for this function:

Here is the caller graph for this function:

strdup_and_migrate_attachments()

char* strdup_and_migrate_attachments

(

char *

a_string

)

Duplicate a string and update the attachments to point to the new returned string:

Parameters

a_string

_string

Definition at line 624 of file attachment_pretty_print.c.

{
    char * new_string = strdup(a_string);
    
    if (new_string != NULL && is_emacs_pretty_print_asked)
        relocate_attachments(a_string, new_string);
    return new_string;
}

References a_string, is_emacs_pretty_print_asked, relocate_attachments(), and strdup().

Here is the call graph for this function:

write_an_attachment_file()

void write_an_attachment_file

(

string

file_name

)

Add the attachment in Emacs mode by creating a twin file that is decorated with Emacs properties:

Now include the original plain file:

Strange semantics: must have read the character first:

Just backslashify the '"' and '\':

Actually add the interesting stuff:

Parameters

file_name

ile_name

Definition at line 912 of file attachment_pretty_print.c.

{
    if (is_emacs_pretty_print_asked) {
        FILE * file_stream;
        char * emacs_file_name = strdup(concatenate(file_name, EMACS_FILE_EXT, NULL));
        FILE * emacs_file_stream = safe_fopen(emacs_file_name, "w");
        init_output_the_attachments_for_emacs(emacs_file_stream);
        /* Now include the original plain file: */
        file_stream = safe_fopen(file_name, "r");
        for(;;) {
            char c = getc(file_stream);
            /* Strange semantics: must have read the character first: */
            if (feof(file_stream))
                break;
            
            /* Just backslashify the '"' and '\': */
            if (c == '"' || c == '\\')
                (void) putc('\\', emacs_file_stream);
            
            (void) putc(c, emacs_file_stream);    
        }
        safe_fclose(file_stream, file_name);
        /* Actually add the interesting stuff: */
        output_the_attachments_for_emacs(emacs_file_stream);
        safe_fclose(emacs_file_stream, emacs_file_name);
        free(emacs_file_name);
    }
}

References concatenate(), file_name, free(), init_output_the_attachments_for_emacs(), is_emacs_pretty_print_asked, output_the_attachments_for_emacs(), safe_fclose(), safe_fopen(), and strdup().

Referenced by make_resource_from_starting_node(), and make_text_resource().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

attachments_before_sorting

list attachments_before_sorting = NIL

To store the attachment before sorting:

attachment_pretty_print.c

Definition at line 65 of file attachment_pretty_print.c.

Referenced by output_the_attachments_in_a_sorted_order(), and put_an_attachment_in_the_list().

is_emacs_pretty_print_asked

bool is_emacs_pretty_print_asked

static

To store the fact a prettyprinter ask for Emacs attachments:

Definition at line 48 of file attachment_pretty_print.c.

Referenced by attach_cumulated_effects_decoration_to_text(), attach_declaration_size_type_to_words(), attach_declaration_to_words(), attach_declaration_type_to_words(), attach_decoration_to_text(), attach_head_to_sentence(), attach_loop_to_sentence_up_to_end_of_text(), attach_preconditions_decoration_to_text(), attach_proper_effects_decoration_to_text(), attach_reference_to_word_list(), attach_regular_call_to_word(), attach_statement_information_to_text(), attach_total_preconditions_decoration_to_text(), attach_transformers_decoration_to_text(), begin_attachment_prettyprint(), deal_with_attachments_at_this_character(), end_attachment_prettyprint(), strcat_word_and_migrate_attachments(), strdup_and_migrate_attachments(), and write_an_attachment_file().