util.c File Reference

#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include "genC.h"
#include "linear.h"
#include "misc.h"
#include "text-util.h"

Include dependency graph for util.c:

Go to the source code of this file.

Macros
#define	LINE_SUFFIX   "\n"

Functions
char *	int2a (int i)
	util.c More...
char *	f2a (float f)
void	add_one_unformated_printf_to_text (text r, string a_format,...)
string	first_word_of_sentence (sentence s)
	Return the first word of a sentence: More...
string	last_word_of_sentence (sentence s)
	Return the last word of a sentence: More...
static int	last_comma_or_clopar (string s)
	returns a possible index where to cut the string. More...
void	add_to_current_line (string buffer, const char *append, string continuation, text txt)
void	close_current_line (string buffer, text txt, string continuation)
void	add_words_to_text (text t, list wl)
	Add the word list wl to the end of the last sentence of text t. More...

Macro Definition Documentation

LINE_SUFFIX

#define LINE_SUFFIX   "\n"

Definition at line 125 of file util.c.

Function Documentation

add_one_unformated_printf_to_text()

void add_one_unformated_printf_to_text	(	text	r,
		string	a_format,
			...
	)

beurk

Parameters

a_format

_format

Definition at line 59 of file util.c.

{
   /* beurk */
   char *buffer;
   va_list some_arguments;
   va_start(some_arguments, a_format);
   int ret = vasprintf(&buffer, a_format, some_arguments);
   pips_assert("vasprintf is ok", ret >= 0);
   ADD_SENTENCE_TO_TEXT(r, make_sentence(is_sentence_formatted,
                                         buffer));
   va_end(some_arguments);
}

References ADD_SENTENCE_TO_TEXT, buffer, is_sentence_formatted, make_sentence(), pips_assert, ret, and vasprintf().

Referenced by ensure_comment_consistency().

Here is the call graph for this function:

Here is the caller graph for this function:

add_to_current_line()

void add_to_current_line	(	string	buffer,
		const char *	append,
		string	continuation,
		text	txt
	)

special case: appends a sole "," on end of line...

2 = strlen("\n\0")

cannot append the string. must go next line.

save the end of the line

trunc!

happend new line.

now regenerate the beginning of the line

get back saved part

current line + new line are too large. Try to append the buffer alone, before trying to add the new line alone

Append the new line

this shouldn't happen. it can occur if lappend+lcontinuation is too large.

Cut the comment

G: warning: I removed the const modifier here

Parameters

buffer	uffer
append	current line being processed
continuation	string to add to this line
txt	prefix when breaking a line where to append completed lines

Definition at line 140 of file util.c.

{
    bool divide;
    char tmp[MAX_LINE_LENGTH];
    int last_cut;
    int lappend;
    int lbuffer = strlen(buffer);
    bool comment = false;
    char stmp;
    /* special case: appends a sole "," on end of line... */
    if (same_string_p(append, ", ") && lbuffer+3==MAX_LINE_LENGTH) 
        append = ",";
 
    lappend = strlen(append);
 
 
    if (lbuffer + lappend + 2 > MAX_LINE_LENGTH) /* 2 = strlen("\n\0") */
    {   
        /* cannot append the string. must go next line.
         */
        last_cut = last_comma_or_clopar(buffer);
 
        divide = (last_cut > 0)
            && (last_cut != lbuffer-1) 
            && (lbuffer - last_cut + lappend +strlen(continuation) 
                < MAX_LINE_LENGTH - 2);
 
        if (divide) 
        {
            int nl_cut = last_cut;
            while (buffer[nl_cut+1]==' ') nl_cut++;
            strcpy(tmp, buffer+nl_cut+1); /* save the end of the line */
            buffer[last_cut+1] = '\0';    /* trunc! */
        }
        
        /* happend new line. */
        strcat(buffer, LINE_SUFFIX);
        ADD_SENTENCE_TO_TEXT
            (txt, make_sentence(is_sentence_formatted, strdup(buffer)));
        
        /* now regenerate the beginning of the line */
        strcpy(buffer, continuation);
        
        if (divide) {
            strcat(buffer, tmp); /* get back saved part */
            
            if (strlen(buffer) + lappend + 2 > MAX_LINE_LENGTH
                && ! same_string_p(buffer,continuation)) {
                /* current line + new line are too large. Try to append the 
                   buffer alone, before trying to add the new line alone */
                strcat(buffer, LINE_SUFFIX);
                ADD_SENTENCE_TO_TEXT
                    (txt, make_sentence(is_sentence_formatted, strdup(buffer)));
                strcpy(buffer, continuation);
            }
        }
        
    }
    
    /* Append the new line */
    lbuffer = strlen(buffer);
    stmp = continuation[0];
    comment = (stmp == 'c'|| stmp == 'C'        || stmp == '!'|| stmp == '*'
      || (continuation[0] == '/' && continuation[1] == '/')
      || (continuation[0] == '/' && continuation[1] == '*'));
    
    if (strlen(buffer) + lappend + 2 > MAX_LINE_LENGTH) {
        /* this shouldn't happen. 
         * it can occur if lappend+lcontinuation is too large.
         */
        if (comment) {
            /* Cut the comment */
            int coupure = MAX_LINE_LENGTH-2 -lbuffer;
            char tmp2[2*MAX_LINE_LENGTH];
            strcpy(tmp2,append+coupure);
        /*SG: warning: I removed the const modifier here */
            ((char*)append)[coupure]='\0';
            
            add_to_current_line(buffer,append,continuation,txt);
            add_to_current_line(buffer,tmp2,continuation,txt);
            
        }
        else 
            pips_internal_error("line code too large...");
    }
    else if (! same_string_p(append, " ") 
             || ! same_string_p(buffer, continuation))
        strcat(buffer, append);
}

References ADD_SENTENCE_TO_TEXT, add_to_current_line(), append, buffer, comment(), continuation, divide, is_sentence_formatted, last_comma_or_clopar(), LINE_SUFFIX, make_sentence(), MAX_LINE_LENGTH, pips_internal_error, same_string_p, and strdup().

Referenced by add_separation(), add_to_current_line(), add_Value_to_current_line(), close_current_line(), constante_to_textline(), contrainte_to_text_2(), contraintes_text_format(), entity_list_text_format(), signed_operation_to_textline(), system_sorted_text_format(), text_directive(), and unsigned_operation_to_textline().

Here is the call graph for this function:

Here is the caller graph for this function:

add_words_to_text()

void add_words_to_text	(	text	t,
		list	wl
	)

Add the word list wl to the end of the last sentence of text t.

Parameters

wl

l

Definition at line 273 of file util.c.

{
  list sl = text_sentences(t);
 
  if(ENDP(sl)) {
    pips_internal_error("what kind of sentence to make?");
  }
  else {
    sentence s = SENTENCE(CAR(gen_last(sl)));
    if(sentence_formatted_p(s)) {
      pips_internal_error("Not implemented");
    }
    else {
      unformatted u = sentence_unformatted(s);
      unformatted_words(u) = gen_nconc(unformatted_words(u), wl);
    }
  }
  pips_assert("t is consistent", text_consistent_p(t));
}

References CAR, ENDP, gen_last(), gen_nconc(), pips_assert, pips_internal_error, SENTENCE, sentence_formatted_p, sentence_unformatted, text_consistent_p(), text_sentences, and unformatted_words.

Referenced by c_text_related_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

close_current_line()

void close_current_line	(	string	buffer,
		text	txt,
		string	continuation
	)

do not append an empty line to text

Parameters

buffer	uffer
txt	xt
continuation	ontinuation

Definition at line 235 of file util.c.

{
  if (strlen(buffer)!=0) /* do not append an empty line to text */ {
    int lbuffer=0;
    char stmp = continuation[0];
    char stmp1 = continuation[1];
    bool comment = stmp == 'c'|| stmp == 'C'
      || stmp == '!'|| stmp == '*'
      || (stmp == '/' && stmp1 == '*') || (stmp == '/' && stmp1 == '/');
 
    if ((lbuffer=strlen(buffer))+2>MAX_LINE_LENGTH) {
      if (comment) {
        int coupure = MAX_LINE_LENGTH-2;
        char tmp2[2*MAX_LINE_LENGTH];
        strcpy(tmp2,buffer+coupure);
        buffer[coupure]='\0';
 
        add_to_current_line(buffer,"  ",continuation,txt);
        add_to_current_line(buffer,tmp2,continuation,txt);
        close_current_line(buffer,txt,continuation);
      }
      else
        pips_assert("buffer is too large",
                    strlen(buffer)+1<MAX_LINE_LENGTH);
    }
    else {
      strcat(buffer, LINE_SUFFIX);
      ADD_SENTENCE_TO_TEXT
        (txt, make_sentence(is_sentence_formatted, strdup(buffer)));
      buffer[0] = '\0';
    }
  }
}

References ADD_SENTENCE_TO_TEXT, add_to_current_line(), buffer, close_current_line(), comment(), continuation, is_sentence_formatted, LINE_SUFFIX, make_sentence(), MAX_LINE_LENGTH, pips_assert, and strdup().

Referenced by close_current_line(), text_continuation(), text_directive(), text_pointer_value(), text_points_to_relation(), text_region_no_action(), and text_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

f2a()

char* f2a

(

float

f

)

Definition at line 51 of file util.c.

{
    char *buffer;
    asprintf(&buffer, "%f", f);
    return buffer;
}

References asprintf, buffer, and f().

Here is the call graph for this function:

first_word_of_sentence()

string first_word_of_sentence

(

sentence

s

)

Return the first word of a sentence:

The sentence is seen as a big word:

From the first word to the last one. Label should is skipped:

Definition at line 76 of file util.c.

{
    string begin = string_undefined;
 
    if (sentence_formatted_p(s))
        /* The sentence is seen as a big word: */
        begin = sentence_formatted(s);
    else if (sentence_unformatted_p(s)) {
        list l = unformatted_words(sentence_unformatted(s));
        /* From the first word to the last one. Label should is
           skipped: */
        begin = STRING(CAR(l));
    }
    else {
      pips_assert("s should be formatted or unformatted...", 0);
      // redundant... to avoid a warning
      abort();
    }
 
    return begin;
}

References abort, CAR, pips_assert, sentence_formatted, sentence_formatted_p, sentence_unformatted, sentence_unformatted_p, STRING, string_undefined, and unformatted_words.

Referenced by attach_to_sentence_list(), get_vertex_by_string(), print_graph_of_text_to_daVinci(), and safe_make_successor().

Here is the caller graph for this function:

int2a()

char* int2a

(

int

i

)

util.c

Definition at line 42 of file util.c.

{
    char *buffer;
    asprintf(&buffer,"%d", i);
    return buffer;
}

References asprintf, and buffer.

Referenced by adg_get_integer_entity(), adg_rename_entities(), attach_declaration_size_type_to_words(), bound_parameter_name(), c_dim_string(), c_reference(), control_rank(), create_pointer_to_array_stub_points_to(), create_stub_entity(), EnterScope(), find_or_create_coeff(), FindEntityFromLocalNameAndPrefix(), make_coeff(), make_datum_movement(), make_HRE_empty_module(), make_movement_scalar_wp65(), make_movements_loop_body_wp65(), module_initial_parameter_pv(), nth_formal_name(), points_to_name(), points_to_rank(), print_call_path(), print_call_precondition(), print_sesam_tasks_buffers_header(), same_or_equivalence_argument_add_aliases(), st_declaration_init(), st_dimension_bound_as_string(), st_dimension_reference_as_string(), st_loop(), task_complexity(), text_equivalence_class(), this_entity_cdeclaration(), update_number_of_use(), words_numerical_dimension(), xml_Argument(), xml_Array(), xml_array_in_task(), xml_AssignArgument(), xml_Bounds(), xml_Bounds_and_Stride(), xml_Call(), xml_Chain_Graph(), xml_declarations(), xml_dim_string(), xml_loop_from_loop(), xml_loop_from_sequence(), xml_Pattern_Paving(), xml_Scalar(), xml_task(), xml_tasks(), and xml_tiling().

last_comma_or_clopar()

static int last_comma_or_clopar ( string  s )

static

returns a possible index where to cut the string.

0 if none.

Definition at line 130 of file util.c.

{
    int last = 0, i;
    for (i=strlen(s)-1; i>0 && !last; i--)
        if (s[i] == ',' || s[i]==')') 
            last = i;
    return last;
}

Referenced by add_to_current_line().

Here is the caller graph for this function:

last_word_of_sentence()

string last_word_of_sentence

(

sentence

s

)

Return the last word of a sentence:

The sentence is seen as a big word:

From the first word to the last one. Label should is skipped:

Definition at line 101 of file util.c.

{
    string end = string_undefined;
 
    if (sentence_formatted_p(s))
        /* The sentence is seen as a big word: */
        end = sentence_formatted(s);
    else if (sentence_unformatted_p(s)) {
        list l = unformatted_words(sentence_unformatted(s));
        /* From the first word to the last one. Label should is
           skipped: */
        end = STRING(CAR(gen_last(l)));
    }
    else {
      pips_assert("s should be formatted or unformatted...", 0);
      // redundant... to avoid a warning
      abort();
    }
 
    return end;
}

References abort, CAR, end, gen_last(), pips_assert, sentence_formatted, sentence_formatted_p, sentence_unformatted, sentence_unformatted_p, STRING, string_undefined, and unformatted_words.

Referenced by attach_to_sentence_list().

Here is the call graph for this function:

Here is the caller graph for this function: